File Coverage

lib/Kwiki/Atom.pm

Criterion	Covered	Total	%
statement	7	9	77.7
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	10	12	83.3

package Kwiki::Atom;
use strict;
use warnings;
use Kwiki::Plugin '-Base';
use Kwiki::Display;
use mixin 'Kwiki::Installer';
our $VERSION = '0.15';

use XML::Atom;
use XML::Atom::Feed;
use XML::Atom::Link;
use XML::Atom::Entry;
use XML::Atom::Content;

use DateTime;
use Kwiki::Atom::Server;

use constant ATOM_TYPE => "application/atom+xml";

const class_id      => 'atom';
const class_title   => 'Atom';
const css_file      => 'atom.css';
const config_file   => 'atom.yaml';
const cgi_class     => 'Kwiki::Atom::CGI';
const server_class  => 'Kwiki::Atom::Server';

field depth => 0;
field 'headers';
field 'server';

sub process {
}

sub register {
    my $registry = shift;
    $registry->add(action => 'atom_edit');
    $registry->add(action => 'atom_feed');
    $registry->add(action => 'atom_post');
    $registry->add(toolbar => 'recent_changes_atom_button',
                   template => 'recent_changes_atom_button.html',
                   show_for => ['recent_changes'],
                  );
    $registry->add(toolbar => 'edit_atom_button',
                   template => 'edit_atom_button.html',
                   show_for => ['display'],
                   params_class => $self->class_id,
                  );
}

sub fill_links {
    my $name = eval { $self->hub->cgi->page_name };
    my $url = CGI->new->url;
    push @{ $self->hub->{links}{all} }, ($name ? {
        rel => 'alternate',
        type => ATOM_TYPE,
        href => "$url?action=atom_edit;page_name=". $self->pages->current->uri,
    } : ()), {
        rel => 'service.feed',
        type => ATOM_TYPE,
        href => "$url?action=atom_feed",
    }, {
        rel => 'service.post',
        type => ATOM_TYPE,
        href => "$url?action=atom_post",
    };
    return;
}

sub toolbar_params {
#    require YAML;
#    open X, '>>/tmp/post.log';
#    print X "POSTDATA:\n", $self->cgi->POSTDATA, "\n";
#    print X "HEADERS:\n", YAML::Dump(\%ENV), $/;
#    close X;
    return () unless $ENV{CONTENT_TYPE} and
                    ($ENV{CONTENT_TYPE} eq ATOM_TYPE
                  or $ENV{CONTENT_TYPE} =~ m{^\w+/xml}); # XXX ecto XXX

    $self->atom_post;

    my %header = &Spoon::Cookie::content_type;
    print CGI::header(%header);
    print $self->server->print;
    exit;
}

sub fill_header {
    $self->wrap_header if !$self->headers;
    $self->headers( [ @{$self->headers||[]}, @_ ] );
}

sub wrap_header {
    my $server = $self->server($self->server_class->new);

    my %accept = map { $_ => 1 }
                 $server->request_header('Accept') =~ m{([^\s,]+/[^;,]+)}g;
    my $content_type = 'text/xml'; # fallback
    foreach my $try_type (qw(
        application/atom+xml
        application/x.atom+xml
        application/xml
    )) {
        $accept{$try_type} or next;
        $content_type = $try_type;
        last;
    }

    $content_type .= '; charset=UTF-8';
    $server->response_content_type($content_type);
    $server->client($self);

    $self->hub->headers->content_type($content_type);
}

sub make_entry {
    my ($page, $depth, $flavor) = @_;
    my $url = $self->server->uri;

    my $author = XML::Atom::Person->new;
    $author->name($page->metadata->edit_by);

    my $link_html = XML::Atom::Link->new;
    $link_html->type('text/html');
    $link_html->rel('alternate');
    $link_html->href("$url?".$page->uri);
    $link_html->title('');

    my $link_edit = XML::Atom::Link->new;
    $link_edit->type(ATOM_TYPE);
    $link_edit->rel('service.edit');
    $link_edit->href("$url?action=atom_edit;page_name=".$page->uri);
    $link_edit->title('');

    my $entry = XML::Atom::Entry->new;
    $entry->title($page->title);

    my $content = XML::Atom::Content->new;
    my $elem = $content->elem;
    my $text = ($content->LIBXML) ? 'XML::LibXML::Text'
                                  : 'XML::XPath::Node::Text';
    if ($flavor and $flavor eq 'html')  {
        $content->type('text/html');

        my $data = $page->to_html;
        my $copy = qq($data);
        my $node;
        local $@;
        eval {
            if ($content->LIBXML) {
                require XML::LibXML;
                my $parser = XML::LibXML->new;
                my $tree = $parser->parse_string($copy);
                $node = $tree->getDocumentElement;
            } else {
                require XML::XPath;
                my $xp = XML::XPath->new(xml => $copy);
                $node = (($xp->find('/')->get_nodelist)[0]->getChildNodes)[0]
                    if $xp;
            }
        };
        if (!$@ && $node) {
            $elem->appendChild($node);
            $elem->setAttribute('mode', 'xml');
        } else {
            $elem->appendChild($text->new($data));
            $elem->setAttribute('mode', 'escaped');
        }
    }
    else {
        $content->type('text/plain');
        $elem->appendChild($text->new($page->content));
        $elem->setAttribute('mode', 'escaped');
    }

    $entry->content($content);
    $entry->summary('');
    $entry->issued( DateTime->from_epoch( epoch => $page->io->ctime || time )->iso8601 . 'Z' );
    $entry->modified( DateTime->from_epoch( epoch => $page->io->mtime || time )->iso8601 . 'Z' );
    $entry->id("$url?".$page->uri);

    $entry->author($author);
    $entry->add_link($link_html);
    $entry->add_link($link_edit);

    return $entry;
}

sub update_page {
    my $page = shift;
    my $method = $self->server->request_method;
    my $entry = eval { $self->server->atom_body };

    if (!$entry) {
        print "Status: 400\n\n";
        $self->fill_header( -status => 400 );
        return;
    }

    if (!$page) {
        my $title = $entry->title;
        if ($entry->content->type =~ /\bx?html\b/i) {
            require HTML::Entities;
            HTML::Entities::decode_entities($title);
        }
        $page = $self->pages->new_page($title);

        if ($page->exists and $method eq 'POST') {
            $self->server->response_code(409);
            $self->server->{_error} = 'This page already exists';
            $self->fill_header(
                -status => 409,
                -type => 'text/plain',
                -warning => 'This page already exists',
            );
            return undef;
        }
    }

    $self->hub->users->current->name(
        eval { $self->server->get_auth_info->{Username} }
            || $self->hub->config->user_default_name
    );
    my $body = $entry->content->body;
    if ($entry->content->type =~ /\bx?html\b/i) {
        $body =~ s/<[^>]+>//g;
        require HTML::Entities;
        HTML::Entities::decode_entities($body);
    }
    $page->content($body);
    $page->update->store;

    return $page;
}

sub atom_list {
    my $url = $self->server->uri;

    my $link_feed = XML::Atom::Link->new;
    $link_feed->type(ATOM_TYPE);
    $link_feed->rel('service.feed');
    $link_feed->title($self->config->site_title);
    $link_feed->href("$url?action=atom_feed");

    my $link_post = XML::Atom::Link->new;
    $link_post->type(ATOM_TYPE);
    $link_post->rel('service.post');
    $link_post->title($self->config->site_title);
    $link_post->href("$url?action=atom_post");

    my $feed = XML::Atom::Feed->new;
    $feed->title($self->config->site_title);
    $feed->info($self->config->site_title);
    $feed->add_link($link_feed);
    $feed->add_link($link_post);
    $feed->modified(DateTime->now->iso8601 . 'Z');

    $self->munge($feed->as_xml);
}

sub atom_post {
    $self->fill_header;
    return $self->atom_list if $self->server->request_method eq 'GET';

    $self->server->{request_content} = $self->cgi->POSTDATA
        if $self->server->request_method eq 'POST';

    $self->server->run;
    $self->server->print;
}

sub atom_edit {
    $self->fill_header;
    $self->server->run;
    $self->server->print;
}

sub atom_feed {
    $self->fill_header;

    my $depth = $self->cgi->depth;
    my $flavor = $self->cgi->flavor;
    my $pages = [
        sort {
            $b->modified_time <=> $a->modified_time
        } ($depth ? $self->pages->recent_by_count($depth) : $self->pages->all)
    ];

    my $timestamp = @$pages ? $pages->[0]->metadata->edit_unixtime : time;

    my $cache = eval { $self->hub->load_class('cache') }
      or return $self->generate($pages, $depth, $flavor, $timestamp);

    $cache->process(
        sub { $self->generate($pages, $depth, $flavor, $timestamp) },
        'atom', $depth, $flavor, $timestamp, int(time / 600)
    );
}

sub generate {
    my ($pages, $depth, $flavor, $timestamp) = @_;

    my $datetime = DateTime->from_epoch( epoch => $timestamp );
    my $url = $self->server->uri;
    my $link_html = XML::Atom::Link->new;
    $link_html->type('text/html');
    $link_html->rel('alternate');
    $link_html->title($self->config->site_title);
    $link_html->href($url);

    my $link_post = XML::Atom::Link->new;
    $link_post->type('application/atom+xml');
    $link_post->rel('service.post');
    $link_post->title($self->config->site_title);
    $link_post->href("$url?action=atom_post");

    my $feed = XML::Atom::Feed->new;
    $feed->title($self->config->site_title);
    $feed->info($self->config->site_title);
    $feed->add_link($link_html);
    $feed->add_link($link_post);
    $feed->modified($datetime->iso8601 . 'Z');

    my $author = XML::Atom::Person->new;
    $author->name($self->config->site_url);

    $self->config->script_name($url);

    for my $page (@$pages) {
        $feed->add_entry( $self->make_entry($page, $depth, $flavor) );
    }

    $self->munge($feed->as_xml);
}

sub munge {
    my $xml = shift;
    $xml =~ /<\?xml/ or $xml = qq($xml);
    $xml =~ s/version="1.0"(?![^>]*encoding=)/version="1.0" encoding="UTF-8"/;
    $xml =~ s/(<\w+)/$1 version="0.3"/;
    $xml =~ s{\?>}{?>};
    return $xml;
}

package Kwiki::Atom::CGI;
use Kwiki::CGI '-base';

cgi 'depth';
cgi 'flavor';
cgi 'POSTDATA';

1;

package Kwiki::Atom;

1;

__DATA__