tagtical 1.1.3 → 1.2.0

data/README.rdoc

@@ -115,6 +115,7 @@ rake spec:plugins
     @user.save
 
     # Cascade tag_list setters =)
+    # It will look at the "possible_values" if provided, and stuff the tags down at that level.
     @user.set_activity_list(["clowning", "boxing"], :cascade => true)
     @user.save!
     @user.sport_list  # => ["boxing"]
@@ -136,6 +137,8 @@ rake spec:plugins
 
     @user.activities # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">,<Tag::Sport value:"boxing">]
     @user.activities(:scope => :children) # => [<Tag::Sport value:"boxing">] - look at only the STI subclasses
+    @user.tags(:scope => :children, :except => :sports) # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">] - filter list
+    @user.tags(:scope => :children, :only => :sports) # => [<Tag::Sport value:"boxing">] - filter list
     @user.activities(:scope => :<) # => [<Tag::Sport value:"boxing">] - look at only the STI subclasses
     @user.activities(:scope => :current) # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">] - look at only the current STI class
     @user.activities(:scope => :==) # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">] - look at only the current STI class

data/VERSION

@@ -1 +1 @@
-1.1.3
+1.2.0

data/lib/tagtical/tag.rb

@@ -105,10 +105,15 @@ module Tagtical
       super || (object.is_a?(self.class) && value == object.value)
     end
 
+    # Relevance is transferred through "taggings" join.
     def relevance
       (v = self[:relevance]) && v.to_f
     end
 
+    def relevance=(relevance)
+      self[:relevance] = relevance
+    end
+
       # Try to sort by the relevance if provided.
     def <=>(tag)
       if (r1 = relevance) && (r2 = tag.relevance)
@@ -229,31 +234,8 @@ module Tagtical
       def finder_type_condition(*args)
         scopes, options = convert_finder_type_arguments(*args)
 
-        # If we want [:current, :children] or [:current, :children, :parents] and we don't need the finder type condition,
-        # then that means we don't need a condition at all since we are at the top-level sti class and we are essentially
-        # searching the whole range of sti classes.
-        if klass && !klass.finder_needs_type_condition?
-          scopes.delete(:parents) # we are at the topmost level.
-          scopes = [] if scopes.sort==[:current, :children].sort # no condition is required if we want the current AND the children.
-        end
-
-        sti_names = []
-        if scopes.include?(:current)
-          sti_names << klass.sti_name
-        end
-        if scopes.include?(:children) && klass
-          sti_names.concat(klass.descendants.map(&:sti_name))
-        end
-        if scopes.include?(:parents) && klass # include searches up the STI chain
-          parent_class = klass.superclass
-          while parent_class <= Tagtical::Tag
-            sti_names << parent_class.sti_name
-            parent_class = parent_class.superclass
-          end
-        end
-
         sti_column = Tagtical::Tag.arel_table[Tagtical::Tag.inheritance_column]
-        condition = sti_names.inject(nil) do |conds, sti_name|
+        condition = expand_tag_types(scopes, options).map { |x| x.klass.sti_name }.inject(nil) do |conds, sti_name|
           cond = sti_column.eq(sti_name)
           conds.nil? ? cond : conds.or(cond)
         end
@@ -372,9 +354,44 @@ module Tagtical
       def convert_finder_type_arguments(*args)
         options = args.extract_options!
         scopes = convert_scope_options(args.presence || options[:scope])
+        scopes.delete(:parents) if klass && !klass.finder_needs_type_condition?  # we are at the topmost level.
         [scopes, options]
       end
 
+      def expand_tag_types(scopes, options)
+        classes, types = [], []
+        types.concat(Array(options[:types]).map { |t| taggable_class.find_tag_type!(t) }) if options[:types]
+
+        if scopes.include?(:current)
+          classes << klass
+        end
+        if scopes.include?(:children)
+          classes.concat(klass.descendants)
+        end
+        if scopes.include?(:parents) # include searches up the STI chain
+          parent_class = klass.superclass
+          while parent_class <= Tagtical::Tag
+            classes << parent_class
+            parent_class = parent_class.superclass
+          end
+        end
+
+        if options[:only]
+          classes &= find_tag_types(options[:only])
+        elsif options[:except]
+          except = find_tag_types(options[:except])
+          classes.reject! { |t| except.any? { |e| t <= e }}
+        end
+        tag_types_by_classes = taggable_class.tag_types.index_by(&:klass)
+        types.concat(classes.map { |k| tag_types_by_classes[k] }.uniq.compact)
+
+        types # for clarity
+      end
+
+      def find_tag_types(input)
+        Array(input).map { |o| taggable_class.find_tag_type!(o).klass }
+      end
+
     end
   end
 end

data/lib/tagtical/tag_list.rb

@@ -37,7 +37,7 @@ module Tagtical
     #   tag_list = TagList.from("One , Two,  Three")
     #   tag_list # ["One", "Two", "Three"] <=== as TagValue
     def self.from(*args)
-      new(*args)
+      args[0].is_a?(self) ? args[0] : new(*args)
     end
 
     def concat(values)

data/lib/tagtical/taggable/cache.rb

@@ -39,9 +39,7 @@ module Tagtical::Taggable
       def save_cached_tag_list
         tag_types.each do |tag_type|
           if self.class.send("caching_#{tag_type.singularize}_list?")
-            if tag_list = tag_list_cache_on(tag_type)[[:children, :current]]
-              self[tag_type.tag_list_name(:cached)] = tag_list.to_s
-            end
+            self[tag_type.tag_list_name(:cached)] = tag_list_on(tag_type).to_s if tag_list_on?(tag_type)
           end
         end
         

data/lib/tagtical/taggable/core.rb

@@ -82,7 +82,7 @@ module Tagtical::Taggable
         object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(", ")
       end
 
-      def find_tag_type!(input)
+      def find_tag_type!(input, options={})
         (@tag_type ||= {})[input] ||= tag_types.find { |t| t.match?(input) } || raise("Cannot find tag type:'#{input}' in #{tag_types.inspect}")
       end
 
@@ -205,12 +205,16 @@ module Tagtical::Taggable
       # model.set_tag_list_on("skill", ["kung fu", "karate"], :scope => :==) # will not overwrite tags from inheriting tag classes
       def set_tag_list_on(context, new_list, *args)
         tag_list = Tagtical::TagList.from(new_list)
-        cascade_set_tag_list!(tag_list, context, *args)
-        tag_list_cache_on(context)[scopes_for_tag_list(context, *args)] = tag_list
+        cascade_set_tag_list!(tag_list, context, *args) if args[-1].is_a?(Hash) && args[-1].delete(:cascade)
+        tag_list_cache_on(context)[expand_tag_types(context, *args)] = tag_list
+      end
+
+      def tag_list_on?(context, *args)
+        !tag_list_cache_on(context)[expand_tag_types(context, *args)].nil?
       end
 
       def tag_list_on(context, *args)
-        tag_list_cache_on(context)[scopes_for_tag_list(context, *args)] ||= Tagtical::TagList.new(tags_on(context, *args))
+        tag_list_cache_on(context)[expand_tag_types(context, *args)] ||= Tagtical::TagList.new(tags_on(context, *args))
       end
 
       def tag_list_cache_on(context, prefix=nil)
@@ -219,7 +223,7 @@ module Tagtical::Taggable
       end
 
       def all_tags_list_on(context, *args)
-        tag_list_cache_on(context, :all)[scopes_for_tag_list(context, *args)] ||= Tagtical::TagList.new(all_tags_on(context, *args)).freeze
+        tag_list_cache_on(context, :all)[expand_tag_types(context, *args)] ||= Tagtical::TagList.new(all_tags_on(context, *args)).freeze
       end
 
       ##
@@ -254,19 +258,21 @@ module Tagtical::Taggable
         # Do the classes from top to bottom. We want the list from "tag" to run before "sub_tag" runs.
         # Otherwise, we will end up removing taggings from "sub_tag" since they aren't on "tag'.
         tag_types.sort_by(&:active_record_sti_level).each do |tag_type|
-          (tag_list_cache_on(tag_type) || {}).each do |scopes, tag_list|
+          (tag_list_cache_on(tag_type) || {}).each do |expanded_tag_types, tag_list|
             # Tag list saving only runs if its affecting the current scope or the current and children scope
-            next unless [:<=, :==].any? { |scope| scopes_for_tag_list(tag_type, scope)==scopes }
+            # next unless [:<=, :==].any? { |scope| scopes_for_tag_list(tag_type, scope)==scopes }
+            next unless expanded_tag_types.include?(tag_type)
             tag_list = tag_list.uniq
 
             # Find existing tags or create non-existing tags:
             tag_value_lookup = tag_type.scoping { find_or_create_tags(tag_list) }
             tags = tag_value_lookup.keys
 
-            current_tags = tags_on(tag_type, *[:parents].concat(scopes)) # add in the parents because we need them later on down.
+
+            current_tags = tags_on(tag_type, :types => expanded_tag_types, :scope => :parents) # add in the parents because we need them later on down.
             old_tags     = current_tags - tags
             new_tags     = tags         - current_tags
-
+            
             unowned_taggings = taggings.where(:tagger_id => nil)
 
             # If relevances are specified on current tags, make sure to update those
@@ -319,8 +325,11 @@ module Tagtical::Taggable
         find_tag_type!(input).send(:convert_finder_type_arguments, *args)
       end
 
-      def scopes_for_tag_list(*args)
-        finder_type_arguments_for_tag_list(*args)[0].sort
+      def expand_tag_types(input, *args)
+        (@expand_tag_types ||= {})[[input, args]] ||= begin
+          scopes, options = finder_type_arguments_for_tag_list(input, *args)
+          find_tag_type!(input).send(:expand_tag_types, scopes, options)
+        end
       end
 
       # Lets say tag class A inherits from B and B has a tag with value "foo". If we tag A with value "foo",
@@ -332,24 +341,39 @@ module Tagtical::Taggable
         end
       end
 
+      # Extracts the valid tag types for the cascade option.
+      def extract_tag_types_from_cascade(input, base_tag_type)
+        case input
+        when Hash
+          if except = input[:except]
+            except = extract_tag_types_from_cascade(except, base_tag_type)
+            tag_types.reject { |t| except.any? { |e| t.klass <= e.klass }} # remove children as well.
+          elsif only = input[:only]
+            extract_tag_types_from_cascade(only, base_tag_type)
+          else raise("Please provide :except or :only")
+          end
+        when true
+          tag_types
+        else
+          Array(input).map { |c| find_tag_type!(c) }
+        end.select do |tag_type|
+          tag_type.klass <= base_tag_type.klass && tag_type.klass.possible_values
+        end
+      end
+
       # If cascade tag types are specified, it will attempt to look at Tag subclasses with
       # possible_values and try to set those tag_lists with values from the possible_values list.
       def cascade_set_tag_list!(tag_list, context, *args)
-        scopes, options = finder_type_arguments_for_tag_list(context, *args)
-        raise("You must include children if you are cascading") if options[:cascade] && !scopes.include?(:current)
-        if (cascade = options.delete(:cascade)) && (tag_type = find_tag_type!(context)).klass
-          tag_types = cascade==true ? self.tag_types : Array(cascade).map { |c| find_tag_type!(c) }
-          tag_types.each do |t|
-            if t.klass && t.klass <= tag_type.klass && t.klass.possible_values
-              new_tag_list = Tagtical::TagList.new
-              tag_list.reject! do |tag_value|
-                if value = t.klass.detect_possible_value(tag_value)
-                  new_tag_list << Tagtical::TagList::TagValue.new(value, tag_value.relevance)
-                  true
-                end
+        expand_tag_types(context, *args).each do |tag_type|
+          if tag_type.klass.possible_values
+            new_tag_list = Tagtical::TagList.new
+            tag_list.reject! do |tag_value|
+              if value = tag_type.klass.detect_possible_value(tag_value)
+                new_tag_list << Tagtical::TagList::TagValue.new(value, tag_value.relevance)
+                true
               end
-              tag_list_cache_on(t)[[:current]] = new_tag_list if !new_tag_list.empty?
             end
+            set_tag_list_on(tag_type, new_tag_list, :current) if !new_tag_list.empty?
           end
         end
       end

data/spec/tagtical/tag_list_spec.rb

@@ -85,7 +85,7 @@ describe Tagtical::TagList do
 
   it "should be able to add a list of tags" do
     tags = [["foo", 1],["bar", 1.3],["car", 0.7]].map do |value, relevance|
-      Tagtical::Tag.new(:value => value).tap { |t| t["relevance"] = relevance }
+      Tagtical::Tag.new(:value => value, :relevance => relevance)
     end
     @tag_list.add(tags)
     tags.each do |tag|

data/spec/tagtical/taggable_spec.rb

@@ -24,7 +24,7 @@ describe Tagtical::Taggable do
 
   it "should be able to create tags" do
     @taggable.skill_list = "ruby, rails, css"
-    @taggable.tag_list_cache_on(:skill)[[:children, :current]].should be_an_instance_of(Tagtical::TagList)
+    @taggable.tag_list_on(:skills).should be_an_instance_of(Tagtical::TagList)
 
     lambda { @taggable.save }.should change(Tagtical::Tag, :count).by(3)
 
@@ -90,7 +90,7 @@ describe Tagtical::Taggable do
           @taggable.tag_list.should have_same_elements %w{Ruby plain}
         end
 
-        it "should set value on skill" do
+        it "should set value on skill even if different case" do
           @taggable.skills.should have_only_tag_values %w{Ruby}
         end
 
@@ -103,10 +103,9 @@ describe Tagtical::Taggable do
         end
 
       end
-      
-      context "when :cascade => :craft" do
+      context "when :cascade only on :craft" do
         before do
-          @taggable.set_tag_list(["ruby", "plain"], :cascade => :craft)
+          @taggable.set_tag_list(["ruby", "plain"], :cascade => true, :types => :craft)
           @taggable.save!
           @taggable.reload
         end
@@ -124,6 +123,37 @@ describe Tagtical::Taggable do
         end
 
       end
+      context "Adding tags with Exclusion" do
+
+        before do
+          @taggable.set_tag_list "Ruby, plain", :cascade => true, :except => :skill
+          @taggable.save!
+          @taggable.reload
+        end
+
+        it "should not change the tags in skill" do
+          @taggable.skill_list.should have_same_elements ["basketball", "pottery"]
+        end
+
+        it "should have set the values at the tag level" do
+          @taggable.tag_list(:current).should have_same_elements ["Ruby", "plain"]
+        end
+
+      end
+      context "Getting tag_list with :except" do
+
+        before do
+          @taggable.set_tag_list "Ruby, plain", :cascade => true
+          @taggable.save!
+          @taggable.reload
+        end
+
+        it "should exclude all defined types" do
+          @taggable.tag_list(:except => :skill).should have(1).item
+        end
+
+      end
+
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tagtical
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-22 00:00:00.000000000Z
+date: 2011-07-23 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &2153720180 !ruby/object:Gem::Requirement
+  requirement: &2156407420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - <=
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.5
   type: :runtime
   prerelease: false
-  version_requirements: *2153720180
+  version_requirements: *2156407420
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153719700 !ruby/object:Gem::Requirement
+  requirement: &2156406940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - <=
@@ -32,10 +32,10 @@ dependencies:
         version: 2.6.0
   type: :runtime
   prerelease: false
-  version_requirements: *2153719700
+  version_requirements: *2156406940
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &2153719220 !ruby/object:Gem::Requirement
+  requirement: &2156406460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153719220
+  version_requirements: *2156406460
 - !ruby/object:Gem::Dependency
   name: mysql
-  requirement: &2153718740 !ruby/object:Gem::Requirement
+  requirement: &2156405980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153718740
+  version_requirements: *2156405980
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2153718260 !ruby/object:Gem::Requirement
+  requirement: &2156405500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153718260
+  version_requirements: *2156405500
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &2153717780 !ruby/object:Gem::Requirement
+  requirement: &2156405020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153717780
+  version_requirements: *2156405020
 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.