radiant-taggable-extension 1.2.0

data/app/views/admin/tags/index.html.haml

@@ -0,0 +1,53 @@
+- include_stylesheet 'admin/tags'
+= render_region :top 
+
+#tags_table.outset
+  %table{ :class => "index", :cellpadding => "0", :cellspacing => "0", :border => "0"}
+    %thead
+      %tr
+        - render_region :thead do |thead|
+          - thead.title_header do
+            %th.tag-title Title
+          - thead.description_header do
+            %th.tag-description Description
+          - thead.usage_header do
+            %th.tag-usage Usage
+          - thead.modify_header do
+            %th.modify{:colspan =>"2"} Modify
+
+    %tbody
+      - for tag in @tags 
+        %tr.node.level-1
+          - render_region :tbody do |tbody|
+            - tbody.title_cell do
+              %td.tag-title
+                = link_to image('tag', :alt => ''), edit_admin_tag_url(:id => tag.id) 
+                = link_to tag.title, edit_admin_tag_url(:id => tag.id) 
+
+            - tbody.description_cell do
+              %td.tag-description
+                = tag.description
+                
+            - tbody.usage_cell do
+              %td.tag-usage
+                - if tag.use_count.to_i > 0
+                  = link_to "#{tag.use_count} #{pluralize(tag.use_count.to_i, 'item')}", admin_tag_url(tag)
+                - else
+                  \-
+
+            - tbody.modify_cell do
+              %td.actions
+                = link_to image('minus') + ' ' + t('remove'), remove_admin_tag_url(tag), :class => "action"
+ 
+- render_region :bottom do |bottom|
+  - bottom.new_button do
+    #actions
+      %ul
+        %li= link_to image('plus') + " " + "new tag", new_admin_tag_url
+        %li= link_to "tag list", admin_tags_url, :class => 'minor'
+        %li= link_to "tag cloud", cloud_admin_tags_url, :class => 'minor'
+   
+%script{ :type => "text/javascript"}
+  // <! [CDATA[
+  new RuledTable('tags')
+  //]

data/app/views/admin/tags/new.html.haml

@@ -0,0 +1,13 @@
+- include_stylesheet 'admin/tags' 
+
+- render_region :main do |main|
+  - main.edit_header do
+    %h1
+      New Tag
+    %p 
+      Tags are usually added while editing pages (or other tagged items). There you can create several tags at once just by typing a list into the 'keywords' field.
+      If you'd like a bit more control than that, you can also create and describe tags one at a time here:
+
+  - main.edit_form do
+    - form_for :tag, :url => admin_tags_path, :html => { :method => "post", :multipart => true } do |form|
+      = render :partial => 'form', :object => form

data/app/views/admin/tags/show.html.haml

@@ -0,0 +1,32 @@
+- include_stylesheet 'admin/tags' 
+
+- render_region :main do |main|
+  - main.show_header do
+    %h1
+      Tag:
+      = link_to @tag.title, edit_admin_tag_url(@tag)
+    - if @tag.description
+      %p
+        = @tag.description
+
+  - main.show_pages do
+    - page_taggings = @tag.taggings.of_a :page
+    - if page_taggings.any?
+      %h2
+        Tagged pages
+      %table.index
+        - page_taggings.each do |tagging|
+          - page = tagging.tagged
+          - dom_id = "tagging_#{tagging.id}"
+          %tr.page.level-1{:id => dom_id}
+            %td{:style => 'width: 48px'}
+              = link_to image('page', :class => "icon"), page.url
+            %td.name
+              = link_to %{ <span class="title">#{ h(page.title) }</span>}, page.url
+            %td.actions
+              = link_to_remote image('minus') + ' detach', |
+                :html => { :class => "action", :title => "Detach tag from page" }, |
+                :url => admin_tagging_url(tagging), :method => :delete, |
+                :after => "Effect.Fade('#{dom_id}', { duration: 0.5 })", |
+                :complete => "Element.remove('#{dom_id}');"
+

data/config/routes.rb

@@ -0,0 +1,6 @@
+ActionController::Routing::Routes.draw do |map|
+  map.namespace :admin do |admin|
+    admin.resources :tags, :member => {:remove => :get }, :collection => {:cloud => :get}
+    admin.resources :taggings, :only => [:destroy]
+  end
+end

data/db/migrate/001_create_tags.rb

@@ -0,0 +1,26 @@
+class CreateTags < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.column :title,            :string
+      t.column :description,      :text
+      t.column :created_by_id,    :integer
+      t.column :updated_by_id,    :integer
+      t.column :created_at,       :datetime
+      t.column :updated_at,       :datetime
+      t.column :site_id,         :integer
+    end
+    add_index :tags, :title, :unique => true
+
+    create_table :taggings do |t|
+      t.column :tag_id,           :integer
+      t.column :tagged_type,      :string
+      t.column :tagged_id,        :integer
+    end
+    add_index :taggings, [:tag_id, :tagged_id, :tagged_type], :unique => true
+  end
+
+  def self.down
+    drop_table :tags
+    drop_table :taggings
+  end
+end

data/db/migrate/002_import_keywords.rb

@@ -0,0 +1,11 @@
+class ImportKeywords < ActiveRecord::Migration
+  def self.up
+    Page.find(:all).each do |page|
+      page.tags_from_keywords
+    end
+  end
+
+  def self.down
+
+  end
+end

data/lib/taggable_admin_page_controller.rb

@@ -0,0 +1,18 @@
+module TaggableAdminPageController      # for inclusion into Admin::PagesController
+
+  # here we have a few more special cases for page tags.
+  # mostly just interface niceties
+  
+  def self.included(base)
+    
+    base.class_eval {
+
+      def initialize_meta_rows_and_buttons_with_tags
+        initialize_meta_rows_and_buttons_without_tags
+        @meta.delete(@meta.find{|m| m[:field] == 'keywords'})
+      end
+      alias_method_chain :initialize_meta_rows_and_buttons, :tags
+
+    }
+  end
+end

data/lib/taggable_admin_ui.rb

@@ -0,0 +1,41 @@
+module TaggableAdminUI
+
+ 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_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}
+            end
+            tag.index = Radiant::AdminUI::RegionSet.new do |index|
+              index.thead.concat %w{title_header description_header usage_header modify_header}
+              index.tbody.concat %w{title_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
+

data/lib/taggable_model.rb

@@ -0,0 +1,128 @@
+module TaggableModel      # 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 is_taggable?
+      false
+    end
+
+    def is_taggable
+      return if is_taggable?
+
+      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_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"
+        }
+      }
+
+      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}"
+        }
+      } 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
+      
+      # this sets up eg Taggings.of_model
+      # and then uses that to define instance methods in Tag:
+      # tag.models
+      # tag.models_count
+      Tag.define_class_retrieval_methods(self.to_s)
+      
+      class_eval {
+        extend TaggableModel::TaggableClassMethods
+        include TaggableModel::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
+  end
+
+  module TaggableClassMethods
+    def tagged_with(somewords=[])
+      if somewords.is_a?(Array)
+        self.from_all_tags(somewords)
+      else
+        self.from_all_tags( Tag.from_list(somewords) )
+      end
+    end
+
+    def is_taggable?
+      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
+

data/lib/taggable_page.rb

@@ -0,0 +1,48 @@
+module TaggablePage      # 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 {
+      named_scope :children_of, lambda { |these|
+        { :conditions => ["parent_id IN (#{these.map{'?'}.join(',')})", *these.map{|t| t.id}] }
+      }
+      extend TaggablePage::ClassMethods
+      include TaggablePage::InstanceMethods
+    }
+  end
+
+  module ClassMethods
+  end
+
+
+  module InstanceMethods
+
+    # 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).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