Changeset 59 in bookmarks for trunk

Timestamp:

08/23/13 15:35:17 (11 years ago)

Author:

peter

Message:

• converted app.psgi from using a CGI::Application::Dispatch dispatcher to a Path::Router dispatcher
• created a more pure PSGI BookmarkController to replace the CGI::Application-based BookmarkApp
• added an access log to the start script

Location:

trunk

Files:

• BookmarkController.pm (copied) (copied from trunk/BookmarkApp.pm) (18 diffs)
• app.psgi (modified) (2 diffs)
• start (modified) (1 diff)

trunk/BookmarkController.pm

@@ -1 @@
-package BookmarkApp;
-use strict;
-use warnings;
-use base qw{CGI::Application};
-
-use CGI::Application::Plugin::TT;
+package BookmarkController;
+use Moose;
 
 use Encode;
@@ -11 +7 @@
 use Bookmarks;
 use URI;
-
-sub setup {
-    my $self = shift;
-    $self->mode_param(path_info => 1);
-    $self->run_modes([qw{
-        list
-        feed
-        view
-        view_field
-        create
-        edit
-    }]);
-
-    my $url = $self->query->url;
+use Template;
+
+has bookmarks => (
+    is => 'rw',
+    handles => [qw{get_bookmark}],
+);
+has base_uri => (
+    is => 'ro',
+    builder => '_build_base_uri',
+    lazy => 1,
+);
+has request => (
+    is => 'ro',
+);
+
+sub _build_base_uri {
+    my $self = shift;
+    my $url = $self->request->base;
+
     $url .= '/' unless $url =~ m{/$};
-    my $base_uri = URI->new($url);
-
-    my $bookmarks = Bookmarks->new({
-        dbname   => $self->param('dbname'),
-        base_uri => $base_uri,
-    });
-
-    $self->param(
-        base_uri  => $base_uri,
-        bookmarks => $bookmarks,
-    );
-}
-
-sub _bookmarks { $_[0]->param('bookmarks') }
+    return URI->new($url);
+}
 
 sub _get_list_links {
@@ -96 +85 @@
     for my $link (@links) {
         $link->{rel}  = $link->{type} eq $self_type ? 'self' : 'alternate';
-        $link->{href} = URI->new_abs($link->{path} || '', $self->param('base_uri'));
+        $link->{href} = URI->new_abs($link->{path} || '', $self->base_uri);
         $link->{href}->query_form($link->{query});
     }
@@ -103 +92 @@
 }
 
+sub find_or_new {
+    my $self = shift;
+
+    my $bookmark = $self->bookmarks->get_bookmark({ uri => $self->request->param('uri') });
+    if ($bookmark) {
+        # redirect to the view of the existing bookmark
+        return [301, [Location => $bookmark->bookmark_uri], []];
+    } else {
+        # bookmark was not found; show the form to create a new bookmark
+        my $template = Template->new;
+        $template->process(
+            'bookmark.tt',
+            {
+                uri   => $self->request->param('uri'),
+                title => $self->request->param('title') || '',
+            },
+            \my $output,
+        );
+        return [404, ['Content-Type' => 'text/html; charset=UTF-8'], [$output]];
+    }
+}
+
 sub list {
     my $self = shift;
-    my $q = $self->query;
-
-    # check for a uri param, and if there is one present,
-    # see if a bookmark for that URI already exists
-    if (defined(my $uri = $q->param('uri'))) {
-        my $bookmark = $self->_bookmarks->get_bookmark({ uri => $uri });
-        if ($bookmark) {
-            # redirect to the view of the existing bookmark
-            $self->header_type('redirect');
-            $self->header_props(
-                -uri => $q->url . '/' . $bookmark->{id},
-            );
-            return;
-        } else {
-            # bookmark was not found; show the form to create a new bookmark
-            $bookmark->{uri} = $uri;
-            $bookmark->{title} = $q->param('title');
-            $self->header_props(
-                -type    => 'text/html',
-                -charset => 'UTF-8',
-                -status  => 404,
-            );
-            return $self->tt_process(
-                'bookmark.tt',
-                $bookmark,
-            );
-        }
-    }
 
     # list all the bookmarks 
-    my $mtime = $self->_bookmarks->get_last_modified_time;
-
-    my $format = $q->param('format') || 'html';
-
-    my @tags = grep { $_ ne '' } $q->param('tag');
-    my $query = $q->param('q');
-    my $limit = $q->param('limit');
-    my $offset = $q->param('offset');
-    my @resources = $self->_bookmarks->get_bookmarks({
+    my $mtime = $self->bookmarks->get_last_modified_time;
+
+    my $format = $self->request->param('format') || 'html';
+
+    my @tags = grep { $_ ne '' } $self->request->param('tag');
+    my $query = $self->request->param('q');
+    my $limit = $self->request->param('limit');
+    my $offset = $self->request->param('offset');
+    my @resources = $self->bookmarks->get_bookmarks({
         query  => $query,
         tag    => \@tags,
@@ -149 +132 @@
         offset => $offset,
     });
-    my @all_tags = $self->_bookmarks->get_tags({ selected => $tags[0] });
-    my @cotags = $self->_bookmarks->get_cotags({
+    my @all_tags = $self->bookmarks->get_tags({ selected => $tags[0] });
+    my @cotags = $self->bookmarks->get_cotags({
         query  => $query,
         tag    => \@tags,
@@ -158 +141 @@
 
     if ($format eq 'json') {
-        $self->header_props(
-            -type    => 'application/json',
-            -charset => 'UTF-8',
-        );
-        return decode_utf8(
+        my $json = decode_utf8(
             JSON->new->utf8->convert_blessed->encode({
                 bookmarks => \@resources,
             })
         );
+        return [200, ['Content-Type' => 'application/json; charset=UTF-8'], [$json]];
     } elsif ($format eq 'xbel') {
         require XML::XBEL;
@@ -193 +173 @@
         }
 
-        $self->header_props(
-            -type    => 'application/xml',
-            -charset => 'UTF-8',
-        );
-
-        return $xbel->toString;
+        return [200, ['Content-Type' => 'application/xml; charset=UTF-8'], [$xbel->toString]];
     } elsif ($format eq 'text') {
-        $self->header_props(
-            -type    => 'text/uri-list',
-            -charset => 'UTF-8',
-        );
-        return join '', 
+        my $text = join '', 
             map {
                 sprintf "# %s\n# Tags: %s\n%s\n",
@@ -211 +182 @@
                 $_->uri
             } @resources;
+        return [200, ['Content-Type' => 'text/uri-list; charset=UTF-8'], [$text]];
     } elsif ($format eq 'csv') {
         require Text::CSV::Encoded;
-        my $csv = Text::CSV::Encoded->new({ encoding => 'utf8' });
+        my $csv = Text::CSV::Encoded->new({ encoding_out => 'utf8' });
         my $text = qq{id,uri,title,tags,ctime,mtime\n};
         for my $bookmark (@resources) {
@@ -231 +203 @@
         $dt =~ s/[^\d]//g;
 
-        $self->header_props(
-            -type       => 'text/csv',
-            -charset    => 'UTF-8',
-            -attachment => 'bookmarks-' . join('_', @tags) . "-$dt.csv",
+        my $filename = sprintf(
+            'bookmarks-%s-%s.csv',
+            join('_', @tags),
+            $dt,
         );
-        return $text;
-    } else {
-        $self->header_props(
-            -type    => 'text/html',
-            -charset => 'UTF-8',
-        );
-
-        # set the base URL, adding a trailing slash if needed
-        my $base_url = $q->url;
-        $base_url .= '/' if $base_url =~ m{/bookmarks$};
-
-        return $self->tt_process(
+
+        return [200, ['Content-Type' => 'text/csv; charset=UTF-8', 'Content-Disposition' => sprintf('attachement; filename="%s"', $filename)], [$text]];
+    } else {
+        my $template = Template->new;
+
+        $template->process(
             'list.tt',
             {
-                base_url     => $base_url,
+                base_url     => $self->base_uri,
                 title        => $title,
                 query        => $query,
@@ -260 +226 @@
                 resources    => \@resources,
             },
+            \my $output,
         );
+        return [200, ['Content-Type' => 'text/html; charset=UTF-8'], [$output]];
     }
 }
@@ -266 +234 @@
 sub feed {
     my $self = shift;
-    my $q = $self->query;
-
-    my $query = $q->param('q');
-    my @tags = grep { $_ ne '' } $q->param('tag');
+
+    my $query = $self->request->param('q');
+    my @tags = grep { $_ ne '' } $self->request->param('tag');
     my $title = 'Bookmarks' . (@tags ? " tagged as " . join(' & ', @tags) : '');
 
@@ -283 +250 @@
     $feed->title($title);
 
-    my $feed_uri = URI->new_abs('feed', $self->param('base_uri'));
+    my $feed_uri = URI->new_abs('feed', $self->base_uri);
     $feed_uri->query_form(tag => \@tags);
     $feed->id($feed_uri->canonical);
@@ -296 +263 @@
 
     # construct a feed from the most recent 12 bookmarks
-    for my $bookmark ($self->_bookmarks->get_bookmarks({ query => $query, tag => \@tags, limit => 12 })) {
+    for my $bookmark ($self->bookmarks->get_bookmarks({ query => $query, tag => \@tags, limit => 12 })) {
         my $entry = XML::Atom::Entry->new;
         $entry->id($bookmark->bookmark_uri->canonical);
@@ -323 +290 @@
     }
 
-    $self->header_props(
-        -type => 'application/atom+xml',
-        -charset => 'UTF-8',
-    );
-    return $feed->as_xml;
+    return [200, ['Content-Type' => 'application/atom+xml; charset=UTF-8'], [$feed->as_xml]];
 }
 
 sub view {
-    my $self = shift;
-    my $id = $self->param('id');
-    my $format = $self->query->param('format') || 'html';
-
-    my $bookmark = $self->_bookmarks->get_bookmark({ id => $id });
+    my ($self, $id) = @_;
+
+    my $format = $self->request->param('format') || 'html';
+
+    my $bookmark = $self->get_bookmark({ id => $id });
     if ($bookmark) {
         # check If-Modified-Since header to return cache response
-        if ($self->query->env->{HTTP_IF_MODIFIED_SINCE}) {
-            my $cache_time = str2time($self->query->env->{HTTP_IF_MODIFIED_SINCE});
+        if ($self->request->env->{HTTP_IF_MODIFIED_SINCE}) {
+            my $cache_time = str2time($self->request->env->{HTTP_IF_MODIFIED_SINCE});
             if ($bookmark->mtime <= $cache_time) {
-                $self->header_type('redirect');
-                $self->header_props(
-                    -status => 304,
-                );
-                return;
+                return [304, [], []];
             }
         }
+        my $last_modified = time2str($bookmark->mtime);
         
         if ($format eq 'json') {
-            $self->header_props(
-                -type    => 'application/json',
-                -charset => 'UTF-8',
-            );
-            return decode_utf8(JSON->new->utf8->convert_blessed->encode($bookmark));
+            my $json = decode_utf8(JSON->new->utf8->convert_blessed->encode($bookmark));
+            return [200, ['Content-Type' => 'application/json; charset=UTF-8', 'Last-Modified' => $last_modified], [$json]];
         } else {
             # display the bookmark form for this bookmark
@@ -360 +317 @@
             $bookmark->{created} = "Created " . localtime($bookmark->ctime);
             $bookmark->{created} .= '; Updated ' . localtime($bookmark->mtime) unless $bookmark->ctime == $bookmark->mtime;
-            $self->header_props(
-                -type    => 'text/html',
-                -charset => 'UTF-8',
-                -Last_Modified => time2str($bookmark->mtime),
-            );
-            return $self->tt_process(
+            my $template = Template->new;
+            $template->process(
                 'bookmark.tt',
                 $bookmark,
+                \my $output,
             );
-        }
-    } else {
-        $self->header_props(
-            -type    => 'text/html',
-            -charset => 'UTF-8',
-            -status  => 404,
-        );
-        return "Bookmark $id Not Found";
+            return [200, ['Content-Type' => 'text/html; charset=UTF-8', 'Last-Modified' => $last_modified], [$output]];
+        }
+    } else {
+        return [404, ['Content-Type' => 'text/plain; charset=UTF-8'], ["Boomark $id not found"]];
     }
 }
 
 sub view_field {
-    my $self = shift;
-    my $id = $self->param('id');
-    my $field = $self->param('field');
-
-    my $bookmark = $self->_bookmarks->get_bookmark({ id => $id });
+    my ($self, $id, $field) = @_;
+
+    my $bookmark = $self->bookmarks->get_bookmark({ id => $id });
     if ($bookmark) {
         # respond with just the requested field as plain text
@@ -391 +339 @@
         if ($@) {
             if ($@ =~ /Can't locate object method/) {
-                $self->header_props(
-                    -type    => 'text/plain',
-                    -charset => 'UTF-8',
-                    -status  => 404,
-                );
-                return qq{"$field" is not a valid bookmark data field};
+                return [404, ['Content-Type' => 'text/plain; charset=UTF-8'], [qq{"$field" is not a valid bookmark data field}]];
             } else {
                 die $@;
             }
         }
-        $self->header_props(
-            -type    => 'text/plain',
-            -charset => 'UTF-8',
-        );
-        return ref $value eq 'ARRAY' ? join(' ', @{ $value }) : $value;
-    } else {
-        $self->header_props(
-            -type    => 'text/html',
-            -charset => 'UTF-8',
-            -status  => 404,
-        );
-        return "Bookmark $id Not Found";
+        return [200, ['Content-Type' => 'text/plain; charset=UTF-8'], [ref $value eq 'ARRAY' ? join(' ', @{ $value }) : $value]];
+    } else {
+        return [404, ['Content-Type' => 'text/plain; charset=UTF-8'], ["Boomark $id not found"]];
     }
 }
@@ -418 +352 @@
 sub create {
     my $self = shift;
-    my $q = $self->query;
-    my $uri = $q->param('uri');
-    my $title = $q->param('title');
-    my @tags = split ' ', $q->param('tags');
-    my $bookmark = $self->_bookmarks->add({
+
+    my $uri   = $self->request->param('uri');
+    my $title = $self->request->param('title');
+    my @tags  = split ' ', $self->request->param('tags');
+
+    my $bookmark = $self->bookmarks->add({
         uri   => $uri,
         title => $title,
@@ -428 +363 @@
     });
 
-=begin
-
-    my $location = URI->new($q->url);
-    $location->query_form(uri => $uri) if defined $q->url_param('uri');
-    $location->fragment('updated');
-
-=cut
-
-    # return to the form
-    $self->header_type('redirect');
-    $self->header_props(
-        -uri => $bookmark->bookmark_uri->canonical,
-        -status => 303,
-    );
+    #TODO: not RESTful; the proper RESTful response would be a 201
+    return [303, ['Location' => $bookmark->bookmark_uri->canonical], []];
 }
 
 sub edit {
     my $self = shift;
-    my $q = $self->query;
-    my $id = $self->param('id');
-
-    my $bookmark = $self->_bookmarks->get_bookmark({ id => $id });
+    my $id = shift;
+
+    my $bookmark = $self->bookmarks->get_bookmark({ id => $id });
     if ($bookmark) {
         # update the URI, title, and tags
-        $bookmark->uri($q->param('uri'));
-        $bookmark->title($q->param('title'));
-        $bookmark->tags([ split ' ', $q->param('tags') || '' ]);
+        $bookmark->uri($self->request->param('uri'));
+        $bookmark->title($self->request->param('title'));
+        $bookmark->tags([ split ' ', $self->request->param('tags') || '' ]);
 
         # write to the database
-        $self->_bookmarks->update($bookmark);
-
-        # return to the form
-        $self->header_type('redirect');
-        $self->header_props(
-            -uri => $bookmark->bookmark_uri->canonical,
-            -status => 303,
-        );
-    } else {
-        $self->header_props(
-            -type    => 'text/html',
-            -charset => 'UTF-8',
-            -status  => 404,
-        );
-        return "Bookmark $id Not Found";
+        $self->bookmarks->update($bookmark);
+
+        #TODO: not RESTful; proper response would be a 200
+        return [303, ['Location' => $bookmark->bookmark_uri->canonical], []];
+    } else {
+        return [404, ['Content-Type' => 'text/plain; charset=UTF-8'], ["Boomark $id not found"]];
     }
 }

trunk/app.psgi

@@ -4 +4 @@
 use YAML;
 use Plack::Builder;
+use Plack::Request;
+use Router::Resource;
 
-use BookmarkApp::Dispatch;
+use BookmarkController;
+use Bookmarks;
+
+#TODO: allow a different config file on the command line, or set options from the command line
 
 -e 'conf.yml' or die "Missing required conf.yml config file\n";
 
 my $config = YAML::LoadFile('conf.yml');
-my $app = BookmarkApp::Dispatch->as_psgi(
-    args_to_new => {
-        PARAMS => { dbname => $config->{dbname} },
-    },
-);
+
+sub get_controller {
+    my $req = shift;
+
+    my $controller = BookmarkController->new({
+        request => $req,
+    });
+    my $bookmarks = Bookmarks->new({
+        dbname   => $config->{dbname},
+        base_uri => $controller->base_uri,
+    });
+    $controller->bookmarks($bookmarks);
+    return $controller;
+}
+
+my $router = router {
+    resource '/' => sub {
+        GET {
+            my ($env) = @_;
+            my $req = Plack::Request->new($env);
+            my $controller = get_controller($req);
+
+            # check for a uri param, and if there is one present,
+            # see if a bookmark for that URI already exists; if so
+            # redirect to that bookmark, and if not, show the form
+            # to create a new bookmark
+            if (defined $req->param('uri')) {
+                return $controller->find_or_new;
+            }
+
+            # otherwise return a list
+            return $controller->list;
+        };
+        POST {
+            my ($env) = @_;
+            my $req = Plack::Request->new($env);
+            my $controller = get_controller($req);
+
+            # create the bookmark and redirect to the new bookmark's edit form
+            return $controller->create;
+        };
+    };
+
+    resource '/list' => sub {
+        GET {
+            my ($env) = @_;
+            my $req = Plack::Request->new($env);
+            my $controller = get_controller($req);
+
+            return $controller->list;
+        };
+    };
+
+    resource '/feed' => sub {
+        GET {
+            my ($env) = @_;
+            my $req = Plack::Request->new($env);
+            my $controller = get_controller($req);
+
+            return $controller->feed;
+        };
+    };
+
+    resource '/{id}' => sub {
+        GET {
+            my ($env, $params) = @_;
+            my $req = Plack::Request->new($env);
+            my $controller = get_controller($req);
+
+            return $controller->view($params->{id});
+        };
+        POST {
+            my ($env, $params) = @_;
+            my $req = Plack::Request->new($env);
+            my $controller = get_controller($req);
+
+            return $controller->edit($params->{id});
+
+            return [200, ['Content-Type' => 'text/plain'], ['update ', $params->{id}]];
+        };
+    };
+
+    resource '/{id}/{field}' => sub {
+        GET {
+            my ($env, $params) = @_;
+            my $req = Plack::Request->new($env);
+            my $controller = get_controller($req);
+
+            return $controller->view_field($params->{id}, $params->{field});
+        };
+    };
+};
+
+#builder {
+#    sub { $router->dispatch(shift); };
+#};
 
 builder {
@@ -24 +120 @@
         authenticator   => sub { $config->{digest_password} }
     );
-    $app;
+    sub { $router->dispatch(shift); };
 };

trunk/start

@@ -1 +1 @@
 #!/bin/sh
 
-starman --listen :5000 --daemonize --pid pid --error-log errors
+starman --listen :5000 --daemonize --pid pid --error-log errors --access-log access