Improved help for single commands in bin/gruta.

[gruta.git] / bin / gruta

#!/usr/bin/perl

use strict;
use warnings;

use File::Temp;

use Gruta;
use Gruta::Source::DBI;
use Gruta::Source::FS;

# = new_source($src_str);
# = Gruta->new( sources => $src );

my $X = {
        'copy' =>       [
                'copy {src} {dst}',
                'Copies the full source {src} to {dst}',
                sub {
                        my $g           = init();
                        my $new_src     = arg();
                        my $dst         = new_source( $new_src );

                        $dst->create();

                        $g->transfer_to_source( $dst );
                }
        ],
        'topics' =>     [
                'topics {src}',
                'Lists the topics in {src}',
                sub {
                        my $g = init();

                        foreach my $t ($g->topics()) {
                                print $t, "\n";
                        }
                }
        ],
        'topic' =>      [
                'topic {src} {topic_id}',
                'Dumps topic data',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();

                        my $topic = $g->topic($topic_id);

                        foreach my $f ($topic->afields()) {
                                print $f, ': ', ($topic->get($f) || ''), "\n";
                        }
                }
        ],
        'stories' =>    [
                'stories {src} {topic_id}',
                'Lists all stories of a topic',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();

                        foreach my $s ($g->stories($topic_id)) {
                                print $s, "\n";
                        }
                }
        ],
        'story' =>      [
                'story {src} {topic_id} {id}',
                'Dumps story data',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();
                        my $id          = arg();

                        print get_story($g, $topic_id, $id);
                }
        ],
        'edit_story' => [
                'edit_story {src} {topic_id} {id}',
                'Calls $EDITOR to edit story data',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();
                        my $id          = arg();

                        my $fh = File::Temp->new();
                        print $fh get_story($g, $topic_id, $id);
                        my $fn = $fh->filename();
                        $fh->close();

                        my $mtime = (stat($fn))[9];
                        system('$EDITOR ' . $fn);

                        if ($mtime != (stat($fn))[9]) {
                                save_story($g, $topic_id, $id, $fn);
                        }
                }
        ],
        'filter_story' => [
                'filter_story {src} {topic_id} {id} {command}',
                'Filters story data through command (STDIN, STDOUT)',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();
                        my $id          = arg();
                        my $filter_cmd  = arg();

                        my $fhr = File::Temp->new();
                        print $fhr get_story($g, $topic_id, $id);
                        my $fnr = $fhr->filename();
                        $fhr->close();

                        my $fhw = File::Temp->new();
                        my $fnw = $fhw->filename();
                        $fhw->close();

                        system("$filter_cmd < $fnr > $fnw");

                        save_story($g, $topic_id, $id, $fnw);
                }
        ],
        'create' =>     [
                'create {src}',
                'Creates {src}',
                sub {
                        init();
                }
        ],
        'tags' =>       [
                'tags {src}',
                'Lists all tags in {src}',
                sub {
                        my $g   = init();

                        foreach my $t ($g->tags()) {
                                print join(' ', @{$t}), "\n";
                        }
                }
        ],
        'stories_by_date' => [
                'stories_by_date {src} {topic(s)} {num} {offset}',
                'Searches stories by date',
                sub {
                        my $g           = init();
                        my $topics      = arg();
                        my $num         = arg();
                        my $offset      = arg();

                        if ($topics) {
                                $topics = [ split(':', $topics) ];
                        }

                        foreach my $s ($g->stories_by_date( $topics,
                                num => $num, offset => $offset) ) {
                                print join(' ', @{$s}), "\n";
                        }
                }
        ],
        'stats' =>      [
                'stats {src}',
                'Dumps statistics for {src}',
                sub {
                        my $g           = init();
                        my $n_topics    = 0;
                        my $n_stories   = 0;
                        my $n_hits      = 0;

                        foreach my $t ($g->topics()) {
                                $n_topics++;

                                foreach my $s ($g->stories($t)) {
                                        $n_stories++;

                                        my $story = $g->story($t, $s);

                                        $n_hits += $story->get('hits') || 0;
                                }
                        }

                        print "Topics: $n_topics, Stories: $n_stories, Hits: $n_hits\n";
                }
        ]
};

my $cmd = arg();

my $c;

if (not $c = $X->{$cmd}) {
        $cmd = undef;
        usage();
}

# execute
$c->[2]();

exit 0;


sub arg
{
        if (@ARGV) {
                return shift(@ARGV);
        }

        usage();
}


sub init
{
        my $src = new_source(arg());
        my $g   = Gruta->new( sources => $src );

        return $g;
}


sub usage
{
        if ($cmd) {
                my $c = $X->{$cmd};

                print "Usage: gruta ", $c->[0], "\n\n\t", $c->[1], "\n";
        }
        else {
                print "Usage: gruta {cmd} [args...]\n\n";

                foreach my $c (values(%{$X})) {
                        print ' ', sprintf('%-50s %s',
                                $c->[0], $c->[1]), "\n";
                }
        }

        exit 1;
}

sub new_source
{
        my $src_str = shift;
        my $src;

        if ($src_str =~ /^dbi:/) {
                $src = Gruta::Source::DBI->new( string => $src_str );
        }
        else {
                $src = Gruta::Source::FS->new( path => $src_str );
        }

        return $src;
}

sub get_story
{
        my $g           = shift;
        my $topic_id    = shift;
        my $id          = shift;
        my @r           = ();

        my $story = $g->story($topic_id, $id);

        foreach my $f ($story->fields()) {
                if ($f ne 'content') {
                        push (@r, $f . ': ' . ($story->get($f) || ''));
                }
        }

        push(@r, 'tags: ' . join(', ', $story->tags()));
        push(@r, '');
        push(@r, $story->get('content'));
        push(@r, '');

        return join("\n", @r);
}


sub save_story
{
        my $g           = shift;
        my $topic_id    = shift;
        my $id          = shift;
        my $fn          = shift;

        open F, $fn or die "Can't open $fn";

        my $story = undef;

        if ($id) {
                $story = $g->story($topic_id, $id);
        }
        else {
                $story = Gruta::Data::Story->new (
                        topic_id        => $topic_id,
                        id              => $id
                );
        }

        while (<F>) {
                chomp();

                last if /^$/;

                my ($key, $value) = (/^(\w+):\s*(.*)$/);

                if ($key eq 'tags') {
                        $story->tags(split(/,\s*/, $value));
                }
                else {
                        $story->set($key, $value);
                }
        }

        my $c = join('', <F>);
        close F;

        $story->set('content', $c);

        if ($story->source()) {
                $story->save();
        }
        else {
                $g->insert_story($story);
        }
}