tagtical 1.5.9 → 1.6.0

data/README.rdoc

@@ -39,6 +39,8 @@ parsed.
 
 7. Custom contexts are *not* supported since we use STI. That is, you must define a set of tag types
 ahead of time.
+8. Functionality for joining across tags (seeing which tags two different models have in common)
+with both superset and subset matching.
 
 Additions include:
 1. Scopes are created on Tag so you can do photo.tags.color and grab all the tags of type Tag::Color, for example.
@@ -282,6 +284,40 @@ just define the subclass and the code will automatically instantiate it as that
 
 Now moving forward, these classes will be instantiated with this model. Wow cool!
 
+=== Tag Groups
+
+This functionality allows to join models across tags (seeing which tags two different models have in common)
+with both superset and subset matching.
+
+You can do it simply by providing :has_many_through_tags call in taggable model, like:
+
+    class User < ActiveRecord::Base
+      acts_as_taggable :skills
+      has_many_through_tags :schools, :superset
+    end
+
+    class School < ActiveRecord::Base
+      acts_as_taggable :skills
+      has_many_through_tags :users # :subset is default
+    end
+
+So, users can study in a school only if they have all the required skills. We want to get
+list of all schools of a user and all users of a school.
+
+    school1.skill_list = "math, biology"
+    school2.skill_list = "programming, chemistry"
+    user.skill_list = "chemistry, math, biology"
+
+    user.schools # => [school1]
+    school1.users # => [user]
+    school2.users # => []
+
+You also may specify different class name, if you want to name your association differently:
+
+    class User < ActiveRecord::Base
+      acts_as_taggable :skills
+      has_many_through_tags :possible_schools, :superset, class_name: "School"
+    end
 
 === Tag Ownership
 

data/VERSION

@@ -1 +1 @@
-1.5.8
+1.6.0

data/generators/tagtical_migration/templates/migration.rb

@@ -2,7 +2,7 @@ class TagticalMigration < ActiveRecord::Migration
   def self.up
     create_table :tags do |t|
       t.column :value, :string
-      t.column :type, :string
+      t.column :type, :string, :limit => 100
     end
     add_index :tags, [:type, :value], :unique => true
     add_index :tags, :value
@@ -12,11 +12,11 @@ class TagticalMigration < ActiveRecord::Migration
       t.column :tag_id, :integer
       t.column :taggable_id, :integer
       t.column :tagger_id, :integer
-      t.column :tagger_type, :string if Tagtical.config.polymorphic_tagger?
+      t.column :tagger_type, :string, :limit => 100 if Tagtical.config.polymorphic_tagger?
       
       # You should make sure that the column created is
       # long enough to store the required class names.
-      t.column :taggable_type, :string
+      t.column :taggable_type, :string, :limit => 100
       
       t.column :created_at, :datetime
     end

data/lib/generators/tagtical/migration/templates/active_record/migration.rb

@@ -2,7 +2,7 @@ class TagticalMigration < ActiveRecord::Migration
   def self.up
     create_table :tags do |t|
       t.string :value
-      t.string :type
+      t.string :type, :limit => 100
     end
     add_index :tags, [:type, :value], :unique => true
     add_index :tags, :value
@@ -13,9 +13,9 @@ class TagticalMigration < ActiveRecord::Migration
 
       # You should make sure that the column created is
       # long enough to store the required class names.
-      t.references :taggable, :polymorphic => true
+      t.references :taggable, :polymorphic => true, :limit => 100
       if Tagtical.config.polymorphic_tagger?
-        t.references :tagger, :polymorphic => true
+        t.references :tagger, :polymorphic => true, :limit => 100
       else
         t.integer :tagger_id
       end

data/lib/tagtical/tag.rb

@@ -469,6 +469,44 @@ module Tagtical
         Array(input).map { |o| taggable_class.find_tag_type!(o).klass }
       end
 
+      # Instead of subclassing from Array, we make a Proxy, so we actually can use method_missing
+      # for catching results and converting them into Collection class if they return Array
+      class Collection
+        def initialize(*args)
+          @array = Array.new(*args)
+        end
+
+        # Usage:
+        #   tag_types.get(["boy", "girl"]) # => ["boy", "girl"]
+        #   tag_types.get("boy")           # => "boy"
+        #   # "boy".class === Tagtical::Tag::Type everywhere
+        def get(tag_type_names)
+          results = @array.select { |tag_type| tag_type_names.include?(tag_type) }
+          tag_type_names.is_a?(Array) ? results : results.first
+        end
+
+        def respond_to?(*args)
+          super || @array.respond_to?(*args)
+        end
+
+        def to_ary
+          @array
+        end
+
+        def to_a
+          @array
+        end
+
+        def method_missing(name, *args)
+          result = if block_given?
+            @array.send(name, *args)  { |*block_args| yield(*block_args) }
+          else
+            @array.send(name, *args)
+          end
+          result.is_a?(@array.class) ? self.class.new(result) : result
+        end
+      end
+
     end
   end
 end

data/lib/tagtical/taggable/core.rb

@@ -14,7 +14,7 @@ module Tagtical::Taggable
           empty_tag_types = tag_types.select do |tag_type|
             Array.wrap(empty_tags_type_names).map(&:to_s).include?(tag_type)
           end
-          empty_tag_type_classes = empty_tag_types.map { |t| t.klass.to_s }
+          empty_tag_type_classes = empty_tag_types.map { |t| t.klass.to_s }.to_a
           if empty_tag_type_classes.present?
             tagging_table = Tagtical::Tagging.arel_table
             tag_table = Tagtical::Tag.arel_table
@@ -359,6 +359,25 @@ module Tagtical::Taggable
         true
       end
 
+      # Returns flat list of tag classes and tag values.
+      #
+      #   taggable.update_attributes!(gender_list: "boy, girl", skill_list: "ruby")
+      #   taggable.short_tags                   # => %w(gender_boy gender_girl skill_ruby tag_boy tag_girl tag_ruby)
+      #   taggable.short_tags(only: :gender)    # => %w(gender_boy gender_girl)
+      #   taggable.short_tags(exclude: :gender) # => %w(skill_ruby tag_boy tag_girl tag_ruby)
+      def short_tags(options = {})
+        tag_types = if options[:only].present?
+          self.class.tag_types.select { |tt| Array.wrap(options[:only]).map(&:to_s).include?(tt) }
+        else
+          self.class.tag_types - Array.wrap(options[:exclude]).compact.map(&:to_s)
+        end
+        tag_types.map do |tag_type|
+          send(tag_type.has_many_name).map do |tag|
+            "#{tag_type}_#{tag.value}"
+          end
+        end.flatten.to_a
+      end
+
 
       private
 

data/lib/tagtical/taggable/tag_group.rb

@@ -0,0 +1,51 @@
+module Tagtical
+  module Taggable
+    module TagGroup
+
+      def has_many_through_tags(association_id, type = :subset, options = {})
+        case type
+        when :subset then has_many_through_tags_subset(association_id, options)
+        when :superset then has_many_through_tags_superset(association_id, options)
+        else raise "Wrong association type, should be :subset or :superset"
+        end
+      end
+
+      private
+
+        def has_many_through_tags_superset(association_id, options)
+          define_method(association_id) do
+            result = instance_variable_get("@#{association_id}") || begin
+              klass = (options[:class_name] || association_id.to_s.singularize.camelize).constantize
+              klass.
+                joins(
+                  "LEFT JOIN #{Tagtical::Tagging.table_name} AS t1 " +
+                  "ON t1.taggable_id = #{klass.table_name}.id AND t1.taggable_type = '#{klass}'"
+                ).
+                joins(
+                  "LEFT JOIN #{Tagtical::Tagging.table_name} AS t2 " +
+                  "ON t2.tag_id = t1.tag_id AND t2.taggable_type = '#{self.class}' AND t2.taggable_id = #{id}"
+                ).
+                group("#{klass.table_name}.id").
+                having("COUNT(t2.tag_id) = COUNT(#{klass.table_name}.id)")
+            end
+            instance_variable_set("@#{association_id}", result)
+            result
+          end
+        end
+
+        def has_many_through_tags_subset(association_id, options)
+          define_method(association_id) do
+            result = instance_variable_get("@#{association_id}") || begin
+              klass = (options[:class_name] || association_id.to_s.singularize.camelize).constantize
+              klass.
+                joins(:taggings).
+                where("#{Tagtical::Tagging.table_name}.`tag_id` IN (?)", taggings.map(&:tag_id)).
+                group("#{klass.table_name}.id").having(["count(#{klass.table_name}.id) = ?", taggings.count])
+            end
+            instance_variable_set("@#{association_id}", result)
+            result
+          end
+        end
+    end
+  end
+end

data/lib/tagtical/taggable.rb

@@ -22,13 +22,14 @@ module Tagtical
     def acts_as_taggable(*tag_types)
       tag_types.flatten!
       tag_types << Tagtical::Tag::Type::BASE # always include the base type.
-      tag_types = Tagtical::Tag::Type.register(tag_types.uniq.compact, self)
+      tag_types = Tagtical::Tag::Type::Collection.new(Tagtical::Tag::Type.register(tag_types.uniq.compact, self))
 
       if taggable?
         self.tag_types = (self.tag_types + tag_types).uniq
       else
-        class_attribute(:tag_types)
+        class_attribute :tag_types, :custom_tag_types
         self.tag_types = tag_types
+        self.custom_tag_types = tag_types - [Tagtical::Tag::Type::BASE]
 
         has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "Tagtical::Tagging"
         has_many :tags, :through => :taggings, :class_name => "Tagtical::Tag"
@@ -45,9 +46,13 @@ module Tagtical
         include Tagtical::Taggable::Cache
         include Tagtical::Taggable::Ownership
         include Tagtical::Taggable::Related
+        extend Tagtical::Taggable::TagGroup
 
       end
 
+      # Purpose of this is to keep additional tagtical class level methods grouped
+      # together with the acts_as_taggable call.
+      yield if block_given?
     end
   end
 end

data/lib/tagtical.rb

@@ -33,6 +33,7 @@ require "tagtical/taggable/collection"
 require "tagtical/taggable/cache"
 require "tagtical/taggable/ownership"
 require "tagtical/taggable/related"
+require "tagtical/taggable/tag_group"
 
 require "tagtical/acts_as_tagger"
 require "tagtical/tag"

data/spec/models.rb

@@ -35,6 +35,7 @@ end
 class TaggableModel < ActiveRecord::Base
   acts_as_taggable(:languages, :skills, {:crafts => Tag::FooCraft}, :needs, :offerings, {:styles => "BarCraft"})
   has_many :untaggable_models
+  has_many_through_tags :custom_groups, :superset
 end
 
 class CachedModel < ActiveRecord::Base
@@ -59,3 +60,9 @@ end
 class UntaggableModel < ActiveRecord::Base
   belongs_to :taggable_model
 end
+
+class CustomGroup < ActiveRecord::Base
+  acts_as_taggable(:skills, :languages) do
+    has_many_through_tags :taggable_models
+  end
+end

data/spec/schema.rb

@@ -43,4 +43,8 @@ ActiveRecord::Schema.define :version => 0 do
     t.column :name, :string
     t.column :type, :string
   end
+
+  create_table :custom_groups, :force => true do |t|
+    t.column :name, :string
+  end
 end

data/spec/tagtical/tag_group_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Tagtical::Taggable::TagGroup do
+
+  before { clean_database! }
+
+  it "should retrieve related tagged objects" do
+    group = CustomGroup.create!(language_list: "ruby", skill_list: "programmer")
+    objects = [
+      {:name => "One", language_list: "ruby, c", skill_list: "programmer"},
+      {:name => "Two", language_list: "c", skill_list: "programmer"},
+      {:name => "Three", language_list: "ruby", skill_list: "manager"},
+      {:name => "Four", language_list: "ruby", skill_list: "programmer"}
+    ].map { |attrs| TaggableModel.create!(attrs) }
+    group.taggable_models.should == [objects[0], objects[3]]
+  end
+
+  it "should retrieve associated tag groups" do
+    groups = [
+      {language_list: "ruby, c", skill_list: "programmer", name: "Ruby C Programmer"},
+      {language_list: "c", skill_list: "programmer", name: "C Programmer"},
+      {language_list: "ruby", skill_list: "manager", name: "Ruby Manager"},
+      {language_list: "ruby", skill_list: "programmer", name: "Ruby Programmer"}
+    ].map { |attrs| CustomGroup.create!(attrs) }
+    model = TaggableModel.create!(language_list: "ruby, c", skill_list: "programmer")
+    model.custom_groups.should == [groups[0], groups[1], groups[3]]
+  end
+
+end

data/spec/tagtical/taggable_spec.rb

@@ -16,10 +16,40 @@ describe Tagtical::Taggable do
   end
 
   it "should have tag types" do
-    TaggableModel.tag_types.should include("tag", "language", "skill", "craft", "need", "offering")
+    TaggableModel.tag_types.should include(Tagtical::Tag::Type::BASE, "language", "skill", "craft", "need", "offering")
     @taggable.tag_types.should == TaggableModel.tag_types
   end
 
+  describe ".custom_tag_types" do
+    subject { TaggableModel.custom_tag_types }
+    it { should include("language", "skill", "craft", "need", "offering") }
+    it { should_not include(Tagtical::Tag::Type::BASE) }
+    it { should == @taggable.custom_tag_types }
+  end
+
+  describe ".tag_types" do
+    subject { TaggableModel.tag_types }
+    it { should be_a(Tagtical::Tag::Type::Collection) }
+    its(:first) { should be_a(Tagtical::Tag::Type) }
+  end
+
+  describe "tag types collection" do
+
+    it "should return its class instance after executing Array's methods" do
+      TaggableModel.tag_types.select { |t| t == "tag" }.should be_a(Tagtical::Tag::Type::Collection)
+    end
+
+    context "get tag types" do
+      specify "by array" do
+        TaggableModel.tag_types.get(["language", "skill"]).should =~ ["skill", "language"]
+      end
+
+      specify "by item" do
+        TaggableModel.tag_types.get("language").should == "language"
+      end
+    end
+  end
+
   it "should have tag_counts_on" do
     TaggableModel.tag_counts_on(:tags).all.should be_empty
 
@@ -30,6 +60,15 @@ describe Tagtical::Taggable do
     @taggable.tag_counts_on(:tags).length.should == 2
   end
 
+  describe ".short_tags" do
+    subject { @taggable }
+    before { subject.update_attributes!(skill_list: %w(ruby rails), tag_list: %w(red)) }
+
+    its(:short_tags) { should == %w(skill_ruby skill_rails tag_red tag_ruby tag_rails) }
+    specify { subject.short_tags(only: :skill).should == %w(skill_ruby skill_rails) }
+    specify { subject.short_tags(exclude: :skill).should == %w(tag_red tag_ruby tag_rails) }
+  end
+
   it "should be able to create tags" do
     @taggable.skill_list = "ruby, rails, css"
     @taggable.tag_list_on(:skills).should be_an_instance_of(Tagtical::TagList)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tagtical
 version: !ruby/object:Gem::Version
-  version: 1.5.9
+  version: 1.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -14,7 +14,7 @@ default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &2165943100 !ruby/object:Gem::Requirement
+  requirement: &2157842540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2165943100
+  version_requirements: *2157842540
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &2165942720 !ruby/object:Gem::Requirement
+  requirement: &2157878760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2165942720
+  version_requirements: *2157878760
 - !ruby/object:Gem::Dependency
   name: mysql
-  requirement: &2165942260 !ruby/object:Gem::Requirement
+  requirement: &2157878300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2165942260
+  version_requirements: *2157878300
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2165941840 !ruby/object:Gem::Requirement
+  requirement: &2157877880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2165941840
+  version_requirements: *2157877880
 description: Tagtical allows you do create subclasses for Tag and add additional functionality
   in an STI fashion. For example. You could do Tag::Color.find_by_name('blue').to_rgb.
   It also supports storing weights or relevance on the taggings.
@@ -80,6 +80,7 @@ files:
 - lib/tagtical/taggable/core.rb
 - lib/tagtical/taggable/ownership.rb
 - lib/tagtical/taggable/related.rb
+- lib/tagtical/taggable/tag_group.rb
 - lib/tagtical/taggable.rb
 - lib/tagtical/tagging.rb
 - lib/tagtical/tags_helper.rb
@@ -97,6 +98,7 @@ files:
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/tagtical/acts_as_tagger_spec.rb
+- spec/tagtical/tag_group_spec.rb
 - spec/tagtical/tag_list_spec.rb
 - spec/tagtical/tag_spec.rb
 - spec/tagtical/taggable_spec.rb
@@ -139,6 +141,7 @@ test_files:
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/tagtical/acts_as_tagger_spec.rb
+- spec/tagtical/tag_group_spec.rb
 - spec/tagtical/tag_list_spec.rb
 - spec/tagtical/tag_spec.rb
 - spec/tagtical/taggable_spec.rb