Changeset 95 for tagwire/trunk

Timestamp:

06/24/05 18:35:31 (4 years ago)

Author:

ogawa

Message:

Add README.txt.
Code cleanup and a bug fix.

Location:

tagwire/trunk

Files:

• README.txt (added)
• tagwire.pl (modified) (11 diffs)

tagwire/trunk/tagwire.pl

@@ -12 +12 @@
 use strict;
 use MT::Template::Context;
+use MT::Request;
 
 # DEBUG
@@ -24 +25 @@
     $plugin->name("Tagwire Plugin");
     $plugin->description("A plugin for listing and handling blog-wide tags and entry tags.");
-#    $plugin->doc_link("http://as-is.net/hacks/2005/03/allkeywords_plugin.html");
+    $plugin->doc_link("http://as-is.net/hacks/2005/06/tagwire_plugin.html");
     MT->add_plugin($plugin);
 };
@@ -74 +75 @@
     $pd->data($data);
     $pd->save or die $pd->errstr;
+    if ($ENABLE_REQ_CACHE) {
+        my $r = MT::Request->instance;
+        my $cname = 'Tagwire::Cache::' . $blog_id;
+        $r->cache($cname, undef);
+    }
 }
 
@@ -135 +141 @@
 }
 
-use MT::Request;
 sub get_pd_indexes {
     return unless $ENABLE_PD_INDEXES && $plugin;
@@ -187 +192 @@
     my ($ctx, $args, $cond) = @_;
 
-    # sort_by option (tag/tag-case/count, default = tag)
+    # sort_by (tag/tag-case/count, default = tag)
     my $sort_by = $args->{sort_by} || 'tag';
-    # sort_order option (ascend/descend, default = ascend)
+    # sort_order (ascend/descend, default = ascend)
     my $sort_order = $args->{sort_order} || 'ascend';
-    # lastn option (default = 0, no cutoff)
+    # lastn (default = 0, no cutoff)
     my $lastn = $args->{lastn} || 0;
-    # case_sensitive option (0/1, default = 1)
+    # case_sensitive (0/1, default = 1)
     my $case_sensitive = defined $args->{case_sensitive} ?
         $args->{case_sensitive} : 1;
@@ -200 +205 @@
     my %tags = ();
 
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id);
-    if ($data) {
-        my %tindex = %{$data->{tindex}};
-        if ($case_sensitive) {
-            map { $tags{$_} = scalar(@{$tindex{$_}}) } keys %tindex;
-        } else {
-            map { $tags{lc $_} += scalar(@{$tindex{$_}}) } keys %tindex;
-        }
-    } else {
-        require MT::Entry;
-        my $iter = MT::Entry->load_iter({ blog_id => $blog_id,
-                                          status => MT::Entry::RELEASE() });
-        while (my $e = $iter->()) {
-            next unless $e->keywords;
-            my @etags = split_tags($e->keywords, $case_sensitive);
-            foreach my $etag (@etags) {
-                $tags{$etag} = exists $tags{$etag} ? $tags{$etag} + 1 : 1;
-            }
-        }
+    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
+        or return '';
+    my %tindex = %{$data->{tindex}};
+    if ($case_sensitive) {
+        map { $tags{$_} = scalar(@{$tindex{$_}}) } keys %tindex;
+    } else {
+        map { $tags{lc $_} += scalar(@{$tindex{$_}}) } keys %tindex;
     }
 
@@ -267 +260 @@
     return '' unless $e->keywords;
 
-    # case_sensitive option (0/1, default = 1)
+    # case_sensitive (0/1, default = 1)
     my $case_sensitive = defined $args->{case_sensitive} ?
         $args->{case_sensitive} : 1;
@@ -309 +302 @@
     my ($ctx, $args, $cond) = @_;
 
-    # tags(keywords) option (REQUIRED)
+    # tags(keywords) (REQUIRED)
     my $search = $args->{tags} || $args->{keywords} or return '';
-    # delimiter option (default = space characters)
+    # delimiter for "tags" argument (default = space characters)
     my $delimiter = $args->{delimiter} || '';
-    # case_sensitive option (0/1, default = 1)
+    # case_sensitive (0/1, default = 1)
     my $case_sensitive = defined $args->{case_sensitive} ?
         $args->{case_sensitive} : 1;
-    # sort_by option (title/status/created_on/modified_on/author_id/excerpt, default = created_on)
+    # sort_by (created_on, default = created_on)
     my $sort_by = $args->{sort_by} || 'created_on';
-    # sort_order option (ascend/descend, default = descend)
+    # sort_order (ascend/descend, default = descend)
     my $sort_order = $args->{sort_order} || 'descend';
-    # lastn option (default = 0, no cutoff)
+    # lastn (default = 0, no cutoff)
     my $lastn = $args->{lastn} || 0;
+
+    my @patterns = split_args($search, $delimiter, $case_sensitive)
+        or return '';
 
     my $blog_id = $ctx->stash('blog_id');
     my @entries;
-    my @patterns = split_args($search, $delimiter, $case_sensitive);
-
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id);
-    if ($data) {
-        my %tindex = %{$data->{tindex}};
-        my %eindex = %{$data->{eindex}};
-        my %match;
-        if ($case_sensitive) {
-            foreach my $tag (@patterns) {
-                foreach my $eid (@{$tindex{$tag}}) {
+
+    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
+        or return '';
+    my %tindex = %{$data->{tindex}};
+    my %eindex = %{$data->{eindex}};
+    my %match;
+    if ($case_sensitive) {
+        foreach my $tag (@patterns) {
+            foreach my $eid (@{$tindex{$tag}}) {
+                $match{$eid} = exists $match{$eid} ? $match{$eid} + 1 : 1;
+            }
+        }
+    } else {
+        foreach my $tag (@patterns) {
+            foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
+                foreach my $eid (@{$tindex{$mtag}}) {
                     $match{$eid} = exists $match{$eid} ? $match{$eid} + 1 : 1;
                 }
             }
-        } else {
-            foreach my $tag (@patterns) {
-                foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
-                    foreach my $eid (@{$tindex{$mtag}}) {
-                        $match{$eid} = exists $match{$eid} ? $match{$eid} + 1 : 1;
-                    }
-                }
-            }
-        }
-        my $count = scalar @patterns;
-        my @eids = grep { $match{$_} == $count } keys %match or return;
-        @eids = sort { $eindex{$b}->{created_on} <=> $eindex{$a}->{created_on} } @eids;
-        @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;
-        map { push @entries, MT::Entry->load($_) } @eids;
-        # The above code is sticked to "created_on".
-    } else {
-        require MT::Entry;
-        my $iter = MT::Entry->load_iter({ blog_id => $blog_id,
-                                          status => MT::Entry::RELEASE() },
-                                        { sort => $sort_by,
-                                          direction => $sort_order });
-        my $i = 0;
-        while (my $e = $iter->()) {
-            last if $lastn && $i >= $lastn;
-            next unless $e->keywords;
-            my @tags = split_tags($e->keywords, $case_sensitive);
-            my $check = 1;
-            foreach my $pattern (@patterns) {
-                unless (scalar grep { $_ eq $pattern } @tags) {
-                    $check = 0;
-                    last;
-                }
-            }
-            if ($check) {
-                push @entries, $e;
-                $i++;
-            }
-        }
-        return '' unless @entries;
-    }
+        }
+    }
+    my $count = scalar @patterns;
+    my @eids = grep { $match{$_} == $count } keys %match or return;
+    @eids = sort { $eindex{$b}->{created_on} <=> $eindex{$a}->{created_on} } @eids;
+    @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;
+    splice(@eids, $lastn) if $lastn && (scalar @eids > $lastn);
+    require MT::Entry;
+    map { push @entries, MT::Entry->load($_) } @eids;
 
     my $res = '';
@@ -412 +382 @@
     return '' unless $entry->keywords;
 
-    # case_sensitive option (0/1, default = 1)
+    # case_sensitive (0/1, default = 1)
     my $case_sensitive = defined $args->{case_sensitive} ?
         $args->{case_sensitive} : 1;
-    # lastn option (default = 0, no cutoff)
+    # sort_order (ascend/descend, default = descend)
+    my $sort_order = $args->{sort_order} || 'descend';
+    # lastn (default = 0, no cutoff)
     my $lastn = $args->{lastn} || 0;
 
@@ -423 +395 @@
     my $blog_id = $ctx->stash('blog_id');
     my @entries;
-    my %match = ();
-
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id);
-    if ($data) {
-        my %tindex = %{$data->{tindex}};
-        my %eindex = %{$data->{eindex}};
-        my %match;
-        if ($case_sensitive) {
-            foreach my $tag (@patterns) {
-                foreach my $eid (@{$tindex{$tag}}) {
+
+    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
+        or return '';
+    my %tindex = %{$data->{tindex}};
+    my %eindex = %{$data->{eindex}};
+    my %match;
+    if ($case_sensitive) {
+        foreach my $tag (@patterns) {
+            foreach my $eid (@{$tindex{$tag}}) {
+                next if $eid == $entry->id;
+                $match{$eid} = exists $match{$eid} ? $match{$eid} + 1 : 1;
+            }
+        }
+    } else {
+        foreach my $tag (@patterns) {
+            foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
+                foreach my $eid (@{$tindex{$mtag}}) {
                     next if $eid == $entry->id;
-                    $match{$eid} = exists $match{$eid} ?
-                        $match{$eid} + 1 : 1;
+                    $match{$eid} = exists $match{$eid} ? $match{$eid} + 1 : 1;
                 }
             }
-        } else {
-            foreach my $tag (@patterns) {
-                foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
-                    foreach my $eid (@{$tindex{$mtag}}) {
-                        next if $eid == $entry->id;
-                        $match{$eid} = exists $match{$eid} ?
-                            $match{$eid} + 1 : 1;
-                    }
-                }
-            }
-        }
-        my @eids = keys %match or return '';
-        @eids = sort { $eindex{$b}->{created_on} <=> $eindex{$a}->{created_on} } @eids;
-        @eids = sort { $match{$b} <=> $match{$a} } @eids;
-        splice(@eids, $lastn) if $lastn && (scalar @eids > $lastn);
-        require MT::Entry;
-        map { push @entries, MT::Entry->load($_) } @eids;
-        return '' unless @entries;
-    } else {
-        require MT::Entry;
-        my $iter = MT::Entry->load_iter({ blog_id => $blog_id,
-                                          status => MT::Entry::RELEASE() },
-                                        { sort => 'created_on',
-                                          direction => 'descend' });
-        while (my $e = $iter->()) {
-            next unless $e->keywords;
-            next if $e->id == $entry->id;
-            my @tags = split_tags($e->keywords, $case_sensitive);
-            my $count = 0;
-            foreach my $pattern (@patterns) {
-                $count++ if (scalar grep { $_ eq $pattern } @tags);
-            }
-            if ($count) {
-                push @entries, $e;
-                $match{ $e->id } = $count;
-            }
-        }
-        return '' unless @entries;
-
-        @entries = sort { $match{$b->id} <=> $match{$a->id} } @entries;
-        splice(@entries, $lastn) if $lastn && (scalar @entries > $lastn);
-    }
+        }
+    }
+    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;
+    @eids = sort { $match{$b} <=> $match{$a} } @eids;
+    splice(@eids, $lastn) if $lastn && (scalar @eids > $lastn);
+    require MT::Entry;
+    map { push @entries, MT::Entry->load($_) } @eids;
+    return '' unless @entries;
 
     my $res = '';
@@ -533 +480 @@
     my @patterns = split_args($args->{search}, $delimiter, $case_sensitive);
 
-    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id);
-    if ($data) {
-        my %tindex = %{$data->{tindex}};
-        my %eindex = %{$data->{eindex}};
-        my %match;
-        if ($case_sensitive) {
-            foreach my $tag (@patterns) {
-                foreach my $eid (@{$tindex{$tag}}) {
-                    $match{$eid} = exists $match{$eid} ?
-                        $match{$eid} + 1 : 1;
+    my $data = get_pd_indexes($blog_id) || get_db_indexes($blog_id)
+        or return \@results;
+    my %tindex = %{$data->{tindex}};
+    my %eindex = %{$data->{eindex}};
+    my %match;
+    if ($case_sensitive) {
+        foreach my $tag (@patterns) {
+            foreach my $eid (@{$tindex{$tag}}) {
+                $match{$eid} = exists $match{$eid} ? $match{$eid} + 1 : 1;
+            }
+        }
+    } else {
+        foreach my $tag (@patterns) {
+            foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
+                foreach my $eid (@{$tindex{$mtag}}) {
+                    $match{$eid} = exists $match{$eid} ? $match{$eid} + 1 : 1;
                 }
             }
-        } else {
-            foreach my $tag (@patterns) {
-                foreach my $mtag (grep { lc $_ eq $tag } keys %tindex) {
-                    foreach my $eid (@{$tindex{$mtag}}) {
-                        $match{$eid} = exists $match{$eid} ?
-                            $match{$eid} + 1 : 1;
-                    }
-                }
-            }
-        }
-        my $count = scalar @patterns;
-        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;
-        map { push @results, MT::Entry->load($_) } @eids;
-        # The above code is sticked to "created_on".
-    } else {
-        my $iter = MT::Entry->load_iter({ blog_id => $blog_id,
-                                          status => MT::Entry::RELEASE() },
-                                        { sort => $sort_by, 
-                                          direction => $sort_order });
-        while (my $e = $iter->()) {
-            next unless $e->keywords;
-            my @tags = split_tags($e->keywords, $case_sensitive)
-                or next;
-            my $check = 1;
-            foreach my $pattern (@patterns) {
-                unless (scalar grep { $_ eq $pattern } @tags) {
-                    $check = 0;
-                    last;
-                }
-            }
-            push @results, $e if $check;
-        }
-    }
+        }
+    }
+    my $count = scalar @patterns;
+    my @eids = grep { $match{$_} == $count } keys %match
+        or return \@results;
+    @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;
+    map { push @results, MT::Entry->load($_) } @eids;
     \@results;
 }