view release on metacpan or  search on metacpan

lib/Bundler/MultiGem/Model/Gem.pm  view on Meta::CPAN

  open(GEMSPEC, "<${gemspec}") || die "Can't open ${gemspec}: $!";
  open(NEW_GEMSPEC, ">${new_gemspec}") || die "Can't open ${new_gemspec}: $!";

  while( my $line = <GEMSPEC> ){
    if ( $line =~ /${n}\/version/ ) { next; }
    for ($line) {
      # Replace version reference from file
      s/${mm}::VERSION/'$v'/;
      s/${n}/${vn}/g;
      s/${mm}/${vmn}/g;
    }

    print NEW_GEMSPEC $line;
  }
  close(NEW_GEMSPEC);
  close(GEMSPEC);

  unlink $gemspec || warn "Could not unlink ${gemspec}: $!";
}

=head2 rename_main_file

Manipulates original gemfile as follows:
  * rename C<lib/foo.rb> for v C<0.1.0> into C<lib/v010-foo.rb>
  * add on top of C<lib/v010-foo.rb>: C<module V010; end> for namespacing
  * copy the rest of original below

This step allows to add a namespace with the gem version (a kind of shading).
All the other replacement are done with other rb, rake and Rakfile files.

=cut

sub rename_main_file {
  my ($self, $v, $lib_dir) = @_;

  my $normv = Bundler::MultiGem::Model::Gem::norm_v($v);
  my $new_main_module = ruby_constantize($normv);

  my $main_module_file = catfile( $lib_dir, $self->name . ".rb" );
  my $new_main_module_file = catfile( $lib_dir, $self->vname($v) . ".rb" );

  if ( -e $main_module_file ) {
    open(ORIGINAL, "<${main_module_file}") ||
      die "Can't open ${main_module_file}: $!";
    my @file_content = <ORIGINAL>;
    close(ORIGINAL);

    open(NEW_FILE, ">${new_main_module_file}")  ||
      die "Can't open ${new_main_module_file}: $!";
    print NEW_FILE "module ${new_main_module}; end\n";
    foreach my $line (@file_content) { print NEW_FILE $line; }
    close(NEW_FILE);

    unlink $main_module_file;
  }
}

=head2 process_single_file

Manipulates each file as follows:
  * create a backup of the original file C<.bak>
  * replace gem name reference with gem vname (C<foo> with C<v010-foo>)
  * replace gem main_module reference with gem vmodule_name (C<Foo> with C<V010::Foo>)
  * unlink the backup C<.bak>

=cut

sub process_single_file {
  my ($self, $v, $f) = @_;

  my ($n, $vn, $mm, $vmn) = (
    $self->name, $self->vname($v), $self->main_module, $self->vmodule_name($v)
  );
  my $bkp = $f . ".bak";
  rename($f, $bkp);
  open(I, "<$bkp");
  open(O, ">$f");
  while(my $line = <I>) {
    for ($line) {
      s/${n}/${vn}/g;
      s/${mm}/${vmn}/g;
    }
    print O $line;
  }
  close(O);
  close(I);
  unlink $bkp;
}

=head2 fetch

This is an alias of the system command C<gem fetch>

    my $gem->name; # "foo"
    my $fp = "pkg/v010-foo.gem"
    my $gv = "0.1.0";
    $gem->fetch($fp, $gv); # if $fp found, do nothing, else fetch gem version and rename it

=cut

sub fetch {
  my ( $self, $fp, $gv ) = (@_);
  if (! -f $fp ) {
    my $cmd = "gem fetch " . $self->name . " --version " . $gv .
              " --source " . $self->source;
    system("$cmd");
    rename( $self->name . "-$gv" . ".gem", $fp );
  }
}

=head1 EXPORTS

=head2 gem_vname

Reusable function to combine and format gem name and version

    use Bundler::MultiGem::Model::Gem qw(gem_vname);
    gem_vname("foo", "0.1.0"); # v010-foo
    gem_vname("foo_bar", "0.1.0"); # v010-foo_bar
    gem_vname("foo-bar", "0.1.0"); # v010-foo-bar

=cut

sub gem_vname {