Changeset 211 for tagwire/trunk/tagwire.pl

Timestamp:

05/28/06 10:08:06 (2 years ago)

Author:

ogawa

Message:

Lots of changes.
Fix for memory leak in the persistent environments such as FastCGI.
Now properly update MT::PluginData? when removing entries.

Files:

• tagwire/trunk/tagwire.pl (modified) (24 diffs)

tagwire/trunk/tagwire.pl

@@ -1 @@
-# Tagwire Plugin (aka AllKeywords Plugin)
-# a plugin for listing and handling "tags"
+# Tagwire - A plugin for listing and handling "tags"
 #
 # $Id$
@@ -7 +6 @@
 # personal use. If you distribute it, please keep this notice intact.
 #
-# Copyright (c) 2005 Hirotaka Ogawa
+# Copyright (c) 2005,2006 Hirotaka Ogawa
 
 package MT::Plugin::Tagwire;
 use strict;
+use MT;
+use base qw(MT::Plugin);
+
 use MT::Template::Context;
+use MT::Entry;
 use MT::Request;
-use vars qw($VERSION);
-
-$VERSION = '0.25';
 
 # DEBUG
 my $FORCE_PD_REFRESH = 0;
-my $ENABLE_PD_INDEXES = 1;
-my $ENABLE_REQ_CACHE = 1;
-
+
+our $HAVE_MT_PLUGINDATA = 0;
+our $HAVE_MT_XSEARCH = 0;
+
+our $cache;
 my $plugin;
-eval {
-    require MT::Plugin;
-    $plugin = new MT::Plugin({
+
+BEGIN {
+    our $VERSION = '0.26';
+    $plugin = __PACKAGE__->new({
         name => 'Tagwire Plugin',
         description => 'A plugin for listing and handling blog-wide tags and entry tags.',
-        doc_link => 'http://as-is.net/wiki/Tagwire_Plugin',
+        doc_link => 'http://as-is.net/hacks/2005/06/tagwire_plugin.html',
         author_name => 'Hirotaka Ogawa',
         author_link => 'http://profile.typekey.com/ogawa/',
-        version => $VERSION
+        version => $VERSION,
+    });
+    MT->add_plugin($plugin);
+
+    eval { require MT::PluginData; $HAVE_MT_PLUGINDATA = 1 };
+
+    if ($HAVE_MT_PLUGINDATA) {
+        MT::Entry->add_callback('post_save', 10, $plugin, \&post_save);
+        MT::Entry->add_callback('post_remove', 10, $plugin, \&post_remove);
+    }
+
+    $cache = MT::Request->instance;
+
+    MT::Template::Context->add_container_tag(Tags => \&tags);
+    MT::Template::Context->add_container_tag(EntryTags => \&entry_tags);
+    MT::Template::Context->add_container_tag(RelatedTags => \&related_tags);
+    MT::Template::Context->add_tag(Tag => \&tag);
+    MT::Template::Context->add_tag(TagCount => \&tag_count);
+    MT::Template::Context->add_tag(TagDate => \&tag_date);
+    MT::Template::Context->add_tag(TagsTotal => \&tags_total);
+    MT::Template::Context->add_tag(TagsTotalSum => \&tags_total_sum);
+    MT::Template::Context->add_container_tag(EntriesWithTags => \&entries);
+    MT::Template::Context->add_container_tag(MostRelatedEntries => \&most_related_entries);
+    MT::Template::Context->add_global_filter(encode_urlplus => \&encode_urlplus);
+
+    # For compatibility (this plugin was formerly named 'AllKeywords')
+    MT::Template::Context->add_container_tag(AllKeywords => \&tags);
+    MT::Template::Context->add_container_tag(EntryAllKeywords => \&entry_tags);
+    MT::Template::Context->add_tag(AllKeyword => \&tag);
+    MT::Template::Context->add_tag(AllKeywordCount => \&tag_count);
+    MT::Template::Context->add_tag(AllKeywordsTotal => \&tags_total);
+    MT::Template::Context->add_tag(AllKeywordsTotalSum => \&tags_total_sum);
+    MT::Template::Context->add_container_tag(EntriesWithKeywords => \&entries);
+
+    eval { require MT::XSearch; $HAVE_MT_XSEARCH = 1 };
+
+    if ($HAVE_MT_XSEARCH) {
+        MT::XSearch->add_search_plugin('Tagwire', {
+            label => 'Tag(Keyword) Search',
+            description => 'Tag(Keyword) Search plugin for MT-XSearch',
+            on_execute => \&xsearch_on_execute,
+            on_stash => \&xsearch_on_stash,
         });
-    MT->add_plugin($plugin);
-};
-
-if (MT->can('add_callback')) {
-    my $mt = MT->instance;
-    MT->add_callback((ref $mt eq 'MT::App::CMS' ? 'AppPostEntrySave' : 'MT::Entry::post_save'),
-                     10, $plugin, \&update_pd_indexes);
-}
-
-sub update_pd_indexes {
-    return unless $ENABLE_PD_INDEXES && $plugin;
-    my ($eh, $app, $entry) = @_;
-    require MT::Entry;
+        MT::Template::Context->add_container_tag(XSearchTags => \&xsearch_tags);
+    }
+}
+
+sub post_save {
+    my ($eh, $dummy, $obj) = @_;
+    update_plugindata($obj);
+}
+
+sub post_remove {
+    my ($eh, $obj) = @_;
+    # set it to be "draft" to remove
+    $obj->status(MT::Entry::HOLD()) if $obj->status == MT::Entry::RELEASE();
+    update_plugindata($obj);
+}
+
+sub update_plugindata {
+    return unless $HAVE_MT_PLUGINDATA && $plugin;
+    my ($entry) = @_;
+    my $refresh = $FORCE_PD_REFRESH || 0;
+    my $version = $plugin->version;
     my $blog_id = $entry->blog_id;
-    require MT::PluginData;
     my $pd = MT::PluginData->load({ plugin => $plugin->name,
                                     key => $blog_id });
-    my (%eindex, %tindex);
-    my $data;
-    my $refresh = $FORCE_PD_REFRESH || 0;
     if (!$pd) {
         $pd = new MT::PluginData();
@@ -59 +107 @@
         $refresh = 1;
     }
-    $data = $pd->data() || {};
-    $refresh = 1 if !exists $data->{version} || ${$data->{version}} ne $VERSION;
+    my $data = $pd->data() || {};
+
+    $refresh = 1 if !exists $data->{version} || ${$data->{version}} ne $version;
+
+    my (%eindex, %tindex);
     if ($refresh) {
         my $iter = MT::Entry->load_iter({ blog_id => $blog_id,
@@ -86 +137 @@
         }
     }
-    $data->{version} = \$VERSION;
+    $data->{version} = \$version;
     $data->{eindex} = \%eindex;
     $data->{tindex} = \%tindex;
     $pd->data($data);
     $pd->save or die $pd->errstr;
-    if ($ENABLE_REQ_CACHE) {
-        my $r = MT::Request->instance;
-        $r->cache('Tagwire::Cache::' . $blog_id, undef);
-    }
-}
-
-MT::Template::Context->add_container_tag('Tags' => \&tags);
-MT::Template::Context->add_container_tag('EntryTags' => \&entry_tags);
-MT::Template::Context->add_container_tag('RelatedTags' => \&related_tags);
-MT::Template::Context->add_tag('Tag' => \&tag);
-MT::Template::Context->add_tag('TagCount' => \&tag_count);
-MT::Template::Context->add_tag('TagDate' => \&tag_date);
-MT::Template::Context->add_tag('TagsTotal' => \&tags_total);
-MT::Template::Context->add_tag('TagsTotalSum' => \&tags_total_sum);
-MT::Template::Context->add_container_tag('EntriesWithTags' => \&entries);
-MT::Template::Context->add_container_tag('MostRelatedEntries' => \&most_related_entries);
-MT::Template::Context->add_global_filter('encode_urlplus' => \&encode_urlplus);
-
-# For compatibility (this plugin was formerly named 'AllKeywords')
-MT::Template::Context->add_container_tag('AllKeywords' => \&tags);
-MT::Template::Context->add_container_tag('EntryAllKeywords' => \&entry_tags);
-MT::Template::Context->add_tag('AllKeyword' => \&tag);
-MT::Template::Context->add_tag('AllKeywordCount' => \&tag_count);
-MT::Template::Context->add_tag('AllKeywordsTotal' => \&tags_total);
-MT::Template::Context->add_tag('AllKeywordsTotalSum' => \&tags_total_sum);
-MT::Template::Context->add_container_tag('EntriesWithKeywords' => \&entries);
+    $cache->cache('Tagwire::Cache::' . $blog_id, undef);
+}
 
 sub split_args {
@@ -162 +189 @@
 }
 
-sub get_pd_indexes {
-    return unless $ENABLE_PD_INDEXES && $plugin;
-    my $blog_id = $_[0] or return;
-    my ($r, $cname);
-    if ($ENABLE_REQ_CACHE) {
-        $r = MT::Request->instance;
-        $cname = 'Tagwire::Cache::' . $blog_id;
-        return $r->cache($cname) if defined $r->cache($cname);
-        $r->cache($cname, undef);
-    }
+sub get_indexes {
+    my $blog_id = shift or return;
+    my $cname = 'Tagwire::Cache::' . $blog_id;
+    return $cache->cache($cname) if defined $cache->cache($cname);
+    $cache->cache($cname, undef);
+
     my $data;
-    eval {
-        require MT::PluginData;
+    if ($HAVE_MT_PLUGINDATA && $plugin) {
         my $pd = MT::PluginData->load({ plugin => $plugin->name,
                                         key => $blog_id });
         $data = $pd->data() if $pd;
-    };
-    return if !exists $data->{version} || ${$data->{version}} ne $VERSION;
-    $r->cache($cname, $data) if $ENABLE_REQ_CACHE && $data;
-    $data;
-}
-
-sub get_db_indexes {
-    my $blog_id = $_[0] or return;
-    my ($r, $cname);
-    if ($ENABLE_REQ_CACHE) {
-        $r = MT::Request->instance;
-        $cname = 'Tagwire::Cache::' . $blog_id;
-        return $r->cache($cname) if defined $r->cache($cname);
-        $r->cache($cname, undef);
-    }
-    my $data;
-    my (%eindex, %tindex);
+
+        $data = undef if (!exists $data->{version} || ${$data->{version}} ne $plugin->version);
+    }
+
+    $data = get_indexes_from_db($blog_id) unless defined $data;
+
+    $cache->cache($cname, $data) if $data;
+}
+
+sub get_indexes_from_db {
+    my $blog_id = shift or return;
+    my ($eindex, $tindex);
     my $iter = MT::Entry->load_iter({ blog_id => $blog_id,
                                       status => MT::Entry::RELEASE() });
     while (my $e = $iter->()) {
         my @tags = split_tags($e->keywords, 1) or next;
-        $eindex{$e->id} = { tags => \@tags,
-                            created_on => $e->created_on };
-    }
-    foreach my $eid (keys %eindex) {
-        my $ts = $eindex{$eid}->{created_on};
-        foreach (@{$eindex{$eid}->{tags}}) {
-            push @{$tindex{$_}->{eids}}, $eid;
-            $tindex{$_}->{ts} = $ts if !exists $tindex{$_}->{ts} || $tindex{$_}->{ts} < $ts;
-        }
-    }
-    $data->{eindex} = \%eindex;
-    $data->{tindex} = \%tindex;
-    $r->cache($cname, $data) if $ENABLE_REQ_CACHE;
+        $eindex->{$e->id} = { tags => \@tags,
+                              created_on => $e->created_on };
+    }
+    foreach my $eid (keys %$eindex) {
+        my $eidx = $eindex->{$eid};
+        my $ts = $eidx->{created_on};
+        foreach (@{$eidx->{tags}}) {
+            push @{$tindex->{$_}->{eids}}, $eid;
+            $tindex->{$_}->{ts} = $ts if !exists $tindex->{$_}->{ts} || $tindex->{$_}->{ts} < $ts;
+        }
+    }
+
+    my $data = { eindex => $eindex, tindex => $tindex };
     $data;
 }
@@ -228 +245 @@
         $args->{case_sensitive} : 1;
 
-    my $blog_id = $ctx->stash('blog_id');
-    my %tags = ();
-    my %ts = ();
-
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
-        or return '';
-    my %tindex = %{$data->{tindex}};
+    my $data = get_indexes($ctx->stash('blog_id')) or return '';
+    my $tindex = $data->{tindex};
+
+    my %tags;
     if ($case_sensitive) {
-        foreach (keys %tindex) {
-            $tags{$_} = scalar @{$tindex{$_}->{eids}};
-            $ts{$_} = $tindex{$_}->{ts};
-        }
-    } else {
-        foreach (keys %tindex) {
+        foreach (keys %$tindex) {
+            my $tidx = $tindex->{$_};
+            $tags{$_} = [ scalar @{$tidx->{eids}}, $tidx->{ts} ];
+        }
+    } else {
+        foreach (keys %$tindex) {
+            my $tidx = $tindex->{$_};
             my $t = lc $_;
-            $tags{$t} += scalar @{$tindex{$_}->{eids}};
-            $ts{$t} = $tindex{$_}->{ts} if !exists $ts{$t} || $ts{$t} < $tindex{$_}->{ts};
+            if (!exists $tags{$t}) {
+                $tags{$t} = [ scalar @{$tidx->{eids}}, $tidx->{ts} ];
+            } else {
+                $tags{$t}[0] += scalar @{$tidx->{eids}};
+                $tags{$t}[1] = $tidx->{ts} if $tags{$t}[1] < $tidx->{ts};
+            }
         }
     }
@@ -259 +278 @@
     } else {
         @list = $sort_order eq 'ascend' ?
-            sort { $tags{$a} <=> $tags{$b} } keys %tags :
-            sort { $tags{$b} <=> $tags{$a} } keys %tags;
+            sort { $tags{$a}[0] <=> $tags{$b}[0] } keys %tags :
+            sort { $tags{$b}[0] <=> $tags{$a}[0] } keys %tags;
     }
 
@@ -266 +285 @@
 
     my $total_sum = 0;
-    $total_sum += $tags{$_} foreach (@list);
+    $total_sum += $tags{$_}[0] foreach (@list);
     $ctx->stash('Tagwire::tags_total_sum', $total_sum);
 
@@ -276 +295 @@
         last if $lastn && $i >= $lastn;
         local $ctx->{__stash}{'Tagwire::tag'} = $_;
-        local $ctx->{__stash}{'Tagwire::tag_count'} = $tags{$_};
-        local $ctx->{__stash}{'Tagwire::tag_date'} = $ts{$_};
+        local $ctx->{__stash}{'Tagwire::tag_count'} = $tags{$_}[0];
+        local $ctx->{__stash}{'Tagwire::tag_date'} = $tags{$_}[1];
         defined(my $out = $builder->build($ctx, $tokens))
             or return $ctx->error($ctx->errstr);
@@ -324 +343 @@
         $args->{case_sensitive} : 1;
 
-    my $blog_id = $ctx->stash('blog_id');
-    my %tags = ();
-    my %ts = ();
-
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
-        or return '';
-    my %tindex = %{$data->{tindex}};
-    my %eindex = %{$data->{eindex}};
+    my $data = get_indexes($ctx->stash('blog_id')) or return '';
+    my ($tindex, $eindex) = ($data->{tindex}, $data->{eindex});
+
+    my %tags;
     if ($case_sensitive) {
-        foreach my $eid (@{$tindex{$tag}->{eids}}) {
-            foreach (@{$eindex{$eid}->{tags}}) {
+        foreach my $eid (@{$tindex->{$tag}->{eids}}) {
+            foreach (@{$eindex->{$eid}->{tags}}) {
                 next if $_ eq $tag;
-                $tags{$_} = exists $tags{$_} ? $tags{$_} + 1 : 1;
-                $ts{$_} = $tindex{$_}->{ts} if !defined $ts{$_};
+                if (!exists $tags{$_}) {
+                    $tags{$_} = [ 1, $tindex->{$_}->{ts} ];
+                } else {
+                    $tags{$_}[0]++;
+                }
             }
         }
     } else {
         $tag = lc $tag;
-        foreach my $nctag (grep { lc $_ eq $tag } keys %tindex) {
-            foreach my $eid (@{$tindex{$nctag}->{eids}}) {
-                foreach (@{$eindex{$eid}->{tags}}) {
-                    my $mtag = lc $_;
-                    next if $mtag eq $tag;
-                    $tags{$mtag} = exists $tags{$mtag} ? $tags{$mtag} + 1 : 1;
-                    $ts{$mtag} = $tindex{$_}->{ts} if $ts{$mtag} < $tindex{$_}->{ts};
+        foreach my $nctag (grep { lc $_ eq $tag } keys %$tindex) {
+            foreach my $eid (@{$tindex->{$nctag}->{eids}}) {
+                foreach (@{$eindex->{$eid}->{tags}}) {
+                    my $t = lc $_;
+                    next if $t eq $tag;
+                    if (!exists $tags{$t}) {
+                        $tags{$t} = [ 1, $tindex->{$_}->{ts} ];
+                    } else {
+                        $tags{$t}[0]++;
+                        $tags{$t}[1] = $tindex->{$_}->{ts} if $tags{$t}[1] < $tindex->{$_}->{ts};
+                    }
                 }
             }
@@ -364 +386 @@
     } else {
         @list = $sort_order eq 'ascend' ?
-            sort { $tags{$a} <=> $tags{$b} } keys %tags :
-            sort { $tags{$b} <=> $tags{$a} } keys %tags;
+            sort { $tags{$a}[0] <=> $tags{$b}[0] } keys %tags :
+            sort { $tags{$b}[0] <=> $tags{$a}[0] } keys %tags;
     }
 
@@ -371 +393 @@
 
     my $total_sum = 0;
-    $total_sum += $tags{$_} foreach (@list);
+    $total_sum += $tags{$_}[0] foreach (@list);
     $ctx->stash('Tagwire::tags_total_sum', $total_sum);
 
@@ -381 +403 @@
         last if $lastn && $i >= $lastn;
         local $ctx->{__stash}{'Tagwire::tag'} = $_;
-        local $ctx->{__stash}{'Tagwire::tag_count'} = $tags{$_};
-        local $ctx->{__stash}{'Tagwire::tag_date'} = $ts{$_};
+        local $ctx->{__stash}{'Tagwire::tag_count'} = $tags{$_}[0];
+        local $ctx->{__stash}{'Tagwire::tag_date'} = $tags{$_}[1];
         defined(my $out = $builder->build($ctx, $tokens))
             or return $ctx->error($ctx->errstr);
@@ -420 +442 @@
     # tags(keywords) (REQUIRED)
     my $search = $args->{tags} || $args->{keywords} or return '';
-    # delimiter for "tags" argument (default = space characters)
+    # delimiter for "tags" argument (default = space)
     my $delimiter = $args->{delimiter} || '';
     # case_sensitive (0/1, default = 1)
@@ -435 +457 @@
         or return '';
 
-    my $blog_id = $ctx->stash('blog_id');
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
-        or return '';
-    my %tindex = %{$data->{tindex}};
-    my %eindex = %{$data->{eindex}};
+    my $data = get_indexes($ctx->stash('blog_id')) or return '';
+    my ($tindex, $eindex) = ($data->{tindex}, $data->{eindex});
+
     my %match;
     if ($case_sensitive) {
         foreach my $tag (@tags) {
-            foreach (@{$tindex{$tag}->{eids}}) {
+            foreach (@{$tindex->{$tag}->{eids}}) {
                 $match{$_} = exists $match{$_} ? $match{$_} + 1 : 1;
             }
@@ -449 +469 @@
     } else {
         foreach my $tag (@tags) {
-            foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
-                foreach (@{$tindex{$mtag}->{eids}}) {
+            foreach my $t (grep { lc $_ eq $tag } keys %$tindex) {
+                foreach (@{$tindex->{$t}->{eids}}) {
                     $match{$_} = exists $match{$_} ? $match{$_} + 1 : 1;
                 }
@@ -459 +479 @@
     my @eids = grep { $match{$_} == $count } keys %match or return '';
     @eids = $sort_order eq 'descend' ?
-        sort { $eindex{$b}->{created_on} <=> $eindex{$a}->{created_on} } @eids :
-        sort { $eindex{$a}->{created_on} <=> $eindex{$b}->{created_on} } @eids;
+        sort { $eindex->{$b}->{created_on} <=> $eindex->{$a}->{created_on} } @eids :
+        sort { $eindex->{$a}->{created_on} <=> $eindex->{$b}->{created_on} } @eids;
     splice(@eids, $lastn) if $lastn && (scalar @eids > $lastn);
-    require MT::Entry;
+
     my @entries;
     map { push @entries, MT::Entry->load($_) } @eids;
@@ -507 +527 @@
         or return '';
 
-    my $blog_id = $ctx->stash('blog_id');
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
-        or return '';
-    my %tindex = %{$data->{tindex}};
-    my %eindex = %{$data->{eindex}};
+    my $data = get_indexes($ctx->stash('blog_id')) or return '';
+    my ($tindex, $eindex) = ($data->{tindex}, $data->{eindex});
+
     my %match;
+    my $entry_id = $entry->id;
     if ($case_sensitive) {
         foreach my $tag (@tags) {
-            foreach (@{$tindex{$tag}->{eids}}) {
-                next if $_ == $entry->id;
+            foreach (@{$tindex->{$tag}->{eids}}) {
+                next if $_ == $entry_id;
                 $match{$_} = exists $match{$_} ? $match{$_} + 1 : 1;
             }
@@ -522 +541 @@
     } else {
         foreach my $tag (@tags) {
-            foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
-                foreach (@{$tindex{$mtag}->{eids}}) {
-                    next if $_ == $entry->id;
+            foreach my $t (grep { lc $_ eq $tag } keys %$tindex) {
+                foreach (@{$tindex->{$t}->{eids}}) {
+                    next if $_ == $entry_id;
                     $match{$_} = exists $match{$_} ? $match{$_} + 1 : 1;
                 }
@@ -532 +551 @@
     my @eids = keys %match or return '';
     @eids = $sort_order eq 'descend' ?
-        sort { $eindex{$b}->{created_on} <=> $eindex{$a}->{created_on} } @eids :
-        sort { $eindex{$a}->{created_on} <=> $eindex{$b}->{created_on} } @eids;
+        sort { $eindex->{$b}->{created_on} <=> $eindex->{$a}->{created_on} } @eids :
+        sort { $eindex->{$a}->{created_on} <=> $eindex->{$b}->{created_on} } @eids;
     @eids = sort { $match{$b} <=> $match{$a} } @eids;
     splice(@eids, $lastn) if $lastn && (scalar @eids > $lastn);
-    require MT::Entry;
     my @entries;
     map { push @entries, MT::Entry->load($_) } @eids;
@@ -564 +582 @@
 }
 
+use MT::Util;
 sub encode_urlplus {
     my $s = $_[0];
     return $s unless $_[1];
-    require MT::Util;
     $s =~ tr/ /+/;
     MT::Util::encode_url($s);
 }
 
-eval {
-    require MT::XSearch;
-    MT::XSearch->add_search_plugin('Tagwire', {
-        label => 'Tag(Keyword) Search',
-        description => 'Tag(Keyword) Search plugin for MT-XSearch',
-        on_execute => \&xsearch_on_execute,
-        on_stash => \&xsearch_on_stash });
-};
-
-MT::Template::Context->add_container_tag('XSearchTags' => \&xsearch_tags);
 sub xsearch_tags {
     my ($ctx, $args, $cond) = @_;
-    my $r = MT::Request->instance;
-    return '' unless defined $r->cache('Tagwire::xsearch_tags');
-    my @tags = @{$r->cache('Tagwire::xsearch_tags')};
+
+    return '' unless defined $ctx->stash('xsearch_tags');
+    my $tags = $ctx->stash('xsearch_tags');
+
     my @res;
     my $builder = $ctx->stash('builder');
     my $tokens = $ctx->stash('tokens');
-    foreach (@tags) {
+    foreach (@$tags) {
         local $ctx->{__stash}{'Tagwire::tag'} = $_;
         defined(my $out = $builder->build($ctx, $tokens))
@@ -601 +610 @@
 
 sub xsearch_on_stash {
-    $_[0]->stash('entry', $_[1]);
-    $_[0]->{current_timestamp} = $_[1]->created_on;
-    $_[0]->{modification_timestamp} = $_[1]->modified_on;
+    my ($ctx, $val, $self) = @_;
+    $ctx->stash('entry', $val);
+    $ctx->{current_timestamp} = $val->created_on;
+    $ctx->{modification_timestamp} = $val->modified_on;
+    $ctx->stash('xsearch_tags', $self->{xsearch_tags});
 }
 
 sub xsearch_on_execute {
-    my $args = shift;
-    my $blog_id = $args->{blog_id} or MT->error('Blog ID is required.');
-    my $sort_by = $args->{sort_by} || 'created_on';
-    my $sort_order = $args->{sort_order} || 'descend';
+    my ($args, $self) = @_;
+
+    MT->error('Blog ID is required.') unless $args->{blog_id};
     my $delimiter = $args->{delimiter} || '';
     my $case_sensitive = defined $args->{case_sensitive} ?
         $args->{case_sensitive} : 1;
-
-    my @entries;
+    my $sort_by = $args->{sort_by} || 'created_on';
+    my $sort_order = $args->{sort_order} || 'descend';
+    my $lastn = $args->{lastn} || 0;
+
     my @tags = split_args($args->{search}, $delimiter, $case_sensitive)
-        or return \@entries;
-
-    my $r = MT::Request->instance;
-    $r->cache('Tagwire::xsearch_tags', \@tags);
-
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
-        or return \@entries;
-    my %tindex = %{$data->{tindex}};
-    my %eindex = %{$data->{eindex}};
+        or return [];
+
+    $self->{xsearch_tags} = \@tags;
+
+    my $data = get_indexes($args->{blog_id}) or return [];
+    my ($tindex, $eindex) = ($data->{tindex}, $data->{eindex});
+
     my %match;
     if ($case_sensitive) {
         foreach my $tag (@tags) {
-            foreach (@{$tindex{$tag}->{eids}}) {
+            foreach (@{$tindex->{$tag}->{eids}}) {
                 $match{$_} = exists $match{$_} ? $match{$_} + 1 : 1;
             }
@@ -635 +645 @@
     } else {
         foreach my $tag (@tags) {
-            foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
-                foreach (@{$tindex{$mtag}->{eids}}) {
+            foreach my $t (grep { lc $_ eq $tag } keys %$tindex) {
+                foreach (@{$tindex->{$t}->{eids}}) {
                     $match{$_} = exists $match{$_} ? $match{$_} + 1 : 1;
                 }
@@ -643 +653 @@
     }
     my $count = scalar @tags;
-    my @eids = grep { $match{$_} == $count } keys %match
-        or return \@entries;
+    my @eids = grep { $match{$_} == $count } keys %match or return [];
     @eids = $sort_order eq 'descend' ?
-        sort { $eindex{$b}->{created_on} <=> $eindex{$a}->{created_on} } @eids :
-        sort { $eindex{$a}->{created_on} <=> $eindex{$b}->{created_on} } @eids;
-    require MT::Entry;
+        sort { $eindex->{$b}->{created_on} <=> $eindex->{$a}->{created_on} } @eids :
+        sort { $eindex->{$a}->{created_on} <=> $eindex->{$b}->{created_on} } @eids;
+    splice(@eids, $lastn) if $lastn && (scalar @eids > $lastn);
+
+    my @entries;
     map { push @entries, MT::Entry->load($_) } @eids;
+
     \@entries;
 }
 
 1;
-
-package MT::Plugin::Tagwire::Cache;
-use strict;
-use MT::Request;
-use vars qw($cache);
-
-sub new {
-    $cache ||= MT::Request->instance;
-}