Catalyst-View-Component-SubInclude-0.10/0000755000076500000240000000000011501700151016473 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/Changes0000644000076500000240000000447311501700001017770 0ustar t0mstaffRevision history for Catalyst-View-Component-SubInclude 0.10 Tue 14 Dec 14:32:00 2010 - Add HTTP support (Wallace Reis) 0.09 Thu 10 June 21:24:00 2010 - Add SSI support (Vladimir Timofeev) - Additional documentation. 0.08 Sun 16 May 15:52:00 2010 - Released 0.07_03 with no further changes. 0.07_03 Fri Feb 19 00:31:00 2010 - Autogenerate README file from Pod. - Fix missing test_requires dependency on parent by dropping use of that module. 0.07_02 Fri Feb 19 00:11:00 2010 - Fix missing test_requires dependency on Catalyst::Action::RenderView. 0.07_01 Mon Feb 15 22:41:54 2010 - It is now possible to configure plugins, and the subrequest and visit plugins can be configured to not replace the stash before redispatching. - Fix Visit plugin to work with newer Catalyst versions. - Use uri_for_action instead of calling methods in the dispatcher directly when possible. - Call pulbic rather than private methods in the dispatcher in the subrequest backend. - Plugins which are used now generate an instance for each plugin which is subsequently cached. - Fix useage of namespace::clean - Proper test application bundled with the distribution. - Proper tests for all engines in the distribution. - Use Catalyst::Component::ContextClosure instead of weakening the context manually. - Make pod tests only run in author mode. - General code cleanup. 0.07 Mon Jul 27 20:45:42 2009 - Fix some issues related to Args/CaptureArgs handling in the SubRequest and Visit plugins. 0.06 - Weaken $c to avoid a memory leak. 0.05 Tue Apr 21 19:16:00 2009 - Change attribute constraint from ClassName to Str to fix issue with newer Catalyst versions 0.04 Wed Feb 11 00:38:02 2009 - Recreate dist because the CPAN indexer doesn't like tarballs generated on Windows. 0.03 Fri Feb 6 17:58:50 2009 - Add "subinclude_using" - Tidy up dist (added README and this Changes file) 0.02 Thu Feb 5 23:26:54 2008 - Fixed several issues related to Chained actions - Added the Visit subinclude plugin 0.01 Fri Jan 30 21:00:00 2009 First public version. Catalyst-View-Component-SubInclude-0.10/inc/0000755000076500000240000000000011501700151017244 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/inc/Module/0000755000076500000240000000000011501700151020471 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/inc/Module/AutoInstall.pm0000644000076500000240000005423111501700064023276 0ustar t0mstaff#line 1 package Module::AutoInstall; use strict; use Cwd (); use ExtUtils::MakeMaker (); use vars qw{$VERSION}; BEGIN { $VERSION = '1.03'; } # special map on pre-defined feature sets my %FeatureMap = ( '' => 'Core Features', # XXX: deprecated '-core' => 'Core Features', ); # various lexical flags my ( @Missing, @Existing, %DisabledTests, $UnderCPAN, $HasCPANPLUS ); my ( $Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly, $AllDeps ); my ( $PostambleActions, $PostambleUsed ); # See if it's a testing or non-interactive session _accept_default( $ENV{AUTOMATED_TESTING} or ! -t STDIN ); _init(); sub _accept_default { $AcceptDefault = shift; } sub missing_modules { return @Missing; } sub do_install { __PACKAGE__->install( [ $Config ? ( UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) : () ], @Missing, ); } # initialize various flags, and/or perform install sub _init { foreach my $arg ( @ARGV, split( /[\s\t]+/, $ENV{PERL_AUTOINSTALL} || $ENV{PERL_EXTUTILS_AUTOINSTALL} || '' ) ) { if ( $arg =~ /^--config=(.*)$/ ) { $Config = [ split( ',', $1 ) ]; } elsif ( $arg =~ /^--installdeps=(.*)$/ ) { __PACKAGE__->install( $Config, @Missing = split( /,/, $1 ) ); exit 0; } elsif ( $arg =~ /^--default(?:deps)?$/ ) { $AcceptDefault = 1; } elsif ( $arg =~ /^--check(?:deps)?$/ ) { $CheckOnly = 1; } elsif ( $arg =~ /^--skip(?:deps)?$/ ) { $SkipInstall = 1; } elsif ( $arg =~ /^--test(?:only)?$/ ) { $TestOnly = 1; } elsif ( $arg =~ /^--all(?:deps)?$/ ) { $AllDeps = 1; } } } # overrides MakeMaker's prompt() to automatically accept the default choice sub _prompt { goto &ExtUtils::MakeMaker::prompt unless $AcceptDefault; my ( $prompt, $default ) = @_; my $y = ( $default =~ /^[Yy]/ ); print $prompt, ' [', ( $y ? 'Y' : 'y' ), '/', ( $y ? 'n' : 'N' ), '] '; print "$default\n"; return $default; } # the workhorse sub import { my $class = shift; my @args = @_ or return; my $core_all; print "*** $class version " . $class->VERSION . "\n"; print "*** Checking for Perl dependencies...\n"; my $cwd = Cwd::cwd(); $Config = []; my $maxlen = length( ( sort { length($b) <=> length($a) } grep { /^[^\-]/ } map { ref($_) ? ( ( ref($_) eq 'HASH' ) ? keys(%$_) : @{$_} ) : '' } map { +{@args}->{$_} } grep { /^[^\-]/ or /^-core$/i } keys %{ +{@args} } )[0] ); # We want to know if we're under CPAN early to avoid prompting, but # if we aren't going to try and install anything anyway then skip the # check entirely since we don't want to have to load (and configure) # an old CPAN just for a cosmetic message $UnderCPAN = _check_lock(1) unless $SkipInstall; while ( my ( $feature, $modules ) = splice( @args, 0, 2 ) ) { my ( @required, @tests, @skiptests ); my $default = 1; my $conflict = 0; if ( $feature =~ m/^-(\w+)$/ ) { my $option = lc($1); # check for a newer version of myself _update_to( $modules, @_ ) and return if $option eq 'version'; # sets CPAN configuration options $Config = $modules if $option eq 'config'; # promote every features to core status $core_all = ( $modules =~ /^all$/i ) and next if $option eq 'core'; next unless $option eq 'core'; } print "[" . ( $FeatureMap{ lc($feature) } || $feature ) . "]\n"; $modules = [ %{$modules} ] if UNIVERSAL::isa( $modules, 'HASH' ); unshift @$modules, -default => &{ shift(@$modules) } if ( ref( $modules->[0] ) eq 'CODE' ); # XXX: bugward combatability while ( my ( $mod, $arg ) = splice( @$modules, 0, 2 ) ) { if ( $mod =~ m/^-(\w+)$/ ) { my $option = lc($1); $default = $arg if ( $option eq 'default' ); $conflict = $arg if ( $option eq 'conflict' ); @tests = @{$arg} if ( $option eq 'tests' ); @skiptests = @{$arg} if ( $option eq 'skiptests' ); next; } printf( "- %-${maxlen}s ...", $mod ); if ( $arg and $arg =~ /^\D/ ) { unshift @$modules, $arg; $arg = 0; } # XXX: check for conflicts and uninstalls(!) them. my $cur = _load($mod); if (_version_cmp ($cur, $arg) >= 0) { print "loaded. ($cur" . ( $arg ? " >= $arg" : '' ) . ")\n"; push @Existing, $mod => $arg; $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { if (not defined $cur) # indeed missing { print "missing." . ( $arg ? " (would need $arg)" : '' ) . "\n"; } else { # no need to check $arg as _version_cmp ($cur, undef) would satisfy >= above print "too old. ($cur < $arg)\n"; } push @required, $mod => $arg; } } next unless @required; my $mandatory = ( $feature eq '-core' or $core_all ); if ( !$SkipInstall and ( $CheckOnly or ($mandatory and $UnderCPAN) or $AllDeps or _prompt( qq{==> Auto-install the } . ( @required / 2 ) . ( $mandatory ? ' mandatory' : ' optional' ) . qq{ module(s) from CPAN?}, $default ? 'y' : 'n', ) =~ /^[Yy]/ ) ) { push( @Missing, @required ); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } elsif ( !$SkipInstall and $default and $mandatory and _prompt( qq{==> The module(s) are mandatory! Really skip?}, 'n', ) =~ /^[Nn]/ ) { push( @Missing, @required ); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { $DisabledTests{$_} = 1 for map { glob($_) } @tests; } } if ( @Missing and not( $CheckOnly or $UnderCPAN ) ) { require Config; print "*** Dependencies will be installed the next time you type '$Config::Config{make}'.\n"; # make an educated guess of whether we'll need root permission. print " (You may need to do that as the 'root' user.)\n" if eval '$>'; } print "*** $class configuration finished.\n"; chdir $cwd; # import to main:: no strict 'refs'; *{'main::WriteMakefile'} = \&Write if caller(0) eq 'main'; return (@Existing, @Missing); } sub _running_under { my $thing = shift; print <<"END_MESSAGE"; *** Since we're running under ${thing}, I'll just let it take care of the dependency's installation later. END_MESSAGE return 1; } # Check to see if we are currently running under CPAN.pm and/or CPANPLUS; # if we are, then we simply let it taking care of our dependencies sub _check_lock { return unless @Missing or @_; my $cpan_env = $ENV{PERL5_CPAN_IS_RUNNING}; if ($ENV{PERL5_CPANPLUS_IS_RUNNING}) { return _running_under($cpan_env ? 'CPAN' : 'CPANPLUS'); } require CPAN; if ($CPAN::VERSION > '1.89') { if ($cpan_env) { return _running_under('CPAN'); } return; # CPAN.pm new enough, don't need to check further } # last ditch attempt, this -will- configure CPAN, very sorry _load_cpan(1); # force initialize even though it's already loaded # Find the CPAN lock-file my $lock = MM->catfile( $CPAN::Config->{cpan_home}, ".lock" ); return unless -f $lock; # Check the lock local *LOCK; return unless open(LOCK, $lock); if ( ( $^O eq 'MSWin32' ? _under_cpan() : == getppid() ) and ( $CPAN::Config->{prerequisites_policy} || '' ) ne 'ignore' ) { print <<'END_MESSAGE'; *** Since we're running under CPAN, I'll just let it take care of the dependency's installation later. END_MESSAGE return 1; } close LOCK; return; } sub install { my $class = shift; my $i; # used below to strip leading '-' from config keys my @config = ( map { s/^-// if ++$i; $_ } @{ +shift } ); my ( @modules, @installed ); while ( my ( $pkg, $ver ) = splice( @_, 0, 2 ) ) { # grep out those already installed if ( _version_cmp( _load($pkg), $ver ) >= 0 ) { push @installed, $pkg; } else { push @modules, $pkg, $ver; } } return @installed unless @modules; # nothing to do return @installed if _check_lock(); # defer to the CPAN shell print "*** Installing dependencies...\n"; return unless _connected_to('cpan.org'); my %args = @config; my %failed; local *FAILED; if ( $args{do_once} and open( FAILED, '.#autoinstall.failed' ) ) { while () { chomp; $failed{$_}++ } close FAILED; my @newmod; while ( my ( $k, $v ) = splice( @modules, 0, 2 ) ) { push @newmod, ( $k => $v ) unless $failed{$k}; } @modules = @newmod; } if ( _has_cpanplus() and not $ENV{PERL_AUTOINSTALL_PREFER_CPAN} ) { _install_cpanplus( \@modules, \@config ); } else { _install_cpan( \@modules, \@config ); } print "*** $class installation finished.\n"; # see if we have successfully installed them while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { if ( _version_cmp( _load($pkg), $ver ) >= 0 ) { push @installed, $pkg; } elsif ( $args{do_once} and open( FAILED, '>> .#autoinstall.failed' ) ) { print FAILED "$pkg\n"; } } close FAILED if $args{do_once}; return @installed; } sub _install_cpanplus { my @modules = @{ +shift }; my @config = _cpanplus_config( @{ +shift } ); my $installed = 0; require CPANPLUS::Backend; my $cp = CPANPLUS::Backend->new; my $conf = $cp->configure_object; return unless $conf->can('conf') # 0.05x+ with "sudo" support or _can_write($conf->_get_build('base')); # 0.04x # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $conf->get_conf('makeflags') || ''; if ( UNIVERSAL::isa( $makeflags, 'HASH' ) ) { # 0.03+ uses a hashref here $makeflags->{UNINST} = 1 unless exists $makeflags->{UNINST}; } else { # 0.02 and below uses a scalar $makeflags = join( ' ', split( ' ', $makeflags ), 'UNINST=1' ) if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } ); } $conf->set_conf( makeflags => $makeflags ); $conf->set_conf( prereqs => 1 ); while ( my ( $key, $val ) = splice( @config, 0, 2 ) ) { $conf->set_conf( $key, $val ); } my $modtree = $cp->module_tree; while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { print "*** Installing $pkg...\n"; MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall; my $success; my $obj = $modtree->{$pkg}; if ( $obj and _version_cmp( $obj->{version}, $ver ) >= 0 ) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) { delete $INC{$inc}; } my $rv = $cp->install( modules => [ $obj->{module} ] ); if ( $rv and ( $rv->{ $obj->{module} } or $rv->{ok} ) ) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation cancelled.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall; } return $installed; } sub _cpanplus_config { my @config = (); while ( @_ ) { my ($key, $value) = (shift(), shift()); if ( $key eq 'prerequisites_policy' ) { if ( $value eq 'follow' ) { $value = CPANPLUS::Internals::Constants::PREREQ_INSTALL(); } elsif ( $value eq 'ask' ) { $value = CPANPLUS::Internals::Constants::PREREQ_ASK(); } elsif ( $value eq 'ignore' ) { $value = CPANPLUS::Internals::Constants::PREREQ_IGNORE(); } else { die "*** Cannot convert option $key = '$value' to CPANPLUS version.\n"; } } else { die "*** Cannot convert option $key to CPANPLUS version.\n"; } } return @config; } sub _install_cpan { my @modules = @{ +shift }; my @config = @{ +shift }; my $installed = 0; my %args; _load_cpan(); require Config; if (CPAN->VERSION < 1.80) { # no "sudo" support, probe for writableness return unless _can_write( MM->catfile( $CPAN::Config->{cpan_home}, 'sources' ) ) and _can_write( $Config::Config{sitelib} ); } # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $CPAN::Config->{make_install_arg} || ''; $CPAN::Config->{make_install_arg} = join( ' ', split( ' ', $makeflags ), 'UNINST=1' ) if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } ); # don't show start-up info $CPAN::Config->{inhibit_startup_message} = 1; # set additional options while ( my ( $opt, $arg ) = splice( @config, 0, 2 ) ) { ( $args{$opt} = $arg, next ) if $opt =~ /^force$/; # pseudo-option $CPAN::Config->{$opt} = $arg; } local $CPAN::Config->{prerequisites_policy} = 'follow'; while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall; print "*** Installing $pkg...\n"; my $obj = CPAN::Shell->expand( Module => $pkg ); my $success = 0; if ( $obj and _version_cmp( $obj->cpan_version, $ver ) >= 0 ) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) { delete $INC{$inc}; } my $rv = $args{force} ? CPAN::Shell->force( install => $pkg ) : CPAN::Shell->install($pkg); $rv ||= eval { $CPAN::META->instance( 'CPAN::Distribution', $obj->cpan_file, ) ->{install} if $CPAN::META; }; if ( $rv eq 'YES' ) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation failed.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall; } return $installed; } sub _has_cpanplus { return ( $HasCPANPLUS = ( $INC{'CPANPLUS/Config.pm'} or _load('CPANPLUS::Shell::Default') ) ); } # make guesses on whether we're under the CPAN installation directory sub _under_cpan { require Cwd; require File::Spec; my $cwd = File::Spec->canonpath( Cwd::cwd() ); my $cpan = File::Spec->canonpath( $CPAN::Config->{cpan_home} ); return ( index( $cwd, $cpan ) > -1 ); } sub _update_to { my $class = __PACKAGE__; my $ver = shift; return if _version_cmp( _load($class), $ver ) >= 0; # no need to upgrade if ( _prompt( "==> A newer version of $class ($ver) is required. Install?", 'y' ) =~ /^[Nn]/ ) { die "*** Please install $class $ver manually.\n"; } print << "."; *** Trying to fetch it from CPAN... . # install ourselves _load($class) and return $class->import(@_) if $class->install( [], $class, $ver ); print << '.'; exit 1; *** Cannot bootstrap myself. :-( Installation terminated. . } # check if we're connected to some host, using inet_aton sub _connected_to { my $site = shift; return ( ( _load('Socket') and Socket::inet_aton($site) ) or _prompt( qq( *** Your host cannot resolve the domain name '$site', which probably means the Internet connections are unavailable. ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/ ); } # check if a directory is writable; may create it on demand sub _can_write { my $path = shift; mkdir( $path, 0755 ) unless -e $path; return 1 if -w $path; print << "."; *** You are not allowed to write to the directory '$path'; the installation may fail due to insufficient permissions. . if ( eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt( qq( ==> Should we try to re-execute the autoinstall process with 'sudo'?), ((-t STDIN) ? 'y' : 'n') ) =~ /^[Yy]/ ) { # try to bootstrap ourselves from sudo print << "."; *** Trying to re-execute the autoinstall process with 'sudo'... . my $missing = join( ',', @Missing ); my $config = join( ',', UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) if $Config; return unless system( 'sudo', $^X, $0, "--config=$config", "--installdeps=$missing" ); print << "."; *** The 'sudo' command exited with error! Resuming... . } return _prompt( qq( ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/; } # load a module and return the version it reports sub _load { my $mod = pop; # class/instance doesn't matter my $file = $mod; $file =~ s|::|/|g; $file .= '.pm'; local $@; return eval { require $file; $mod->VERSION } || ( $@ ? undef: 0 ); } # Load CPAN.pm and it's configuration sub _load_cpan { return if $CPAN::VERSION and $CPAN::Config and not @_; require CPAN; # CPAN-1.82+ adds CPAN::Config::AUTOLOAD to redirect to # CPAN::HandleConfig->load. CPAN reports that the redirection # is deprecated in a warning printed at the user. # CPAN-1.81 expects CPAN::HandleConfig->load, does not have # $CPAN::HandleConfig::VERSION but cannot handle # CPAN::Config->load # Which "versions expect CPAN::Config->load? if ( $CPAN::HandleConfig::VERSION || CPAN::HandleConfig->can('load') ) { # Newer versions of CPAN have a HandleConfig module CPAN::HandleConfig->load; } else { # Older versions had the load method in Config directly CPAN::Config->load; } } # compare two versions, either use Sort::Versions or plain comparison # return values same as <=> sub _version_cmp { my ( $cur, $min ) = @_; return -1 unless defined $cur; # if 0 keep comparing return 1 unless $min; $cur =~ s/\s+$//; # check for version numbers that are not in decimal format if ( ref($cur) or ref($min) or $cur =~ /v|\..*\./ or $min =~ /v|\..*\./ ) { if ( ( $version::VERSION or defined( _load('version') )) and version->can('new') ) { # use version.pm if it is installed. return version->new($cur) <=> version->new($min); } elsif ( $Sort::Versions::VERSION or defined( _load('Sort::Versions') ) ) { # use Sort::Versions as the sorting algorithm for a.b.c versions return Sort::Versions::versioncmp( $cur, $min ); } warn "Cannot reliably compare non-decimal formatted versions.\n" . "Please install version.pm or Sort::Versions.\n"; } # plain comparison local $^W = 0; # shuts off 'not numeric' bugs return $cur <=> $min; } # nothing; this usage is deprecated. sub main::PREREQ_PM { return {}; } sub _make_args { my %args = @_; $args{PREREQ_PM} = { %{ $args{PREREQ_PM} || {} }, @Existing, @Missing } if $UnderCPAN or $TestOnly; if ( $args{EXE_FILES} and -e 'MANIFEST' ) { require ExtUtils::Manifest; my $manifest = ExtUtils::Manifest::maniread('MANIFEST'); $args{EXE_FILES} = [ grep { exists $manifest->{$_} } @{ $args{EXE_FILES} } ]; } $args{test}{TESTS} ||= 't/*.t'; $args{test}{TESTS} = join( ' ', grep { !exists( $DisabledTests{$_} ) } map { glob($_) } split( /\s+/, $args{test}{TESTS} ) ); my $missing = join( ',', @Missing ); my $config = join( ',', UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) if $Config; $PostambleActions = ( ($missing and not $UnderCPAN) ? "\$(PERL) $0 --config=$config --installdeps=$missing" : "\$(NOECHO) \$(NOOP)" ); return %args; } # a wrapper to ExtUtils::MakeMaker::WriteMakefile sub Write { require Carp; Carp::croak "WriteMakefile: Need even number of args" if @_ % 2; if ($CheckOnly) { print << "."; *** Makefile not written in check-only mode. . return; } my %args = _make_args(@_); no strict 'refs'; $PostambleUsed = 0; local *MY::postamble = \&postamble unless defined &MY::postamble; ExtUtils::MakeMaker::WriteMakefile(%args); print << "." unless $PostambleUsed; *** WARNING: Makefile written with customized MY::postamble() without including contents from Module::AutoInstall::postamble() -- auto installation features disabled. Please contact the author. . return 1; } sub postamble { $PostambleUsed = 1; return <<"END_MAKE"; config :: installdeps \t\$(NOECHO) \$(NOOP) checkdeps :: \t\$(PERL) $0 --checkdeps installdeps :: \t$PostambleActions END_MAKE } 1; __END__ #line 1071 Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/0000755000076500000240000000000011501700151022077 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/inc/Module/Install/AuthorRequires.pm0000644000076500000240000000113111501700064025416 0ustar t0mstaff#line 1 use strict; use warnings; package Module::Install::AuthorRequires; use base 'Module::Install::Base'; # cargo cult BEGIN { our $VERSION = '0.02'; our $ISCORE = 1; } sub author_requires { my $self = shift; return $self->{values}->{author_requires} unless @_; my @added; while (@_) { my $mod = shift or last; my $version = shift || 0; push @added, [$mod => $version]; } push @{ $self->{values}->{author_requires} }, @added; $self->admin->author_requires(@added); return map { @$_ } @added; } 1; __END__ #line 92 Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/AuthorTests.pm0000644000076500000240000000221511501700064024725 0ustar t0mstaff#line 1 package Module::Install::AuthorTests; use 5.005; use strict; use Module::Install::Base; use Carp (); #line 16 use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.002'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } #line 42 sub author_tests { my ($self, @dirs) = @_; _add_author_tests($self, \@dirs, 0); } #line 56 sub recursive_author_tests { my ($self, @dirs) = @_; _add_author_tests($self, \@dirs, 1); } sub _wanted { my $href = shift; sub { /\.t$/ and -f $_ and $href->{$File::Find::dir} = 1 } } sub _add_author_tests { my ($self, $dirs, $recurse) = @_; return unless $Module::Install::AUTHOR; my @tests = $self->tests ? (split / /, $self->tests) : 't/*.t'; # XXX: pick a default, later -- rjbs, 2008-02-24 my @dirs = @$dirs ? @$dirs : Carp::confess "no dirs given to author_tests"; @dirs = grep { -d } @dirs; if ($recurse) { require File::Find; my %test_dir; File::Find::find(_wanted(\%test_dir), @dirs); $self->tests( join ' ', @tests, map { "$_/*.t" } sort keys %test_dir ); } else { $self->tests( join ' ', @tests, map { "$_/*.t" } sort @dirs ); } } #line 107 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/AutoInstall.pm0000644000076500000240000000306411501700064024702 0ustar t0mstaff#line 1 package Module::Install::AutoInstall; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub AutoInstall { $_[0] } sub run { my $self = shift; $self->auto_install_now(@_); } sub write { my $self = shift; $self->auto_install(@_); } sub auto_install { my $self = shift; return if $self->{done}++; # Flatten array of arrays into a single array my @core = map @$_, map @$_, grep ref, $self->build_requires, $self->requires; my @config = @_; # We'll need Module::AutoInstall $self->include('Module::AutoInstall'); require Module::AutoInstall; my @features_require = Module::AutoInstall->import( (@config ? (-config => \@config) : ()), (@core ? (-core => \@core) : ()), $self->features, ); my %seen; my @requires = map @$_, map @$_, grep ref, $self->requires; while (my ($mod, $ver) = splice(@requires, 0, 2)) { $seen{$mod}{$ver}++; } my @deduped; while (my ($mod, $ver) = splice(@features_require, 0, 2)) { push @deduped, $mod => $ver unless $seen{$mod}{$ver}++; } $self->requires(@deduped); $self->makemaker_args( Module::AutoInstall::_make_args() ); my $class = ref($self); $self->postamble( "# --- $class section:\n" . Module::AutoInstall::postamble() ); } sub auto_install_now { my $self = shift; $self->auto_install(@_); Module::AutoInstall::do_install(); } 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Base.pm0000644000076500000240000000214711501700064023316 0ustar t0mstaff#line 1 package Module::Install::Base; use strict 'vars'; use vars qw{$VERSION}; BEGIN { $VERSION = '0.99'; } # Suspend handler for "redefined" warnings BEGIN { my $w = $SIG{__WARN__}; $SIG{__WARN__} = sub { $w }; } #line 42 sub new { my $class = shift; unless ( defined &{"${class}::call"} ) { *{"${class}::call"} = sub { shift->_top->call(@_) }; } unless ( defined &{"${class}::load"} ) { *{"${class}::load"} = sub { shift->_top->load(@_) }; } bless { @_ }, $class; } #line 61 sub AUTOLOAD { local $@; my $func = eval { shift->_top->autoload } or return; goto &$func; } #line 75 sub _top { $_[0]->{_top}; } #line 90 sub admin { $_[0]->_top->{admin} or Module::Install::Base::FakeAdmin->new; } #line 106 sub is_admin { ! $_[0]->admin->isa('Module::Install::Base::FakeAdmin'); } sub DESTROY {} package Module::Install::Base::FakeAdmin; use vars qw{$VERSION}; BEGIN { $VERSION = $Module::Install::Base::VERSION; } my $fake; sub new { $fake ||= bless(\@_, $_[0]); } sub AUTOLOAD {} sub DESTROY {} # Restore warning handler BEGIN { $SIG{__WARN__} = $SIG{__WARN__}->(); } 1; #line 159 Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Can.pm0000644000076500000240000000333311501700064023143 0ustar t0mstaff#line 1 package Module::Install::Can; use strict; use Config (); use File::Spec (); use ExtUtils::MakeMaker (); use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # check if we can load some module ### Upgrade this to not have to load the module if possible sub can_use { my ($self, $mod, $ver) = @_; $mod =~ s{::|\\}{/}g; $mod .= '.pm' unless $mod =~ /\.pm$/i; my $pkg = $mod; $pkg =~ s{/}{::}g; $pkg =~ s{\.pm$}{}i; local $@; eval { require $mod; $pkg->VERSION($ver || 0); 1 }; } # check if we can run some command sub can_run { my ($self, $cmd) = @_; my $_cmd = $cmd; return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd)); for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') { next if $dir eq ''; my $abs = File::Spec->catfile($dir, $_[1]); return $abs if (-x $abs or $abs = MM->maybe_command($abs)); } return; } # can we locate a (the) C compiler sub can_cc { my $self = shift; my @chunks = split(/ /, $Config::Config{cc}) or return; # $Config{cc} may contain args; try to find out the program part while (@chunks) { return $self->can_run("@chunks") || (pop(@chunks), next); } return; } # Fix Cygwin bug on maybe_command(); if ( $^O eq 'cygwin' ) { require ExtUtils::MM_Cygwin; require ExtUtils::MM_Win32; if ( ! defined(&ExtUtils::MM_Cygwin::maybe_command) ) { *ExtUtils::MM_Cygwin::maybe_command = sub { my ($self, $file) = @_; if ($file =~ m{^/cygdrive/}i and ExtUtils::MM_Win32->can('maybe_command')) { ExtUtils::MM_Win32->maybe_command($file); } else { ExtUtils::MM_Unix->maybe_command($file); } } } } 1; __END__ #line 156 Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Catalyst.pm0000644000076500000240000001637011501700064024233 0ustar t0mstaff#line 1 package Module::Install::Catalyst; use strict; our @ISA; require Module::Install::Base; @ISA = qw/Module::Install::Base/; use File::Find; use FindBin; use File::Copy::Recursive 'rcopy'; use File::Spec (); use Getopt::Long qw(GetOptionsFromString :config no_ignore_case); use Data::Dumper; my $SAFETY = 0; our @IGNORE = qw/Build Build.PL Changes MANIFEST META.yml Makefile.PL Makefile README _build blib lib script t inc .*\.svn \.git _darcs \.bzr \.hg debian build-stamp install-stamp configure-stamp/; our @CLASSES = (); our $ENGINE = 'CGI'; our $SCRIPT = ''; our $USAGE = ''; our %PAROPTS = (); #line 57 sub catalyst { my $self = shift; print <catalyst_files; $self->catalyst_par; print <name; for my $orig (@files) { my $path = File::Spec->catdir( 'blib', 'lib', @path, $orig ); rcopy( $orig, $path ); } } #line 105 sub catalyst_ignore_all { my ( $self, $ignore ) = @_; @IGNORE = @$ignore; } #line 116 sub catalyst_ignore { my ( $self, @ignore ) = @_; push @IGNORE, @ignore; } #line 125 # Workaround for a namespace conflict sub catalyst_par { my ( $self, $par ) = @_; $par ||= ''; return if $SAFETY; $SAFETY++; my $name = $self->name; my $usage = $USAGE; $usage =~ s/"/\\"/g; my $class_string = join "', '", @CLASSES; $class_string = "'$class_string'" if $class_string; local $Data::Dumper::Indent = 0; local $Data::Dumper::Terse = 1; local $Data::Dumper::Pad = ' '; my $paropts_string = Dumper(\%PAROPTS) || "{ }"; $self->postamble(< [$class_string], PAROPTS => $paropts_string, ENGINE => '$ENGINE', SCRIPT => '$SCRIPT', USAGE => q#$usage# } )" EOF print <options); %PAROPTS = ( %PAROPTS, %o); } } #line 230 sub catalyst_par_script { my ( $self, $script ) = @_; $SCRIPT = $script; } #line 239 sub catalyst_par_usage { my ( $self, $usage ) = @_; $USAGE = $usage; } package Catalyst::Module::Install; use strict; use FindBin; use File::Copy::Recursive 'rmove'; use File::Spec (); sub _catalyst_par { my ( $par, $class_name, $opts ) = @_; my $ENGINE = $opts->{ENGINE}; my $CLASSES = $opts->{CLASSES} || []; my $USAGE = $opts->{USAGE}; my $SCRIPT = $opts->{SCRIPT}; my $PAROPTS = $opts->{PAROPTS}; my $name = $class_name; $name =~ s/::/_/g; $name = lc $name; $par ||= "$name.par"; my $engine = $ENGINE || 'CGI'; # Check for PAR eval "use PAR ()"; die "Please install PAR\n" if $@; eval "use PAR::Packer ()"; die "Please install PAR::Packer\n" if $@; eval "use App::Packer::PAR ()"; die "Please install App::Packer::PAR\n" if $@; eval "use Module::ScanDeps ()"; die "Please install Module::ScanDeps\n" if $@; my $root = $FindBin::Bin; $class_name =~ s/-/::/g; my $path = File::Spec->catfile( 'blib', 'lib', split( '::', $class_name ) ); $path .= '.pm'; unless ( -f $path ) { print qq/Not writing PAR, "$path" doesn't exist\n/; return 0; } print qq/Writing PAR "$par"\n/; chdir File::Spec->catdir( $root, 'blib' ); my $par_pl = 'par.pl'; unlink $par_pl; my $version = $Catalyst::VERSION; my $class = $class_name; my $classes = ''; $classes .= " require $_;\n" for @$CLASSES; unlink $par_pl; my $usage = $USAGE || <<"EOF"; Usage: [parl] $name\[.par] [script] [arguments] Examples: parl $name.par $name\_server.pl -r myapp $name\_cgi.pl EOF my $script = $SCRIPT; my $tmp_file = IO::File->new("> $par_pl "); print $tmp_file <<"EOF"; if ( \$ENV{PAR_PROGNAME} ) { my \$zip = \$PAR::LibCache{\$ENV{PAR_PROGNAME}} || Archive::Zip->new(__FILE__); my \$script = '$script'; \$ARGV[0] ||= \$script if \$script; if ( ( \@ARGV == 0 ) || ( \$ARGV[0] eq '-h' ) || ( \$ARGV[0] eq '-help' )) { my \@members = \$zip->membersMatching('.*script/.*\.pl'); my \$list = " Available scripts:\\n"; for my \$member ( \@members ) { my \$name = \$member->fileName; \$name =~ /(\\w+\\.pl)\$/; \$name = \$1; next if \$name =~ /^main\.pl\$/; next if \$name =~ /^par\.pl\$/; \$list .= " \$name\\n"; } die <<"END"; $usage \$list END } my \$file = shift \@ARGV; \$file =~ s/^.*[\\/\\\\]//; \$file =~ s/\\.[^.]*\$//i; my \$member = eval { \$zip->memberNamed("./script/\$file.pl") }; die qq/Can't open perl script "\$file"\n/ unless \$member; PAR::_run_member( \$member, 1 ); } else { require lib; import lib 'lib'; \$ENV{CATALYST_ENGINE} = '$engine'; require $class; import $class; require Catalyst::Helper; require Catalyst::Test; require Catalyst::Engine::HTTP; require Catalyst::Engine::CGI; require Catalyst::Controller; require Catalyst::Model; require Catalyst::View; require Getopt::Long; require Pod::Usage; require Pod::Text; $classes } EOF $tmp_file->close; # Create package local $SIG{__WARN__} = sub { }; open my $olderr, '>&STDERR'; open STDERR, '>', File::Spec->devnull; my %opt = ( %{$PAROPTS}, # take user defined options first and override them with harcoded defaults 'x' => 1, 'n' => 0, 'o' => $par, 'p' => 1, ); # do not replace the whole $opt{'a'} array; just push required default value push @{$opt{'a'}}, grep( !/par.pl/, glob '.' ); App::Packer::PAR->new( frontend => 'Module::ScanDeps', backend => 'PAR::Packer', frontopts => \%opt, backopts => \%opt, args => ['par.pl'], )->go; open STDERR, '>&', $olderr; unlink $par_pl; chdir $root; rmove( File::Spec->catfile( 'blib', $par ), $par ); return 1; } #line 401 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Fetch.pm0000644000076500000240000000462711501700065023503 0ustar t0mstaff#line 1 package Module::Install::Fetch; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub get_file { my ($self, %args) = @_; my ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; if ( $scheme eq 'http' and ! eval { require LWP::Simple; 1 } ) { $args{url} = $args{ftp_url} or (warn("LWP support unavailable!\n"), return); ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; } $|++; print "Fetching '$file' from $host... "; unless (eval { require Socket; Socket::inet_aton($host) }) { warn "'$host' resolve failed!\n"; return; } return unless $scheme eq 'ftp' or $scheme eq 'http'; require Cwd; my $dir = Cwd::getcwd(); chdir $args{local_dir} or return if exists $args{local_dir}; if (eval { require LWP::Simple; 1 }) { LWP::Simple::mirror($args{url}, $file); } elsif (eval { require Net::FTP; 1 }) { eval { # use Net::FTP to get past firewall my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600); $ftp->login("anonymous", 'anonymous@example.com'); $ftp->cwd($path); $ftp->binary; $ftp->get($file) or (warn("$!\n"), return); $ftp->quit; } } elsif (my $ftp = $self->can_run('ftp')) { eval { # no Net::FTP, fallback to ftp.exe require FileHandle; my $fh = FileHandle->new; local $SIG{CHLD} = 'IGNORE'; unless ($fh->open("|$ftp -n")) { warn "Couldn't open ftp: $!\n"; chdir $dir; return; } my @dialog = split(/\n/, <<"END_FTP"); open $host user anonymous anonymous\@example.com cd $path binary get $file $file quit END_FTP foreach (@dialog) { $fh->print("$_\n") } $fh->close; } } else { warn "No working 'ftp' program available!\n"; chdir $dir; return; } unless (-f $file) { warn "Fetching failed: $@\n"; chdir $dir; return; } return if exists $args{size} and -s $file != $args{size}; system($args{run}) if exists $args{run}; unlink($file) if $args{remove}; print(((!exists $args{check_for} or -e $args{check_for}) ? "done!" : "failed! ($!)"), "\n"); chdir $dir; return !$?; } 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Include.pm0000644000076500000240000000101511501700064024020 0ustar t0mstaff#line 1 package Module::Install::Include; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub include { shift()->admin->include(@_); } sub include_deps { shift()->admin->include_deps(@_); } sub auto_include { shift()->admin->auto_include(@_); } sub auto_include_deps { shift()->admin->auto_include_deps(@_); } sub auto_include_dependent_dists { shift()->admin->auto_include_dependent_dists(@_); } 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Makefile.pm0000644000076500000240000002703211501700064024161 0ustar t0mstaff#line 1 package Module::Install::Makefile; use strict 'vars'; use ExtUtils::MakeMaker (); use Module::Install::Base (); use Fcntl qw/:flock :seek/; use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub Makefile { $_[0] } my %seen = (); sub prompt { shift; # Infinite loop protection my @c = caller(); if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) { die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])"; } # In automated testing or non-interactive session, always use defaults if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) { local $ENV{PERL_MM_USE_DEFAULT} = 1; goto &ExtUtils::MakeMaker::prompt; } else { goto &ExtUtils::MakeMaker::prompt; } } # Store a cleaned up version of the MakeMaker version, # since we need to behave differently in a variety of # ways based on the MM version. my $makemaker = eval $ExtUtils::MakeMaker::VERSION; # If we are passed a param, do a "newer than" comparison. # Otherwise, just return the MakeMaker version. sub makemaker { ( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0 } # Ripped from ExtUtils::MakeMaker 6.56, and slightly modified # as we only need to know here whether the attribute is an array # or a hash or something else (which may or may not be appendable). my %makemaker_argtype = ( C => 'ARRAY', CONFIG => 'ARRAY', # CONFIGURE => 'CODE', # ignore DIR => 'ARRAY', DL_FUNCS => 'HASH', DL_VARS => 'ARRAY', EXCLUDE_EXT => 'ARRAY', EXE_FILES => 'ARRAY', FUNCLIST => 'ARRAY', H => 'ARRAY', IMPORTS => 'HASH', INCLUDE_EXT => 'ARRAY', LIBS => 'ARRAY', # ignore '' MAN1PODS => 'HASH', MAN3PODS => 'HASH', META_ADD => 'HASH', META_MERGE => 'HASH', PL_FILES => 'HASH', PM => 'HASH', PMLIBDIRS => 'ARRAY', PMLIBPARENTDIRS => 'ARRAY', PREREQ_PM => 'HASH', CONFIGURE_REQUIRES => 'HASH', SKIP => 'ARRAY', TYPEMAPS => 'ARRAY', XS => 'HASH', # VERSION => ['version',''], # ignore # _KEEP_AFTER_FLUSH => '', clean => 'HASH', depend => 'HASH', dist => 'HASH', dynamic_lib=> 'HASH', linkext => 'HASH', macro => 'HASH', postamble => 'HASH', realclean => 'HASH', test => 'HASH', tool_autosplit => 'HASH', # special cases where you can use makemaker_append CCFLAGS => 'APPENDABLE', DEFINE => 'APPENDABLE', INC => 'APPENDABLE', LDDLFLAGS => 'APPENDABLE', LDFROM => 'APPENDABLE', ); sub makemaker_args { my ($self, %new_args) = @_; my $args = ( $self->{makemaker_args} ||= {} ); foreach my $key (keys %new_args) { if ($makemaker_argtype{$key}) { if ($makemaker_argtype{$key} eq 'ARRAY') { $args->{$key} = [] unless defined $args->{$key}; unless (ref $args->{$key} eq 'ARRAY') { $args->{$key} = [$args->{$key}] } push @{$args->{$key}}, ref $new_args{$key} eq 'ARRAY' ? @{$new_args{$key}} : $new_args{$key}; } elsif ($makemaker_argtype{$key} eq 'HASH') { $args->{$key} = {} unless defined $args->{$key}; foreach my $skey (keys %{ $new_args{$key} }) { $args->{$key}{$skey} = $new_args{$key}{$skey}; } } elsif ($makemaker_argtype{$key} eq 'APPENDABLE') { $self->makemaker_append($key => $new_args{$key}); } } else { if (defined $args->{$key}) { warn qq{MakeMaker attribute "$key" is overriden; use "makemaker_append" to append values\n}; } $args->{$key} = $new_args{$key}; } } return $args; } # For mm args that take multiple space-seperated args, # append an argument to the current list. sub makemaker_append { my $self = shift; my $name = shift; my $args = $self->makemaker_args; $args->{$name} = defined $args->{$name} ? join( ' ', $args->{$name}, @_ ) : join( ' ', @_ ); } sub build_subdirs { my $self = shift; my $subdirs = $self->makemaker_args->{DIR} ||= []; for my $subdir (@_) { push @$subdirs, $subdir; } } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join ' ', grep { length $_ } ($clean->{FILES} || (), @_), ); } sub realclean_files { my $self = shift; my $realclean = $self->makemaker_args->{realclean} ||= {}; %$realclean = ( %$realclean, FILES => join ' ', grep { length $_ } ($realclean->{FILES} || (), @_), ); } sub libs { my $self = shift; my $libs = ref $_[0] ? shift : [ shift ]; $self->makemaker_args( LIBS => $libs ); } sub inc { my $self = shift; $self->makemaker_args( INC => shift ); } sub _wanted_t { } sub tests_recursive { my $self = shift; my $dir = shift || 't'; unless ( -d $dir ) { die "tests_recursive dir '$dir' does not exist"; } my %tests = map { $_ => 1 } split / /, ($self->tests || ''); require File::Find; File::Find::find( sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 }, $dir ); $self->tests( join ' ', sort keys %tests ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; # Check the current Perl version my $perl_version = $self->perl_version; if ( $perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; } # Make sure we have a new enough MakeMaker require ExtUtils::MakeMaker; if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) { # MakeMaker can complain about module versions that include # an underscore, even though its own version may contain one! # Hence the funny regexp to get rid of it. See RT #35800 # for details. my $v = $ExtUtils::MakeMaker::VERSION =~ /^(\d+\.\d+)/; $self->build_requires( 'ExtUtils::MakeMaker' => $v ); $self->configure_requires( 'ExtUtils::MakeMaker' => $v ); } else { # Allow legacy-compatibility with 5.005 by depending on the # most recent EU:MM that supported 5.005. $self->build_requires( 'ExtUtils::MakeMaker' => 6.42 ); $self->configure_requires( 'ExtUtils::MakeMaker' => 6.42 ); } # Generate the MakeMaker params my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name; $args->{NAME} =~ s/-/::/g; $args->{VERSION} = $self->version or die <<'EOT'; ERROR: Can't determine distribution version. Please specify it explicitly via 'version' in Makefile.PL, or set a valid $VERSION in a module, and provide its file path via 'version_from' (or 'all_from' if you prefer) in Makefile.PL. EOT $DB::single = 1; if ( $self->tests ) { my @tests = split ' ', $self->tests; my %seen; $args->{test} = { TESTS => (join ' ', grep {!$seen{$_}++} @tests), }; } elsif ( $Module::Install::ExtraTests::use_extratests ) { # Module::Install::ExtraTests doesn't set $self->tests and does its own tests via harness. # So, just ignore our xt tests here. } elsif ( -d 'xt' and ($Module::Install::AUTHOR or $ENV{RELEASE_TESTING}) ) { $args->{test} = { TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ t xt } ), }; } if ( $] >= 5.005 ) { $args->{ABSTRACT} = $self->abstract; $args->{AUTHOR} = join ', ', @{$self->author || []}; } if ( $self->makemaker(6.10) ) { $args->{NO_META} = 1; #$args->{NO_MYMETA} = 1; } if ( $self->makemaker(6.17) and $self->sign ) { $args->{SIGN} = 1; } unless ( $self->is_admin ) { delete $args->{SIGN}; } if ( $self->makemaker(6.31) and $self->license ) { $args->{LICENSE} = $self->license; } my $prereq = ($args->{PREREQ_PM} ||= {}); %$prereq = ( %$prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->requires) ); # Remove any reference to perl, PREREQ_PM doesn't support it delete $args->{PREREQ_PM}->{perl}; # Merge both kinds of requires into BUILD_REQUIRES my $build_prereq = ($args->{BUILD_REQUIRES} ||= {}); %$build_prereq = ( %$build_prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->configure_requires, $self->build_requires) ); # Remove any reference to perl, BUILD_REQUIRES doesn't support it delete $args->{BUILD_REQUIRES}->{perl}; # Delete bundled dists from prereq_pm, add it to Makefile DIR my $subdirs = ($args->{DIR} || []); if ($self->bundles) { my %processed; foreach my $bundle (@{ $self->bundles }) { my ($mod_name, $dist_dir) = @$bundle; delete $prereq->{$mod_name}; $dist_dir = File::Basename::basename($dist_dir); # dir for building this module if (not exists $processed{$dist_dir}) { if (-d $dist_dir) { # List as sub-directory to be processed by make push @$subdirs, $dist_dir; } # Else do nothing: the module is already present on the system $processed{$dist_dir} = undef; } } } unless ( $self->makemaker('6.55_03') ) { %$prereq = (%$prereq,%$build_prereq); delete $args->{BUILD_REQUIRES}; } if ( my $perl_version = $self->perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; if ( $self->makemaker(6.48) ) { $args->{MIN_PERL_VERSION} = $perl_version; } } if ($self->installdirs) { warn qq{old INSTALLDIRS (probably set by makemaker_args) is overriden by installdirs\n} if $args->{INSTALLDIRS}; $args->{INSTALLDIRS} = $self->installdirs; } my %args = map { ( $_ => $args->{$_} ) } grep {defined($args->{$_} ) } keys %$args; my $user_preop = delete $args{dist}->{PREOP}; if ( my $preop = $self->admin->preop($user_preop) ) { foreach my $key ( keys %$preop ) { $args{dist}->{$key} = $preop->{$key}; } } my $mm = ExtUtils::MakeMaker::WriteMakefile(%args); $self->fix_up_makefile($mm->{FIRST_MAKEFILE} || 'Makefile'); } sub fix_up_makefile { my $self = shift; my $makefile_name = shift; my $top_class = ref($self->_top) || ''; my $top_version = $self->_top->VERSION || ''; my $preamble = $self->preamble ? "# Preamble by $top_class $top_version\n" . $self->preamble : ''; my $postamble = "# Postamble by $top_class $top_version\n" . ($self->postamble || ''); local *MAKEFILE; open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!"; eval { flock MAKEFILE, LOCK_EX }; my $makefile = do { local $/; }; $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /; $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g; $makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g; $makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m; $makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m; # Module::Install will never be used to build the Core Perl # Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks # PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist $makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m; #$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m; # Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well. $makefile =~ s/(\"?)-I\$\(PERL_LIB\)\1//g; # XXX - This is currently unused; not sure if it breaks other MM-users # $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg; seek MAKEFILE, 0, SEEK_SET; truncate MAKEFILE, 0; print MAKEFILE "$preamble$makefile$postamble" or die $!; close MAKEFILE or die $!; 1; } sub preamble { my ($self, $text) = @_; $self->{preamble} = $text . $self->{preamble} if defined $text; $self->{preamble}; } sub postamble { my ($self, $text) = @_; $self->{postamble} ||= $self->admin->postamble; $self->{postamble} .= $text if defined $text; $self->{postamble} } 1; __END__ #line 541 Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Metadata.pm0000644000076500000240000004302011501700064024157 0ustar t0mstaff#line 1 package Module::Install::Metadata; use strict 'vars'; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } my @boolean_keys = qw{ sign }; my @scalar_keys = qw{ name module_name abstract version distribution_type tests installdirs }; my @tuple_keys = qw{ configure_requires build_requires requires recommends bundles resources }; my @resource_keys = qw{ homepage bugtracker repository }; my @array_keys = qw{ keywords author }; *authors = \&author; sub Meta { shift } sub Meta_BooleanKeys { @boolean_keys } sub Meta_ScalarKeys { @scalar_keys } sub Meta_TupleKeys { @tuple_keys } sub Meta_ResourceKeys { @resource_keys } sub Meta_ArrayKeys { @array_keys } foreach my $key ( @boolean_keys ) { *$key = sub { my $self = shift; if ( defined wantarray and not @_ ) { return $self->{values}->{$key}; } $self->{values}->{$key} = ( @_ ? $_[0] : 1 ); return $self; }; } foreach my $key ( @scalar_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} = shift; return $self; }; } foreach my $key ( @array_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} ||= []; push @{$self->{values}->{$key}}, @_; return $self; }; } foreach my $key ( @resource_keys ) { *$key = sub { my $self = shift; unless ( @_ ) { return () unless $self->{values}->{resources}; return map { $_->[1] } grep { $_->[0] eq $key } @{ $self->{values}->{resources} }; } return $self->{values}->{resources}->{$key} unless @_; my $uri = shift or die( "Did not provide a value to $key()" ); $self->resources( $key => $uri ); return 1; }; } foreach my $key ( grep { $_ ne "resources" } @tuple_keys) { *$key = sub { my $self = shift; return $self->{values}->{$key} unless @_; my @added; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @added, [ $module, $version ]; } push @{ $self->{values}->{$key} }, @added; return map {@$_} @added; }; } # Resource handling my %lc_resource = map { $_ => 1 } qw{ homepage license bugtracker repository }; sub resources { my $self = shift; while ( @_ ) { my $name = shift or last; my $value = shift or next; if ( $name eq lc $name and ! $lc_resource{$name} ) { die("Unsupported reserved lowercase resource '$name'"); } $self->{values}->{resources} ||= []; push @{ $self->{values}->{resources} }, [ $name, $value ]; } $self->{values}->{resources}; } # Aliases for build_requires that will have alternative # meanings in some future version of META.yml. sub test_requires { shift->build_requires(@_) } sub install_requires { shift->build_requires(@_) } # Aliases for installdirs options sub install_as_core { $_[0]->installdirs('perl') } sub install_as_cpan { $_[0]->installdirs('site') } sub install_as_site { $_[0]->installdirs('site') } sub install_as_vendor { $_[0]->installdirs('vendor') } sub dynamic_config { my $self = shift; unless ( @_ ) { warn "You MUST provide an explicit true/false value to dynamic_config\n"; return $self; } $self->{values}->{dynamic_config} = $_[0] ? 1 : 0; return 1; } sub perl_version { my $self = shift; return $self->{values}->{perl_version} unless @_; my $version = shift or die( "Did not provide a value to perl_version()" ); # Normalize the version $version = $self->_perl_version($version); # We don't support the reall old versions unless ( $version >= 5.005 ) { die "Module::Install only supports 5.005 or newer (use ExtUtils::MakeMaker)\n"; } $self->{values}->{perl_version} = $version; } sub all_from { my ( $self, $file ) = @_; unless ( defined($file) ) { my $name = $self->name or die( "all_from called with no args without setting name() first" ); $file = join('/', 'lib', split(/-/, $name)) . '.pm'; $file =~ s{.*/}{} unless -e $file; unless ( -e $file ) { die("all_from cannot find $file from $name"); } } unless ( -f $file ) { die("The path '$file' does not exist, or is not a file"); } $self->{values}{all_from} = $file; # Some methods pull from POD instead of code. # If there is a matching .pod, use that instead my $pod = $file; $pod =~ s/\.pm$/.pod/i; $pod = $file unless -e $pod; # Pull the different values $self->name_from($file) unless $self->name; $self->version_from($file) unless $self->version; $self->perl_version_from($file) unless $self->perl_version; $self->author_from($pod) unless @{$self->author || []}; $self->license_from($pod) unless $self->license; $self->abstract_from($pod) unless $self->abstract; return 1; } sub provides { my $self = shift; my $provides = ( $self->{values}->{provides} ||= {} ); %$provides = (%$provides, @_) if @_; return $provides; } sub auto_provides { my $self = shift; return $self unless $self->is_admin; unless (-e 'MANIFEST') { warn "Cannot deduce auto_provides without a MANIFEST, skipping\n"; return $self; } # Avoid spurious warnings as we are not checking manifest here. local $SIG{__WARN__} = sub {1}; require ExtUtils::Manifest; local *ExtUtils::Manifest::manicheck = sub { return }; require Module::Build; my $build = Module::Build->new( dist_name => $self->name, dist_version => $self->version, license => $self->license, ); $self->provides( %{ $build->find_dist_packages || {} } ); } sub feature { my $self = shift; my $name = shift; my $features = ( $self->{values}->{features} ||= [] ); my $mods; if ( @_ == 1 and ref( $_[0] ) ) { # The user used ->feature like ->features by passing in the second # argument as a reference. Accomodate for that. $mods = $_[0]; } else { $mods = \@_; } my $count = 0; push @$features, ( $name => [ map { ref($_) ? ( ref($_) eq 'HASH' ) ? %$_ : @$_ : $_ } @$mods ] ); return @$features; } sub features { my $self = shift; while ( my ( $name, $mods ) = splice( @_, 0, 2 ) ) { $self->feature( $name, @$mods ); } return $self->{values}->{features} ? @{ $self->{values}->{features} } : (); } sub no_index { my $self = shift; my $type = shift; push @{ $self->{values}->{no_index}->{$type} }, @_ if $type; return $self->{values}->{no_index}; } sub read { my $self = shift; $self->include_deps( 'YAML::Tiny', 0 ); require YAML::Tiny; my $data = YAML::Tiny::LoadFile('META.yml'); # Call methods explicitly in case user has already set some values. while ( my ( $key, $value ) = each %$data ) { next unless $self->can($key); if ( ref $value eq 'HASH' ) { while ( my ( $module, $version ) = each %$value ) { $self->can($key)->($self, $module => $version ); } } else { $self->can($key)->($self, $value); } } return $self; } sub write { my $self = shift; return $self unless $self->is_admin; $self->admin->write_meta; return $self; } sub version_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->version( ExtUtils::MM_Unix->parse_version($file) ); # for version integrity check $self->makemaker_args( VERSION_FROM => $file ); } sub abstract_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix' )->parse_abstract($file) ); } # Add both distribution and module name sub name_from { my ($self, $file) = @_; if ( Module::Install::_read($file) =~ m/ ^ \s* package \s* ([\w:]+) \s* ; /ixms ) { my ($name, $module_name) = ($1, $1); $name =~ s{::}{-}g; $self->name($name); unless ( $self->module_name ) { $self->module_name($module_name); } } else { die("Cannot determine name from $file\n"); } } sub _extract_perl_version { if ( $_[0] =~ m/ ^\s* (?:use|require) \s* v? ([\d_\.]+) \s* ; /ixms ) { my $perl_version = $1; $perl_version =~ s{_}{}g; return $perl_version; } else { return; } } sub perl_version_from { my $self = shift; my $perl_version=_extract_perl_version(Module::Install::_read($_[0])); if ($perl_version) { $self->perl_version($perl_version); } else { warn "Cannot determine perl version info from $_[0]\n"; return; } } sub author_from { my $self = shift; my $content = Module::Install::_read($_[0]); if ($content =~ m/ =head \d \s+ (?:authors?)\b \s* ([^\n]*) | =head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b \s* .*? copyright .*? \d\d\d[\d.]+ \s* (?:\bby\b)? \s* ([^\n]*) /ixms) { my $author = $1 || $2; # XXX: ugly but should work anyway... if (eval "require Pod::Escapes; 1") { # Pod::Escapes has a mapping table. # It's in core of perl >= 5.9.3, and should be installed # as one of the Pod::Simple's prereqs, which is a prereq # of Pod::Text 3.x (see also below). $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $Pod::Escapes::Name2character_number{$1} ? chr($Pod::Escapes::Name2character_number{$1}) : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) { # Pod::Text < 3.0 has yet another mapping table, # though the table name of 2.x and 1.x are different. # (1.x is in core of Perl < 5.6, 2.x is in core of # Perl < 5.9.3) my $mapping = ($Pod::Text::VERSION < 2) ? \%Pod::Text::HTML_Escapes : \%Pod::Text::ESCAPES; $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $mapping->{$1} ? $mapping->{$1} : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } else { $author =~ s{E}{<}g; $author =~ s{E}{>}g; } $self->author($author); } else { warn "Cannot determine author info from $_[0]\n"; } } #Stolen from M::B my %license_urls = ( perl => 'http://dev.perl.org/licenses/', apache => 'http://apache.org/licenses/LICENSE-2.0', apache_1_1 => 'http://apache.org/licenses/LICENSE-1.1', artistic => 'http://opensource.org/licenses/artistic-license.php', artistic_2 => 'http://opensource.org/licenses/artistic-license-2.0.php', lgpl => 'http://opensource.org/licenses/lgpl-license.php', lgpl2 => 'http://opensource.org/licenses/lgpl-2.1.php', lgpl3 => 'http://opensource.org/licenses/lgpl-3.0.html', bsd => 'http://opensource.org/licenses/bsd-license.php', gpl => 'http://opensource.org/licenses/gpl-license.php', gpl2 => 'http://opensource.org/licenses/gpl-2.0.php', gpl3 => 'http://opensource.org/licenses/gpl-3.0.html', mit => 'http://opensource.org/licenses/mit-license.php', mozilla => 'http://opensource.org/licenses/mozilla1.1.php', open_source => undef, unrestricted => undef, restrictive => undef, unknown => undef, ); sub license { my $self = shift; return $self->{values}->{license} unless @_; my $license = shift or die( 'Did not provide a value to license()' ); $license = __extract_license($license) || lc $license; $self->{values}->{license} = $license; # Automatically fill in license URLs if ( $license_urls{$license} ) { $self->resources( license => $license_urls{$license} ); } return 1; } sub _extract_license { my $pod = shift; my $matched; return __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ L(?i:ICEN[CS]E|ICENSING)\b.*?) (=head \d.*|=cut.*|)\z /xms ) || __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ (?:C(?i:OPYRIGHTS?)|L(?i:EGAL))\b.*?) (=head \d.*|=cut.*|)\z /xms ); } sub __extract_license { my $license_text = shift or return; my @phrases = ( '(?:under )?the same (?:terms|license) as (?:perl|the perl (?:\d )?programming language)' => 'perl', 1, '(?:under )?the terms of (?:perl|the perl programming language) itself' => 'perl', 1, 'Artistic and GPL' => 'perl', 1, 'GNU general public license' => 'gpl', 1, 'GNU public license' => 'gpl', 1, 'GNU lesser general public license' => 'lgpl', 1, 'GNU lesser public license' => 'lgpl', 1, 'GNU library general public license' => 'lgpl', 1, 'GNU library public license' => 'lgpl', 1, 'GNU Free Documentation license' => 'unrestricted', 1, 'GNU Affero General Public License' => 'open_source', 1, '(?:Free)?BSD license' => 'bsd', 1, 'Artistic license' => 'artistic', 1, 'Apache (?:Software )?license' => 'apache', 1, 'GPL' => 'gpl', 1, 'LGPL' => 'lgpl', 1, 'BSD' => 'bsd', 1, 'Artistic' => 'artistic', 1, 'MIT' => 'mit', 1, 'Mozilla Public License' => 'mozilla', 1, 'Q Public License' => 'open_source', 1, 'OpenSSL License' => 'unrestricted', 1, 'SSLeay License' => 'unrestricted', 1, 'zlib License' => 'open_source', 1, 'proprietary' => 'proprietary', 0, ); while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) { $pattern =~ s#\s+#\\s+#gs; if ( $license_text =~ /\b$pattern\b/i ) { return $license; } } return ''; } sub license_from { my $self = shift; if (my $license=_extract_license(Module::Install::_read($_[0]))) { $self->license($license); } else { warn "Cannot determine license info from $_[0]\n"; return 'unknown'; } } sub _extract_bugtracker { my @links = $_[0] =~ m#L<( \Qhttp://rt.cpan.org/\E[^>]+| \Qhttp://github.com/\E[\w_]+/[\w_]+/issues| \Qhttp://code.google.com/p/\E[\w_\-]+/issues/list )>#gx; my %links; @links{@links}=(); @links=keys %links; return @links; } sub bugtracker_from { my $self = shift; my $content = Module::Install::_read($_[0]); my @links = _extract_bugtracker($content); unless ( @links ) { warn "Cannot determine bugtracker info from $_[0]\n"; return 0; } if ( @links > 1 ) { warn "Found more than one bugtracker link in $_[0]\n"; return 0; } # Set the bugtracker bugtracker( $links[0] ); return 1; } sub requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->requires( $module => $version ); } } sub test_requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->test_requires( $module => $version ); } } # Convert triple-part versions (eg, 5.6.1 or 5.8.9) to # numbers (eg, 5.006001 or 5.008009). # Also, convert double-part versions (eg, 5.8) sub _perl_version { my $v = $_[-1]; $v =~ s/^([1-9])\.([1-9]\d?\d?)$/sprintf("%d.%03d",$1,$2)/e; $v =~ s/^([1-9])\.([1-9]\d?\d?)\.(0|[1-9]\d?\d?)$/sprintf("%d.%03d%03d",$1,$2,$3 || 0)/e; $v =~ s/(\.\d\d\d)000$/$1/; $v =~ s/_.+$//; if ( ref($v) ) { # Numify $v = $v + 0; } return $v; } sub add_metadata { my $self = shift; my %hash = @_; for my $key (keys %hash) { warn "add_metadata: $key is not prefixed with 'x_'.\n" . "Use appopriate function to add non-private metadata.\n" unless $key =~ /^x_/; $self->{values}->{$key} = $hash{$key}; } } ###################################################################### # MYMETA Support sub WriteMyMeta { die "WriteMyMeta has been deprecated"; } sub write_mymeta_yaml { my $self = shift; # We need YAML::Tiny to write the MYMETA.yml file unless ( eval { require YAML::Tiny; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.yml\n"; YAML::Tiny::DumpFile('MYMETA.yml', $meta); } sub write_mymeta_json { my $self = shift; # We need JSON to write the MYMETA.json file unless ( eval { require JSON; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.json\n"; Module::Install::_write( 'MYMETA.json', JSON->new->pretty(1)->canonical->encode($meta), ); } sub _write_mymeta_data { my $self = shift; # If there's no existing META.yml there is nothing we can do return undef unless -f 'META.yml'; # We need Parse::CPAN::Meta to load the file unless ( eval { require Parse::CPAN::Meta; 1; } ) { return undef; } # Merge the perl version into the dependencies my $val = $self->Meta->{values}; my $perl = delete $val->{perl_version}; if ( $perl ) { $val->{requires} ||= []; my $requires = $val->{requires}; # Canonize to three-dot version after Perl 5.6 if ( $perl >= 5.006 ) { $perl =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2||0), int($3||0))}e } unshift @$requires, [ perl => $perl ]; } # Load the advisory META.yml file my @yaml = Parse::CPAN::Meta::LoadFile('META.yml'); my $meta = $yaml[0]; # Overwrite the non-configure dependency hashs delete $meta->{requires}; delete $meta->{build_requires}; delete $meta->{recommends}; if ( exists $val->{requires} ) { $meta->{requires} = { map { @$_ } @{ $val->{requires} } }; } if ( exists $val->{build_requires} ) { $meta->{build_requires} = { map { @$_ } @{ $val->{build_requires} } }; } return $meta; } 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/Win32.pm0000644000076500000240000000340311501700065023343 0ustar t0mstaff#line 1 package Module::Install::Win32; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # determine if the user needs nmake, and download it if needed sub check_nmake { my $self = shift; $self->load('can_run'); $self->load('get_file'); require Config; return unless ( $^O eq 'MSWin32' and $Config::Config{make} and $Config::Config{make} =~ /^nmake\b/i and ! $self->can_run('nmake') ); print "The required 'nmake' executable not found, fetching it...\n"; require File::Basename; my $rv = $self->get_file( url => 'http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe', ftp_url => 'ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe', local_dir => File::Basename::dirname($^X), size => 51928, run => 'Nmake15.exe /o > nul', check_for => 'Nmake.exe', remove => 1, ); die <<'END_MESSAGE' unless $rv; ------------------------------------------------------------------------------- Since you are using Microsoft Windows, you will need the 'nmake' utility before installation. It's available at: http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe or ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe Please download the file manually, save it to a directory in %PATH% (e.g. C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to that directory, and run "Nmake15.exe" from there; that will create the 'nmake.exe' file needed by this module. You may then resume the installation process described in README. ------------------------------------------------------------------------------- END_MESSAGE } 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install/WriteAll.pm0000644000076500000240000000237611501700065024174 0ustar t0mstaff#line 1 package Module::Install::WriteAll; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.99'; @ISA = qw{Module::Install::Base}; $ISCORE = 1; } sub WriteAll { my $self = shift; my %args = ( meta => 1, sign => 0, inline => 0, check_nmake => 1, @_, ); $self->sign(1) if $args{sign}; $self->admin->WriteAll(%args) if $self->is_admin; $self->check_nmake if $args{check_nmake}; unless ( $self->makemaker_args->{PL_FILES} ) { # XXX: This still may be a bit over-defensive... unless ($self->makemaker(6.25)) { $self->makemaker_args( PL_FILES => {} ) if -f 'Build.PL'; } } # Until ExtUtils::MakeMaker support MYMETA.yml, make sure # we clean it up properly ourself. $self->realclean_files('MYMETA.yml'); if ( $args{inline} ) { $self->Inline->write; } else { $self->Makefile->write; } # The Makefile write process adds a couple of dependencies, # so write the META.yml files after the Makefile. if ( $args{meta} ) { $self->Meta->write; } # Experimental support for MYMETA if ( $ENV{X_MYMETA} ) { if ( $ENV{X_MYMETA} eq 'JSON' ) { $self->Meta->write_mymeta_json; } else { $self->Meta->write_mymeta_yaml; } } return 1; } 1; Catalyst-View-Component-SubInclude-0.10/inc/Module/Install.pm0000644000076500000240000003002611501700064022441 0ustar t0mstaff#line 1 package Module::Install; # For any maintainers: # The load order for Module::Install is a bit magic. # It goes something like this... # # IF ( host has Module::Install installed, creating author mode ) { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to installed version of inc::Module::Install # 3. The installed version of inc::Module::Install loads # 4. inc::Module::Install calls "require Module::Install" # 5. The ./inc/ version of Module::Install loads # } ELSE { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to ./inc/ version of Module::Install # 3. The ./inc/ version of Module::Install loads # } use 5.005; use strict 'vars'; use Cwd (); use File::Find (); use File::Path (); use vars qw{$VERSION $MAIN}; BEGIN { # All Module::Install core packages now require synchronised versions. # This will be used to ensure we don't accidentally load old or # different versions of modules. # This is not enforced yet, but will be some time in the next few # releases once we can make sure it won't clash with custom # Module::Install extensions. $VERSION = '0.99'; # Storage for the pseudo-singleton $MAIN = undef; *inc::Module::Install::VERSION = *VERSION; @inc::Module::Install::ISA = __PACKAGE__; } sub import { my $class = shift; my $self = $class->new(@_); my $who = $self->_caller; #------------------------------------------------------------- # all of the following checks should be included in import(), # to allow "eval 'require Module::Install; 1' to test # installation of Module::Install. (RT #51267) #------------------------------------------------------------- # Whether or not inc::Module::Install is actually loaded, the # $INC{inc/Module/Install.pm} is what will still get set as long as # the caller loaded module this in the documented manner. # If not set, the caller may NOT have loaded the bundled version, and thus # they may not have a MI version that works with the Makefile.PL. This would # result in false errors or unexpected behaviour. And we don't want that. my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm'; unless ( $INC{$file} ) { die <<"END_DIE" } Please invoke ${\__PACKAGE__} with: use inc::${\__PACKAGE__}; not: use ${\__PACKAGE__}; END_DIE # This reportedly fixes a rare Win32 UTC file time issue, but # as this is a non-cross-platform XS module not in the core, # we shouldn't really depend on it. See RT #24194 for detail. # (Also, this module only supports Perl 5.6 and above). eval "use Win32::UTCFileTime" if $^O eq 'MSWin32' && $] >= 5.006; # If the script that is loading Module::Install is from the future, # then make will detect this and cause it to re-run over and over # again. This is bad. Rather than taking action to touch it (which # is unreliable on some platforms and requires write permissions) # for now we should catch this and refuse to run. if ( -f $0 ) { my $s = (stat($0))[9]; # If the modification time is only slightly in the future, # sleep briefly to remove the problem. my $a = $s - time; if ( $a > 0 and $a < 5 ) { sleep 5 } # Too far in the future, throw an error. my $t = time; if ( $s > $t ) { die <<"END_DIE" } Your installer $0 has a modification time in the future ($s > $t). This is known to create infinite loops in make. Please correct this, then run $0 again. END_DIE } # Build.PL was formerly supported, but no longer is due to excessive # difficulty in implementing every single feature twice. if ( $0 =~ /Build.PL$/i ) { die <<"END_DIE" } Module::Install no longer supports Build.PL. It was impossible to maintain duel backends, and has been deprecated. Please remove all Build.PL files and only use the Makefile.PL installer. END_DIE #------------------------------------------------------------- # To save some more typing in Module::Install installers, every... # use inc::Module::Install # ...also acts as an implicit use strict. $^H |= strict::bits(qw(refs subs vars)); #------------------------------------------------------------- unless ( -f $self->{file} ) { foreach my $key (keys %INC) { delete $INC{$key} if $key =~ /Module\/Install/; } local $^W; require "$self->{path}/$self->{dispatch}.pm"; File::Path::mkpath("$self->{prefix}/$self->{author}"); $self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top => $self ); $self->{admin}->init; @_ = ($class, _self => $self); goto &{"$self->{name}::import"}; } local $^W; *{"${who}::AUTOLOAD"} = $self->autoload; $self->preload; # Unregister loader and worker packages so subdirs can use them again delete $INC{'inc/Module/Install.pm'}; delete $INC{'Module/Install.pm'}; # Save to the singleton $MAIN = $self; return 1; } sub autoload { my $self = shift; my $who = $self->_caller; my $cwd = Cwd::cwd(); my $sym = "${who}::AUTOLOAD"; $sym->{$cwd} = sub { my $pwd = Cwd::cwd(); if ( my $code = $sym->{$pwd} ) { # Delegate back to parent dirs goto &$code unless $cwd eq $pwd; } unless ($$sym =~ s/([^:]+)$//) { # XXX: it looks like we can't retrieve the missing function # via $$sym (usually $main::AUTOLOAD) in this case. # I'm still wondering if we should slurp Makefile.PL to # get some context or not ... my ($package, $file, $line) = caller; die <<"EOT"; Unknown function is found at $file line $line. Execution of $file aborted due to runtime errors. If you're a contributor to a project, you may need to install some Module::Install extensions from CPAN (or other repository). If you're a user of a module, please contact the author. EOT } my $method = $1; if ( uc($method) eq $method ) { # Do nothing return; } elsif ( $method =~ /^_/ and $self->can($method) ) { # Dispatch to the root M:I class return $self->$method(@_); } # Dispatch to the appropriate plugin unshift @_, ( $self, $1 ); goto &{$self->can('call')}; }; } sub preload { my $self = shift; unless ( $self->{extensions} ) { $self->load_extensions( "$self->{prefix}/$self->{path}", $self ); } my @exts = @{$self->{extensions}}; unless ( @exts ) { @exts = $self->{admin}->load_all_extensions; } my %seen; foreach my $obj ( @exts ) { while (my ($method, $glob) = each %{ref($obj) . '::'}) { next unless $obj->can($method); next if $method =~ /^_/; next if $method eq uc($method); $seen{$method}++; } } my $who = $self->_caller; foreach my $name ( sort keys %seen ) { local $^W; *{"${who}::$name"} = sub { ${"${who}::AUTOLOAD"} = "${who}::$name"; goto &{"${who}::AUTOLOAD"}; }; } } sub new { my ($class, %args) = @_; delete $INC{'FindBin.pm'}; require FindBin; # ignore the prefix on extension modules built from top level. my $base_path = Cwd::abs_path($FindBin::Bin); unless ( Cwd::abs_path(Cwd::cwd()) eq $base_path ) { delete $args{prefix}; } return $args{_self} if $args{_self}; $args{dispatch} ||= 'Admin'; $args{prefix} ||= 'inc'; $args{author} ||= ($^O eq 'VMS' ? '_author' : '.author'); $args{bundle} ||= 'inc/BUNDLES'; $args{base} ||= $base_path; $class =~ s/^\Q$args{prefix}\E:://; $args{name} ||= $class; $args{version} ||= $class->VERSION; unless ( $args{path} ) { $args{path} = $args{name}; $args{path} =~ s!::!/!g; } $args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm"; $args{wrote} = 0; bless( \%args, $class ); } sub call { my ($self, $method) = @_; my $obj = $self->load($method) or return; splice(@_, 0, 2, $obj); goto &{$obj->can($method)}; } sub load { my ($self, $method) = @_; $self->load_extensions( "$self->{prefix}/$self->{path}", $self ) unless $self->{extensions}; foreach my $obj (@{$self->{extensions}}) { return $obj if $obj->can($method); } my $admin = $self->{admin} or die <<"END_DIE"; The '$method' method does not exist in the '$self->{prefix}' path! Please remove the '$self->{prefix}' directory and run $0 again to load it. END_DIE my $obj = $admin->load($method, 1); push @{$self->{extensions}}, $obj; $obj; } sub load_extensions { my ($self, $path, $top) = @_; my $should_reload = 0; unless ( grep { ! ref $_ and lc $_ eq lc $self->{prefix} } @INC ) { unshift @INC, $self->{prefix}; $should_reload = 1; } foreach my $rv ( $self->find_extensions($path) ) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; local $@; my $new = eval { local $^W; require $file; $pkg->can('new') }; unless ( $new ) { warn $@ if $@; next; } $self->{pathnames}{$pkg} = $should_reload ? delete $INC{$file} : $INC{$file}; push @{$self->{extensions}}, &{$new}($pkg, _top => $top ); } $self->{extensions} ||= []; } sub find_extensions { my ($self, $path) = @_; my @found; File::Find::find( sub { my $file = $File::Find::name; return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is; my $subpath = $1; return if lc($subpath) eq lc($self->{dispatch}); $file = "$self->{path}/$subpath.pm"; my $pkg = "$self->{name}::$subpath"; $pkg =~ s!/!::!g; # If we have a mixed-case package name, assume case has been preserved # correctly. Otherwise, root through the file to locate the case-preserved # version of the package name. if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) { my $content = Module::Install::_read($subpath . '.pm'); my $in_pod = 0; foreach ( split //, $content ) { $in_pod = 1 if /^=\w/; $in_pod = 0 if /^=cut/; next if ($in_pod || /^=cut/); # skip pod text next if /^\s*#/; # and comments if ( m/^\s*package\s+($pkg)\s*;/i ) { $pkg = $1; last; } } } push @found, [ $file, $pkg ]; }, $path ) if -d $path; @found; } ##################################################################### # Common Utility Functions sub _caller { my $depth = 0; my $call = caller($depth); while ( $call eq __PACKAGE__ ) { $depth++; $call = caller($depth); } return $call; } # Done in evals to avoid confusing Perl::MinimumVersion eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@; sub _read { local *FH; open( FH, '<', $_[0] ) or die "open($_[0]): $!"; my $string = do { local $/; }; close FH or die "close($_[0]): $!"; return $string; } END_NEW sub _read { local *FH; open( FH, "< $_[0]" ) or die "open($_[0]): $!"; my $string = do { local $/; }; close FH or die "close($_[0]): $!"; return $string; } END_OLD sub _readperl { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; $string =~ s/(\n)\n*__(?:DATA|END)__\b.*\z/$1/s; $string =~ s/\n\n=\w+.+?\n\n=cut\b.+?\n+/\n\n/sg; return $string; } sub _readpod { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; return $string if $_[0] =~ /\.pod\z/; $string =~ s/(^|\n=cut\b.+?\n+)[^=\s].+?\n(\n=\w+|\z)/$1$2/sg; $string =~ s/\n*=pod\b[^\n]*\n+/\n\n/sg; $string =~ s/\n*=cut\b[^\n]*\n+/\n\n/sg; $string =~ s/^\n+//s; return $string; } # Done in evals to avoid confusing Perl::MinimumVersion eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@; sub _write { local *FH; open( FH, '>', $_[0] ) or die "open($_[0]): $!"; foreach ( 1 .. $#_ ) { print FH $_[$_] or die "print($_[0]): $!"; } close FH or die "close($_[0]): $!"; } END_NEW sub _write { local *FH; open( FH, "> $_[0]" ) or die "open($_[0]): $!"; foreach ( 1 .. $#_ ) { print FH $_[$_] or die "print($_[0]): $!"; } close FH or die "close($_[0]): $!"; } END_OLD # _version is for processing module versions (eg, 1.03_05) not # Perl versions (eg, 5.8.1). sub _version ($) { my $s = shift || 0; my $d =()= $s =~ /(\.)/g; if ( $d >= 2 ) { # Normalise multipart versions $s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg; } $s =~ s/^(\d+)\.?//; my $l = $1 || 0; my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g; $l = $l . '.' . join '', @v if @v; return $l + 0; } sub _cmp ($$) { _version($_[0]) <=> _version($_[1]); } # Cloned from Params::Util::_CLASS sub _CLASS ($) { ( defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s ) ? $_[0] : undef; } 1; # Copyright 2008 - 2010 Adam Kennedy. Catalyst-View-Component-SubInclude-0.10/lib/0000755000076500000240000000000011501700151017241 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/lib/Catalyst/0000755000076500000240000000000011501700151021025 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/0000755000076500000240000000000011501700151021737 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/0000755000076500000240000000000011501700151023701 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/SubInclude/0000755000076500000240000000000011501700151025736 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/SubInclude/ESI.pm0000644000076500000240000000432511477771143026745 0ustar t0mstaffpackage Catalyst::View::Component::SubInclude::ESI; use Moose; use namespace::clean -except => 'meta'; =head1 NAME Catalyst::View::Component::SubInclude::ESI - Edge Side Includes (ESI) plugin for C::V::Component::SubInclude =head1 VERSION Version 0.07_03 =cut our $VERSION = '0.07_03'; $VERSION = eval $VERSION; =head1 SYNOPSIS In your view class: package MyApp::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( subinclude_plugin => 'ESI' ); Then, somewhere in your templates: [% subinclude('/my/widget') %] =head1 DESCRIPTION C renders C calls as Edge Side Includes (ESI) include directives. This is a feature implemented by Varnish (L) which allows cache-efficient uses of includes. =head1 METHODS =head2 C Note that C<$path> should be the private action path - translation to the public path is handled internally. After translation, this will roughly translate to the following code: my $url = $c->uri_for( $translated_path, @args )->path_query; return ''; Notice that the stash will always be empty. This behavior could be configurable in the future through an additional switch - for now, this behavior guarantees a common interface for plugins. =cut sub generate_subinclude { my ($self, $c, $path, @params) = @_; my $uri = $c->uri_for_action( $path, @params ); return ''; } =head1 SEE ALSO L, L, L =head1 AUTHOR Nilson Santos Figueiredo Junior, C<< >> =head1 SPONSORSHIP Development sponsored by Ionzero LLC L. =head1 COPYRIGHT & LICENSE Copyright (C) 2009 Nilson Santos Figueiredo Junior. Copyright (C) 2009 Ionzero LLC. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut __PACKAGE__->meta->make_immutable; 1; Catalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/SubInclude/HTTP.pm0000644000076500000240000001041111501677672027075 0ustar t0mstaffpackage Catalyst::View::Component::SubInclude::HTTP; use Moose; use namespace::clean -except => 'meta'; use Moose::Util::TypeConstraints; use LWP::UserAgent; use List::MoreUtils 'firstval'; use URI; our $VERSION = '0.01'; $VERSION = eval $VERSION; has http_method => ( isa => 'Str', is => 'ro', default => 'GET', ); has ua_timeout => ( isa => 'Int', is => 'ro', default => 10, ); has base_url => ( isa => 'Str', is => 'ro', required => 0, ); has uri_map => ( isa => 'HashRef', is => 'ro', required => 0, ); has user_agent => ( isa => duck_type([qw/get post/]), is => 'ro', lazy => 1, builder => '_build_user_agent', ); sub _build_user_agent { my $self = shift; return LWP::UserAgent->new( agent => ref($self), timeout => $self->ua_timeout, ); } sub generate_subinclude { my ($self, $c, $path, $args) = @_; my $error_msg_prefix = "SubInclude for $path failed: "; my $base_url = $self->base_url || $c->req->base; my $uri_map = $self->uri_map || { q{/} => $base_url }; $base_url = $uri_map->{ firstval { $path =~ s/^$_// } keys %$uri_map }; $base_url =~ s{/$}{}; my $uri = URI->new(join(q{/}, $base_url, $path)); my $req_method = q{_} . lc $self->http_method . '_request'; my $response; if ( $self->can($req_method) ) { $response = $self->$req_method($uri, $args); } else { confess $self->http_method . ' not supported'; } if ($response->is_success) { return $response->content; } else { $c->log->info($error_msg_prefix . $response->status_line); return undef; } } sub _get_request { my ( $self, $uri, $args) = @_; $uri->query_form($args); return $self->user_agent->get($uri); } sub _post_request { my ( $self, $uri, $args ) = @_; return $self->user_agent->post($uri, $args); } __PACKAGE__->meta->make_immutable; 1; __END__ =head1 NAME Catalyst::View::Component::SubInclude::HTTP - HTTP plugin for C::V::Component::SubInclude =head1 SYNOPSIS In your view class: package MyApp::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( subinclude_plugin => 'HTTP::GET', subinclude => { 'HTTP::GET' => { class => 'HTTP', http_method => 'GET', ua_timeout => '10', uri_map => { '/my/' => 'http://localhost:5000/', }, }, 'HTTP::POST' => { class => 'HTTP', http_method => 'POST', ua_timeout => '10', uri_map => { '/foo/' => 'http://www.foo.com/', }, }, }, ); Then, somewhere in your templates: [% subinclude('/my/widget') %] ... [% subinclude_using('HTTP::POST', '/foo/path', { foo => 1 }) %] =head1 DESCRIPTION C does HTTP requests (currently using L) and uses the responses to render subinclude contents. =head1 CONFIGURATION The configuration is passed in the C key based on your plugin name which can be arbitrary. =over =item class Required just in case your plugin name differs from C. =item http_method Accepts C and C as values. The default one is C. =item user_agent This lazily builds a L obj, however you can pass a different user agent obj that implements the required API. =item ua_timeout User Agent's timeout config param. Defaults to 10 seconds. =item uri_map This expects a HashRef in order to map paths to different URLs. =item base_url Used only if C is C and defaults to C<< $c->request->base >>. =back =head1 METHODS =head2 C Note that C<$path> should be the relative path. =head1 SEE ALSO L =head1 AUTHOR Wallace Reis C<< >> =head1 SPONSORSHIP Development sponsored by Ionzero LLC L. =head1 COPYRIGHT & LICENSE Copyright (c) 2010 Wallace Reis. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut Catalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/SubInclude/SSI.pm0000644000076500000240000000374411501700035026743 0ustar t0mstaffpackage Catalyst::View::Component::SubInclude::SSI; use Moose; use namespace::clean -except => 'meta'; =head1 NAME Catalyst::View::Component::SubInclude::SSI - Server Side Includes (SSI) plugin for C::V::Component::SubInclude =head1 VERSION Version 0.10 =cut our $VERSION = '0.10'; $VERSION = eval $VERSION; =head1 SYNOPSIS In your view class: package MyApp::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( subinclude_plugin => 'SSI' ); Then, somewhere in your templates: [% subinclude('/my/widget') %] =head1 DESCRIPTION C renders C calls as Server Side Includes (SSI) include directives. This is a feature implemented by Apache (L), nginx (L) and many other web servers which allows cache-efficient uses of includes. =head1 METHODS =head2 C Note that C<$path> should be the private action path - translation to the public path is handled internally. After translation, this will roughly translate to the following code: my $url = $c->uri_for( $translated_path, @args )->path_query; return ''; Notice that the stash will always be empty. This behavior could be configurable in the future through an additional switch - for now, this behavior guarantees a common interface for plugins. =cut sub generate_subinclude { my ($self, $c, $path, @params) = @_; my $uri = $c->uri_for_action( $path, @params ); return ''; } =head1 SEE ALSO L, =head1 AUTHOR Vladimir Timofeev, C<< >> =head1 COPYRIGHT & LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut __PACKAGE__->meta->make_immutable; 1; Catalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/SubInclude/SubRequest.pm0000644000076500000240000000527411477771170030433 0ustar t0mstaffpackage Catalyst::View::Component::SubInclude::SubRequest; use Moose; use Carp qw/croak/; use MooseX::Types::Moose qw/ Bool /; use namespace::clean -except => 'meta'; =head1 NAME Catalyst::View::Component::SubInclude::SubRequest - Sub-requests plugin for C::V::Component::SubInclude =head1 VERSION Version 0.07_03 =cut our $VERSION = '0.07_03'; $VERSION = eval $VERSION; =head1 SYNOPSIS In your application class: package MyApp; use Catalyst qw/ ConfigLoader Static::Simple ... SubRequest /; In your view class: package MyApp::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( subinclude_plugin => 'SubRequest' ); Then, somewhere in your templates: [% subinclude('/my/widget') %] =head1 DESCRIPTION C uses Catalyst sub-requests to render the subinclude contents. It requires L. =head1 METHODS =head2 C This will make a sub-request call to the action specified by C<$path>. Note that C<$path> should be the private action path - translation to the public path is handled internally. So, after path translation, the call will be (roughly) equivalent to: $c->sub_request( $translated_path, {}, @args ); Notice that the stash will always be empty. This behavior could be configurable in the future through an additional switch - for now, this behavior guarantees a common interface for all plugins. =cut has keep_stash => ( isa => Bool, is => 'ro', default => 0, ); sub generate_subinclude { my ($self, $c, $path, @params) = @_; my $stash = $self->keep_stash ? { %{ $c->stash } } : {}; croak "subincludes through subrequests require Catalyst::Plugin::SubRequest" unless $c->can('sub_request'); my $query = ref $params[-1] eq 'HASH' ? pop @params : {}; my $action = blessed($path) ? $path : $c->dispatcher->get_action_by_path($path); my $uri = $c->uri_for( $action, @params ); $c->sub_request( $uri->path, $stash, $query ); } =head1 SEE ALSO L, L =head1 AUTHOR Nilson Santos Figueiredo Junior, C<< >> =head1 SPONSORSHIP Development sponsored by Ionzero LLC L. =head1 COPYRIGHT & LICENSE Copyright (C) 2009 Nilson Santos Figueiredo Junior. Copyright (C) 2009 Ionzero LLC. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut __PACKAGE__->meta->make_immutable; 1; Catalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/SubInclude/Visit.pm0000644000076500000240000000500411477771176027424 0ustar t0mstaffpackage Catalyst::View::Component::SubInclude::Visit; use Moose; use Carp qw/croak/; use MooseX::Types::Moose qw/ Bool /; use namespace::clean -except => 'meta'; =head1 NAME Catalyst::View::Component::SubInclude::Visit - visit() plugin for C::V::Component::SubInclude =head1 VERSION Version 0.07_03 =cut our $VERSION = '0.07_03'; $VERSION = eval $VERSION; =head1 SYNOPSIS In your view class: package MyApp::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( subinclude_plugin => 'Visit' ); Then, somewhere in your templates: [% subinclude('/my/widget') %] =head1 DESCRIPTION C uses C<< $c->visit() >> to render subinclude contents. This method is only supported when using L version 5.71000 or newer. B. Apparently, C doesn't handle this type of actions yet. =head1 METHODS =head2 C This is (roughly) equivalent to the following call: $c->visit( $path, @args ); But it will handle all the nasty details such as localizing the stash, parameters and response body. This is necessary to keep behavior consistent with the other plugins. =cut has keep_stash => ( isa => Bool, is => 'ro', default => 0, ); sub generate_subinclude { my ($self, $c, $path, @params) = @_; croak "subincludes through visit() require Catalyst version 5.71000 or newer" unless $c->can('visit'); { local $c->{stash} = $self->keep_stash ? $c->{stash} : {}; local $c->request->{parameters} = ref $params[-1] eq 'HASH' ? pop @params : {}; local $c->response->{body}; my $captures = ref $params[0] eq 'ARRAY' ? shift @params : []; $c->visit( $path, $captures, \@params ); return $c->response->{body}; } } =head1 SEE ALSO L, L =head1 AUTHOR Nilson Santos Figueiredo Junior, C<< >> =head1 SPONSORSHIP Development sponsored by Ionzero LLC L. =head1 COPYRIGHT & LICENSE Copyright (C) 2009 Nilson Santos Figueiredo Junior. Copyright (C) 2009 Ionzero LLC. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut __PACKAGE__->meta->make_immutable; 1; Catalyst-View-Component-SubInclude-0.10/lib/Catalyst/View/Component/SubInclude.pm0000644000076500000240000001427111501700035026302 0ustar t0mstaffpackage Catalyst::View::Component::SubInclude; use Moose::Role; use Carp qw/croak/; use Catalyst::Utils (); use Class::MOP (); use MooseX::Types::Moose qw/Str HashRef/; use namespace::clean -except => 'meta'; with 'Catalyst::Component::ContextClosure'; =head1 NAME Catalyst::View::Component::SubInclude - Use subincludes in your Catalyst views =head1 VERSION Version 0.10 =cut our $VERSION = '0.10'; $VERSION = eval $VERSION; =head1 SYNOPSIS package MyApp::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( subinclude_plugin => 'SubRequest' ); Then, somewhere in your templates: [% subinclude('/my/widget') %] [% subinclude_using('SubRequest', '/page/footer') %] =head1 DESCRIPTION C allows you to include content in your templates (or, more generally, somewhere in your view's C processing) which comes from another action in your application. It's implemented as a L, so using L in your view is required. Simply put, it's a way to include the output of a Catalyst sub-request somewhere in your page. It's built in an extensible way so that you're free to use sub-requests, Varnish ESI (L) or any other sub-include plugin you might want to implement. =head1 STASH FUNCTIONS This component does its magic by exporting a C coderef entry to the stash. This way, it's easily accessible by the templates (which is the most common use-case). =head2 C This will render and return the body of the included resource (as specified by C<$path>) using the default subinclude plugin. =head2 C This will render and return the body of the included resource (as specified by C<$path>) using the specified subinclude plugin. The C function above is implemented basically as a shortcut which calls this function using the default plugin as the first parameter. =head1 SUBINCLUDE PLUGINS The module comes with two subinclude plugins: L, L and L. By default, the C plugin will be used. This can be changed in the view's configuration options (either in the config file or in the view module itself). Configuration file example: subinclude_plugin ESI =head2 C This method changes the current active subinclude plugin in runtime. It expects the plugin suffix (e.g. C or C) or a fully-qualified class name in the C namespace. =head2 Writing plugins If writing your own plugin, keep in kind plugins are required to implement a class method C with the following signature: sub generate_subinclude { my ($class, $c, @args) = @_; } The default plugin is stored in the C which can be changed in runtime. It expects a fully qualified class name. =cut has 'subinclude_plugin' => ( is => 'rw', isa => Str, ); has subinclude => ( is => 'ro', isa => HashRef, default => sub { {} }, ); around 'new' => sub { my $next = shift; my $class = shift; my $self = $class->$next( @_ ); my $subinclude_plugin = $self->config->{subinclude_plugin} || 'SubRequest'; $self->set_subinclude_plugin( $subinclude_plugin ); $self; }; before 'render' => sub { my ($self, $c, @args) = @_; $c->stash->{subinclude} = $self->make_context_closure(sub { $self->_subinclude( @_ ) }, $c); $c->stash->{subinclude_using} = $self->make_context_closure(sub { $self->_subinclude_using( @_ ) }, $c); }; sub set_subinclude_plugin { my ($self, $plugin) = @_; my $subinclude_class = blessed $self->_subinclude_plugin_class_instance( $plugin ); $self->subinclude_plugin( $subinclude_class ); } sub _subinclude { my ($self, $c, @args) = @_; $self->_subinclude_using( $c, $self->subinclude_plugin, @args ); } sub _subinclude_using { my ($self, $c, $plugin, @args) = @_; $plugin = $self->_subinclude_plugin_class_instance($plugin); $plugin->generate_subinclude( $c, @args ); } has _subinclude_plugin_class_instance_cache => ( isa => HashRef, is => 'ro', default => sub { {} }, ); sub _subinclude_plugin_class_instance { my ($self, $plugin) = @_; my $cache = $self->_subinclude_plugin_class_instance_cache; return $cache->{$plugin} if exists $cache->{$plugin}; my $plugin_config = Catalyst::Utils::merge_hashes( $self->subinclude->{ALL}||{}, $self->subinclude->{$plugin}||{} ); my $short_class = $plugin_config->{'class'} ? delete $plugin_config->{'class'} : $plugin; my $class = $short_class =~ /::/ ? $short_class : __PACKAGE__ . '::' . $short_class; Class::MOP::load_class($class); return $cache->{$class} = $class->new($plugin_config); } =head1 SEE ALSO L, L, L, L =head1 BUGS Please report any bugs or feature requests to C, or through the web interface at L. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes. =head1 AUTHOR Nilson Santos Figueiredo Junior, C<< >> =head1 CONTRIBUTORS Tomas Doran (t0m) C<< >. Vladimir Timofeev, C<< >>. Wallace Reis (wreis) C<< >>. =head1 SPONSORSHIP Development sponsored by Ionzero LLC L. =head1 COPYRIGHT & LICENSE Copyright (C) 2010 Nilson Santos Figueiredo Junior and the above contributors. Copyright (C) 2009 Nilson Santos Figueiredo Junior. Copyright (C) 2009 Ionzero LLC. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =cut 1; Catalyst-View-Component-SubInclude-0.10/Makefile.PL0000644000076500000240000000174111501677672020475 0ustar t0mstaffuse strict; use warnings; use inc::Module::Install 0.91; use Module::Install::AuthorRequires; use Module::Install::AuthorTests; name 'Catalyst-View-Component-SubInclude'; all_from 'lib/Catalyst/View/Component/SubInclude.pm'; requires 'Catalyst::Runtime' => '5.80014'; requires 'Catalyst::Plugin::SubRequest'; requires 'Moose'; requires 'Moose::Role'; requires 'MooseX::Types'; requires 'Carp'; requires 'namespace::clean'; requires 'LWP::UserAgent'; requires 'List::MoreUtils'; requires 'URI'; test_requires 'Test::More' => '0.88'; test_requires 'Catalyst::View::TT'; test_requires 'Catalyst::Action::RenderView'; author_requires 'Test::Pod::Coverage' => '1.04'; author_requires 'Test::Pod' => '1.14'; author_tests 't/author'; catalyst; resources repository => 'git://git.shadowcat.co.uk/catagits/Catalyst-View-Component-SubInclude'; if ($Module::Install::AUTHOR) { system("pod2text lib/Catalyst/View/Component/SubInclude.pm > README") and die $! } auto_install; WriteAll; Catalyst-View-Component-SubInclude-0.10/MANIFEST0000644000076500000240000000207111501700117017626 0ustar t0mstaffChanges inc/Module/AutoInstall.pm inc/Module/Install.pm inc/Module/Install/AuthorRequires.pm inc/Module/Install/AuthorTests.pm inc/Module/Install/AutoInstall.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Catalyst.pm inc/Module/Install/Fetch.pm inc/Module/Install/Include.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm lib/Catalyst/View/Component/SubInclude.pm lib/Catalyst/View/Component/SubInclude/ESI.pm lib/Catalyst/View/Component/SubInclude/HTTP.pm lib/Catalyst/View/Component/SubInclude/SSI.pm lib/Catalyst/View/Component/SubInclude/SubRequest.pm lib/Catalyst/View/Component/SubInclude/Visit.pm Makefile.PL MANIFEST This list of files META.yml README t/00-load.t t/01-app.t t/app.t t/author/http.t t/author/pod-coverage.t t/author/pod.t t/lib/ESITest.pm t/lib/ESITest/Controller/Root.pm t/lib/ESITest/root/http_cpan.tt t/lib/ESITest/root/http_github.tt t/lib/ESITest/root/index.tt t/lib/ESITest/root/time_include.tt t/lib/ESITest/View/TT.pm t/script/esitest_server.pl Catalyst-View-Component-SubInclude-0.10/META.yml0000644000076500000240000000173311501700065017754 0ustar t0mstaff--- abstract: 'Use subincludes in your Catalyst views' author: - 'Nilson Santos Figueiredo Junior, C<< >>' build_requires: Catalyst::Action::RenderView: 0 Catalyst::View::TT: 0 ExtUtils::MakeMaker: 6.42 Test::More: 0.88 configure_requires: ExtUtils::MakeMaker: 6.42 distribution_type: module generated_by: 'Module::Install version 0.99' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Catalyst-View-Component-SubInclude no_index: directory: - inc - t requires: Carp: 0 Catalyst::Action::RenderView: 0 Catalyst::Plugin::SubRequest: 0 Catalyst::Runtime: 5.80014 Catalyst::View::TT: 0 LWP::UserAgent: 0 List::MoreUtils: 0 Moose: 0 Moose::Role: 0 MooseX::Types: 0 Test::More: 0.88 URI: 0 namespace::clean: 0 resources: license: http://dev.perl.org/licenses/ repository: git://git.shadowcat.co.uk/catagits/Catalyst-View-Component-SubInclude version: 0.10 Catalyst-View-Component-SubInclude-0.10/README0000644000076500000240000000755411501700064017371 0ustar t0mstaffNAME Catalyst::View::Component::SubInclude - Use subincludes in your Catalyst views VERSION Version 0.10 SYNOPSIS package MyApp::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( subinclude_plugin => 'SubRequest' ); Then, somewhere in your templates: [% subinclude('/my/widget') %] [% subinclude_using('SubRequest', '/page/footer') %] DESCRIPTION "Catalyst::View::Component::SubInclude" allows you to include content in your templates (or, more generally, somewhere in your view's "render" processing) which comes from another action in your application. It's implemented as a Moose::Role, so using Moose in your view is required. Simply put, it's a way to include the output of a Catalyst sub-request somewhere in your page. It's built in an extensible way so that you're free to use sub-requests, Varnish ESI () or any other sub-include plugin you might want to implement. STASH FUNCTIONS This component does its magic by exporting a "subinclude" coderef entry to the stash. This way, it's easily accessible by the templates (which is the most common use-case). "subinclude( $path, @args )" This will render and return the body of the included resource (as specified by $path) using the default subinclude plugin. "subinclude_using( $plugin, $path, @args )" This will render and return the body of the included resource (as specified by $path) using the specified subinclude plugin. The "subinclude" function above is implemented basically as a shortcut which calls this function using the default plugin as the first parameter. SUBINCLUDE PLUGINS The module comes with two subinclude plugins: SubRequest, Visit and ESI. By default, the "SubRequest" plugin will be used. This can be changed in the view's configuration options (either in the config file or in the view module itself). Configuration file example: subinclude_plugin ESI "set_subinclude_plugin( $plugin )" This method changes the current active subinclude plugin in runtime. It expects the plugin suffix (e.g. "ESI" or "SubRequest") or a fully-qualified class name in the "Catalyst::View::Component::SubInclude" namespace. Writing plugins If writing your own plugin, keep in kind plugins are required to implement a class method "generate_subinclude" with the following signature: sub generate_subinclude { my ($class, $c, @args) = @_; } The default plugin is stored in the "subinclude_plugin" which can be changed in runtime. It expects a fully qualified class name. SEE ALSO Catalyst::Plugin::SubRequest, Moose::Role, Moose, BUGS Please report any bugs or feature requests to "bug-catalyst-view-component-subinclude at rt.cpan.org", or through the web interface at . I will be notified, and then you'll automatically be notified of progress on your bug as I make changes. AUTHOR Nilson Santos Figueiredo Junior, "" CONTRIBUTORS Tomas Doran (t0m) "". Wallace Reis (wreis) "". SPONSORSHIP Development sponsored by Ionzero LLC . COPYRIGHT & LICENSE Copyright (C) 2010 Nilson Santos Figueiredo Junior and the above contributors. Copyright (C) 2009 Nilson Santos Figueiredo Junior. Copyright (C) 2009 Ionzero LLC. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Catalyst-View-Component-SubInclude-0.10/t/0000755000076500000240000000000011501700151016736 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/00-load.t0000644000076500000240000000104411501677735020303 0ustar t0mstaff#!perl use Test::More; BEGIN { use_ok( 'Catalyst::View::Component::SubInclude' ); use_ok( 'Catalyst::View::Component::SubInclude::SubRequest' ); use_ok( 'Catalyst::View::Component::SubInclude::ESI' ); use_ok( 'Catalyst::View::Component::SubInclude::SSI' ); use_ok( 'Catalyst::View::Component::SubInclude::Visit' ); use_ok( 'Catalyst::View::Component::SubInclude::HTTP' ); } diag( "Testing Catalyst::View::Component::SubInclude $Catalyst::View::Component::SubInclude::VERSION, Perl $], $^X" ); done_testing; Catalyst-View-Component-SubInclude-0.10/t/01-app.t0000644000076500000240000000477711501677672020165 0ustar t0mstaffuse strict; use warnings; use FindBin qw/$Bin/; use lib "$Bin/lib"; use Test::More; use Catalyst::Test 'ESITest'; like get('/'), qr{SubInclude test: will include /time_include using default plugin Catalyst::View::Component::SubInclude::Visit
Current time is: [\w\s:]+ --> \| foo = bar \|\s*
Current time is: [\w\s:]+ --> Capture Arg: test\| baz = quux \|\s*


Test subinclude using specific plugins:
Current time is: [\w\s:]+ --> \| plugin = SubRequest \|\s*
Current time is: [\w\s:]+ --> \| plugin = Visit \|\s*




Test CaptureArgs and Args interaction \(SubRequest\):

Current time is: [\w\s:]+ --> Capture Arg: capture_argtest \| query_arg = val \| Action Arg: regular_arg\s*
\(using: http://localhost/capture_argtest/time/regular_arg\?query_arg=val\)

Current time is: [\w\s:]+ --> \| query_arg = val \| Action Arg: regular_arg\s*
\(using: http://localhost/time/regular_arg\?query_arg=val\)


Test CaptureArgs and Args interaction \(Visit\):

Current time is: [\w\s:]+ --> Capture Arg: capture_argtest \| query_arg = val \| Action Arg: regular_arg\s*
\(using: http://localhost/capture_argtest/time/regular_arg\?query_arg=val\)

Current time is: [\w\s:]+ --> \| query_arg = val \| Action Arg: regular_arg\s*
\(using: http://localhost/time/regular_arg\?query_arg=val\)


Test CaptureArgs and Args interaction \(ESI\):


\(using: http://localhost/capture_argtest/time/regular_arg\?query_arg=val\)


\(using: http://localhost/time/regular_arg\?query_arg=val\)


Test CaptureArgs and Args interaction \(SSI\):


\(using: http://localhost/capture_argtest/time/regular_arg\?query_arg=val\)


\(using: http://localhost/time/regular_arg\?query_arg=val\)



Test Args when Chained is not being used: Current time is: [\w\s:]+ --> \| query_arg = val \| No Chained Args: regular_arg1, regular_arg2
\(using: http://localhost/time_args_no_chained/regular_arg1/regular_arg2\?query_arg=val\)
}; done_testing; Catalyst-View-Component-SubInclude-0.10/t/author/0000755000076500000240000000000011501700151020240 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/author/http.t0000644000076500000240000000053011501677672021427 0ustar t0mstaffuse strict; use warnings; use FindBin qw/$Bin/; use lib "$Bin/../lib"; use Test::More; use Catalyst::Test 'ESITest'; my $res_content = get('/http_cpan'); like $res_content, qr{CPAN Directory}; like $res_content, qr{WREIS}; $res_content = get('/http_github'); like $res_content, qr{GitHub}; like $res_content, qr{Wallace Reis}; done_testing; Catalyst-View-Component-SubInclude-0.10/t/author/pod-coverage.t0000644000076500000240000000012511336343565023020 0ustar t0mstaff#!perl -T use Test::More; use Test::Pod::Coverage 1.04; all_pod_coverage_ok(); Catalyst-View-Component-SubInclude-0.10/t/author/pod.t0000644000076500000240000000011011336343565021221 0ustar t0mstaff#!perl -T use Test::More; use Test::Pod 1.14; all_pod_files_ok(); Catalyst-View-Component-SubInclude-0.10/t/lib/0000755000076500000240000000000011501700151017504 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/lib/ESITest/0000755000076500000240000000000011501700151020764 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/lib/ESITest/Controller/0000755000076500000240000000000011501700151023107 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/lib/ESITest/Controller/Root.pm0000644000076500000240000000514211501677672024417 0ustar t0mstaffpackage ESITest::Controller::Root; use strict; use warnings; use base 'Catalyst::Controller'; __PACKAGE__->config->{namespace} = ''; sub index :Path Args(0) {} sub base : Chained('/') PathPart('') CaptureArgs(0) {} sub time_include : Chained('base') PathPart('time') Args(0) { my ( $self, $c ) = @_; my $params = $c->req->params; $c->stash->{current_time} = localtime(); my $additional = ''; for my $key (keys %$params) { $additional .= "| $key = $params->{$key} | " } $c->stash->{additional} = $additional; } sub capture : Chained('base') PathPart('') CaptureArgs(1) { my ( $self, $c, $arg ) = @_; $c->log->debug("Capture: $arg") if $c->debug; $c->stash->{additional} = "Capture Arg: $arg"; } sub time_args : Chained('capture') PathPart('time') Args(0) { my ( $self, $c ) = @_; my $params = $c->req->params; $c->stash->{current_time} = localtime(); my $additional = $c->stash->{additional}; for my $key (keys %$params) { $additional .= "| $key = $params->{$key} | " } $c->stash->{additional} = $additional; $c->stash->{template} = 'time_include.tt'; } sub time_args_with_args : Chained('capture') PathPart('time') Args(1) { my ( $self, $c, $arg ) = @_; my $params = $c->req->params; $c->stash->{current_time} = localtime(); my $additional = $c->stash->{additional}; for my $key (keys %$params) { $additional .= " | $key = $params->{$key} | " } $additional .= " Action Arg: $arg "; $c->stash->{additional} = $additional; $c->stash->{template} = 'time_include.tt'; } sub time_args_without_capture : Chained('base') PathPart('time') Args(1) { my ( $self, $c, $arg ) = @_; my $params = $c->req->params; $c->stash->{current_time} = localtime(); my $additional = ''; for my $key (keys %$params) { $additional .= " | $key = $params->{$key} | " } $additional .= " Action Arg: $arg "; $c->stash->{additional} = $additional; $c->stash->{template} = 'time_include.tt'; } sub time_args_no_chained : Path('time_args_no_chained') Args { my ($self, $c, @args) = @_; my $params = $c->req->params; $c->stash->{current_time} = localtime(); my $additional = ''; for my $key (keys %$params) { $additional .= " | $key = $params->{$key} | " } $additional .= " No Chained Args: " . join ', ', @args; $c->stash->{additional} = $additional; $c->stash->{template} = 'time_include.tt'; } sub http_cpan : Chained('base') Args(0) {} sub http_github : Chained('base') Args(0) {} sub end : ActionClass('RenderView') {} 1; Catalyst-View-Component-SubInclude-0.10/t/lib/ESITest/root/0000755000076500000240000000000011501700151021747 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/lib/ESITest/root/http_cpan.tt0000644000076500000240000000006311501677672024324 0ustar t0mstaff[% subinclude_using('HTTP::GET', '/cpan/wreis') %] Catalyst-View-Component-SubInclude-0.10/t/lib/ESITest/root/http_github.tt0000644000076500000240000000006511501677672024667 0ustar t0mstaff[% subinclude_using('HTTP::GET', '/github/wreis') %] Catalyst-View-Component-SubInclude-0.10/t/lib/ESITest/root/index.tt0000644000076500000240000000622111477770737023465 0ustar t0mstaffSubInclude test: will include /time_include using default plugin [% c.view('TT').subinclude_plugin %]
[% subinclude('/time_include', { 'foo' => 'bar'} ) %]
[% subinclude('/time_args', ['test'], { 'baz' => 'quux' }) %]


Test subinclude using specific plugins:
[% subinclude_using('SubRequest', '/time_include', { 'plugin' => 'SubRequest'} ) %]
[% subinclude_using('Visit', '/time_include', { 'plugin' => 'Visit'} ) %]
[% subinclude_using('ESI', '/time_include', { 'plugin' => 'ESI'} ) %]
[% subinclude_using('SSI', '/time_include', { 'plugin' => 'SSI'} ) %]


Test CaptureArgs and Args interaction (SubRequest):

[% subinclude_using('SubRequest', '/time_args_with_args', ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %]
(using: [% c.uri_for( c.controller.action_for('time_args_with_args'), ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %])

[% subinclude_using('SubRequest', '/time_args_without_capture', 'regular_arg', { query_arg => 'val' }) %]
(using: [% c.uri_for( c.controller.action_for('time_args_without_capture'), 'regular_arg', { query_arg => 'val' } ) %])


Test CaptureArgs and Args interaction (Visit):

[% subinclude_using('Visit', '/time_args_with_args', ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %]
(using: [% c.uri_for( c.controller.action_for('time_args_with_args'), ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %])

[% subinclude_using('Visit', '/time_args_without_capture', 'regular_arg', { query_arg => 'val' }) %]
(using: [% c.uri_for( c.controller.action_for('time_args_without_capture'), 'regular_arg', { query_arg => 'val' } ) %])


Test CaptureArgs and Args interaction (ESI):

[% subinclude_using('ESI', '/time_args_with_args', ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %]
(using: [% c.uri_for( c.controller.action_for('time_args_with_args'), ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %])

[% subinclude_using('ESI', '/time_args_without_capture', 'regular_arg', { query_arg => 'val' }) %]
(using: [% c.uri_for( c.controller.action_for('time_args_without_capture'), 'regular_arg', { query_arg => 'val' } ) %])


Test CaptureArgs and Args interaction (SSI):

[% subinclude_using('SSI', '/time_args_with_args', ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %]
(using: [% c.uri_for( c.controller.action_for('time_args_with_args'), ['capture_argtest'], 'regular_arg', { query_arg => 'val' } ) %])

[% subinclude_using('SSI', '/time_args_without_capture', 'regular_arg', { query_arg => 'val' }) %]
(using: [% c.uri_for( c.controller.action_for('time_args_without_capture'), 'regular_arg', { query_arg => 'val' } ) %])



Test Args when Chained is not being used: [% subinclude_using('SubRequest', '/time_args_no_chained', 'regular_arg1', 'regular_arg2', { query_arg => 'val' } ) %]
(using: [% c.uri_for( c.controller.action_for('time_args_no_chained'), 'regular_arg1', 'regular_arg2', { query_arg => 'val' } ) %])
Catalyst-View-Component-SubInclude-0.10/t/lib/ESITest/root/time_include.tt0000644000076500000240000000007111336343565025001 0ustar t0mstaffCurrent time is: [% current_time %] --> [% additional %] Catalyst-View-Component-SubInclude-0.10/t/lib/ESITest/View/0000755000076500000240000000000011501700151021676 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/lib/ESITest/View/TT.pm0000644000076500000240000000074511501677672022616 0ustar t0mstaffpackage ESITest::View::TT; use Moose; extends 'Catalyst::View::TT'; with 'Catalyst::View::Component::SubInclude'; __PACKAGE__->config( TEMPLATE_EXTENSION => '.tt', subinclude_plugin => 'Visit', subinclude => { 'HTTP::GET' => { class => 'HTTP', http_method => 'GET', uri_map => { '/cpan/' => 'http://search.cpan.org/~', '/github/' => 'http://github.com/', }, }, }, ); 1; Catalyst-View-Component-SubInclude-0.10/t/lib/ESITest.pm0000644000076500000240000000034511336343565021346 0ustar t0mstaffpackage ESITest; use strict; use warnings; use Catalyst::Runtime '5.70'; use base qw/Catalyst/; use Catalyst qw/ SubRequest /; our $VERSION = '0.01'; __PACKAGE__->config( name => 'ESITest' ); __PACKAGE__->setup(); 1; Catalyst-View-Component-SubInclude-0.10/t/script/0000755000076500000240000000000011501700151020242 5ustar t0mstaffCatalyst-View-Component-SubInclude-0.10/t/script/esitest_server.pl0000644000076500000240000000626611336343565023701 0ustar t0mstaff#/usr/bin/perl -w BEGIN { $ENV{CATALYST_ENGINE} ||= 'HTTP'; $ENV{CATALYST_SCRIPT_GEN} = 31; require Catalyst::Engine::HTTP; } use strict; use warnings; use Getopt::Long; use Pod::Usage; use FindBin; use lib "$FindBin::Bin/../lib"; use lib "$FindBin::Bin/../../../lib"; my $debug = 0; my $fork = 0; my $help = 0; my $host = undef; my $port = $ENV{ESITEST_PORT} || $ENV{CATALYST_PORT} || 3000; my $keepalive = 0; my $restart = $ENV{ESITEST_RELOAD} || $ENV{CATALYST_RELOAD} || 0; my $restart_delay = 1; my $restart_regex = '(?:/|^)(?!\.#).+(?:\.yml$|\.yaml$|\.conf|\.pm)$'; my $restart_directory = undef; my $follow_symlinks = 0; my @argv = @ARGV; GetOptions( 'debug|d' => \$debug, 'fork' => \$fork, 'help|?' => \$help, 'host=s' => \$host, 'port=s' => \$port, 'keepalive|k' => \$keepalive, 'restart|r' => \$restart, 'restartdelay|rd=s' => \$restart_delay, 'restartregex|rr=s' => \$restart_regex, 'restartdirectory=s@' => \$restart_directory, 'followsymlinks' => \$follow_symlinks, ); pod2usage(1) if $help; if ( $restart && $ENV{CATALYST_ENGINE} eq 'HTTP' ) { $ENV{CATALYST_ENGINE} = 'HTTP::Restarter'; } if ( $debug ) { $ENV{CATALYST_DEBUG} = 1; } # This is require instead of use so that the above environment # variables can be set at runtime. require ESITest; ESITest->run( $port, $host, { argv => \@argv, 'fork' => $fork, keepalive => $keepalive, restart => $restart, restart_delay => $restart_delay, restart_regex => qr/$restart_regex/, restart_directory => $restart_directory, follow_symlinks => $follow_symlinks, } ); 1; =head1 NAME esitest_server.pl - Catalyst Testserver =head1 SYNOPSIS esitest_server.pl [options] Options: -d -debug force debug mode -f -fork handle each request in a new process (defaults to false) -? -help display this help and exits -host host (defaults to all) -p -port port (defaults to 3000) -k -keepalive enable keep-alive connections -r -restart restart when files get modified (defaults to false) -rd -restartdelay delay between file checks -rr -restartregex regex match files that trigger a restart when modified (defaults to '\.yml$|\.yaml$|\.conf|\.pm$') -restartdirectory the directory to search for modified files, can be set mulitple times (defaults to '[SCRIPT_DIR]/..') -follow_symlinks follow symlinks in search directories (defaults to false. this is a no-op on Win32) See also: perldoc Catalyst::Manual perldoc Catalyst::Manual::Intro =head1 DESCRIPTION Run a Catalyst Testserver for this application. =head1 AUTHORS Catalyst Contributors, see Catalyst.pm =head1 COPYRIGHT This library is free software, you can redistribute it and/or modify it under the same terms as Perl itself. =cut