Math-RandomOrg-0.04/0000755000076500007650000000000010532631630014445 5ustar samofoolsamofoolMath-RandomOrg-0.04/Changes0000644000076500007650000000077010532631464015751 0ustar samofoolsamofoolRevision history for Perl extension Math/RandomOrg.pm: 0.04 Mon Nov 27 2006 - Changes to conform to CPANTS Kwalitee: - Added pod tests. - Added examples directory. - Updated Makefile.PL to use Module::Install and provide licensing terms. 0.03 Tue May 30 02:56:00 EST 2006 - Added checkbuf() and randseq() functions (thanks to Aaron Dalton). 0.02 Wed Jan 9 06:50:00 EST 2002 - fixed POD syntax error - cleaned up for CPAN release 0.01 Tue Oct 16 16:34:00 EST 2001 - original version Math-RandomOrg-0.04/examples/0000755000076500007650000000000010532631630016263 5ustar samofoolsamofoolMath-RandomOrg-0.04/examples/coin_toss.pl0000755000076500007650000000031610513223340020615 0ustar samofoolsamofool#!/usr/bin/perl use strict; use warnings; use lib qw(../lib); use Math::RandomOrg qw(randnum); my @names = qw(Heads Tails); for (1 .. 10) { my $value = randnum(0, 1); print $names[ $value ] . "\n"; } Math-RandomOrg-0.04/inc/0000755000076500007650000000000010532631630015216 5ustar samofoolsamofoolMath-RandomOrg-0.04/inc/Module/0000755000076500007650000000000010532631630016443 5ustar samofoolsamofoolMath-RandomOrg-0.04/inc/Module/Install/0000755000076500007650000000000010532631630020051 5ustar samofoolsamofoolMath-RandomOrg-0.04/inc/Module/Install/Base.pm0000644000076500007650000000203510502142505021254 0ustar samofoolsamofool#line 1 package Module::Install::Base; $VERSION = '0.63'; # 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; } 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 138 Math-RandomOrg-0.04/inc/Module/Install/Makefile.pm0000644000076500007650000001337310502142505022126 0ustar samofoolsamofool#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.63'; $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, @_ ) if @_; $args; } # For mm args that take multiple space-seperated args, # append an argument to the current list. sub makemaker_append { my $self = shift; my $name = shift; my $args = $self->makemaker_args; $args->{name} = defined $args->{$name} ? join( ' ', $args->{name}, @_ ) : join( ' ', @_ ); } sub build_subdirs { my $self = shift; my $subdirs = $self->makemaker_args->{DIR} ||= []; for my $subdir (@_) { push @$subdirs, $subdir; } } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join(' ', grep length, $clean->{FILES}, @_), ); } sub realclean_files { my $self = shift; my $realclean = $self->makemaker_args->{realclean} ||= {}; %$realclean = ( %$realclean, FILES => join(' ', grep length, $realclean->{FILES}, @_), ); } sub libs { my $self = shift; my $libs = ref $_[0] ? shift : [ shift ]; $self->makemaker_args( LIBS => $libs ); } sub inc { my $self = shift; $self->makemaker_args( INC => shift ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name || $self->determine_NAME($args); $args->{VERSION} = $self->version || $self->determine_VERSION($args); $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->build_requires, $self->requires) ); # 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"; } my %args = map { ( $_ => $args->{$_} ) } grep {defined($args->{$_})} keys %$args; if ($self->admin->preop) { $args{dist} = $self->admin->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 334 Math-RandomOrg-0.04/inc/Module/Install/MakeMaker.pm0000644000076500007650000000206410502142505022241 0ustar samofoolsamofool#line 1 package Module::Install::MakeMaker; use strict; use Module::Install::Base; use ExtUtils::MakeMaker (); use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.63'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } my $makefile; sub WriteMakefile { my ($self, %args) = @_; $makefile = $self->load('Makefile'); # mapping between MakeMaker and META.yml keys $args{MODULE_NAME} = $args{NAME}; unless ($args{NAME} = $args{DISTNAME} or !$args{MODULE_NAME}) { $args{NAME} = $args{MODULE_NAME}; $args{NAME} =~ s/::/-/g; } foreach my $key (qw(name module_name version version_from abstract author)) { my $value = delete($args{uc($key)}) or next; $self->$key($value); } if (my $prereq = delete($args{PREREQ_PM})) { while (my($k,$v) = each %$prereq) { $self->requires($k,$v); } } # put the remaining args to makemaker_args $self->makemaker_args(%args); } END { if ( $makefile ) { $makefile->write; $makefile->Meta->write; } } 1; Math-RandomOrg-0.04/inc/Module/Install/Metadata.pm0000644000076500007650000001747610502142505022141 0ustar samofoolsamofool#line 1 package Module::Install::Metadata; use strict 'vars'; use Module::Install::Base; use vars qw{$VERSION $ISCORE @ISA}; BEGIN { $VERSION = '0.63'; $ISCORE = 1; @ISA = qw{Module::Install::Base}; } my @scalar_keys = qw{ name module_name abstract author version license distribution_type perl_version tests }; my @tuple_keys = qw{ build_requires requires recommends bundles }; sub Meta { shift } sub Meta_ScalarKeys { @scalar_keys } sub Meta_TupleKeys { @tuple_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 (@tuple_keys) { *$key = sub { my $self = shift; return $self->{values}{$key} unless @_; my @rv; while (@_) { my $module = shift or last; my $version = shift || 0; if ( $module eq 'perl' ) { $version =~ s{^(\d+)\.(\d+)\.(\d+)} {$1 + $2/1_000 + $3/1_000_000}e; $self->perl_version($version); next; } my $rv = [ $module, $version ]; push @rv, $rv; } push @{ $self->{values}{$key} }, @rv; @rv; }; } 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, skipping\n"; return $self; } $self->{'values'}{'dynamic_config'} = $_[0] ? 1 : 0; return $self; } 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; die "all_from: cannot find $file from $name" unless -e $file; } $self->version_from($file) unless $self->version; $self->perl_version_from($file) unless $self->perl_version; # The remaining probes read from POD sections; if the file # has an accompanying .pod, use that instead my $pod = $file; if ( $pod =~ s/\.pm$/.pod/i and -e $pod ) { $file = $pod; } $self->author_from($file) unless $self->author; $self->license_from($file) unless $self->license; $self->abstract_from($file) unless $self->abstract; } 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', 0 ); require YAML; my $data = YAML::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 { my ( $self, $file ) = @_; require ExtUtils::MM_Unix; $self->version( ExtUtils::MM_Unix->parse_version($file) ); } sub abstract_from { my ( $self, $file ) = @_; require ExtUtils::MM_Unix; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix' )->parse_abstract($file) ); } sub _slurp { my ( $self, $file ) = @_; local *FH; open FH, "< $file" or die "Cannot open $file.pod: $!"; do { local $/; }; } sub perl_version_from { my ( $self, $file ) = @_; if ( $self->_slurp($file) =~ m/ ^ use \s* v? ([\d_\.]+) \s* ; /ixms ) { my $v = $1; $v =~ s{_}{}g; $self->perl_version($1); } else { warn "Cannot determine perl version info from $file\n"; return; } } sub author_from { my ( $self, $file ) = @_; my $content = $self->_slurp($file); 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 $file\n"; } } sub license_from { my ( $self, $file ) = @_; if ( $self->_slurp($file) =~ 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', 'GNU public license' => 'gpl', 'GNU lesser public license' => 'gpl', 'BSD license' => 'bsd', 'Artistic license' => 'artistic', 'GPL' => 'gpl', 'LGPL' => 'lgpl', 'BSD' => 'bsd', 'Artistic' => 'artistic', ); while ( my ( $pattern, $license ) = splice( @phrases, 0, 2 ) ) { $pattern =~ s{\s+}{\\s+}g; if ( $license_text =~ /\b$pattern\b/i ) { $self->license($license); return 1; } } } warn "Cannot determine license info from $file\n"; return 'unknown'; } 1; Math-RandomOrg-0.04/inc/Module/Install.pm0000644000076500007650000001761110502142505020410 0ustar samofoolsamofool#line 1 package Module::Install; # For any maintainers: # The load order for Module::Install is a bit magic. # It goes something like this... # # IF ( host has Module::Install installed, creating author mode ) { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to installed version of inc::Module::Install # 3. The installed version of inc::Module::Install loads # 4. inc::Module::Install calls "require Module::Install" # 5. The ./inc/ version of Module::Install loads # } ELSE { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to ./inc/ version of Module::Install # 3. The ./inc/ version of Module::Install loads # } use 5.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.63'; } # 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 } use Cwd (); use File::Find (); use File::Path (); use FindBin; *inc::Module::Install::VERSION = *VERSION; @inc::Module::Install::ISA = __PACKAGE__; 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"}; } sub preload { my ($self) = @_; 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"; 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) ) { open PKGFILE, "<$subpath.pm" or die "find_extensions: Can't open $subpath.pm: $!"; my $in_pod = 0; while ( ) { $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; } } close PKGFILE; } push @found, [ $file, $pkg ]; }, $path ) if -d $path; @found; } sub _caller { my $depth = 0; my $call = caller($depth); while ( $call eq __PACKAGE__ ) { $depth++; $call = caller($depth); } return $call; } 1; Math-RandomOrg-0.04/lib/0000755000076500007650000000000010532631630015213 5ustar samofoolsamofoolMath-RandomOrg-0.04/lib/Math/0000755000076500007650000000000010532631630016104 5ustar samofoolsamofoolMath-RandomOrg-0.04/lib/Math/RandomOrg.pm0000644000076500007650000001320710532631553020341 0ustar samofoolsamofool=head1 NAME Math::RandomOrg - Retrieve random numbers and data from random.org. =head1 SYNOPSIS use Math::RandomOrg qw(randnum randbyte); my $number = randnum(0, 10); my $octet = randbyte(1); =head1 DESCRIPTION Math::RandomOrg provides functions for retrieving random data from the random.org server. Data may be retrieved in an integer or byte-stream format using the C and C functions respectively. =head1 REQUIRES =over 4 =item Carp =item Exporter =item Math::BigInt =item LWP::Simple =back =head1 EXPORT None by default. You may request the following symbols be exported: =over 4 =item * randnum =item * randbyte =back =cut package Math::RandomOrg; use strict; use warnings; our ($VERSION, @ISA, @EXPORT, @EXPORT_OK); require Exporter; @ISA = qw(Exporter); @EXPORT_OK = qw( checkbuf randnum randbyte randseq ); @EXPORT = qw(); $VERSION = '0.04'; use Carp; use Math::BigInt; use LWP::Simple (); my $RAND_MIN = new Math::BigInt "-1000000000"; # random.org fixed min my $RAND_MAX = new Math::BigInt "1000000000"; # random.org fixed max my $NUM_BUF = 256; # at least, request this number of random integers in each request to random.org =head1 FUNCTIONS =over 4 =cut { my @randnums; =item C This routine takes no parameters and simply returns a single value (e.g., C<28%>) telling you how full the buffer is. At 100%, the buffer is full and you are free to hit it with automated clients. At 0%, the buffer is empty and requests will hang. When less than 100%, the buffer is being filled continually, but doing so takes time. I advise people with automated clients to check the buffer level every once in a while and only issue requests when the buffer level is 20% or higher. =cut sub checkbuf { my $url = "http://www.random.org/cgi-bin/checkbuf"; my $data = LWP::Simple::get( $url ); if (defined($data)) { $data =~ s/\%//; return $data; } else { carp "HTTP GET failed for $url"; return; } } =item C Return an integer (specifically a Math::BigInt object) between the bounds [ $min, $max ] (inclusive). By default, $max and $min are positive and negative 1e9, respectively. These default values represent random.org's current extrema for the bounds of the randnum function. Therefore, $min and $max may not exceed the default values. =cut sub randnum (;$$) { use integer; my $min = new Math::BigInt (defined($_[0]) ? $_[0] : $RAND_MIN); my $max = new Math::BigInt (defined($_[1]) ? $_[1] : $RAND_MAX); if ($min < $RAND_MIN or $max > $RAND_MAX) { carp "The $min and $max arguments to the randnum() function may not exceed the bounds ($RAND_MIN, $RAND_MAX)!"; return undef; } if ($#randnums == -1) { my $url = "http://www.random.org/cgi-bin/randnum?num=${NUM_BUF}&min=${RAND_MIN}&max=${RAND_MAX}&col=1"; my $data = LWP::Simple::get( $url ); if (defined($data)) { @randnums = map { new Math::BigInt $_ } (split(/\n/, $data)); } else { carp "HTTP GET failed for $url"; return undef; } } my $num = shift(@randnums); $num -= $RAND_MIN; $num *= (1 + $max - $min); $num /= ($RAND_MAX - $RAND_MIN); $num += $min; return $num; } my $randbytes = ''; =item C Returns an octet-string of specified length (defaults to one byte), which contains random bytes. $length may not exceed 16,384, as this is the maximum number of bytes retrievable from the random.org server in one request, and making multiple requests for an unbounded amount of data would unfairly tax the random.org server. If you need large amounts of random data, you may wish to try the Math::TrulyRandom module. =cut sub randbyte (;$) { my $length = +(shift || 1); if ($length > 16_384) { carp "randbyte() should not be used to generate random data larger than 16,384 bytes (lest we swamp random.org's entropy source)."; return ''; } elsif (length($randbytes) < $length) { my $nbytes = ($length > 512) ? $length : 512; my $url = "http://www.random.org/cgi-bin/randbyte?nbytes=${nbytes}&format=f"; my $data = LWP::Simple::get( $url ); if (defined($data)) { $randbytes .= $data; } else { carp "HTTP GET failed for $url"; return undef; } } return substr($randbytes, 0, $length, ''); } } =item C The randseq script returns a randomized sequence of numbers. This corresponds to dropping a number of lottery tickets into a hat and drawing them out in random order. Hence, each number in a randomized sequence occurs exactly once. Example: C will return the numbers between 1 and 10 (both inclusive) in a random order. =cut sub randseq (;$$) { my ($min, $max) = @_; return if ( (! defined $min) || (! defined $max) || ($min !~ /^\-?\d+$/) || ($max !~ /^\-?\d+$/) ); if ($max < $min) { carp "MAX must be greater than MIN."; return; } if ($max - $min > 10000) { carp "random.org restricts the size of sequences to <= 10,000."; return; } my @sequence = (); my $url = "http://www.random.org/cgi-bin/randseq?min=$min&max=$max"; my $data = LWP::Simple::get( $url ); if (defined($data)) { @sequence = map { new Math::BigInt $_ } (split(/\n/, $data)); } else { carp "HTTP GET failed for $url"; return undef; } return wantarray ? @sequence : \@sequence; } 1; __END__ =back =head1 BUGS None known. =head1 SEE ALSO =over 4 =item * L =item * L =back =head1 COPYRIGHT Copyright (c) 2001-2006 Gregory Todd Williams. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 AUTHOR Gregory Todd Williams C<< >> =cut Math-RandomOrg-0.04/Makefile.PL0000644000076500007650000000102110513306370016410 0ustar samofoolsamofool# use ExtUtils::MakeMaker; use inc::Module::Install; license 'perl'; build_requires 'Test::More' => '0.42'; no_index 'directory' => 'examples'; perl_version '5.006'; WriteMakefile( 'NAME' => 'Math::RandomOrg', 'AUTHOR' => 'Gregory Todd Williams ', 'ABSTRACT' => 'Retrieve random numbers and data from the random.org webservice.', 'VERSION_FROM' => 'lib/Math/RandomOrg.pm', # finds $VERSION 'PREREQ_PM' => { 'LWP' => 0, 'Math::BigInt' => 0, } ); Math-RandomOrg-0.04/MANIFEST0000644000076500007650000000046210527733457015616 0ustar samofoolsamofoolChanges lib/Math/RandomOrg.pm Makefile.PL META.yml MANIFEST MANIFEST.SKIP README t/randbyte.t t/randnum.t t/pod.t t/pod_coverage.t SIGNATURE inc/Module/Install/Base.pm inc/Module/Install/Makefile.pm inc/Module/Install/MakeMaker.pm inc/Module/Install/Metadata.pm inc/Module/Install.pm examples/coin_toss.pl Math-RandomOrg-0.04/MANIFEST.SKIP0000644000076500007650000000027010513213767016350 0ustar samofoolsamofoolinc/.author MANIFEST.SKIP Makefile .DS_Store .svn \.AppleDouble/.* CVS/.* \.bak$ \.sw[a-z]$ \.tar$ \.tgz$ \.tar\.gz$ ^mess/ ^tmp/ ^Tblib/ ^Makefile$ ^Makefile\.[a-z]+$ ^pm_to_blib$ ~$ Math-RandomOrg-0.04/META.yml0000644000076500007650000000071710527733347015737 0ustar samofoolsamofool--- #YAML:1.0 meta-spec: version: 1.3 url: http://module-build.sourceforge.net/META-spec-v1.3.html name: Math-RandomOrg abstract: Retrieve random numbers and data from the random.org webservice. author: 'Gregory Todd Williams ' build_requires: Test::More: 0.61 distribution_type: module generated_by: Module::Install version 0.630 license: perl no_index: directory: - inc - t requires: LWP: 0 Math::BigInt: 0 version: 0.04 Math-RandomOrg-0.04/README0000644000076500007650000000172010436766441015341 0ustar samofoolsamofool============================================================================== Release of version 0.02 of Math::RandomOrg ============================================================================== NAME Math::RandomOrg - Retrieve random numbers and data from random.org. DESCRIPTION Math::RandomOrg provides functions for retrieving random data from the random.org server. Data may be retrieved in an integer or byte stream format using the C and C functions respectively. REQUIRES Carp LWP::Simple Math::BigInt INSTALLING To install, run the following commands: perl Makefile.PL make make test make install AUTHOR Gregory Todd Williams COPYRIGHT Copyright (c) 2001--2006, Gregory Williams. All rights reserved. This module is free software. It may be used, redistributed and/or modified under the same terms as Perl itself. Math-RandomOrg-0.04/SIGNATURE0000644000076500007650000000340610532631624015737 0ustar samofoolsamofoolThis file contains message digests of all files listed in MANIFEST, signed via the Module::Signature module, version 0.55. To verify the content in this distribution, first make sure you have Module::Signature installed, then type: % cpansign -v It will check each file's integrity, as well as the signature's validity. If "==> Signature verified OK! <==" is not displayed, the distribution may already have been compromised, and you should not run its Makefile.PL or Build.PL. -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 SHA1 e0a717659a772c0c5ad1b7064c0253d2d4d66389 Changes SHA1 11cea98f0f34df50ab28a45db24ab7f288143381 MANIFEST SHA1 1dd2e3c2a3bfe7f15de250ecc198ad01f3d37cf2 MANIFEST.SKIP SHA1 155ee802c38a31a39654c26ad784dae6acaeaf2e META.yml SHA1 6b8d23797e0c630d18ef880f0e3bdc1697983620 Makefile.PL SHA1 56ec8fb179b5a06c23553df5105780af6a5cd1f4 README SHA1 cf8c8a35c5503cb474d671d6f6f331a4ab4e0c8c examples/coin_toss.pl SHA1 017bedfcba1e0c72b36301e6ef21b8712b84d175 inc/Module/Install.pm SHA1 b1a70869c098ba602151631386fc510b5bfd3511 inc/Module/Install/Base.pm SHA1 d864f4a0dd148e4651cbe29c54c2ffc94d0f05f7 inc/Module/Install/MakeMaker.pm SHA1 176d68fe7c07b6ab7cfe09093078b8127bbde786 inc/Module/Install/Makefile.pm SHA1 8b37b38215d14f922b3d5132ce33d11d21d531ba inc/Module/Install/Metadata.pm SHA1 773a169d632a63c07ade15441af93e4ce0ac8262 lib/Math/RandomOrg.pm SHA1 fada08a138c7f5d0c435fbd184ebfbd975f5da7d t/pod.t SHA1 7dfbc25c2ead100477bc171b71bb85ba596adcc7 t/pod_coverage.t SHA1 467e7603cfc807aa7bd33480864b535018216d78 t/randbyte.t SHA1 d3895ff017283a27d281252f7bdecadf973077b1 t/randnum.t -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.2.4 (Darwin) iD8DBQFFazOUhPK6VMqoyC0RAgfjAJ9ZlaXpjlhsZ58yHR2zVmeU8qLeyACdEZ48 qV+NWR9QnUoUrpw4l/q7LLw= =6OCu -----END PGP SIGNATURE----- Math-RandomOrg-0.04/t/0000755000076500007650000000000010532631630014710 5ustar samofoolsamofoolMath-RandomOrg-0.04/t/pod.t0000644000076500007650000000021510450023410015643 0ustar samofoolsamofooluse strict; use Test::More; eval "use Test::Pod 1.00"; plan skip_all => "Test::Pod 1.00 required for testing POD" if $@; all_pod_files_ok(); Math-RandomOrg-0.04/t/pod_coverage.t0000644000076500007650000000025510450023410017522 0ustar samofoolsamofooluse strict; use Test::More; eval "use Test::Pod::Coverage 1.00"; plan skip_all => "Test::Pod::Coverage 1.00 required for testing POD coverage" if $@; all_pod_coverage_ok(); Math-RandomOrg-0.04/t/randbyte.t0000644000076500007650000000026307363105524016714 0ustar samofoolsamofooluse strict; use Test; use Math::RandomOrg qw(randnum randbyte); BEGIN { plan tests => (10) } for my $i (1 .. 10) { my $octets = randbyte( $i ); ok( length($octets), $i ); } Math-RandomOrg-0.04/t/randnum.t0000644000076500007650000000046707363120643016555 0ustar samofoolsamofooluse strict; use Test; use Math::RandomOrg qw(randnum randbyte); BEGIN { plan tests => (3*3*20) } foreach my $max (1, 1_000, 1_000_000_000) { foreach my $min (1, 0, -1_000_000_000) { for (1 .. 20) { my $number = randnum( $min, $max ); ($number >= $min and $number <= $max) ? ok(1) : ok(0); } } }