parent results from the CPAN

  - SVM: Added binding for predict_values, improved memory usage
  - DataSet: changed to use sparse format internally
             internal format similar to what libsvm uses
             added asArray function, improved memory usage
  - All changes (except libsvm update which slightly changes the
    learned models) are completely transparent to the user. No
    changes in programs depending on this should be necessary.

0.13  Tue Jan 22 13:38:00 PDT 2008
	- Updated the underlaying libsvm version to 2.85

view all matches for this distribution

Algorithm-Scale2x

1 match

	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";
		my $method = $1;
		if ( uc($method) eq $method ) {

view all matches for this distribution

Algorithm-Shape-RandomTree

2 results

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN

            $self->create_branch( $stem, $level );
        }

    } else {

        # Get the current level's parent branches
        # ( i.e. the previous level's branches )
        my @parent_branches = $self->filter_branches( 
            sub { $_->level = ( $level - 1 ) }
        );

        foreach my $parent ( @parent_branches ) {
            # Number of sub branches 
            my $sub_branches = int( rand( $self->complexity ) );
            
            # Create sub-branches for the current parent branch
            foreach my $idx ( 1 .. $sub_branches ) {
                $self->create_branch( $parent, $level );
            }
        }
    }
}

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN

    return $stem;
}

# Linear algorithm's branch creation sub
sub create_branch {
    my ( $self, $parent, $level ) = @_;
    my $start_point = $parent->end_point;

    my $verb = $self->verbose;

    my ( $dx, $dy )       = $self->calc_new_deltas( $parent );
    my ( $x_end, $y_end ) = $self->calc_new_endpoints(
        $start_point, $dx, $dy
    );

    my $end_point = Algorithm::Shape::RandomTree::Branch::Point->new(

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN

        start_point => $start_point,
        end_point   => $end_point,
        dx          => $dx,
        dy          => $dy,
        level       => $level,
        parent      => $parent,
#       nodulation  => ,
#       complexity  => ,
    );

    $self->add_branch( $newbranch );
}


# Calculate New Deltas: uses the parent branch's attributes and random factors
# to modify a new branche's dx and dy values, who determin the angle and length
# of the new branch.
sub calc_new_deltas {
    my ( $self, $parent ) = @_;

    my $verb = $self->verbose;

    # Get parent branch's deltas
    my $old_dx = $parent->dx;
    my $old_dy = $parent->dy;
    
    # Calculate modifiers:
    # These slightly change the dx and dy to create variation and randomness
    # in branches lengths and angles.
    # Modifiers range from -range_value to +range_value

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN

    );
    
    # If the level is 0, it's the stem's children, so the falloff should be 1.5
    # (so that they would still be a bit shorter than the stem).
    # otherwise, it should be the level + 1
    my $falloff = ( $parent->level == 0 ) ? 1.5 : $parent->level + 1;
    
    # Apply modifiers
    my $new_dx = int ( ( $old_dx + $dx_modifier ) / $falloff );
    my $new_dy = int ( ( $old_dy + $dy_modifier ) / $falloff );

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN

    return( $x_end, $y_end );
}

# The recursive algorithm for creating all non-stem branches
sub create_branches_recursive {
    my ( $self, $parent ) = @_;

    my $verb = $self->verbose;

    my $name = $parent->name;
    $verb && print "[create_branches_recursive] on parent: $name\n";
    
    # Create a new branch connected to parent
    my $branch = $self->make_branch( $parent );
    
    # Create this branche's sub-branches
    if ( $branch->nodulation ) {
        foreach my $idx ( 1 .. $branch->complexity ) {
            $verb && print qq{

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN

    }
}

# Sub for creating single branches used by the recursive algorithm
sub make_branch {
    my ( $self, $parent ) = @_;
    my $start_point = $parent->end_point;

    my $verb = $self->verbose;

    my $name = $parent->name;
    $verb && print "[make_branche] on parent: $name\n";

    my ( $dx, $dy )       = $self->calc_new_deltas( $parent );
    my ( $x_end, $y_end ) = $self->calc_new_endpoints(
        $start_point, $dx, $dy
    );

    my $end_point  = Algorithm::Shape::RandomTree::Branch::Point->new(
        x => $x_end, y => $y_end
    );

    my $number     = $self->count_branches + 1;        # New branch's num (name)
    my $nodulation = $self->calc_new_nodulation( $parent );

    my $complexity = int( rand( $self->complexity ) ); # Calculate new complexity
    
    # Calculate new width, and prevent a less than 1 width
    my $falloff   = ( $parent->level == 0 ) ? 1.5 : $parent->level + 1;
    my $new_width = int ( $self->tree_width / $falloff );
    my $width     = $new_width ? $new_width : 1;
    
    my $path_str  = $self->create_path( $start_point, $end_point, $dx, $dy );

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN

        name        => $number,
        start_point => $start_point,
        end_point   => $end_point,
        dx          => $dx,
        dy          => $dy,
        level       => $parent->level + 1,
        parent      => $parent,
        nodulation  => $nodulation,
        complexity  => $complexity,
        width       => $width,
        path_string => $path_str,
    );

lib/Algorithm/Shape/RandomTree.pm view on Meta::CPAN


    return $newbranch;
}

sub calc_new_nodulation {
    my ( $self, $parent ) = @_;

    my $verb = $self->verbose;

    my $old = $parent->nodulation;
    
    # Reduce ebbing factor from the parent's nodulation
    my $new = $old - $self->ebbing_factor;
    
    return $new;
}

view all matches for this distribution

Algorithm-SocialNetwork

1 match

    my $sym = "$caller\::AUTOLOAD";

    $sym->{$cwd} = sub {
        my $pwd = Cwd::cwd();
        if (my $code = $sym->{$pwd}) {
            goto &$code unless $cwd eq $pwd; # delegate back to parent dirs
        }
        $$sym =~ /([^:]+)$/ or die "Cannot autoload $caller";
        unshift @_, ($self, $1);
        goto &{$self->can('call')} unless uc($1) eq $1;
    };

view all matches for this distribution

Algorithm-SpatialIndex-Storage-Redis

3 results

lib/Algorithm/SpatialIndex/Storage/Redis.pm view on Meta::CPAN

our $VERSION = '0.01';

use Scalar::Util qw(blessed);
use Redis;

use parent 'Algorithm::SpatialIndex::Storage';
use Sereal::Encoder;
use Sereal::Decoder;

use Class::XSAccessor {
  getters => {

view all matches for this distribution

Algorithm-SpatialIndex-Strategy-MedianQuadTree

1 match

lib/Algorithm/SpatialIndex/Strategy/MedianQuadTree.pm view on Meta::CPAN

use Carp qw(croak);

our $VERSION = '0.02';

use Algorithm::SpatialIndex::Strategy::QuadTree qw(:all);
use parent 'Algorithm::SpatialIndex::Strategy::QuadTree';

use Statistics::CaseResampling qw(median);

sub _node_split_coords {
  my ($self, $node, $bucket, $coords) = @_;

view all matches for this distribution

Algorithm-SpatialIndex

9 results

lib/Algorithm/SpatialIndex/Storage/DBI.pm view on Meta::CPAN

use warnings;
use Carp qw(croak);

our $VERSION = '0.02';

use parent 'Algorithm::SpatialIndex::Storage';
use constant DEBUG => 0;

=head1 NAME

Algorithm::SpatialIndex::Storage::DBI - DBI storage backend

view all matches for this distribution

Algorithm-ToNumberMunger

2 results

lib/Algorithm/ToNumberMunger.pm view on Meta::CPAN


The timestamp is parsed once and both columns are filled together, so they can
never drift apart or be half-configured. C<parts> and C<into> must be the same
length. (Using C<parts> without C<into>, or C<part> with C<into>, is an error.)

B<Performance.> Two transparent accelerations, both value-identical to the plain
path: a one-slot memo returns the previous result when the same stamp string
repeats (the common case in bursty event streams); and when the format is built
from only the six numeric codes C<%Y %m %d %H %M %S> (once each, e.g.
C<%Y-%m-%dT%H:%M:%S>), parsing skips C<strptime> for a compiled regex plus
integer date math, falling back to C<strptime> for any value the regex does not

lib/Algorithm/ToNumberMunger.pm view on Meta::CPAN

=back

Semantics worth knowing: a marked read B<includes the event just marked>; keys
have whitespace/control bytes replaced with C<_> to satisfy the daemon's key
rules; connections are made lazily on first use and kept open (reconnecting
transparently after a fork or an error), so compiling a plan -- including the
eager validation in C<write_info> -- needs no running daemon. Each eps column
costs one unix-socket round trip per row; the multi-output form exists so
rate+count of the same key costs one round trip, not two.

=cut

lib/Algorithm/ToNumberMunger.pm view on Meta::CPAN

# Default socket path of the iqbi-damiq daemon.
our $EPS_SOCKET = '/var/run/iqbi-damiq.sock';

# Persistent daemon connections, keyed by socket path, shared by every eps
# munger in the process. Entries record the pid that opened them so a forked
# writer transparently reopens instead of sharing a socket with its parent.
# Connections are made lazily on first use -- never at munger build time, so a
# plan can compile (eager validation) with no daemon running.
my %EPS_CONN;

sub _eps_conn {

view all matches for this distribution

Algorithm-Tree-NCA

1 match


use 5.006;
use strict;
use warnings;

use fields qw(_run _magic _number _parent _leader _max _node);

sub new ($%) {
    my $class = shift;
    # Default values first, then the provided parameters
    my %args = (_run => 0,        # Corresponds to I(v)
                _magic => 0,      # Corresponds to A_v
                _max => 0,        # Maximum number assigned to subtree
                _number => 0,     # The DFS number assigned to this node
                _parent => undef, # The parent node data for this node
                _leader => undef, # The leader node data for this node
                _node => undef,   # The node that the data is for
                @_);

    my $self = fields::new($class);

    # Computing magic number and leaders
    $self->_compute_magic($root, $self->_data($root), 0);
}

# Enumerate each node of the tree with a number v and compute the run
# I(v) for each node. Also set the parent for each node.
sub _enumerate ($$$;$) {
    my($self,$node,$number,$parent) = @_;

    my $data = Algorithm::Tree::NCA::Data
	->new(_node => $node,
	      _run => $number, 
	      _parent => $parent,
	      _number => $number);

    $self->{_data}->[$number] = $data;

    $self->_set($node,$number);

    #    Form the number u consisting of the bits of I(x) to the left
    #    of position k, followed by a 1-bit in position k, followed by
    #    all zeroes. (u will be I(w))
    my $u = ~(($k - 1) | $k) & $xd->{_run} | $k;

    #    Look up node L(I(w)), which must be node w. nx is then the parent
    #    of node w.
    my $wd = $self->{_data}->[$u]->{_leader};

    return $wd->{_parent};
    
}

sub nca ($$$) {
    my($self,$x,$y) = @_;


=item -
A I<magic> number (L<"ALGORITHM">)

=item -
The I<parent> node for each node

=item -
The I<maximum> number assigned to a any node in the subtree

=back

      ComputeMagic(root,root,0);
  End;

In the first phase, we enumerate the tree, compute the I<run> for each
node, the I<max> number assigned to a node in the subtree, and also
the I<parent> of each node. If the parent is already available through
other means, that part is redundant. The run of a node is the number
of the node in the subtree with the largest height.

  Function Enumerate(node,parent:Node; num:Integer) : (Integer,Integer)
  Var run : Integer;
  Begin
      node.parent := parent;
      node.number := num;
      node.run := num;

      run := num;
      num := num + 1;

    l := LSSB(n.magic);
    If l = j Then Return x
    k := MSSB((j - 1) AND x.magic);
    u := ((NOT ((k - 1) OR k)) AND x.run) OR k
    w := Leader(u);
    Return w.parent;  (* z = w.parent *)
  End;

=head1 REFERENCES

=over 4

view all matches for this distribution

Algorithm-VSM

6 results

examples/corpus_with_java_and_cpp/CrazyWindow.cc view on Meta::CPAN


#include "MyTextPanel.h"
#include "MyDrawPanel.h"


CrazyWindow::CrazyWindow( QWidget* parent, const char* name )    // (B)
    : QWidget( parent, name )
{
    QGridLayout* grid = new QGridLayout( this, 0, 1 );           // (C)

    MyTextPanel* textPanel = 
               new MyTextPanel( this, "for text only" );         // (D)

view all matches for this distribution

Algorithm-WordLevelStatistics

1 match

03. Space and Time in Classical Mechanics
04. The Galileian System of Co-ordinates
05. The Principle of Relativity (in the Restricted Sense)
06. The Theorem of the Addition of Velocities employed in
Classical Mechanics
07. The Apparent Incompatability of the Law of Propagation of
Light with the Principle of Relativity
08. On the Idea of Time in Physics
09. The Relativity of Simultaneity
10. On the Relativity of the Conception of Distance
11. The Lorentz Transformation

ideas. Geometry ought to refrain from such a course, in order to give
to its structure the largest possible logical unity. The practice, for
example, of seeing in a "distance" two marked positions on a
practically rigid body is something which is lodged deeply in our
habit of thought. We are accustomed further to regard three points as
being situated on a straight line, if their apparent positions can be
made to coincide for observation with one eye, under suitable choice
of our place of observation.

If, in pursuance of our habit of thought, we now supplement the
propositions of Euclidean geometry by the single proposition that two


A priori it is by no means certain that this last measurement will
supply us with the same result as the first. Thus the length of the
train as measured from the embankment may be different from that
obtained by measuring in the train itself. This circumstance leads us
to a second objection which must be raised against the apparently
obvious consideration of Section 6. Namely, if the man in the
carriage covers the distance w in a unit of time -- measured from the
train, -- then this distance -- as measured from the embankment -- is
not necessarily also equal to w.



THE LORENTZ TRANSFORMATION


The results of the last three sections show that the apparent
incompatibility of the law of propagation of light with the principle
of relativity (Section 7) has been derived by means of a
consideration which borrowed two unjustifiable hypotheses from
classical mechanics; these are as follows:

disappears, because the theorem of the addition of velocities derived
in Section 6 becomes invalid. The possibility presents itself that
the law of the propagation of light in vacuo may be compatible with
the principle of relativity, and the question arises: How have we to
modify the considerations of Section 6 in order to remove the
apparent disagreement between these two fundamental results of
experience? This question leads to a general one. In the discussion of
Section 6 we have to do with places and times relative both to the
train and to the embankment. How are we to find the place and time of
an event in relation to the train, when we know the place and time of
the event with respect to the railway embankment ? Is there a

here the fact that the theory of relativity enables us to predict the
effects produced on the light reaching us from the fixed stars. These
results are obtained in an exceedingly simple manner, and the effects
indicated, which are due to the relative motion of the earth with
reference to those fixed stars are found to be in accord with
experience. We refer to the yearly movement of the apparent position
of the fixed stars resulting from the motion of the earth round the
sun (aberration), and to the influence of the radial components of the
relative motions of the fixed stars with respect to the earth on the
colour of the light reaching us from them. The latter effect manifests
itself in a slight displacement of the spectral lines of the light

one, for reasons which will become evident at a later stage.

Since the introduction of the special principle of relativity has been
justified, every intellect which strives after generalisation must
feel the temptation to venture the step towards the general principle
of relativity. But a simple and apparently quite reliable
consideration seems to suggest that, for the present at any rate,
there is little hope of success in such an attempt; Let us imagine
ourselves transferred to our old friend the railway carriage, which is
travelling at a uniform rate. As long as it is moving unifromly, the
occupant of the carriage is not sensible of its motion, and it is for

gravitational field. Before proceeding farther, however, I must warn
the reader against a misconception suggested by these considerations.
A gravitational field exists for the man in the chest, despite the
fact that there was no such field for the co-ordinate system first
chosen. Now we might easily suppose that the existence of a
gravitational field is always only an apparent one. We might also
think that, regardless of the kind of gravitational field which may be
present, we could always choose another reference-body such that no
gravitational field exists with reference to it. This is by no means
true for all gravitational fields, but only for those of quite special
form. It is, for instance, impossible to choose a body of reference

incidence is nevertheless 1.7 seconds of arc. This ought to manifest
itself in the following way. As seen from the earth, certain fixed
stars appear to be in the neighbourhood of the sun, and are thus
capable of observation during a total eclipse of the sun. At such
times, these stars ought to appear to be displaced outwards from the
sun by an amount indicated above, as compared with their apparent
position in the sky when the sun is situated at another part of the
heavens. The examination of the correctness or otherwise of this
deduction is a problem of the greatest importance, the early solution
of which is to be expected of astronomers.[2]*

view all matches for this distribution

Alice

8 results

	my $cwd  = Cwd::cwd();
	my $sym  = "${who}::AUTOLOAD";
	$sym->{$cwd} = sub {
		my $pwd = Cwd::cwd();
		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.

view all matches for this distribution

Alien-7zip

1 match

alienfile view on Meta::CPAN

      my ($build) = @_;
      my $prefix = Path::Tiny::path($build->install_prop->{prefix});
      my $output = Path::Tiny::path($build_dir, $output_dir);

      my $prefix_bin_name = $prefix->child('bin', $bin_name);
      $prefix_bin_name->parent->mkpath;
      File::Copy::Recursive::fcopy($output->child($bin_name), $prefix_bin_name);
    }
  ];
  after build => sub {
    my($build) = @_;

alienfile view on Meta::CPAN

      $_->remove for $_7zip->children( qr/\.chm$|History\.txt|readme\.txt/ );
      my $bin_dir = $cwd->child('bin');
      $bin_dir->mkpath;
      File::Copy::Recursive::rmove( "$_7zip/*", $bin_dir );
      $_7zip->remove_tree;
      $_7zip->parent->remove_tree unless $_7zip->parent->children;
    };
    plugin 'Build::Copy';
    after build => sub {
      my($build) = @_;
      $build->runtime_prop->{'style'} = 'binary';

view all matches for this distribution

Alien-ActiveMQ

2 results

	my $cwd  = Cwd::cwd();
	my $sym  = "${who}::AUTOLOAD";
	$sym->{$cwd} = sub {
		my $pwd = Cwd::cwd();
		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.

view all matches for this distribution

Alien-Adaptagrams

4 results

lib/Alien/Adaptagrams.pm view on Meta::CPAN

# ABSTRACT: Alien package for the Adaptagrams adaptive diagram library
$Alien::Adaptagrams::VERSION = '0.001';
use strict;
use warnings;

use parent qw(Alien::Base);

sub pkg_config_path {
	my ($class) = @_;
	if( $class->install_type eq 'share' ) {
		return File::Spec->catfile( File::Spec->rel2abs($class->dist_dir), qw(lib pkgconfig) );

view all matches for this distribution

Alien-BCM2835

1 match

lib/Alien/BCM2835.pm view on Meta::CPAN

package Alien::BCM2835;

use strict;
use warnings;

use parent 'Alien::Base';

our $VERSION = '1.056';

1;

view all matches for this distribution

Alien-Base-Dino

6 results

lib/Alien/Base/Dino/darwin.pm view on Meta::CPAN


use strict;
use warnings;
use 5.008001;

# Apparently no OS specific operations need to be done
# on OS X / darwin

1;

__END__

view all matches for this distribution

Alien-Base-ModuleBuild

13 results

lib/Alien/Base/ModuleBuild.pm view on Meta::CPAN

package Alien::Base::ModuleBuild;

use strict;
use warnings;
use 5.008001;
use parent 'Module::Build';
use Capture::Tiny 0.17 qw/capture tee/;
use File::chdir;
use File::Spec;
use File::Basename qw/fileparse/;
use Carp;

lib/Alien/Base/ModuleBuild.pm view on Meta::CPAN


=over

=item General Usage (L<Module::Build>)

This is the landing document for L<Alien::Base::ModuleBuild>'s parent class.
It describes basic usage and background information.
Its main purpose is to assist the user who wants to learn how to invoke
and control C<Module::Build> scripts at the command line.

It also lists the extra documentation for its use. Users and authors of Alien::

view all matches for this distribution

Alien-Base-Wrapper

1 match

xt/author/version.t view on Meta::CPAN

use YAML qw( LoadFile );
use FindBin;
use File::Spec;

plan skip_all => "test not built yet (run dzil test)"
  unless -e dir( $FindBin::Bin)->parent->parent->file('Makefile.PL')
  ||     -e dir( $FindBin::Bin)->parent->parent->file('Build.PL');

my $config_filename = File::Spec->catfile(
  $FindBin::Bin, File::Spec->updir, File::Spec->updir, 'author.yml'
);

view all matches for this distribution

Alien-Base

2 results

lib/Alien/Base.pm view on Meta::CPAN

 package Alien::MyLibrary;

 use strict;
 use warnings;

 use parent 'Alien::Base';

 1;

(for details on the C<Makefile.PL> or C<Build.PL> and L<alienfile>
that should be bundled with your L<Alien::Base> subclass, please see

view all matches for this distribution

Alien-BatToExeConverter

1 match

	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";
		unless ( uc($1) eq $1 ) {
			unshift @_, ( $self, $1 );

view all matches for this distribution

Alien-Bazel

2 results

lib/Alien/Bazel/Util.pm view on Meta::CPAN

    }

    if( my $javac = which('javac') ) {
        my ($version, $exit) = capture_stdout { system($javac, qw(--version)) };
        if( !$exit && $version =~ /javac/s ) {
            my $java_home = path($javac)->realpath->parent(2);
            push @checks, { home => $java_home,
                src => 'javac in PATH' };
        }
    }

view all matches for this distribution

Alien-Bit

1 match

lib/Alien/Bit.pm view on Meta::CPAN

  use strict;
  use warnings;
  package Alien::Bit;
$Alien::Bit::VERSION = '0.09';
use parent qw( Alien::Base );

=head1 NAME

Alien::Bit - Find or install the Bit library

view all matches for this distribution

Alien-Build-Git

2 results

maint/update-corpus.pl view on Meta::CPAN

use warnings;
use autodie qw( :all );
use 5.010;
use Path::Tiny qw( path );

chdir(path(__FILE__)->absolute->parent->parent->child('corpus')->stringify);

system 'rm -rf Alien-Build-Git-Example1 example1.tar example1';
system 'git clone git@github.com:plicease/Alien-Build-Git-Example1.git Alien-Build-Git-Example1';
system 'mv Alien-Build-Git-Example1 example1';
system 'tar cvf example1.tar example1';

view all matches for this distribution

Alien-Build-MB

1 match

lib/Alien/Build/MB.pm view on Meta::CPAN


sub _alien_touch ($)
{
  my($name) = @_;
  my $path = Path::Tiny->new("_alien/mb/$name");
  $path->parent->mkpath;
  $path->touch;
}


sub ACTION_alien_download

lib/Alien/Build/MB.pm view on Meta::CPAN


  {
    my @parts = split /-/, $self->dist_name;
    my $package = join '::', @parts;
    my $install_files = Path::Tiny->new("./blib/lib")->child( @parts, 'Install', 'Files.pm' );
    $install_files->parent->mkpath;
    $install_files->spew_utf8(
      "package ${package}::Install::Files;\n",
      "use strict;\n",
      "use warnings;\n",
      "require ${package};\n",

view all matches for this distribution

Alien-Build-Plugin-Build-Make

2 results

t/alien_build_plugin_build_make.t view on Meta::CPAN

        path('install.pl')->spew("#!$^X\n", q{
          use strict;
          use warnings;
          use Path::Tiny qw( path );
          my($from, $to) = map { path($_) } @ARGV;
          $to->parent->mkpath;
          $from->copy($to);
          print "copy $from $to\n";
        });
        
        path('foo.c')->spew(

view all matches for this distribution

Alien-Build-Plugin-Cleanse-BuildDir

1 match

lib/Alien/Build/Plugin/Cleanse/BuildDir.pm view on Meta::CPAN

        $build->log ("Going to delete $build_dir\n");
        $build->log ("Currently in " . getcwd() . "\n");

        my $curdir = getcwd();
        if (path($curdir)->subsumes ($build_dir)) {
            $build->log ("Going to parent of build directory\n");
            chdir "$build_dir/..";
        }
        
        my $count = eval {
            remove_tree ($build_dir, {

view all matches for this distribution

Alien-Build-Plugin-Fetch-Cache

2 results

lib/Alien/Build/Plugin/Fetch/Cache.pm view on Meta::CPAN

      }
      my $res = $orig->($build, $url);

      if(defined $local_file)
      {
        $local_file->parent->mkpath;
        if($res->{type} eq 'file')
        {
          my $md5 = Digest::MD5->new;

          if($res->{content})

lib/Alien/Build/Plugin/Fetch/Cache.pm view on Meta::CPAN

          }

          my $data = Path::Tiny->new(bsd_glob '~/.alienbuild/plugin_fetch_cache/payload')
                     ->child($md5->hexdigest)
                     ->child($res->{filename});
          $data->parent->mkpath;

          my $res2 = {
            type     => 'file',
            filename => $res->{filename},
            path     => $data->stringify,

view all matches for this distribution

Alien-Build

48 results