ADAMK-Release
view release on metacpan or search on metacpan
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
inc/Module/Install.pm view on Meta::CPAN
# 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__};
inc/Module/Install.pm view on Meta::CPAN
# 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
inc/Module/Install.pm view on Meta::CPAN
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;
inc/Module/Install/Makefile.pm view on Meta::CPAN
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 {
inc/Module/Install/Makefile.pm view on Meta::CPAN
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 ) {
lib/ADAMK/Release.pm view on Meta::CPAN
######################################################################
# Constructor
sub new {
my $self = shift->SUPER::new(@_);
# Check module
unless ( _CLASS($self->module) ) {
$self->error("Missing or invalid module");
}
# Inflate and check the github object
if ( Params::Util::_HASH($self->github) ) {
$self->{github} = GitHub::Extract->new( %{$self->github} );
}
unless ( Params::Util::_INSTANCE($self->github, 'GitHub::Extract')) {
$self->error("Missing or invalid GitHub specification");
}
# Release options
$self->{release} = !!$self->{release};
# Find all of the command line tools
foreach my $tool ( TOOLS ) {
$self->{ "bin_" . $tool } = $self->which($tool);
}
lib/ADAMK/Release.pm view on Meta::CPAN
######################################################################
# Command Methods
sub run {
my $self = shift;
# Export from GitHub and change to the directory
my $pushd = $self->github->pushd;
unless ( $pushd ) {
$self->error(
"Failed to download and extract %s: %s",
$self->github->url,
$self->github->error,
);
}
# This is total bulldozer coding, there is no reason whatsoever why
# this stuff should be in seperate methods except that it provides
# a little cleaner logical breakup, and maybe I want to subclass this
# someday or something.
$self->validate;
$self->assemble;
$self->build;
lib/ADAMK/Release.pm view on Meta::CPAN
# Release the distribution
$self->upload if $self->release;
return;
}
sub validate {
my $self = shift;
unless ( $self->dist_version ) {
$self->error("Failed to find version number in main module");
}
unless ( $self->makefile_pl or $self->build_pl ) {
$self->error("Failed to find Makefile.PL or Build.PL");
}
return;
}
sub assemble {
my $self = shift;
# Create MANIFEST.SKIP
if ( -f $self->dist_manifest_add ) {
lib/ADAMK/Release.pm view on Meta::CPAN
)
}
# Localise all newlines in text files
$self->file_localize->localize( $self->dist_dir );
# Check for various unsafe things in Makefile.PL
if ( $self->makefile_pl ) {
if ( $self->makefile_pl =~ /use inc::Module::Install/ ) {
if ( $self->makefile_pl =~ /\bauto_install\b/ ) {
$self->error("Makefile.PL contains dangerous auto_install");
}
} else {
unless ( $self->makefile_pl =~ /use strict/ ) {
$self->error("Makefile.PL does not use strict");
}
unless ( $self->makefile_pl =~ /(?:use|require) \d/ ) {
$self->error("Makefile.PL does not declare a minimum Perl version");
}
}
}
# Check file permissions
foreach my $file ( sort $self->find_0644->in( $self->dist_dir ) ) {
my $mode = (stat($file))[2] & 07777;
next if $mode == 0644;
$self->shell(
$self->bin_chmod,
'0644',
$file,
"Error setting $file to 0644 permissions",
);
}
# Make sure exe files are marked with executable permissions
if ( $self->find_executable->in( $self->dist_dir ) ) {
$self->error("Found at least one .exe file without -x unix permissions");
}
# Check the Changes file
unless ( $self->no_changes ) {
# Read in the Changes file
unless ( -f $self->dist_changes ) {
$self->error("Distribution does not have a Changes file");
}
unless ( open( CHANGES, $self->dist_changes ) ) {
$self->error("Failed to open Changes file");
}
my @lines = <CHANGES>;
close CHANGES;
unless ( @lines >= 3 ) {
$self->error("Changes file is empty or too small");
}
# The Changes version should be the first thing on the third line
my $current = $lines[2];
my ($version) = split /\s+/, $current;
unless ( $version =~ /[\d\._]{3}/ ) {
$self->error(
"Failed to find current version, or too short, in '%2'",
$current,
);
}
# Does it match the version in the main module
unless ( $version eq $self->dist_version ) {
$self->error(
"Version in Changes file (%s) does not match module version (%s)",
$version,
$self->dist_version,
);
}
}
# Check that the main module documentation Copyright is the current year
unless ( $self->no_copyright ) {
# Read the file
unless ( open( MODULE, $self->module_doc ) ) {
$self->error(
"Failed to open '%s'",
$self->module_doc,
);
}
my @lines = <MODULE>;
close MODULE;
# Look for the current year
my $year = 1900 + (localtime time)[5];
unless ( grep { /copyright/i and /$year/ } @lines ) {
$self->error("Missing Copyright, or does not refer to current year");
}
# Merge the module to a single string
my $merged = join "\n", @lines;
unless ( $self->no_rt ) {
my $dist_name = $self->dist;
unless ( $merged =~ /L\<http\:\/\/rt\.cpan\.org\/.+?=([\w-]+)\>/ ) {
$self->error("Failed to find a link to the public RT queue");
}
unless ( $dist_name eq $1 ) {
$self->error("Expected a public link to $dist_name RT queue, but found a link to the $1 queue");
}
}
}
# Touch all files to correct any potential time skews
foreach my $file ( $self->find_files->in( $self->dist_dir ) ) {
$self->shell(
$self->bin_touch,
$file,
"Error while touching $file to prevent clock skew",
lib/ADAMK/Release.pm view on Meta::CPAN
local $ENV{RELEASE_TESTING} = '';
# Run either of the build protocols
if ( $self->makefile_pl ) {
$self->build_make;
} elsif ( $self->build_pl ) {
$self->build_perl;
} else {
$self->error("Module does not have a Makefile.PL or Build.PL");
}
# Double check that the build produced a tarball where we expect it to be
unless ( -f $self->dist_tardist ) {
$self->error(
"Failed to create tardist at '%s'",
$self->dist_tardist,
);
}
return;
}
sub build_make {
my $self = shift;
lib/ADAMK/Release.pm view on Meta::CPAN
);
return;
}
sub upload {
my $self = shift;
my $pauseid = $self->prompt("PAUSEID:");
unless (_STRING($pauseid) and $pauseid =~ /^[A-Z]{3,}$/) {
$self->error("Missing or invalid PAUSEID");
}
my $password = $self->password("Password:");
unless (_STRING($password) and $password =~ /^\S{5,}$/) {
$self->error("Missing or invalid CPAN password");
}
# Execute the upload to CPAN
CPAN::Uploader->upload_file( $self->dist_tardist, {
user => $pauseid,
password => $password,
});
}
lib/ADAMK/Release.pm view on Meta::CPAN
sub shared_manifest_skip {
catfile( $_[0]->shared_dir, 'MANIFEST.SKIP' );
}
sub shared_license {
catfile( $_[0]->shared_dir, 'LICENSE' );
}
sub shared_dir {
File::ShareDir::dist_dir('ADAMK-Release')
or $_[0]->error("Failed to find share directory");
}
######################################################################
# Support Methods
# Is a particular program installed, and where
sub which {
my $self = shift;
my $program = shift;
my ($location) = (`which $program`);
chomp $location;
unless ( $location ) {
$self->error("Can't find the required program '$program'. Please install it");
}
unless ( -r $location and -x $location ) {
$self->error("The required program '$program' is installed, but I do not have permission to read or execute it");
}
return $location;
}
sub copy {
my $self = shift;
my $from = shift;
my $to = shift;
File::Flat->copy( $from => $to ) and return 1;
$self->error("Failed to copy '$from' to '$to'");
}
sub move {
my $self = shift;
my $from = shift;
my $to = shift;
File::Flat->copy( $from => $to ) and return 1;
$self->error("Failed to move '$from' to '$to'");
}
sub remove {
my $self = shift;
my $path = shift;
if ( -e $path ) {
$self->sudo(
"rm -rf $path",
"Failed to remove '$path'"
);
lib/ADAMK/Release.pm view on Meta::CPAN
ADAMK_RELEASE => 1,
RELEASE_TESTING => $ENV{RELEASE_TESTING} ? 1 : 0,
AUTOMATED_TESTING => $ENV{AUTOMATED_TESTING} ? 1 : 0,
);
print "> (sudo) $cmd\n" if $self->verbose;
my $sudo = $self->bin_sudo;
my $rv = ! system( "$sudo bash -c '$env $cmd'" );
if ( $rv or ! @_ ) {
return $rv;
}
$self->error($message);
}
sub shell {
my $self = shift;
my $message = pop @_;
my $cmd = join ' ', @_;
my $env = $self->env(
ADAMK_RELEASE => 1,
RELEASE_TESTING => $ENV{RELEASE_TESTING} ? 1 : 0,
AUTOMATED_TESTING => $ENV{AUTOMATED_TESTING} ? 1 : 0,
);
print "> $cmd\n" if $self->verbose;
my $rv = ! system( "$env $cmd" );
if ( $rv or ! @_ ) {
return $rv;
}
$self->error($message);
}
sub env {
my $self = shift;
my %env = @_;
join ' ', map { "$_=$env{$_}" } sort keys %env;
}
sub error {
my $self = shift;
my $message = sprintf(shift, @_);
Carp::croak($message);
}
sub prompt {
my $self = shift;
return IO::Prompt::Tiny::prompt(@_);
}
share/LICENSE view on Meta::CPAN
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
share/LICENSE view on Meta::CPAN
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
share/LICENSE view on Meta::CPAN
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
( run in 1.224 second using v1.01-cache-2.11-cpan-49f99fa48dc )