radiant-taggable-extension 1.2.5 → 2.0.0.rc1

data/lib/taggable/admin_ui.rb

@@ -0,0 +1,43 @@
+module Taggable
+  module AdminUI
+
+   def self.included(base)
+     base.class_eval do
+
+        attr_accessor :tag
+        alias_method :tags, :tag
+
+        def load_default_regions_with_tags
+          load_default_regions_without_tags
+          @tag = load_default_tag_regions
+        end
+
+        alias_method_chain :load_default_regions, :tags
+
+        protected
+
+          def load_default_tag_regions
+            returning OpenStruct.new do |tag|
+              tag.edit = Radiant::AdminUI::RegionSet.new do |edit|
+                edit.main.concat %w{edit_header edit_form}
+                edit.form.concat %w{edit_name edit_role edit_description}
+                edit.form_bottom.concat %w{edit_timestamp edit_buttons}
+              end
+              tag.show = Radiant::AdminUI::RegionSet.new do |show|
+                show.main.concat %w{show_header show_pages show_assets}
+              end
+              tag.index = Radiant::AdminUI::RegionSet.new do |index|
+                index.thead.concat %w{title_header link_header description_header usage_header modify_header}
+                index.tbody.concat %w{title_cell link_cell description_cell usage_cell modify_cell}
+                index.bottom.concat %w{new_button}
+              end
+              tag.remove = tag.index
+              tag.new = tag.edit
+            end
+          end
+      
+      end
+    end
+  end
+
+end

data/lib/taggable/asset.rb

@@ -0,0 +1,37 @@
+module Taggable
+  module Asset
+  
+    def self.included(base)
+      base.class_eval {
+        has_tags
+        named_scope :furniture, {:conditions => 'assets.furniture = 1'}
+        named_scope :not_furniture, {:conditions => 'assets.furniture = 0 or assets.furniture is null'}
+
+        extend Taggable::Asset::ClassMethods
+        include Taggable::Asset::InstanceMethods
+      }
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      # just keeping compatibility with page tags
+      # so as to present the same interface
+
+      def keywords 
+        self.attached_tags.map {|t| t.title}.join(', ')
+      end
+    
+      def keywords=(somewords="")
+        self.attached_tags = Tag.from_list(somewords)
+      end
+    
+      def keywords_before_type_cast   # called by form_helper
+        keywords
+      end
+
+    end
+  end
+end

data/lib/taggable/model.rb

@@ -0,0 +1,144 @@
+module Taggable
+  module Model      # for inclusion into ActiveRecord::Base
+  
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval {
+        @@taggable_models = []
+        cattr_accessor :taggable_models
+      }
+    end
+
+    module ClassMethods
+      def has_tags?
+        false
+      end
+
+      def has_tags
+        return if has_tags?
+
+        has_many :taggings, :as => :tagged
+        has_many :attached_tags, :through => :taggings, :source => :tag    # can't be just has_many :tags because that stomps on the radius tags in Page.
+      
+        named_scope :from_tag, lambda { |tag|
+          tag = Tag.find_by_title(tag) unless tag.is_a? Tag
+          {
+            :joins => "INNER JOIN taggings as tt on tt.tagged_id = #{self.table_name}.id AND tt.tagged_type = '#{self.to_s}'", 
+            :conditions => ["tt.tag_id = ?", tag.id],
+            :readonly => false
+          }
+        }
+
+        named_scope :from_tags, lambda { |tags| 
+          {
+            :joins => "INNER JOIN taggings as tt on tt.tagged_id = #{self.table_name}.id AND tt.tagged_type = '#{self.to_s}'", 
+            :conditions => ["tt.tag_id in(#{tags.map{ '?' }.join(',')})"] + tags.map(&:id),
+            :group => column_names.map { |n| table_name + '.' + n }.join(','),    # postgres is strict and requires that we group by all selected (but not aggregated) columns
+            :order => "count(tt.id) DESC",
+            :readonly => false
+          }
+        }
+
+        named_scope :from_all_tags, lambda { |tags| 
+          {
+            :joins => "INNER JOIN taggings as tt on tt.tagged_id = #{self.table_name}.id AND tt.tagged_type = '#{self.to_s}'", 
+            :conditions => ["tt.tag_id in(#{tags.map{ '?' }.join(',')})"] + tags.map(&:id),
+            :group => column_names.map { |n| table_name + '.' + n }.join(','),    # postgres is strict and requires that we group by all selected (but not aggregated) columns
+            :having => "count(tt.id) >= #{tags.length}",
+            :readonly => false
+          }
+        } do
+          # count is badly sugared here: it omits the group and having clauses.
+          # length performs the query and looks at the array: less neat, but more right
+          # this gives us back any? and empty? as well.
+          def count
+            length
+          end
+        end
+      
+        # creates eg. tag.pages, tag.assets
+        # (returning the from_tag scope defined above)
+        Tag.define_retrieval_methods(self.to_s)
+      
+        class_eval {
+          extend Taggable::Model::TaggableClassMethods
+          include Taggable::Model::TaggableInstanceMethods
+          alias_method "related_#{self.to_s.underscore.pluralize}".intern, :related
+          alias_method "closely_related_#{self.to_s.underscore.pluralize}".intern, :closely_related
+        }
+
+        ActiveRecord::Base.taggable_models.push(self.to_s.intern)
+      end
+      
+      alias :is_taggable :has_tags
+      alias :is_taggable? :has_tags?
+    end
+
+    module TaggableClassMethods
+      def tagged_with(somewords=[])
+        if somewords.is_a?(Tag)
+          self.from_tag(somewords)
+        elsif somewords.is_a?(Array)
+          self.from_all_tags(somewords)
+        else
+          self.from_all_tags( Tag.from_list(somewords) )
+        end
+      end
+
+      def has_tags?
+        true
+      end
+    
+      def tags_for_cloud_from(these, limit=50)
+        Tag.attached_to(these).most_popular(limit)   # here popularity is use-count *within the group*
+      end
+    end
+  
+    module TaggableInstanceMethods
+
+      def add_tag(word=nil)
+        self.attached_tags << Tag.for(word) if word && !word.blank?
+      end
+
+      def remove_tag(word=nil)
+        tag = Tag.find_by_title(word) if word && !word.blank?
+        self.attached_tags.delete(tag) if tag
+      end
+    
+      def related
+        self.attached_tags.empty? ? [] : self.class.from_tags(self.attached_tags) - [self]
+      end
+    
+      def closely_related
+        self.attached_tags.empty? ? [] : self.class.from_all_tags(self.attached_tags) - [self]
+      end
+    
+      # in the case of pages and anything else that keywords in the same way this overrides the existing column
+      # the rest of the time it's just another way of specifying tags.
+    
+      def keywords 
+        self.attached_tags.map {|t| t.title}.join(', ')
+      end
+    
+      def keywords=(somewords="")
+        if somewords.blank?
+          self.attached_tags.clear
+        else
+          self.attached_tags = Tag.from_list(somewords)
+        end
+      end
+    
+      def keywords_before_type_cast   # for form_helper
+        keywords
+      end
+    
+      def tags_from_keywords
+        if self.class.column_names.include?('keywords') && keys = read_attribute(:keywords)
+          self.attached_tags = Tag.from_list(keys)
+        end
+      end
+    
+    end
+  end
+
+end

data/lib/taggable/page.rb

@@ -0,0 +1,54 @@
+module Taggable
+  module Page      # for inclusion into Page
+
+    # here we have a few special cases for page tags.
+    # because of the page tree
+  
+    def self.included(base)
+      base.class_eval {
+        has_tags
+        has_one :pointer, :class_name => 'Tag'
+        named_scope :children_of, lambda { |these|
+          { :conditions => ["parent_id IN (#{these.map{'?'}.join(',')})", *these.map{|t| t.id}] }
+        }
+        extend Taggable::Page::ClassMethods
+        include Taggable::Page::InstanceMethods
+      }
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      def has_pointer?
+        !pointer.nil?
+      end
+
+      # note varying logic here: tag clouds are used differently when describing a group.
+      # if only one object is relevant, all of its tags will be equally (locally) important. 
+      # Presumably that cloud should show global tag importance.
+      # If several objects are relevant, either from a list or a tree of descendants, we  
+      # probably want to show local tag importance, ie prominence within that list.
+    
+      def tags_for_cloud(limit=50, bands=6)
+        tags = Tag.attached_to(self.with_children).visible.most_popular(limit)
+        Tag.sized(tags, bands)
+      end
+    
+      # the family-tree builder works with generations instead of individuals to cut down the number of retrieval steps
+    
+      def with_children
+        this_generation = [self]
+        return this_generation unless self.respond_to?(:children) && self.children.any?
+        family = [self]
+        while this_generation.any? && next_generation = self.class.children_of(this_generation)
+          family.push(*next_generation)
+          this_generation = next_generation
+        end
+        family
+      end
+
+    end
+  end
+end

data/lib/taggable/site_controller.rb

@@ -0,0 +1,33 @@
+module Taggable
+  module SiteController
+
+    def self.included(base)
+  
+      base.class_eval {
+
+        def find_page_with_tags(url)
+          url = clean_url(url)
+          page = find_page_without_tags(url)
+          return page unless page.is_a?(LibraryPage)
+          page.add_request_tags(Tag.in_this_list(params[:tag])) if params[:tag]      
+          raise LibraryPage::RedirectRequired, page.url unless page.url == url     # to handle removal of tags and ensure consistent addressing. should also allow cache hit.
+          page
+        end
+        alias_method_chain :find_page, :tags
+
+        def show_page_with_tags
+          show_page_without_tags
+        rescue LibraryPage::RedirectRequired => e
+          redirect_to e.message
+        end
+        alias_method_chain :show_page, :tags
+    
+      protected
+        def clean_url(url)
+          "/#{ url.strip }/".gsub(%r{//+}, '/')
+        end
+    
+      }
+    end
+  end
+end

data/radiant-taggable-extension.gemspec

@@ -1,93 +1,31 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "radiant-taggable-extension"
 
 Gem::Specification.new do |s|
-  s.name = %q{radiant-taggable-extension}
-  s.version = "1.2.5"
+  s.name        = "radiant-taggable-extension"
+  s.version     = RadiantTaggableExtension::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = RadiantTaggableExtension::AUTHORS
+  s.email       = RadiantTaggableExtension::EMAIL
+  s.homepage    = RadiantTaggableExtension::URL
+  s.summary     = RadiantTaggableExtension::SUMMARY
+  s.description = RadiantTaggableExtension::DESCRIPTION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["spanner"]
-  s.date = %q{2011-04-12}
-  s.description = %q{General purpose tagging extension: more versatile but less focused than the tags extension}
-  s.email = %q{will@spanner.org}
-  s.extra_rdoc_files = [
-    "README.md"
-  ]
-  s.files = [
-    ".gitignore",
-     "README.md",
-     "Rakefile",
-     "VERSION",
-     "app/controllers/admin/taggings_controller.rb",
-     "app/controllers/admin/tags_controller.rb",
-     "app/helpers/taggable_helper.rb",
-     "app/models/tag.rb",
-     "app/models/tagging.rb",
-     "app/views/admin/pages/_edit_title.html.haml",
-     "app/views/admin/tags/_form.html.haml",
-     "app/views/admin/tags/_search_results.html.haml",
-     "app/views/admin/tags/cloud.html.haml",
-     "app/views/admin/tags/edit.html.haml",
-     "app/views/admin/tags/index.html.haml",
-     "app/views/admin/tags/new.html.haml",
-     "app/views/admin/tags/show.html.haml",
-     "config/locales/en.yml",
-     "config/routes.rb",
-     "db/migrate/001_create_tags.rb",
-     "db/migrate/002_import_keywords.rb",
-     "db/migrate/20110316210834_structural_tags.rb",
-     "db/migrate/20110411075109_metaphones.rb",
-     "lib/natcmp.rb",
-     "lib/radiant-taggable-extension.rb",
-     "lib/taggable_admin_page_controller.rb",
-     "lib/taggable_admin_ui.rb",
-     "lib/taggable_model.rb",
-     "lib/taggable_page.rb",
-     "lib/taggable_tags.rb",
-     "lib/tasks/taggable_extension_tasks.rake",
-     "lib/text/double_metaphone.rb",
-     "lib/text/metaphone.rb",
-     "public/images/admin/new-tag.png",
-     "public/images/admin/tag.png",
-     "public/javascripts/admin/taggable.js",
-     "public/javascripts/autocomplete.js",
-     "public/stylesheets/sass/admin/taggable.sass",
-     "public/stylesheets/sass/tagcloud.sass",
-     "radiant-taggable-extension.gemspec",
-     "spec/datasets/tag_sites_dataset.rb",
-     "spec/datasets/tags_dataset.rb",
-     "spec/lib/taggable_page_spec.rb",
-     "spec/models/tag_spec.rb",
-     "spec/spec.opts",
-     "spec/spec_helper.rb",
-     "taggable_extension.rb"
-  ]
-  s.homepage = %q{http://github.com/spanner/radiant-taggable-extension}
-  s.rdoc_options = ["--charset=UTF-8"]
+  ignores = if File.exist?('.gitignore')
+    File.read('.gitignore').split("\n").inject([]) {|a,p| a + Dir[p] }
+  else
+    []
+  end
+  s.files         = Dir['**/*'] - ignores
+  s.test_files    = Dir['test/**/*','spec/**/*','features/**/*'] - ignores
+  # s.executables   = Dir['bin/*'] - ignores
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Taggable Extension for Radiant CMS}
-  s.test_files = [
-    "spec/datasets/tag_sites_dataset.rb",
-     "spec/datasets/tags_dataset.rb",
-     "spec/lib/taggable_page_spec.rb",
-     "spec/models/tag_spec.rb",
-     "spec/spec_helper.rb"
-  ]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.post_install_message = %{
+  Add this to your radiant project with:
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<radiant>, [">= 0.9.0"])
-    else
-      s.add_dependency(%q<radiant>, [">= 0.9.0"])
-    end
-  else
-    s.add_dependency(%q<radiant>, [">= 0.9.0"])
-  end
-end
+    config.gem 'radiant-taggable-extension', :version => '~> #{RadiantTaggableExtension::VERSION}'
 
+  }
+end

data/spec/controllers/site_controller_spec.rb

@@ -0,0 +1,96 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SiteController do
+  dataset :tags
+
+  describe "on get to a library page" do
+    before do
+      get :show_page, :url => '/library/'
+    end
+    
+    it "should render the tag page" do
+      response.should be_success      
+      response.body.should == 'Shhhhh. body.'
+    end
+    
+    describe "with tags in child position" do
+      before do
+        get :show_page, :url => '/library/colourless/green/'
+      end
+
+      it "should still render the tag page" do
+        response.should be_success
+        response.body.should == 'Shhhhh. body.'
+      end
+    end
+
+    describe "with tags in child position and missing final /" do
+      before do
+        get :show_page, :url => '/library/colourless/green'
+      end
+
+      it "should still render the tag page" do
+        response.should be_success
+        response.body.should == 'Shhhhh. body.'
+      end
+    end
+
+    describe "with tag negation" do
+      before do
+        get :show_page, :url => '/library/colourless/green/-colourless'
+      end
+
+      it "should redirect to the reduced address" do
+        response.should be_redirect      
+        response.should redirect_to('http://test.host/library/green/')
+      end
+    end
+  end
+
+  describe "caching" do
+    describe "without tags requested" do
+      it "should add a default Cache-Control header with public and max-age of 5 minutes" do
+        get :show_page, :url => '/library/'
+        response.headers['Cache-Control'].should =~ /public/
+        response.headers['Cache-Control'].should =~ /max-age=300/
+      end
+
+      it "should pass along the etag set by the page" do
+        get :show_page, :url => '/library/'
+        response.headers['ETag'].should be
+      end
+
+      it "should return a not-modified response when the sent etag matches" do
+        response.stub!(:etag).and_return("foobar")
+        request.if_none_match = 'foobar'
+        get :show_page, :url => '/library/'
+        response.response_code.should == 304
+        response.body.should be_blank
+      end
+    end
+    
+    describe "with tags requested" do
+      it "should add a default Cache-Control header with public and max-age of 5 minutes" do
+        get :show_page, :url => '/library/green/furiously'
+        response.headers['Cache-Control'].should =~ /public/
+        response.headers['Cache-Control'].should =~ /max-age=300/
+      end
+
+      it "should pass along the etag set by the page" do
+        get :show_page, :url => '/library/green/furiously'
+        response.headers['ETag'].should be
+      end
+
+      it "should return a not-modified response when the sent etag matches" do
+        response.stub!(:etag).and_return("foobar")
+        request.if_none_match = 'foobar'
+        get :show_page, :url => '/library/green/furiously'
+        response.response_code.should == 304
+        response.body.should be_blank
+      end
+    end
+    
+    
+  end
+    
+end

data/spec/datasets/tags_dataset.rb

@@ -16,6 +16,8 @@ class TagsDataset < Dataset::Base
     apply_tag :ideas, pages(:first), pages(:another), pages(:grandchild)
     apply_tag :sleep, pages(:first)
     apply_tag :furiously, pages(:first)
+    
+    create_page "library", :slug => "library", :class_name => 'LibraryPage', :body => 'Shhhhh.'
   end
   
   helpers do

data/spec/lib/taggable_page_spec.rb

@@ -4,7 +4,7 @@ describe Page do
   dataset :tags
   
   it "should report itself taggable" do
-    Page.is_taggable?.should be_true
+    Page.has_tags?.should be_true
   end
 
   it "should return a list of pages form tag list" do

data/spec/models/library_page_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe LibraryPage do
+  dataset :tags
+  
+  it "should be a Page" do
+    page = LibraryPage.new
+    page.is_a?(Page).should be_true
+  end
+  
+  describe "on request" do
+    describe "with one tag" do
+      before do
+        @page = Page.find_by_url('/library/colourless')
+      end
+  
+      it "should interrupt find_by_url" do
+        @page.should == pages(:library)
+        @page.is_a?(LibraryPage).should be_true
+      end
+
+      it "should set tag context correctly" do
+        @page.requested_tags.should == [tags(:colourless)]
+      end
+    end
+    
+    describe "with several tags" do
+      before do
+        @page = Page.find_by_url('/library/colourless/green/ideas')
+      end
+      it "should set tag context correctly" do
+        @page.requested_tags.should == [tags(:colourless), tags(:green), tags(:ideas)]
+      end
+    end
+    
+    describe "with several tags and one tag negation" do
+      before do
+        @page = Page.find_by_url('/library/colourless/green/ideas/-green')
+      end
+      it "should set tag context correctly" do
+        @page.requested_tags.should == [tags(:colourless), tags(:ideas)]
+      end
+    end
+    
+  end
+  
+end

data/taggable_extension.rb

@@ -1,19 +1,25 @@
+require_dependency 'application_controller'
+require "radiant-taggable-extension"
+
 class TaggableExtension < Radiant::Extension
-  version "1.2.5"
-  description "General purpose tagging and retrieval extension: more versatile but less focused than the tags extension"
-  url "http://github.com/spanner/radiant-taggable-extension"
+  version RadiantTaggableExtension::VERSION
+  description RadiantTaggableExtension::DESCRIPTION
+  url RadiantTaggableExtension::URL
     
   def activate
-    require 'natcmp'                                                    # a natural sort algorithm. possibly not that efficient.
-    ActiveRecord::Base.send :include, TaggableModel                     # provide is_taggable for everything but don't call it for anything
-    Page.send :is_taggable                                              # make pages taggable 
-    Page.send :include, TaggablePage                                    # then fake the keywords column and add some inheritance
-    Page.send :include, TaggableTags                                    # and the basic radius tags for showing page tags and tag pages
-    Admin::PagesController.send :include, TaggableAdminPageController   # tweak the admin interface to make page tags more prominent
-    UserActionObserver.instance.send :add_observer!, Tag                # tags get creator-stamped
+    require 'natcmp'                                                      # a natural sort algorithm. possibly not that efficient.
+    ActiveRecord::Base.send :include, Taggable::Model                     # provide has_tags for everything but don't call it for anything
+    Page.send :include, Taggable::Page                                    # pages are taggable (and the keywords column is overridden)
+    Asset.send :include, Taggable::Asset                                  # assets are taggable (and a fake keywords column is provided)
+    Page.send :include, Radius::TaggableTags                              # adds the basic radius tags for showing page tags and tag pages
+    Page.send :include, Radius::AssetTags                                 # adds some asset:* tags
+    LibraryPage.send :include, Radius::LibraryTags                        #
+    SiteController.send :include, Taggable::SiteController                # some path and parameter handling in support of library pages
+    Admin::PagesController.send :include, Taggable::AdminPagesController  # tweaks the admin interface to make page tags more prominent
+    UserActionObserver.instance.send :add_observer!, Tag                  # tags get creator-stamped
 
     unless defined? admin.tag
-      Radiant::AdminUI.send :include, TaggableAdminUI
+      Radiant::AdminUI.send :include, Taggable::AdminUI
       admin.tag = Radiant::AdminUI.load_default_tag_regions
     end