view release on metacpan or  search on metacpan

lib/ExtUtils/Builder/Planner.pm  view on Meta::CPAN

sub _new_scope {
	my ($self, $base_class, $outer, $nodes, $filesets) = @_;

	my $class = __PACKAGE__ . '::Anon_' . ++$class_counter;
	no strict 'refs';
	push @{ "$class\::ISA" }, $base_class;

	my $new = bless {
		nodes    => $nodes,
		filesets => $filesets
	}, $class;

	$new->add_delegate('self', sub { $new });
	$new->add_delegate('outer', sub { $outer });

	return $new;
}

sub new_scope {
	my ($self) = @_;
	return $self->_new_scope(ref($self), $self, $self->{nodes}, $self->{filesets});
}

sub add_node {
	my ($self, $node) = @_;
	my $target = $node->target;
	if (exists $self->{nodes}{$target}) {
		Carp::croak("Duplicate for target $target") if !$node->mergeable or !$self->{nodes}{$target}->mergeable;
		my @dependencies = List::Util::uniq($self->{nodes}{$target}->dependencies, $node->dependencies);
		my $new = ExtUtils::Builder::Node->new(target => $target, dependencies => \@dependencies, phony => 1);
		$self->{nodes}{$target} = $new;
	} else {
		$self->{nodes}{$target} = $node;
		$self->{filesets}{'all-files'}->add_input($target) if not $node->phony;
	}
	return $node->target;
}

sub create_node {
	my ($self, %args) = @_;
	my $node = ExtUtils::Builder::Node->new(%args);
	return $self->add_node($node);
}

sub create_phony {
	my ($self, $target, @dependencies) = @_;
	return $self->create_node(
		target       => $target,
		dependencies => \@dependencies,
		type         => 'phony',
	);
}

my $counter = 0;

sub _create_callback {
	my ($self, $add_to) = @_;
	return undef unless $add_to;
	my $this = $self;
	Scalar::Util::weaken($this);
	return sub {
		my ($entry) = @_;
		$this->create_phony($add_to, $entry);
	};
}

sub create_filter {
	my ($self, %args) = @_;
	my $set = ExtUtils::Builder::FileSet::Filter->new(
		condition => $args{condition},
		callback  => $self->_create_callback($args{add_to}),
	);
	my $on = $args{on} // 'all-files';
	my @sources = ref($on) eq 'ARRAY' ? @{$on} : $on;
	for my $source (@sources) {
		my $object = $self->{filesets}{$source} or die "No such source $source";
		$object->add_dependent($set);
	}
	my $name = $args{name} // 'filter-' . $counter++;
	$self->{filesets}{$name} = $set;
	return $name;
}

sub _make_pattern {
	my ($self, %options) = @_;
	if ($options{file}) {
		my $file = ExtUtils::Builder::Util::glob_to_regex($options{file});
		if ($options{dir}) {
			my $dir = ExtUtils::Builder::Util::native_to_unix_path($options{dir});
			$dir =~ s{(?<!/)$}{/}ms;
			return sub {
				my ($input) = @_;
				my $filename = ExtUtils::Builder::Util::native_to_unix_path($input);
				return if substr($filename, 0, length $dir) ne $dir;
				return File::Basename::basename($filename) =~ $file;
			};
		} else {
			return sub {
				my ($filename) = @_;
				return File::Basename::basename($filename) =~ $file;
			};
		}
	} elsif ($options{dir}) {
		my $dir = ExtUtils::Builder::Util::native_to_unix_path($options{dir});
		$dir =~ s{(?<!/)$}{/}ms;
		return sub {
			my ($input) = @_;
			my $filename = ExtUtils::Builder::Util::native_to_unix_path($input);
			return substr($filename, 0, length $dir) eq $dir;
		};
	} else {
		Carp::croak("Unknown pattern type");
	}
}

sub create_pattern {
	my ($self, %args) = @_;
	my $positive = $self->_make_pattern(%args);
	my $callback = $args{negate} ? sub { !$positive->($_[0]) } : $positive;
	return $self->create_filter(%args, condition => $callback);