00dani/stow
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

stow_node: rename $target => $target_subpath

Browse source 
The $target variable was ambiguous, as it could have referred to the
path to the target directory, or the path to a sub-directory in the
target, as well as its intended meaning of a subpath relative to the
target directory.  So rename it to try to find the balance between
clarity and verbosity.
This commit is contained in:
Adam Spiers 2024-04-01 11:17:59 +01:00
parent 86f03d115d
commit 1f752a3c94
1 changed files with 42 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
lib/Stow.pm.in
View file

@ -464,7 +464,7 @@ sub stow_contents {
} }
} }
=head2 stow_node($stow_path, $package, $target, $source) =head2 stow_node($stow_path, $package, $target_subpath, $source)
Stow the given node Stow the given node
@ -482,7 +482,7 @@ Stow Directories" section of the manual).
The package containing the node being stowed The package containing the node being stowed
=item $target =item $target_subpath
Subpath relative to package directory of node which needs stowing as a Subpath relative to package directory of node which needs stowing as a
symlink at subpath relative to target directory. symlink at subpath relative to target directory.
@ -493,19 +493,19 @@ Relative path to symlink source from the dir of target.
=back =back
C<stow_node()> and C<stow_contents()> are mutually recursive. $source C<stow_node()> and C<stow_contents()> are mutually recursive.
and $target are used for creating the symlink C<$path> is used for C<$source> and C<$target_subpath> are used for creating the symlink.
folding/unfolding trees as necessary. C<$target_subpath> is used for folding/unfolding trees as necessary.
=cut =cut
sub stow_node { sub stow_node {
my $self = shift; my $self = shift;
my ($stow_path, $package, $target, $source, $level) = @_; my ($stow_path, $package, $target_subpath, $source, $level) = @_;
my $path = join_paths($stow_path, $package, $target); my $path = join_paths($stow_path, $package, $target_subpath);
debug(3, 0, "Stowing entry $stow_path / $package / $target"); debug(3, 0, "Stowing entry $stow_path / $package / $target_subpath");
debug(4, 1, "=> $source"); debug(4, 1, "=> $source");
# Don't try to stow absolute symlinks (they can't be unstowed) # Don't try to stow absolute symlinks (they can't be unstowed)
@ -523,61 +523,61 @@ sub stow_node {
} }
# Does the target already exist? # Does the target already exist?
if ($self->is_a_link($target)) { if ($self->is_a_link($target_subpath)) {
# Where is the link pointing? # Where is the link pointing?
my $existing_link_dest = $self->read_a_link($target); my $existing_link_dest = $self->read_a_link($target_subpath);
if (not $existing_link_dest) { if (not $existing_link_dest) {
error("Could not read link: $target"); error("Could not read link: $target_subpath");
} }
debug(4, 1, "Evaluate existing link: $target => $existing_link_dest"); debug(4, 1, "Evaluate existing link: $target_subpath => $existing_link_dest");
# Does it point to a node under any stow directory? # Does it point to a node under any stow directory?
my ($existing_path, $existing_stow_path, $existing_package) = my ($existing_path, $existing_stow_path, $existing_package) =
$self->find_stowed_path($target, $existing_link_dest); $self->find_stowed_path($target_subpath, $existing_link_dest);
if (not $existing_path) { if (not $existing_path) {
$self->conflict( $self->conflict(
'stow', 'stow',
$package, $package,
"existing target is not owned by stow: $target" "existing target is not owned by stow: $target_subpath"
); );
return; # XXX # return; # XXX #
} }
# Does the existing $target actually point to anything? # Does the existing $target_subpath actually point to anything?
if ($self->is_a_node($existing_path)) { if ($self->is_a_node($existing_path)) {
if ($existing_link_dest eq $source) { if ($existing_link_dest eq $source) {
debug(2, 0, "--- Skipping $target as it already points to $source"); debug(2, 0, "--- Skipping $target_subpath as it already points to $source");
} }
elsif ($self->defer($target)) { elsif ($self->defer($target_subpath)) {
debug(2, 0, "--- Deferring installation of: $target"); debug(2, 0, "--- Deferring installation of: $target_subpath");
} }
elsif ($self->override($target)) { elsif ($self->override($target_subpath)) {
debug(2, 0, "--- Overriding installation of: $target"); debug(2, 0, "--- Overriding installation of: $target_subpath");
$self->do_unlink($target); $self->do_unlink($target_subpath);
$self->do_link($source, $target); $self->do_link($source, $target_subpath);
} }
elsif ($self->is_a_dir(join_paths(parent($target), $existing_link_dest)) && elsif ($self->is_a_dir(join_paths(parent($target_subpath), $existing_link_dest)) &&
$self->is_a_dir(join_paths(parent($target), $source))) $self->is_a_dir(join_paths(parent($target_subpath), $source)))
{ {
# If the existing link points to a directory, # If the existing link points to a directory,
# and the proposed new link points to a directory, # and the proposed new link points to a directory,
# then we can unfold (split open) the tree at that point # then we can unfold (split open) the tree at that point
debug(2, 0, "--- Unfolding $target which was already owned by $existing_package"); debug(2, 0, "--- Unfolding $target_subpath which was already owned by $existing_package");
$self->do_unlink($target); $self->do_unlink($target_subpath);
$self->do_mkdir($target); $self->do_mkdir($target_subpath);
$self->stow_contents( $self->stow_contents(
$existing_stow_path, $existing_stow_path,
$existing_package, $existing_package,
$target, $target_subpath,
join_paths('..', $existing_link_dest), join_paths('..', $existing_link_dest),
$level + 1, $level + 1,
); );
$self->stow_contents( $self->stow_contents(
$self->{stow_path}, $self->{stow_path},
$package, $package,
$target, $target_subpath,
join_paths('..', $source), join_paths('..', $source),
$level + 1, $level + 1,
); );
@ -587,54 +587,54 @@ sub stow_node {
'stow', 'stow',
$package, $package,
"existing target is stowed to a different package: " "existing target is stowed to a different package: "
. "$target => $existing_link_dest" . "$target_subpath => $existing_link_dest"
); );
} }
} }
else { else {
# The existing link is invalid, so replace it with a good link # The existing link is invalid, so replace it with a good link
debug(2, 0, "--- replacing invalid link: $path"); debug(2, 0, "--- replacing invalid link: $path");
$self->do_unlink($target); $self->do_unlink($target_subpath);
$self->do_link($source, $target); $self->do_link($source, $target_subpath);
} }
} }
elsif ($self->is_a_node($target)) { elsif ($self->is_a_node($target_subpath)) {
debug(4, 1, "Evaluate existing node: $target"); debug(4, 1, "Evaluate existing node: $target_subpath");
if ($self->is_a_dir($target)) { if ($self->is_a_dir($target_subpath)) {
$self->stow_contents( $self->stow_contents(
$self->{stow_path}, $self->{stow_path},
$package, $package,
$target, $target_subpath,
join_paths('..', $source), join_paths('..', $source),
$level + 1, $level + 1,
); );
} }
else { else {
if ($self->{adopt}) { if ($self->{adopt}) {
$self->do_mv($target, $path); $self->do_mv($target_subpath, $path);
$self->do_link($source, $target); $self->do_link($source, $target_subpath);
} }
else { else {
$self->conflict( $self->conflict(
'stow', 'stow',
$package, $package,
"existing target is neither a link nor a directory: $target" "existing target is neither a link nor a directory: $target_subpath"
); );
} }
} }
} }
elsif ($self->{'no-folding'} && -d $path && ! -l $path) { elsif ($self->{'no-folding'} && -d $path && ! -l $path) {
$self->do_mkdir($target); $self->do_mkdir($target_subpath);
$self->stow_contents( $self->stow_contents(
$self->{stow_path}, $self->{stow_path},
$package, $package,
$target, $target_subpath,
join_paths('..', $source), join_paths('..', $source),
$level + 1, $level + 1,
); );
} }
else { else {
$self->do_link($source, $target); $self->do_link($source, $target_subpath);
} }
return; return;
} }