New command 'new_story' 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;
use Gruta::Source::Mbox;

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();

                        print get_topic($g, $topic_id);
                }
        ],
        'edit_topic' => [
                'edit_topic {src} {topic_id}',
                'Edits topic data',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();

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

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

                        if ($mtime != (stat($fn))[9]) {
                                save_topic($g, $topic_id, $fn);
                                1;
                        }
                }
        ],
        '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);
                        }
                }
        ],
        'new_story' =>  [
                'new_story {src} {topic_id} {id} {date} {date2} {format} {tags}',
                'Creates a new story from STDIN',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();
                        my $id          = arg();
                        my $date        = arg();
                        my $date2       = arg();
                        my $format      = arg();
                        my $tags        = arg();

                        my $content = join('', <>);

                        my $story = Gruta::Data::Story->new(
                                topic_id        => $topic_id,
                                id              => $id
                        );

                        $story->set('date', $date || Gruta::Data::today());
                        $story->set('date2', $date2);
                        $story->set('format', $format || 'grutatxt');
                        $story->set('ctime', time());
                        $story->set('userid', $ENV{USER});
                        $story->set('content', $content);

                        $story = $g->insert_story($story);

                        if ($tags) {
                                $story->tags(split(/\s*,\s*/, $tags));
                        }
                }
        ],
        '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} [{from}] [{to}] [{future}]',
                'Searches stories by date',
                sub {
                        my $g           = init();
                        my $topics      = arg();
                        my $num         = arg();
                        my $offset      = arg();
                        my $from        = arg_o();
                        my $to          = arg_o();
                        my $future      = arg_o();

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

                        foreach my $s ($g->stories_by_date(
                                        $topics,
                                        num     => $num,
                                        offset  => $offset,
                                        from    => $from,
                                        to      => $to,
                                        future  => $future
                                ) ) {
                                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";
                }
        ],
        'stories_by_tag' => [
                'stories_by_tag {src} {topic(s)} {tag(s)}',
                'Searches stories by tag(s)',
                sub {
                        my $g           = init();
                        my $topics      = arg();
                        my $tags        = arg();

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

                        foreach my $s ($g->stories_by_tag($topics, $tags)) {
                                print join(' ', @{$s}), "\n";
                        }
                }
        ],
        'search'        => [
                'search {src} {topic_id} {query}',
                'Searches stories by content',
                sub {
                        my $g           = init();
                        my $topic_id    = arg();
                        my $query       = arg();

                        foreach my $s ($g->search_stories($topic_id, $query)) {
                                print $s, "\n";
                        }
                }
        ],
        'top_ten'       => [
                'top_ten {src} [{num}]',
                'Shows the top N stories',
                sub {
                        my $g           = init();
                        my $num         = arg_o() || 10;

                        foreach my $s ($g->stories_top_ten($num)) {
                                print join(' ', @{$s}), "\n";
                        }
                }
        ],
        'users_by_xdate'        => [
                'users_by_xdate {src} [{max_date}]',
                'Lists users by expiration date',
                sub {
                        my $g           = init();
                        my $max_date    = arg_o() || '99999999999999';

                        foreach my $id ($g->users()) {
                                my $u = $g->user($id);

                                my $xdate = $u->get('xdate');

                                if ($xdate &&
                                        $xdate gt Gruta::Data::today() &&
                                        $xdate lt $max_date) {
                                        print $id, ' ', $u->{email}, ' ', $xdate, "\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 arg_o
{
        return shift(@ARGV) || shift;
}

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 $k (sort keys %{$X}) {
                        my $c = $X->{$k};

                        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 );
        }
        elsif ($src_str =~ /^mbox:(.+)/) {
                my $file = $1;

                $src = Gruta::Source::Mbox->new(
                        file            =>      $file
                );
        }
        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 get_topic
{
        my $g           = shift;
        my $topic_id    = shift;
        my @r           = ();

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

        foreach my $f ($topic->afields()) {
                push(@r, $f . ': ' . ($topic->get($f) || ''));
        }

        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);
        }
}


sub save_topic
{
        my $g           = shift;
        my $topic_id    = shift;
        my $fn          = shift;

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

        my $topic = undef;

        if ($topic_id) {
                $topic = $g->topic($topic_id);
        }
        else {
                $topic = Gruta::Data::Topic->new (
                        topic_id        => $topic_id,
                );
        }

        while (<F>) {
                chomp();

                last if /^$/;

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

                $topic->set($key, $value);
        }

        if ($topic->source()) {
                $topic->save();
        }
        else {
                $g->insert_topic($topic);
        }
}