typo fixes

[p5sagit/App-FatPacker.git] / lib / App / FatPacker.pm

package App::FatPacker;

use strict;
use warnings FATAL => 'all';
use 5.008001;
use Getopt::Long;
use Cwd qw(cwd);
use File::Find qw(find);
use File::Spec::Functions qw(
  catdir splitpath splitdir catpath rel2abs abs2rel
);
use File::Spec::Unix;
use File::Copy qw(copy);
use File::Path qw(mkpath rmtree);
use B qw(perlstring);

our $VERSION = '0.010000'; # 0.10.0

$VERSION = eval $VERSION;

sub call_parser {
  my $self = shift;
  my ($args, $options) = @_;

  local *ARGV = [ @{$args} ];
  $self->{option_parser}->getoptions(@$options);

  return [ @ARGV ];
}

sub lines_of {
  map +(chomp,$_)[1], do { local @ARGV = ($_[0]); <> };
}

sub stripspace {
  my ($text) = @_;
  $text =~ /^(\s+)/ && $text =~ s/^$1//mg;
  $text;
}

sub import {
  $_[1] && $_[1] eq '-run_script'
    and return shift->new->run_script;
}

sub new {
  bless {
    option_parser => Getopt::Long::Parser->new(
      config => [ qw(require_order pass_through bundling no_auto_abbrev) ]
    ),
  }, $_[0];
}

sub run_script {
  my ($self, $args) = @_;
  my @args = $args ? @$args : @ARGV;
  (my $cmd = shift @args || 'help') =~ s/-/_/g;

  if (my $meth = $self->can("script_command_${cmd}")) {
    $self->$meth(\@args);
  } else {
    die "No such command ${cmd}";
  }
}

sub script_command_help {
  print "Try `perldoc fatpack` for how to use me\n";
}

sub script_command_pack {
  my ($self, $args) = @_;

  my @modules = split /\r?\n/, $self->trace(args => $args);
  my @packlists = $self->packlists_containing(\@modules);

  my $base = catdir(cwd, 'fatlib');
  $self->packlists_to_tree($base, \@packlists);

  my $file = shift @$args;
  print $self->fatpack_file($file);
}

sub script_command_trace {
  my ($self, $args) = @_;

  $args = $self->call_parser($args => [
    'to=s' => \my $file,
    'to-stderr' => \my $to_stderr,
    'use=s' => \my @additional_use
  ]);

  die "Can't use to and to-stderr on same call" if $file && $to_stderr;

  $file ||= 'fatpacker.trace';

  if (!$to_stderr and -e $file) {
    unlink $file or die "Couldn't remove old trace file: $!";
  }
  my $arg = do {
    if ($to_stderr) {
      ">&STDERR"
    } elsif ($file) {
      ">>${file}"
    }
  };

  $self->trace(
    use => \@additional_use,
    args => $args,
    output => $arg,
  );
}

sub trace {
  my ($self, %opts) = @_;

  my $output = $opts{output};
  my $trace_opts = join ',', $output||'>&STDOUT', @{$opts{use}||[]};

  local $ENV{PERL5OPT} = '-MApp::FatPacker::Trace='.$trace_opts;

  my @args = @{$opts{args}||[]};

  if ($output) {
    # user specified output target, JFDI
    system $^X, @args;
    return;
  } else {
    # no output target specified, slurp
    open my $out_fh, "$^X @args |";
    return do { local $/; <$out_fh> };
  }
}

sub script_command_packlists_for {
  my ($self, $args) = @_;
  foreach my $pl ($self->packlists_containing($args)) {
    print "${pl}\n";
  }
}

sub packlists_containing {
  my ($self, $targets) = @_;
  my @targets = @$targets;
  foreach my $t (@targets) {
    require $t;
  }
  my @search = grep -d $_, map catdir($_, 'auto'), @INC;
  my %pack_rev;
  find({
    no_chdir => 1,
    wanted => sub {
      return unless /[\\\/]\.packlist$/ && -f $_;
      $pack_rev{$_} = $File::Find::name for lines_of $File::Find::name;
    },
  }, @search);
  my %found; @found{map +($pack_rev{Cwd::abs_path($INC{$_})}||()), @targets} = ();
  sort keys %found;
}

sub script_command_tree {
  my ($self, $args) = @_;
  my $base = catdir(cwd,'fatlib');
  $self->packlists_to_tree($base, $args);
}

sub packlists_to_tree {
  my ($self, $where, $packlists) = @_;
  rmtree $where;
  mkpath $where;
  foreach my $pl (@$packlists) {
    my ($vol, $dirs, $file) = splitpath $pl;
    my @dir_parts = splitdir $dirs;
    my $pack_base;
    PART: foreach my $p (0 .. $#dir_parts) {
      if ($dir_parts[$p] eq 'auto') {
        # $p-2 since it's <wanted path>/$Config{archname}/auto
        $pack_base = catpath $vol, catdir @dir_parts[0..$p-2];
        last PART;
      }
    }
    die "Couldn't figure out base path of packlist ${pl}" unless $pack_base;
    foreach my $source (lines_of $pl) {
      # there is presumably a better way to do "is this under this base?"
      # but if so, it's not obvious to me in File::Spec
      next unless substr($source,0,length $pack_base) eq $pack_base;
      my $target = rel2abs( abs2rel($source, $pack_base), $where );
      my $target_dir = catpath((splitpath $target)[0,1]);
      mkpath $target_dir;
      copy $source => $target;
    }
  }
}

sub script_command_file {
  my ($self, $args) = @_;
  my $file = shift @$args;
  print $self->fatpack_file($file);
}

sub fatpack_file {
  my ($self, $file) = @_;

  my $shebang = "";
  my $script = "";
  if ( defined $file and -r $file ) {
    ($shebang, $script) = $self->load_main_script($file);
  }

  my @dirs = $self->collect_dirs();
  my %files;
  $self->collect_files($_, \%files) for @dirs;

  return join "\n", $shebang, $self->fatpack_code(\%files), $script;
}

# This method can be overload in sub classes
# For example to skip POD
sub load_file {
  my ($self, $file) = @_;
  my $content = do {
    local (@ARGV, $/) = ($file);
    <>
  };
  close ARGV;
  return $content;
}

sub collect_dirs {
  my ($self) = @_;
  my $cwd = cwd;
  return grep -d, map rel2abs($_, $cwd), ('lib','fatlib');
}

sub collect_files {
  my ($self, $dir, $files) = @_;
  find(sub {
    return unless -f $_;
    !/\.pm$/ and warn "File ${File::Find::name} isn't a .pm file - can't pack this -- if you hoped we were going to, things may not be what you expected later\n" and return;
    $files->{File::Spec::Unix->abs2rel($File::Find::name,$dir)} =
      $self->load_file($File::Find::name);
  }, $dir);
}

sub load_main_script {
  my ($self, $file) = @_;
  open my $fh, "<", $file or die("Can't read $file: $!");
  my $shebang = <$fh>;
  my $script = join "", <$fh>;
  close $fh;
  unless ( index($shebang, '#!') == 0 ) {
    $script = $shebang . $script;
    $shebang = "";
  }
  return ($shebang, $script);
}

sub fatpack_start {
  return stripspace <<'  END_START';
    # This chunk of stuff was generated by App::FatPacker. To find the original
    # file's code, look for the end of this BEGIN block or the string 'FATPACK'
    BEGIN {
    my %fatpacked;
  END_START
}

sub fatpack_end {
  return stripspace <<'  END_END';
    s/^  //mg for values %fatpacked;

    my $class = 'FatPacked::'.(0+\%fatpacked);
    no strict 'refs';
    *{"${class}::files"} = sub { keys %{$_[0]} };

    if ($] < 5.008) {
      *{"${class}::INC"} = sub {
         if (my $fat = $_[0]{$_[1]}) {
           return sub {
             return 0 unless length $fat;
             $fat =~ s/^([^\n]*\n?)//;
             $_ = $1;
             return 1;
           };
         }
         return;
      };
    }

    else {
      *{"${class}::INC"} = sub {
        if (my $fat = $_[0]{$_[1]}) {
          open my $fh, '<', \$fat
            or die "FatPacker error loading $_[1] (could be a perl installation issue?)";
          return $fh;
        }
        return;
      };
    }

    unshift @INC, bless \%fatpacked, $class;
  } # END OF FATPACK CODE
  END_END
}

sub fatpack_code {
  my ($self, $files) = @_;
  my @segments = map {
    (my $stub = $_) =~ s/\.pm$//;
    my $name = uc join '_', split '/', $stub;
    my $data = $files->{$_}; $data =~ s/^/  /mg; $data =~ s/(?<!\n)\z/\n/;
    '$fatpacked{'.perlstring($_).qq!} = '#line '.(1+__LINE__).' "'.__FILE__."\\"\\n".<<'${name}';\n!
    .qq!${data}${name}\n!;
  } sort keys %$files;

  return join "\n", $self->fatpack_start, @segments, $self->fatpack_end;
}

=encoding UTF-8

=head1 NAME

App::FatPacker - pack your dependencies onto your script file

=head1 SYNOPSIS

  $ fatpack pack myscript.pl >myscript.packed.pl

Or, with more step-by-step control:

  $ fatpack trace myscript.pl
  $ fatpack packlists-for `cat fatpacker.trace` >packlists
  $ fatpack tree `cat packlists`
  $ fatpack file myscript.pl >myscript.packed.pl

See the documentation for the L<fatpack> script itself for more information.

The programmatic API for this code is not yet fully decided, hence the 0.x
release version. Expect that to be cleaned up for 1.0.

=head1 SEE ALSO

L<article for Perl Advent 2012|http://www.perladvent.org/2012/2012-12-14.html>

=head1 SUPPORT

Your current best avenue is to come annoy mst on #toolchain on
irc.perl.org. There should be a non-IRC means of support by 1.0.

=head1 AUTHOR

Matt S. Trout (mst) <mst@shadowcat.co.uk>

=head2 CONTRIBUTORS

miyagawa - Tatsuhiko Miyagawa (cpan:MIYAGAWA) <miyagawa@bulknews.net>

tokuhirom - MATSUNO★Tokuhiro (cpan:TOKUHIROM) <tokuhirom@gmail.com>

dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>

gugod - 劉康民 (cpan:GUGOD) <gugod@cpan.org>

t0m - Tomas Doran (cpan:BOBTFISH) <bobtfish@bobtfish.net>

sawyer - Sawyer X (cpan:XSAWYERX) <xsawyerx@cpan.org>

ether - Karen Etheridge (cpan:ETHER) <ether@cpan.org>

Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>

dolmen - Olivier Mengué (cpan:DOLMEN) <dolmen@cpan.org>

djerius - Diab Jerius (cpan:DJERIUS) <djerius@cpan.org>

haarg - Graham Knop (cpan:HAARG> <haarg@haarg.org>

Many more people are probably owed thanks for ideas. Yet
another doc nit to fix.

=head1 COPYRIGHT

Copyright (c) 2010 the App::FatPacker L</AUTHOR> and L</CONTRIBUTORS>
as listed above.

=head1 LICENSE

This library is free software and may be distributed under the same terms
as perl itself.

=cut

1;