view release on metacpan or  search on metacpan

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

                $in = decode( 'utf8', read_file($path) );
            }
            else {
                local $/;
                $in = decode( 'utf8' => <STDIN> );
            }
            my $converted = JSON::from_json($in);
            my $marks     = {};
            for my $id ( keys %$converted ) {
                if ( defined $converted->{$id} ) {
                    if ( ref $converted->{$id} ) {
                        if ( ref $converted->{$id} eq 'ARRAY' ) {
                            next unless @{ $converted->{$id} };
                            $marks->{$id} =
                              { map { $_ => 1 } @{ $converted->{$id} } };
                        }
                        elsif ( ref $converted->{$id} eq 'HASH' ) {
                            next unless %{ $converted->{$id} };
                            $marks->{$id} =
                              { map { $_ => 1 } keys %{ $converted->{$id} } };
                        }
                    }
                    else {
                        $marks->{$id} = { $converted->{$id} => 1 };
                    }
                }
            }
            set_marks($marks);
            puts 'imported.';
            return;
        }
    }
    elsif ( $self->prune ) {
        my $relation = relation();
        my $pruned;
        for my $id ( keys %$marks ) {
            next if $relation->{$id};
            delete $marks->{$id};
            $pruned = 1;
        }

        if ( $pruned ) {
            puts 'pruned.';
        }
        else {
            puts 'no orphans found.';
        }
        return;
    }
    else {

        my @ids;
        $args = $self->resolve_ids( $args );
        for my $i (@$args) {
            if ( length $i == 32 ) {
                push @ids, $i;
            }
            else {
                my @ret = resolve_entry( $i, handle => current_handle() || undef );
                unless (@ret) {
                    @ret = resolve_entry($i) or die_entry_not_found($i);
                }
                die_entry_ambiguous( $i, @ret ) unless @ret == 1;
                push @ids, $ret[0]->{id};
            }
        }

        if ( $self->add || $self->delete || $self->set || $self->unset ) {

            for my $id (@ids) {

                if ( $self->delete ) {
                    for my $mark ( @{ $self->delete } ) {
                        last unless $marks->{$id};
                        if ( exists $marks->{$id}{$mark} ) {
                            delete $marks->{$id}{$mark};
                        }
                        delete $marks->{$id} unless %{ $marks->{$id} };
                    }
                }

                if ( $self->unset ) {
                    if ( $marks->{$id} ) {
                        delete $marks->{$id};
                    }
                }

                if ( $self->set ) {
                    $marks->{$id} = {};
                    for my $mark ( @{ $self->set } ) {
                        $marks->{$id}{$mark} = 1;
                    }
                }

                if ( $self->add ) {
                    for my $mark ( @{ $self->add } ) {
                        if ( !$marks->{$id}{$mark} ) {
                            $marks->{$id}{$mark} = 1;
                        }
                    }
                }
            }

            if (@ids) {
                set_marks($marks);
                puts 'updated.';
            }
        }
        else {

            @ids = keys %$marks unless @ids;

            for my $id (@ids) {
                puts "$id ",
                  $marks->{$id}
                  ? ( join ', ', sort keys %{ $marks->{$id} } )
                  : '<not exist>';
            }
        }

    }