view release on metacpan or  search on metacpan

lib/Beagle/Cmd/Command/att.pm  view on Meta::CPAN

    die "beagle att --add --parent foo /path/to/a.txt [...]"
      if $self->add && !$self->parent && !$self->info;

    die "--parent and --info can't coexist" if $self->parent && $self->info;

    die "beagle att --delete 3 [...]" if $self->delete && !@$args;

    my @bh;
    if ( $self->all ) {
        @bh = values %{handles()};
    }
    elsif ( $self->names ) {
        my $handles = handles();
        my $names = to_array( $self->names );
        for my $name ( @$names ) {
            die "invalid name: $name" unless $handles->{$name};
            push @bh, $handles->{$name};
        }
    }
    else {
        @bh = current_handle or die "please specify beagle by --name or --root";
    }

    if ( $self->prune ) {
        my $pruned;
        for my $bh (@bh) {
            for my $p ( keys %{ $bh->attachments_map } ) {
                unless ( $bh->map->{$p} ) {
                    my $dir = catdir( 'attachments', split_id($p) );
                    if ( -e catdir( $bh->root, $dir ) ) {
                        $bh->backend->delete(
                            undef,
                            path    => $dir,
                            message => "prune $dir"
                        ) or die "failed to delete $dir: $!";
                        $pruned = 1;
                    }
                }
            }
        }
        if ( $pruned ) {
            puts 'pruned.';
        }
        else {
            puts 'no orphans found.';
        }
        return;
    }

    my $bh;
    my $pid;

    if ( $self->info ) {
        $bh = current_handle();
        $pid = $bh->info->id;
    }
    elsif ( $self->parent ) {
        my @ret = resolve_entry( $self->parent, handle => current_handle() || undef );
        unless (@ret) {
            @ret = resolve_entry($pid) or die_entry_not_found($pid);
        }
        die_entry_ambiguous( $pid, @ret ) unless @ret == 1;
        $pid = $ret[0]->{id};
        $bh = $ret[0]->{handle};
    }

    if ( $self->add ) {
        my @added;
        for my $file (@$args) {
            if ( -f $file ) {
                require File::Basename;
                my $basename = decode_utf8 File::Basename::basename $file;
                my $att      = Beagle::Model::Attachment->new(
                    name         => $basename,
                    content_file => $file,
                    parent_id    => $pid,
                );
                if ( $bh->create_attachment( $att, message => $self->message ) ) {
                    push @added, $basename;
                }
                else {
                    die "failed to create attachment $file.";
                }
            }
            else {
                die "$file is not a file or doesn't exist";
            }
        }

        if (@added) {
            puts 'added ', join( ', ', @added ), '.';
        }
        return;
    }

    my %handle_map;


    my @att;
    if ($pid) {
        my $map = $bh->attachments_map->{$pid};
        @att = sort values %$map;
    }
    else {
        for my $bh (@bh) {
            $handle_map{ $bh->root } = $bh;
            for my $p ( keys %{ $bh->attachments_map } ) {
                warn "$p doesn't exist, use 'att --prune' to clean"
                  unless $bh->map->{$p};
            }

            for my $entry (
                sort {
                        $bh->map->{$a}
                      ? $bh->map->{$b}
                          ? $bh->map->{$b}->created <=> $bh->map->{$a}->created
                          : -1
                      : 1
                }
                sort keys %{ $bh->attachments_map }