acts_as_20ggable 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZGFiNzE5NjQ1ZWI5YmJmODA3MWQ4OWIyMGVlZTNiNmI5YTY2MjQ1NA==
+  data.tar.gz: !binary |-
+    MmE1ZjYxYjczZGE0MGNlYzI5YzExZDU4MTE1MTg4MzQzMjRjOTNhZQ==
+SHA512:
+  metadata.gz: !binary |-
+    Y2MyOGU3ZjE0ZjcyZDY5ODlmYTZlNWNkMDNkYWZmODcyNmJhMWUzNGY4NDQ3
+    MDIwYTYxYzkxZTM1ZDliYmE0YzQ2NGUzODEyNzViMDBmYTMxZjgwYTZmYzEy
+    ODMzODNhMzc1YzNmMGJlNDgxMTUyNjU3YThiY2RiMzgzMmJkODg=
+  data.tar.gz: !binary |-
+    OWU5Y2Y5NzA2OWM1NGJiMTU4ODQxYmZhZDlkNzAxMTRkMjAxZGZlNmVkNmVm
+    OWM0ZDc0NTlhMmJkYTJhNGI0MTBhNDQzNzc2MTgwMzA5YWM3ZTgxYjkzYjg5
+    ZjgzZGM3MDE0ODQwZDI1MzYzNTk4ODAyM2I0ZjQ2M2QyYzE1NTI=

data/.gitignore

@@ -0,0 +1 @@
+test/debug.log

data/CHANGELOG

@@ -0,0 +1,6 @@
+[02 September 2014]
+ + Gemify
+ + Rails3 compatibility
+
+[17 September 2008]
+Initial upload to github ;)

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    acts_as_20ggable (1.0.0)
+      activerecord (~> 3.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionpack (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.5)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.19)
+      activesupport (= 3.2.19)
+      builder (~> 3.0.0)
+    activerecord (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.19)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    builder (3.0.4)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.11)
+    journey (1.0.4)
+    multi_json (1.10.1)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.3.2)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sqlite3 (1.3.9)
+    tilt (1.4.1)
+    tzinfo (0.3.41)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  actionpack (~> 3.2.0)
+  activesupport (~> 3.2.0)
+  acts_as_20ggable!
+  rake
+  sqlite3

data/README

@@ -0,0 +1,76 @@
+= acts_as_20ggable
+
+This gem implements categories ('Tags v2.0') engine inspired by Dmitriy Smirnov's
+post http://spectator.ru/technology/web-building/tags2null .
+
+It is heavily based on acts_as_taggable_on_steroids by Jonathan Viney (thanks!):
+http://svn.viney.net.nz/things/rails/plugins/acts_as_taggable_on_steroids/
+
+Also, it is under development and not production-ready yet. Look at FIXMEs, TODOs and OPTIMIZEs in code. Interface is subject to change, too.
+  
+== Instructions & usage
+
+Almost everything concerned with original acts_as_taggable_on_steriods applies equally
+to this plugin, so read original README first: 
+
+ http://svn.viney.net.nz/things/rails/plugins/acts_as_taggable_on_steroids/README
+ 
+=== Attention
+
+TagHierarchyBuilder.rebuild_hierarchy relies on DB transactions. So, on
+non-transactional datastores everything can break suddenly.
+
+=== Playground configuration
+
+Generate and apply migration:
+
+  ruby script/generate acts_as_20ggable_migration
+  rake db:migrate
+
+Let's suppose we have photos and we want those photos to have tags:
+
+  class Photo < ActiveRecord::Base
+    acts_as_taggable
+  end
+  
+Also let's suppose we already have some photos with some tags in DB.
+ 
+=== Tags hierarchy editing
+
+To dump tags hierarchy for editing, use
+
+  hierarchy = TagHierarchyBuilder.dump_tags # => ['# Categories',
+                                                  '# Synonyms',
+                                                  '# Unlinked tags',
+                                                  'Nature',
+                                                  'Horse',
+                                                  'Cat',
+                                                  'Kitty',
+                                                  'Animals']
+
+Let user edit it as plain text, then to update hierarchy use
+
+  # hierarchy => ['# Categories',
+                  'Nature / Animals',
+                  'Animals / Horse',
+                  'Nature / Animals / Cat',
+                  '# Synonyms',
+                  'Cat = Kitty']
+
+  TagHierarchyBuilder.rebuild_hierarchy(hierarchy)
+
+Comments ("# …") in hierarchy specification are purely optional and inserted only 
+for user convenience.
+
+TagHierarchyBuilder can throw TagHierarchyBuilder::WrongSpecificationSyntax or Tag::HierarchyCycle. Errors descriptions still not implemented, sorry.
+
+=== Finding tagged objects
+
+find_tagged_with by default returns models with all subtags:
+
+  Photo.find_tagged_with('Animals') # => Everything tagged with Animals, Horse, Cat, Kitty
+  Photo.find_tagged_with('Animals', :exclude_subtags => true) # => Only tagged with Animals
+  
+== Other
+
+Problems, comments, and suggestions all welcome. avanie@gmail.com

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_taggable_on_steroids plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.libs << 'test/support'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_taggable_on_steroids plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Acts As Taggable On Steroids'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/acts_as_20ggable.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "acts_as_20ggable"
+  s.version = "1.0.0"
+
+  s.authors = ["Dmitriy Timokhin", "Andrey Subbota"]
+  s.email = ["subbota@gmail.com"]
+  s.homepage = "https://github.com/numbata/acts_as_20ggable"
+  s.summary = "Implements categories ('Tags v2.0') engine inspired by Dmitriy Smirnov's"
+  s.description = "This gem is rails3.2 compatible version of Dmitriy Timokhin's plugin acts_as_20ggable: https://github.com/pager/acts_as_20ggable"
+  s.license = "MIT"
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+    "README"
+  ]
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activerecord", '~> 3.2', ">= 3.2.0"
+  s.add_development_dependency "rake", "~> 0"
+  s.add_development_dependency "actionpack", '~> 3.2', ">= 3.2.0"
+  s.add_development_dependency "activesupport", "~> 3.2", ">= 3.2.0"
+  s.add_development_dependency "sqlite3", "~> 0"
+end

data/generators/acts_as_20ggable_migration/acts_as_20ggable_migration_generator.rb

@@ -0,0 +1,11 @@
+class ActsAs20ggableMigrationGenerator < Rails::Generator::Base 
+  def manifest 
+    record do |m| 
+      m.migration_template 'migration.rb', 'db/migrate' 
+    end 
+  end
+  
+  def file_name
+    "acts_as_20ggable_migration"
+  end
+end

data/generators/acts_as_20ggable_migration/templates/migration.rb

@@ -0,0 +1,45 @@
+class ActsAs20ggableMigration < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.column :name, :string
+    end
+    
+    create_table :taggings do |t|
+      t.column :tag_id, :integer
+      t.column :taggable_id, :integer
+      
+      # You should make sure that the column created is
+      # long enough to store the required class names.
+      t.column :taggable_type, :string
+      
+      t.column :created_at, :datetime
+    end
+    
+    create_table :tags_hierarchy, :id => false do |t|
+      t.column :tag_id, :integer
+      t.column :child_id, :integer
+    end
+
+    create_table :tags_transitive_hierarchy, :id => false do |t|
+      t.column :tag_id, :integer
+      t.column :child_id, :integer
+    end
+
+    create_table :tags_synonyms, :id => false do |t|
+      t.column :tag_id, :integer
+      t.column :synonym_id, :integer
+    end      
+    
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type]
+    add_index :tags, :name
+  end
+  
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+    drop_table :tags_hierarchy
+    drop_table :tags_transitive_hierarchy
+    drop_table :tags_synonyms
+  end
+end

data/lib/acts_as_20ggable.rb

@@ -0,0 +1,7 @@
+require 'acts_as_taggable'
+require 'tag'
+require 'tag_counts_extension'
+require 'tag_hierarchy_builder'
+require 'tag_list'
+require 'tagging'
+require 'tags_helper'

data/lib/acts_as_taggable.rb

@@ -0,0 +1,201 @@
+require 'active_record'
+module ActiveRecord
+  module Acts
+    module Taggable
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def acts_as_taggable
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag
+          has_many :tags, :through => :taggings
+
+          before_save :save_cached_tag_list
+          after_save :save_tags
+
+          extend ActiveRecord::Acts::Taggable::SingletonMethods
+
+          alias_method_chain :reload, :tag_list
+        end
+
+        def cached_tag_list_column_name
+          :cached_tag_list
+        end
+
+        def set_cached_tag_list_column_name(value = nil, &block)
+          define_attr_method :cached_tag_list_column_name, value, &block
+        end
+      end
+
+      module SingletonMethods
+        # Returns an array of related tags.
+        # Related tags are all the other tags that are found on the models tagged with the provided tags.
+        #
+        # Pass either a tag, string, or an array of strings or tags.
+        #
+        # Options:
+        #   :order - SQL Order how to order the tags. Defaults to "count DESC, tags.name".
+        def find_related_tags(tags, options = {})
+          tags = tags.is_a?(Array) ? TagList.new(tags.map(&:to_s)) : TagList.from(tags)
+
+          related_models = find_tagged_with(tags)
+
+          return [] unless related_models.exists?
+
+          related_ids = related_models.select("distinct #{table_name}.id")
+
+          Tag.select("#{Tag.table_name}.*, COUNT(#{Tag.table_name}.id) AS count").
+            joins("JOIN #{Tagging.table_name} ON #{Tagging.table_name}.taggable_type = '#{base_class.name}'
+              AND  #{Tagging.table_name}.taggable_id IN (#{related_ids.to_sql})
+              AND  #{Tagging.table_name}.tag_id = #{Tag.table_name}.id").
+            order(options[:order] || "count DESC, #{Tag.table_name}.name").
+            group("#{Tag.table_name}.id, #{Tag.table_name}.name HAVING LOWER(#{Tag.table_name}.name) NOT IN (#{tags.map { |n| quote_value(n.downcase) }.join(",")})")
+        end
+
+        # Pass either a tag, string, or an array of strings or tags.
+        #
+        # Options:
+        #   :exclude - Find models that are not tagged with the given tags
+        #   :match_all - Find models that match all of the given tags, not just one
+        #   :conditions - A piece of SQL conditions to add to the query
+        #   :exclude_subtags - Find models that are tagged with only given tags, not their subtags
+        def find_tagged_with(tags, options = {})
+          tags = tags.is_a?(Array) ? TagList.new(tags.map(&:to_s)) : TagList.from(tags)
+
+          options = options.dup
+          exclude_subtags = options.delete(:exclude_subtags)
+
+          return where("1=0") if tags.empty?
+
+          taggings_alias = "#{table_name}_taggings"
+          tags_alias = "#{table_name}_tags"
+
+          results = base_class.joins("INNER JOIN #{Tagging.table_name} #{taggings_alias} ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key} AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)} " +
+                      "INNER JOIN #{Tag.table_name} #{tags_alias} ON #{tags_alias}.id = #{taggings_alias}.tag_id")
+
+          if options.delete(:exclude)
+            tc = tags_condition(tags, Tag.table_name, !exclude_subtags)
+            results = results.where("#{table_name}.id NOT IN
+                (SELECT #{Tagging.table_name}.taggable_id FROM #{Tagging.table_name}
+                 INNER JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id
+                 WHERE #{tc} AND #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)})")
+          else
+            if options.delete(:match_all)
+              tc = tags_condition(tags, Tag.table_name, !exclude_subtags)
+              results = results.where("
+                (SELECT COUNT(*) FROM #{Tagging.table_name}
+                 INNER JOIN #{Tag.table_name} ON #{Tagging.table_name}.tag_id = #{Tag.table_name}.id
+                 WHERE #{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)} AND
+                 taggable_id = #{table_name}.id AND
+                 #{tc}) = #{tags.size}")
+            else
+              results = results.where(tags_condition(tags, tags_alias, !exclude_subtags))
+            end
+          end
+
+          results
+        end
+
+        # Calculate the tag counts for all tags.
+        #
+        # See Tag.counts for available options.
+        def tag_counts(options = {})
+          Tag.find(:all, find_options_for_tag_counts(options))
+        end
+
+        def find_options_for_tag_counts(options = {})
+          options = options.dup
+          scope = scoped
+
+          conditions = []
+          conditions << send(:sanitize_conditions, options.delete(:conditions)) if options[:conditions]
+          conditions << scope.where_values.reduce(:and).to_sql if scope.where_values.any?
+          conditions << "#{Tagging.table_name}.taggable_type = #{quote_value(base_class.name)}"
+          conditions << type_condition.to_sql unless descends_from_active_record?
+          conditions.compact!
+          conditions = conditions.join(" AND ")
+
+          joins = ["INNER JOIN #{table_name} ON #{table_name}.#{primary_key} = #{Tagging.table_name}.taggable_id"]
+          joins << options.delete(:joins) if options[:joins]
+          joins << scope.joins_values.map(&:to_sql).join if scope.joins_values.any?
+          joins = joins.join(" ")
+
+          options = { :conditions => conditions, :joins => joins }.update(options)
+
+          Tag.options_for_counts(options)
+        end
+
+        def caching_tag_list?
+          column_names.include?(cached_tag_list_column_name.to_s)
+        end
+
+       private
+        def tags_condition(tags, table_name = Tag.table_name, include_subtags = true)
+          # FIXME N+1
+          tags += tags.map do |tag_name|
+            tag = Tag.find_with_like_by_name(tag_name)
+            tag ? tag.transitive_children.find(:all).map(&:name) : []
+          end.flatten if include_subtags
+          condition = tags.map { |t| sanitize_sql(["#{table_name}.name LIKE ?", t]) }.join(" OR ")
+          condition.blank? ? '(1=0)' : "(" + condition + ")"
+        end
+      end
+
+      included do
+        def tag_list
+          return @tag_list if @tag_list
+
+          if self.class.caching_tag_list? and !(cached_value = send(self.class.cached_tag_list_column_name)).nil?
+            @tag_list = TagList.from(cached_value)
+          else
+            @tag_list = TagList.new(*tags.map(&:name))
+          end
+        end
+
+        def tag_list=(value)
+          @tag_list = TagList.from(value)
+        end
+
+        def save_cached_tag_list
+          if self.class.caching_tag_list?
+            self[self.class.cached_tag_list_column_name] = tag_list.to_s
+          end
+        end
+
+        def save_tags
+          return unless @tag_list
+
+          new_tag_names = @tag_list - tags.map(&:name)
+          old_tags = tags.reject { |tag| @tag_list.include?(tag.name) }
+
+          self.class.transaction do
+            if old_tags.any?
+              taggings.find(:all, :conditions => ["tag_id IN (?)", old_tags.map(&:id)]).each(&:destroy)
+              taggings.reset
+            end
+
+            new_tag_names.each do |new_tag_name|
+              tags << Tag.find_or_create_with_like_by_name(new_tag_name)
+            end
+          end
+
+          true
+        end
+
+        # Calculate the tag counts for the tags used by this model.
+        #
+        # The possible options are the same as the tag_counts class method, excluding :conditions.
+        def tag_counts(options = {})
+          self.class.tag_counts({ :conditions => self.class.send(:tags_condition, tag_list, Tag.table_name, false) }.reverse_merge!(options))
+        end
+
+        def reload_with_tag_list(*args) #:nodoc:
+          @tag_list = nil
+          reload_without_tag_list(*args)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActiveRecord::Acts::Taggable)