Jifty-Plugin-Authentication-Ldap-1.01/0000755000175000017500000000000011444365714020034 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/.gitignore0000644000175000017500000000005011444120440022000 0ustar agostiniagostiniMETA.yml Makefile blib/ inc/ pm_to_blib Jifty-Plugin-Authentication-Ldap-1.01/t/0000755000175000017500000000000011444365714020277 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/t/00-load.t0000644000175000017500000000017211444111700021600 0ustar agostiniagostini#!/usr/bin/env perl use warnings; use strict; use Test::More tests => 1; use_ok('Jifty::Plugin::Authentication::Ldap'); Jifty-Plugin-Authentication-Ldap-1.01/Makefile.PL0000644000175000017500000000034411444111700021767 0ustar agostiniagostiniuse inc::Module::Install; name('Jifty-Plugin-Authentication-Ldap'); all_from('lib/Jifty/Plugin/Authentication/Ldap.pm'); requires('Jifty'); requires('Net::LDAP'); auto_install(); tests(qw( t/*.t )); install_share; WriteAll; Jifty-Plugin-Authentication-Ldap-1.01/README0000644000175000017500000001310611444121045020700 0ustar agostiniagostiniNAME Jifty::Plugin::Authentication::Ldap - LDAP Authentication Plugin for Jifty DESCRIPTION CAUTION: This plugin is experimental. This may be combined with the User Mixin to provide user accounts and ldap password authentication to your application. When a new user authenticates using this plugin, a new User object will be created automatically. The "name" and "email" fields will be automatically populated with LDAP data. in etc/config.yml Plugins: - Authentication::Ldap: LDAPhost: ldap.univ.fr # ldap server LDAPbase: ou=people,dc=..... # base ldap LDAPName: displayname # name to be displayed (cn givenname) LDAPMail: mailLocalAddress # email used optional LDAPuid: uid # optional Then create a user model jifty model --name=User and edit lib/App/Model/User.pm to look something like this: use strict; use warnings; package Venice::Model::User; use Jifty::DBI::Schema; use Venice::Record schema { # More app-specific user columns go here }; use Jifty::Plugin::User::Mixin::Model::User; use Jifty::Plugin::Authentication::Ldap::Mixin::Model::User; sub current_user_can { my $self = shift; my $type = shift; my %args = (@_); return 1 if $self->current_user->is_superuser; # all logged in users can read this table return 1 if ($type eq 'read' && $self->current_user->id); return $self->SUPER::current_user_can($type, @_); }; 1; ACTIONS This plugin will add the following actions to your application. For testing you can access these from the Admin plugin. Jifty::Plugin::Authentication::Ldap::Action::LDAPLogin The login path is "/ldaplogin". Jifty::Plugin::Authentication::Ldap::Action::LDAPLogout The logout path is "/ldaplogout". METHODS prereq_plugins This plugin depends on the User Mixin. Configuration The following options are available in your "config.yml" under the Authentication::Ldap Plugins section. "LDAPhost" Your LDAP server. "LDAPbase" [Mandatory] The base object where your users live. If "LDAPBindTemplate" is defined, "LDAPbase" is only used for user search. "LDAPBindTemplate" Alternatively to "LDAPbase", you can specify here the whole DN string, with *%u* as a placeholder for UID. "LDAPMail" The DN that your organization uses to store Email addresses. This gets copied into the User object as the "email". "LDAPName" The DN that your organization uses to store Real Name. This gets copied into the User object as the "name". "LDAPuid" The DN that your organization uses to store the user ID. Usually "cn". This gets copied into the User object as the "ldap_id". "LDAPOptions" These options get passed through to Net::LDAP. Default Options : debug => 0 onerror => undef async => 1 Other options you may want : timeout => 30 See "Net::LDAP" for a full list. You can overwrite the defaults selectively or not at all. "LDAPLoginHooks" Optional list of Perl functions that would be called after a successful login and after a corresponding User object is loaded and updated. The function is called with a hash array arguments, as follows: username => string user_object => User object ldap => Net::LDAP object infos => User attributes as returned by get_infos "LDAPFetchUserAttr" Optional list of LDAP user attributes fetched by get_infos. The values are returned to the login hook as arrayrefs. Example The following example authenticates the application against a MS Active Directory server for the domain MYDOMAIN. Each user entry has the attribute 'department' which is used for authorization. "LDAPbase" is used for user searching, and binding is done in a Microsoft way. The login hook checks if the user belongs to specific departments and updates the user record. ###### # etc/config.yml: Plugins: - User: {} - Authentication::Ldap: LDAPhost: ldap1.mydomain.com LDAPbase: 'DC=mydomain,DC=com' LDAPBindTemplate: 'MYDOMAIN\%u' LDAPName: displayName LDAPMail: mail LDAPuid: cn LDAPFetchUserAttr: - department LDAPLoginHooks: - 'Myapp::Model::User::ldap_login_hook' ###### # package Myapp::Model::User; sub ldap_login_hook { my %args = @_; my $u = $args{'user_object'}; my $department = $args{'infos'}->{'department'}[0]; my $editor = 0; if( $department eq 'NOC' or $department eq 'ENGINEERING' ) { $editor = 1; } $u->__set( column => 'is_content_editor', value => $editor ); } SEE ALSO Jifty::Manual::AccessControl, Jifty::Plugin::User::Mixin::Model::User, Net::LDAP AUTHORS Yves Agostini, , Stanislav Sinyagin and others authors from Jifty (maxbaker, clkao, sartak, alexmv) LICENSE Copyright 2007-2010 Yves Agostini. All Rights Reserved. This program is free software and may be modified and distributed under the same terms as Perl itself. Jifty-Plugin-Authentication-Ldap-1.01/lib/0000755000175000017500000000000011444365714020602 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/0000755000175000017500000000000011444365714021667 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/0000755000175000017500000000000011444365714023125 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/0000755000175000017500000000000011444365714026104 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/0000755000175000017500000000000011444365714026764 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/View.pm0000644000175000017500000000247311444111700030222 0ustar agostiniagostiniuse utf8; use warnings; use strict; =head1 NAME Jifty::Plugin::Authentication::Ldap::View - provides templates for the pages and forms used by the ldap authentication plugin. =cut package Jifty::Plugin::Authentication::Ldap::View; use Jifty::View::Declare -base; { no warnings 'redefine'; sub page (&;$) { no strict 'refs'; BEGIN {Jifty::Util->require(Jifty->app_class('View'))}; Jifty->app_class('View')->can('page')->(@_); } } template ldaplogin => page { title => _('Login!') } content { show('/ldaplogin_widget'); }; template ldaplogin_widget => sub { # title is _("Login with your Ldap account") my ( $action, $next ) = get( 'action', 'next' ); $action ||= new_action( class => 'LDAPLogin' ); $next ||= Jifty::Continuation->new( request => Jifty::Request->new( path => "/" ) ); unless ( Jifty->web->current_user->id ) { h3 { _('Login with your ldap account') }; div { attr { id => 'jifty-login' }; Jifty->web->form->start( call => $next ); render_param( $action, 'ldap_id', focus => 1 ); render_param( $action, 'password' ); form_return( label => _(q{Login}), submit => $action ); Jifty->web->form->end(); }; } else { outs( _("You're already logged in.") ); } }; 1; Jifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/Dispatcher.pm0000644000175000017500000000142411444111700031371 0ustar agostiniagostiniuse strict; use warnings; package Jifty::Plugin::Authentication::Ldap::Dispatcher; use Jifty::Dispatcher -base; # Put any plugin-specific dispatcher rules here. # whitelist safe actions to avoid cross-site scripting before '*' => run { Jifty->api->allow('LDAPLogout') }; # Log out before 'ldaplogout' => run { Jifty->web->request->add_action( class => 'LDAPLogout', moniker => 'ldaplogout', ); }; on ldaplogout => run { redirect '/'; }; # Login on 'ldaplogin' => run { set 'action' => Jifty->web->new_action( class => 'LDAPLogin', moniker => 'ldaploginbox' ); set 'next' => Jifty->web->request->continuation || Jifty::Continuation->new( request => Jifty::Request->new( path => "/" ) ); }; 1; Jifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/Action/0000755000175000017500000000000011444365714030201 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/Action/LDAPLogout.pm0000644000175000017500000000074411444111700032436 0ustar agostiniagostiniuse warnings; use strict; =head1 NAME Jifty::Plugin::Authentication::Ldap::Action::LDAPLogout - process LDAP logout plugin =cut package Jifty::Plugin::Authentication::Ldap::Action::LDAPLogout; use base qw/Jifty::Action/; =head2 arguments Return the email and password form fields =cut sub arguments { return ( {} ); } =head2 take_action Nuke the current user object =cut sub take_action { my $self = shift; Jifty->web->current_user(undef); return 1; } 1; Jifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/Action/LDAPLogin.pm0000644000175000017500000000733211444120440032236 0ustar agostiniagostiniuse warnings; use strict; =head1 NAME Jifty::Plugin::Authentication::Ldap::Action::LDAPLogin - process LDAP login plugin =cut package Jifty::Plugin::Authentication::Ldap::Action::LDAPLogin; use base qw/Jifty::Action/; =head1 ARGUMENTS Return the login form field =cut use Jifty::Param::Schema; use Jifty::Action schema { param ldap_id => label is _('Login'), is mandatory; # is ajax_validates; param password => type is 'password', label is _('Password'), is mandatory; }; =head2 validate_name NAME For ajax_validates. Makes sure that the name submitted is a legal login. =cut sub validate_ldap_id { my $self = shift; my $name = shift; unless ( $name =~ /^[A-Za-z0-9-]+$/ ) { return $self->validation_error( name => _("That doesn't look like a valid login.") ); } return $self->validation_ok('ldap_id'); } =head2 take_action Bind on ldap to check the user's password. If it's right, log them in. Otherwise, throw an error. =cut sub take_action { my $self = shift; my $username = $self->argument_value('ldap_id'); my ($plugin) = Jifty->find_plugin('Jifty::Plugin::Authentication::Ldap'); my $dn = $plugin->bind_template(); $dn =~ s/\%u/$username/g; Jifty->log->debug( "dn = $dn" ); # Bind on ldap my $msg = $plugin->LDAP()->bind($dn ,'password' =>$self->argument_value('password')); if ($msg->code) { $self->result->error( _('You may have mistyped your login or password. Give it another shot?') ); Jifty->log->error( "LDAP bind $dn " . $msg->error . "" ); return; } # Load up the user my $infos = $plugin->get_infos($username); my $name = $infos->{name}; my $email = $infos->{email}; my $current_user = Jifty->app_class('CurrentUser'); my $user = ($email) ? $current_user->new( email => $email) # load by email to mix authentication : $current_user->new( ldap_id => $username ); # else load by ldap_id # Autocreate the user if necessary if ( not $user->id ) { my $action = Jifty->web->new_action( class => 'CreateUser', current_user => $current_user->superuser, arguments => { ldap_id => $username } ); $action->run; if ( not $action->result->success ) { # Should this be less "friendly"? $self->result->error(_("Sorry, something weird happened (we couldn't create a user for you). Try again later.")); return; } $user = $current_user->new( ldap_id => $username ); } my $u = $user->user_object; # Update, just in case $u->__set( column => 'ldap_id', value => $username ) unless ($u->ldap_id and $u->ldap_id eq $username); $u->__set( column => 'name', value => $username ) unless ($u->name and length $u->name); $u->__set( column => 'name', value => $name ) if ($name); $u->__set( column => 'email', value => $email ) if ($email); # Login! Jifty->web->current_user( $user ); Jifty->web->session->set_cookie; foreach my $proc ($plugin->login_hooks()) { eval( '&' . $proc . '( username => $username, ' . 'user_object => $u, ldap => $plugin->LDAP(), infos => $infos )' ); if( $@ ) { Jifty->log->error('Cannot eval ' . $proc . ': ' . $@); $self->result->error('Cannot eval ' . $proc . ': ' . $@); return; } } # Success! $self->report_success; return 1; }; =head2 report_success =cut sub report_success { my $self = shift; $self->result->message(_("Hi %1!", Jifty->web->current_user->user_object->name )); }; 1; Jifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/Mixin/0000755000175000017500000000000011444365714030050 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/Mixin/Model/0000755000175000017500000000000011444365714031110 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap/Mixin/Model/User.pm0000644000175000017500000000121211444111700032340 0ustar agostiniagostinipackage Jifty::Plugin::Authentication::Ldap::Mixin::Model::User; use strict; use warnings; use Jifty::DBI::Schema; use base 'Jifty::DBI::Record::Plugin'; use URI; =head1 NAME Jifty::Plugin::Authentication::Ldap::Mixin::Model::User - Ldap mixin with User model =head1 DESCRIPTION L mixin for the User model. Provides an 'ldap_id' column. =cut our @EXPORT = qw(has_alternative_auth); use Jifty::Plugin::Authentication::Ldap::Record schema { column ldap_id => type is 'text', label is 'Ldap ID', is distinct; #is immutable; }; =head2 has_alternative_auth =cut sub has_alternative_auth { 1 } 1; Jifty-Plugin-Authentication-Ldap-1.01/lib/Jifty/Plugin/Authentication/Ldap.pm0000644000175000017500000001715011444120574027317 0ustar agostiniagostiniuse strict; use warnings; package Jifty::Plugin::Authentication::Ldap; use base qw/Jifty::Plugin/; our $VERSION = '1.01'; =head1 NAME Jifty::Plugin::Authentication::Ldap - LDAP Authentication Plugin for Jifty =head1 DESCRIPTION B This plugin is experimental. This may be combined with the L Mixin to provide user accounts and ldap password authentication to your application. When a new user authenticates using this plugin, a new User object will be created automatically. The C and C fields will be automatically populated with LDAP data. in etc/config.yml Plugins: - Authentication::Ldap: LDAPhost: ldap.univ.fr # ldap server LDAPbase: ou=people,dc=..... # base ldap LDAPName: displayname # name to be displayed (cn givenname) LDAPMail: mailLocalAddress # email used optional LDAPuid: uid # optional Then create a user model jifty model --name=User and edit lib/App/Model/User.pm to look something like this: use strict; use warnings; package Venice::Model::User; use Jifty::DBI::Schema; use Venice::Record schema { # More app-specific user columns go here }; use Jifty::Plugin::User::Mixin::Model::User; use Jifty::Plugin::Authentication::Ldap::Mixin::Model::User; sub current_user_can { my $self = shift; my $type = shift; my %args = (@_); return 1 if $self->current_user->is_superuser; # all logged in users can read this table return 1 if ($type eq 'read' && $self->current_user->id); return $self->SUPER::current_user_can($type, @_); }; 1; =head2 ACTIONS This plugin will add the following actions to your application. For testing you can access these from the Admin plugin. =over =item Jifty::Plugin::Authentication::Ldap::Action::LDAPLogin The login path is C. =item Jifty::Plugin::Authentication::Ldap::Action::LDAPLogout The logout path is C. =back =cut =head2 METHODS =head2 prereq_plugins This plugin depends on the L Mixin. =cut sub prereq_plugins { return ('User'); } use Net::LDAP; my ($LDAP, %params); =head2 Configuration The following options are available in your C under the Authentication::Ldap Plugins section. =over =item C Your LDAP server. =item C [Mandatory] The base object where your users live. If C is defined, C is only used for user search. =item C Alternatively to C, you can specify here the whole DN string, with I<%u> as a placeholder for UID. =item C The DN that your organization uses to store Email addresses. This gets copied into the User object as the C. =item C The DN that your organization uses to store Real Name. This gets copied into the User object as the C. =item C The DN that your organization uses to store the user ID. Usually C. This gets copied into the User object as the C. =item C These options get passed through to L. Default Options : debug => 0 onerror => undef async => 1 Other options you may want : timeout => 30 See C for a full list. You can overwrite the defaults selectively or not at all. =item C Optional list of Perl functions that would be called after a successful login and after a corresponding User object is loaded and updated. The function is called with a hash array arguments, as follows: username => string user_object => User object ldap => Net::LDAP object infos => User attributes as returned by get_infos =item C Optional list of LDAP user attributes fetched by get_infos. The values are returned to the login hook as arrayrefs. =back =head2 Example The following example authenticates the application against a MS Active Directory server for the domain MYDOMAIN. Each user entry has the attribute 'department' which is used for authorization. C is used for user searching, and binding is done in a Microsoft way. The login hook checks if the user belongs to specific departments and updates the user record. ###### # etc/config.yml: Plugins: - User: {} - Authentication::Ldap: LDAPhost: ldap1.mydomain.com LDAPbase: 'DC=mydomain,DC=com' LDAPBindTemplate: 'MYDOMAIN\%u' LDAPName: displayName LDAPMail: mail LDAPuid: cn LDAPFetchUserAttr: - department LDAPLoginHooks: - 'Myapp::Model::User::ldap_login_hook' ###### # package Myapp::Model::User; sub ldap_login_hook { my %args = @_; my $u = $args{'user_object'}; my $department = $args{'infos'}->{'department'}[0]; my $editor = 0; if( $department eq 'NOC' or $department eq 'ENGINEERING' ) { $editor = 1; } $u->__set( column => 'is_content_editor', value => $editor ); } =cut sub init { my $self = shift; my %args = @_; $params{'Hostname'} = $args{LDAPhost}; $params{'bind_template'} = $args{LDAPBindTemplate}; $params{'base'} = $args{LDAPbase} or die "Need LDAPbase in plugin config"; $params{'uid'} = $args{LDAPuid} || "uid"; $params{'email'} = $args{LDAPMail} || ""; $params{'name'} = $args{LDAPName} || "cn"; $params{'login_hooks'} = $args{LDAPLoginHooks} || []; $params{'fetch_attrs'} = $args{LDAPFetchUserAttr} || []; if( not $params{'bind_template'} ) { $params{'bind_template'} = $params{'uid'}.'=%u,'.$params{'base'}; } my $opts = $args{LDAPOptions} || {}; # Default options for Net::LDAP $opts->{'debug'} = 0 unless defined $opts->{'debug'}; $opts->{'onerror'} = 'undef' unless defined $opts->{'onerror'}; $opts->{'async'} = 1 unless defined $opts->{'async'}; $params{'opts'} = $opts; $LDAP = Net::LDAP->new($params{Hostname},%{$opts}) or die "Can't connect to LDAP server ",$params{Hostname}; } sub LDAP { return $LDAP; } sub bind_template { return $params{'bind_template'}; } sub base { return $params{'base'}; } sub uid { return $params{'uid'}; } sub email { return $params{'email'}; }; sub name { return $params{'name'}; }; sub opts { return $params{'opts'}; }; sub login_hooks { return @{$params{'login_hooks'}}; } sub get_infos { my ($self,$user) = @_; my $result = $self->LDAP()->search ( base => $self->base(), filter => '('.$self->uid().'='.$user.')', attrs => [$self->name(),$self->email(), @{$params{'fetch_attrs'}}], sizelimit => 1 ); $result->code && Jifty->log->error( 'LDAP uid=' . $user . ' ' . $result->error ); my ($entry) = $result->entries; my $ret = { dn => $entry->dn(), name => $entry->get_value($self->name()), email => $entry->get_value($self->email()), }; foreach my $attr (@{$params{'fetch_attrs'}}) { my @val = $entry->get_value($attr); $ret->{$attr} = [ @val ]; } return $ret; }; =head1 SEE ALSO L, L, L =head1 AUTHORS Yves Agostini, , Stanislav Sinyagin and others authors from Jifty (maxbaker, clkao, sartak, alexmv) =head1 LICENSE Copyright 2007-2010 Yves Agostini. All Rights Reserved. This program is free software and may be modified and distributed under the same terms as Perl itself. =cut 1; Jifty-Plugin-Authentication-Ldap-1.01/MANIFEST0000644000175000017500000000142111444365702021160 0ustar agostiniagostini.gitignore Changes inc/Module/AutoInstall.pm inc/Module/Install.pm inc/Module/Install/AutoInstall.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Fetch.pm inc/Module/Install/Include.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Share.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm lib/Jifty/Plugin/Authentication/Ldap.pm lib/Jifty/Plugin/Authentication/Ldap/Action/LDAPLogin.pm lib/Jifty/Plugin/Authentication/Ldap/Action/LDAPLogout.pm lib/Jifty/Plugin/Authentication/Ldap/Dispatcher.pm lib/Jifty/Plugin/Authentication/Ldap/Mixin/Model/User.pm lib/Jifty/Plugin/Authentication/Ldap/View.pm Makefile.PL MANIFEST This list of files META.yml README share/po/jifty_plugin_authentication_ldap.pot t/00-load.t Jifty-Plugin-Authentication-Ldap-1.01/META.yml0000644000175000017500000000104111444365616021302 0ustar agostiniagostini--- abstract: 'LDAP Authentication Plugin for Jifty' author: - 'Yves Agostini, , Stanislav Sinyagin' build_requires: ExtUtils::MakeMaker: 6.11 distribution_type: module generated_by: 'Module::Install version 0.76' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Jifty-Plugin-Authentication-Ldap no_index: directory: - share - share - inc - t requires: Jifty: 0 Net::LDAP: 0 resources: license: http://dev.perl.org/licenses/ version: 1.01 Jifty-Plugin-Authentication-Ldap-1.01/inc/0000755000175000017500000000000011444365714020605 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/inc/Module/0000755000175000017500000000000011444365714022032 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install.pm0000644000175000017500000002100711444365614023775 0ustar agostiniagostini#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 # } BEGIN { require 5.004; } use strict 'vars'; use vars qw{$VERSION}; 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.76'; *inc::Module::Install::VERSION = *VERSION; @inc::Module::Install::ISA = __PACKAGE__; } # 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 # 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 and (stat($0))[9] > time ) { die <<"END_DIE" } Your installer $0 has a modification time in the future. 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)); use Cwd (); use File::Find (); use File::Path (); use FindBin; 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; } $$sym =~ /([^:]+)$/ or die "Cannot autoload $who - $sym"; unshift @_, ( $self, $1 ); goto &{$self->can('call')} unless uc($1) eq $1; }; } sub import { my $class = shift; my $self = $class->new(@_); my $who = $self->_caller; unless ( -f $self->{file} ) { 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"}; } *{"${who}::AUTOLOAD"} = $self->autoload; $self->preload; # Unregister loader and worker packages so subdirs can use them again delete $INC{"$self->{file}"}; delete $INC{"$self->{path}.pm"}; return 1; } sub preload { my $self = shift; unless ( $self->{extensions} ) { $self->load_extensions( "$self->{prefix}/$self->{path}", $self ); } my @exts = @{$self->{extensions}}; unless ( @exts ) { my $admin = $self->{admin}; @exts = $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 ) { *{"${who}::$name"} = sub { ${"${who}::AUTOLOAD"} = "${who}::$name"; goto &{"${who}::AUTOLOAD"}; }; } } sub new { my ($class, %args) = @_; # 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) = @_; unless ( grep { lc $_ eq lc $self->{prefix} } @INC ) { unshift @INC, $self->{prefix}; } foreach my $rv ( $self->find_extensions($path) ) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; local $@; my $new = eval { require $file; $pkg->can('new') }; unless ( $new ) { warn $@ if $@; next; } $self->{pathnames}{$pkg} = delete $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; } ##################################################################### # Utility Functions sub _caller { my $depth = 0; my $call = caller($depth); while ( $call eq __PACKAGE__ ) { $depth++; $call = caller($depth); } return $call; } sub _read { local *FH; open FH, "< $_[0]" or die "open($_[0]): $!"; my $str = do { local $/; }; close FH or die "close($_[0]): $!"; return $str; } 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]): $!"; } sub _version ($) { my $s = shift || 0; $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; } # Cloned from Params::Util::_CLASS sub _CLASS ($) { ( defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*$/s ) ? $_[0] : undef; } 1; # Copyright 2008 Adam Kennedy. Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/AutoInstall.pm0000644000175000017500000005077211444365614024641 0ustar agostiniagostini#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 ); 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; } } } # 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] ); 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. if ( defined( my $cur = _version_check( _load($mod), $arg ||= 0 ) ) ) { print "loaded. ($cur" . ( $arg ? " >= $arg" : '' ) . ")\n"; push @Existing, $mod => $arg; $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { print "missing." . ( $arg ? " (would need $arg)" : '' ) . "\n"; push @required, $mod => $arg; } } next unless @required; my $mandatory = ( $feature eq '-core' or $core_all ); if ( !$SkipInstall and ( $CheckOnly 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; } } $UnderCPAN = _check_lock(); # check for $UnderCPAN 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'; } # 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; if ($ENV{PERL5_CPANPLUS_IS_RUNNING}) { print <<'END_MESSAGE'; *** Since we're running under CPANPLUS, I'll just let it take care of the dependency's installation later. END_MESSAGE return 1; } _load_cpan(); # 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 ( defined( _version_check( _load($pkg), $ver ) ) ) { 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() ) { _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 ( defined( _version_check( _load($pkg), $ver ) ) ) { 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 defined( _version_check( $obj->{version}, $ver ) ) ) { 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 defined( _version_check( $obj->cpan_version, $ver ) ) ) { 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 defined( _version_check( _load($class), $ver ) ); # 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; require CPAN; if ( $CPAN::HandleConfig::VERSION ) { # 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 sub _version_check { my ( $cur, $min ) = @_; return unless defined $cur; $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) ) ? $cur : undef ); } 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 ) != -1 ) ? $cur : undef ); } 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 ? $cur : undef ); } # 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 ? "\$(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 << "."; config :: installdeps \t\$(NOECHO) \$(NOOP) checkdeps :: \t\$(PERL) $0 --checkdeps installdeps :: \t$PostambleActions . } 1; __END__ #line 1003 Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/0000755000175000017500000000000011444365714023440 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Win32.pm0000644000175000017500000000340211444365616024700 0ustar agostiniagostini#line 1 package Module::Install::Win32; use strict; use Module::Install::Base; use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.76'; @ISA = qw{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; Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Fetch.pm0000644000175000017500000000463011444365616025033 0ustar agostiniagostini#line 1 package Module::Install::Fetch; use strict; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.76'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } 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; Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Include.pm0000644000175000017500000000101411444365614025354 0ustar agostiniagostini#line 1 package Module::Install::Include; use strict; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.76'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } 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; Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Can.pm0000644000175000017500000000337411444365616024507 0ustar agostiniagostini#line 1 package Module::Install::Can; use strict; use Module::Install::Base; use Config (); ### This adds a 5.005 Perl version dependency. ### This is a bug and will be fixed. use File::Spec (); use ExtUtils::MakeMaker (); use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.76'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } # 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}), '.') { 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 157 Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Metadata.pm0000644000175000017500000002573211444365614025526 0ustar agostiniagostini#line 1 package Module::Install::Metadata; use strict 'vars'; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.76'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } my @scalar_keys = qw{ name module_name abstract author version distribution_type tests installdirs }; my @tuple_keys = qw{ configure_requires build_requires requires recommends bundles resources }; my @resource_keys = qw{ homepage bugtracker repository }; sub Meta { shift } sub Meta_ScalarKeys { @scalar_keys } sub Meta_TupleKeys { @tuple_keys } sub Meta_ResourceKeys { @resource_keys } 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 ( @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; }; } sub requires { my $self = shift; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @{ $self->{values}{requires} }, [ $module, $version ]; } $self->{values}{requires}; } sub build_requires { my $self = shift; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @{ $self->{values}{build_requires} }, [ $module, $version ]; } $self->{values}{build_requires}; } sub configure_requires { my $self = shift; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @{ $self->{values}{configure_requires} }, [ $module, $version ]; } $self->{values}{configure_requires}; } sub recommends { my $self = shift; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @{ $self->{values}{recommends} }, [ $module, $version ]; } $self->{values}{recommends}; } sub bundles { my $self = shift; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @{ $self->{values}{bundles} }, [ $module, $version ]; } $self->{values}{bundles}; } # 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 sign { my $self = shift; return $self->{values}{sign} if defined wantarray and ! @_; $self->{values}{sign} = ( @_ ? $_[0] : 1 ); return $self; } 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()" ); $version =~ s/_.+$//; $version = $version + 0; # Numify unless ( $version >= 5.005 ) { die "Module::Install only supports 5.005 or newer (use ExtUtils::MakeMaker)\n"; } $self->{values}{perl_version} = $version; return 1; } sub license { my $self = shift; return $self->{values}{license} unless @_; my $license = shift or die( 'Did not provide a value to license()' ); $self->{values}{license} = $license; # Automatically fill in license URLs if ( $license eq 'perl' ) { $self->resources( license => 'http://dev.perl.org/licenses/' ); } return 1; } 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"); } } # 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) ); } 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 perl_version_from { my $self = shift; if ( Module::Install::_read($_[0]) =~ m/ ^ (?:use|require) \s* v? ([\d_\.]+) \s* ; /ixms ) { my $perl_version = $1; $perl_version =~ s{_}{}g; $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; $author =~ s{E}{<}g; $author =~ s{E}{>}g; $self->author($author); } else { warn "Cannot determine author info from $_[0]\n"; } } sub license_from { my $self = shift; if ( Module::Install::_read($_[0]) =~ m/ ( =head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b .*? ) (=head\\d.*|=cut.*|) \z /ixms ) { my $license_text = $1; my @phrases = ( 'under the same (?:terms|license) as perl itself' => 'perl', 1, 'GNU public license' => 'gpl', 1, 'GNU lesser public license' => 'lgpl', 1, 'BSD license' => 'bsd', 1, 'Artistic license' => 'artistic', 1, 'GPL' => 'gpl', 1, 'LGPL' => 'lgpl', 1, 'BSD' => 'bsd', 1, 'Artistic' => 'artistic', 1, 'MIT' => 'mit', 1, 'proprietary' => 'proprietary', 0, ); while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) { $pattern =~ s{\s+}{\\s+}g; if ( $license_text =~ /\b$pattern\b/i ) { if ( $osi and $license_text =~ /All rights reserved/i ) { print "WARNING: 'All rights reserved' in copyright may invalidate Open Source license.\n"; } $self->license($license); return 1; } } } warn "Cannot determine license info from $_[0]\n"; return 'unknown'; } sub bugtracker_from { my $self = shift; my $content = Module::Install::_read($_[0]); my @links = $content =~ m/L\<(http\:\/\/rt\.cpan\.org\/[^>]+)\>/g; unless ( @links ) { warn "Cannot determine bugtracker info from $_[0]\n"; return 0; } if ( @links > 1 ) { warn "Found more than on rt.cpan.org link in $_[0]\n"; return 0; } # Set the bugtracker bugtracker( $links[0] ); return 1; } sub install_script { my $self = shift; my $args = $self->makemaker_args; my $exe = $args->{EXE_FILES} ||= []; foreach ( @_ ) { if ( -f $_ ) { push @$exe, $_; } elsif ( -d 'script' and -f "script/$_" ) { push @$exe, "script/$_"; } else { die("Cannot find script '$_'"); } } } 1; Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Base.pm0000644000175000017500000000205011444365614024644 0ustar agostiniagostini#line 1 package Module::Install::Base; $VERSION = '0.76'; # Suspend handler for "redefined" warnings BEGIN { my $w = $SIG{__WARN__}; $SIG{__WARN__} = sub { $w }; } ### This is the ONLY module that shouldn't have strict on # use strict; #line 41 sub new { my ($class, %args) = @_; foreach my $method ( qw(call load) ) { *{"$class\::$method"} = sub { shift()->_top->$method(@_); } unless defined &{"$class\::$method"}; } bless( \%args, $class ); } #line 61 sub AUTOLOAD { my $self = shift; local $@; my $autoload = eval { $self->_top->autoload } or return; goto &$autoload; } #line 76 sub _top { $_[0]->{_top} } #line 89 sub admin { $_[0]->_top->{admin} or Module::Install::Base::FakeAdmin->new; } #line 101 sub is_admin { $_[0]->admin->VERSION; } sub DESTROY {} package Module::Install::Base::FakeAdmin; my $Fake; sub new { $Fake ||= bless(\@_, $_[0]) } sub AUTOLOAD {} sub DESTROY {} # Restore warning handler BEGIN { $SIG{__WARN__} = $SIG{__WARN__}->(); } 1; #line 146 Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Makefile.pm0000644000175000017500000001445411444365616025524 0ustar agostiniagostini#line 1 package Module::Install::Makefile; use strict 'vars'; use Module::Install::Base; use ExtUtils::MakeMaker (); use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.76'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } 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, always use defaults if ( $ENV{AUTOMATED_TESTING} and ! $ENV{PERL_MM_USE_DEFAULT} ) { local $ENV{PERL_MM_USE_DEFAULT} = 1; goto &ExtUtils::MakeMaker::prompt; } else { goto &ExtUtils::MakeMaker::prompt; } } sub makemaker_args { my $self = shift; my $args = ( $self->{makemaker_args} ||= {} ); %$args = ( %$args, @_ ); return $args; } # For mm args that take multiple space-seperated args, # append an argument to the current list. sub makemaker_append { my $self = sShift; 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 ); } my %test_dir = (); sub _wanted_t { /\.t$/ and -f $_ and $test_dir{$File::Find::dir} = 1; } sub tests_recursive { my $self = shift; if ( $self->tests ) { die "tests_recursive will not work if tests are already defined"; } my $dir = shift || 't'; unless ( -d $dir ) { die "tests_recursive dir '$dir' does not exist"; } %test_dir = (); require File::Find; File::Find::find( \&_wanted_t, $dir ); $self->tests( join ' ', map { "$_/*.t" } sort keys %test_dir ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; # Make sure we have a new enough require ExtUtils::MakeMaker; # 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. $self->configure_requires( 'ExtUtils::MakeMaker' => $ExtUtils::MakeMaker::VERSION =~ /^(\d+\.\d+)/ ); # Generate the my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name; $args->{VERSION} = $self->version; $args->{NAME} =~ s/-/::/g; if ( $self->tests ) { $args->{test} = { TESTS => $self->tests }; } if ($] >= 5.005) { $args->{ABSTRACT} = $self->abstract; $args->{AUTHOR} = $self->author; } if ( eval($ExtUtils::MakeMaker::VERSION) >= 6.10 ) { $args->{NO_META} = 1; } if ( eval($ExtUtils::MakeMaker::VERSION) > 6.17 and $self->sign ) { $args->{SIGN} = 1; } unless ( $self->is_admin ) { delete $args->{SIGN}; } # merge both kinds of requires into prereq_pm my $prereq = ($args->{PREREQ_PM} ||= {}); %$prereq = ( %$prereq, map { @$_ } map { @$_ } grep $_, ($self->configure_requires, $self->build_requires, $self->requires) ); # Remove any reference to perl, PREREQ_PM doesn't support it delete $args->{PREREQ_PM}->{perl}; # merge both kinds of requires into prereq_pm my $subdirs = ($args->{DIR} ||= []); if ($self->bundles) { foreach my $bundle (@{ $self->bundles }) { my ($file, $dir) = @$bundle; push @$subdirs, $dir if -d $dir; delete $prereq->{$file}; } } 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"; } $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)) { $args{dist} = $preop; } 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: $!"; my $makefile = do { local $/; }; close MAKEFILE or die $!; $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; open MAKEFILE, "> $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!"; 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 377 Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/AutoInstall.pm0000644000175000017500000000227211444365614026237 0ustar agostiniagostini#line 1 package Module::Install::AutoInstall; use strict; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.76'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } 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; Module::AutoInstall->import( (@config ? (-config => \@config) : ()), (@core ? (-core => \@core) : ()), $self->features, ); $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; Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/WriteAll.pm0000644000175000017500000000132111444365616025517 0ustar agostiniagostini#line 1 package Module::Install::WriteAll; use strict; use Module::Install::Base; use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '0.76'; @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->Meta->write if $args{meta}; $self->admin->WriteAll(%args) if $self->is_admin; $self->check_nmake if $args{check_nmake}; unless ( $self->makemaker_args->{PL_FILES} ) { $self->makemaker_args( PL_FILES => {} ); } if ( $args{inline} ) { $self->Inline->write; } else { $self->Makefile->write; } } 1; Jifty-Plugin-Authentication-Ldap-1.01/inc/Module/Install/Share.pm0000644000175000017500000000315411444365616025044 0ustar agostiniagostini#line 1 package Module::Install::Share; use strict; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.76'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } sub install_share { my $self = shift; my $dir = @_ ? pop : 'share'; my $type = @_ ? shift : 'dist'; unless ( defined $type and $type eq 'module' or $type eq 'dist' ) { die "Illegal or invalid share dir type '$type'"; } unless ( defined $dir and -d $dir ) { die "Illegal or missing directory install_share param"; } # Split by type my $S = ($^O eq 'MSWin32') ? "\\" : "\/"; if ( $type eq 'dist' ) { die "Too many parameters to install_share" if @_; # Set up the install $self->postamble(<<"END_MAKEFILE"); config :: \t\$(NOECHO) \$(MOD_INSTALL) \\ \t\t"$dir" \$(INST_LIB)${S}auto${S}share${S}dist${S}\$(DISTNAME) END_MAKEFILE } else { my $module = Module::Install::_CLASS($_[0]); unless ( defined $module ) { die "Missing or invalid module name '$_[0]'"; } $module =~ s/::/-/g; # Set up the install $self->postamble(<<"END_MAKEFILE"); config :: \t\$(NOECHO) \$(MOD_INSTALL) \\ \t\t"$dir" \$(INST_LIB)${S}auto${S}share${S}module${S}$module END_MAKEFILE } # The above appears to behave incorrectly when used with old versions # of ExtUtils::Install (known-bad on RHEL 3, with 5.8.0) # So when we need to install a share directory, make sure we add a # dependency on a moderately new version of ExtUtils::MakeMaker. $self->build_requires( 'ExtUtils::MakeMaker' => '6.11' ); # 99% of the time we don't want to index a shared dir $self->no_index( directory => $dir ); } 1; __END__ #line 125 Jifty-Plugin-Authentication-Ldap-1.01/Changes0000644000175000017500000000063711444121014021314 0ustar agostiniagostiniRevision history for Perl module Jifty::Plugin::Authentication::Ldap 1.01 Wed, 15 Sep 2010 12:36:08 +0200 - Active Directory style binding (ssinyagin) - hooks login (ssinyagin) 1.00 Wed, 10 Jun 2009 11:49:12 +0200 - bump version number to avoid conflict with debian 0.10 Tue, 09 Jun 2009 20:39:53 +0200 - mistake in test path 0.9 Tue, 15 May 2009 10:10:50 +0200 - original version for CPAN Jifty-Plugin-Authentication-Ldap-1.01/share/0000755000175000017500000000000011444365714021136 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/share/po/0000755000175000017500000000000011444365714021554 5ustar agostiniagostiniJifty-Plugin-Authentication-Ldap-1.01/share/po/jifty_plugin_authentication_ldap.pot0000644000175000017500000000214011444111700031057 0ustar agostiniagostini# SOME DESCRIPTIVE TITLE. # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER # This file is distributed under the same license as the PACKAGE package. # FIRST AUTHOR , YEAR. # #, fuzzy msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "POT-Creation-Date: YEAR-MO-DA HO:MI+ZONE\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=CHARSET\n" "Content-Transfer-Encoding: 8bit\n" #: plugins/Authentication-Ldap/lib/Jifty/Plugin/Authentication/Ldap/View.pm:28 msgid "Login with your Ldap account" msgstr "" #: plugins/Authentication-Ldap/lib/Jifty/Plugin/Authentication/Ldap/View.pm:35 msgid "Login with your ldap account" msgstr "" #: plugins/Authentication-Ldap/lib/Jifty/Plugin/Authentication/Ldap/Action/LDAPLogin.pm:46 msgid "That doesn't look like a valid login." msgstr "" #: plugins/Authentication-Ldap/lib/Jifty/Plugin/Authentication/Ldap/Action/LDAPLogin.pm:77 msgid "You may have mistyped your login or password. Give it another shot?" msgstr ""