tagtical 1.1.1 → 1.1.2

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.1.2

data/lib/tagtical/tag.rb

@@ -227,25 +227,24 @@ module Tagtical
       #   <tt>only</tt> - An array of the following: :parents, :current, :children. Will construct conditions to query the current, parent, and/or children STI classes.
       #
       def finder_type_condition(*args)
-        options = convert_finder_type_arguments(*args)
-        type = convert_type_options(options[:scope])
+        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?
-          type.delete(:parents) # we are at the topmost level.
-          type = [] if type==[:current, :children] # no condition is required if we want the current AND the children.
+          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 type.include?(:current)
+        if scopes.include?(:current)
           sti_names << klass.sti_name
         end
-        if type.include?(:children) && klass
+        if scopes.include?(:children) && klass
           sti_names.concat(klass.descendants.map(&:sti_name))
         end
-        if type.include?(:parents) && klass # include searches up the STI chain
+        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
@@ -340,8 +339,8 @@ module Tagtical
       end
 
       # Take operator types (ie <, >, =) and convert them into :children, :current, or :parents.
-      def convert_type_options(input)
-        Array.wrap(input || (klass ? [:current, :children] : :current)).map do |type, i|
+      def convert_scope_options(input)
+        Array.wrap(input || [:current, :children]).map do |type|
           if (t = type.to_s)=~/^[=><]+$/
             {"=" => :current, ">" => :parents, "<" => :children}.map do |operator, val|
               val if t.include?(operator)
@@ -372,8 +371,8 @@ module Tagtical
 
       def convert_finder_type_arguments(*args)
         options = args.extract_options!
-        options[:scope] = args[0] if args[0] # allow for adding this in the front
-        options
+        scopes = convert_scope_options(args.presence || options[:scope])
+        [scopes, options]
       end
 
     end

data/lib/tagtical/tag_list.rb

@@ -49,6 +49,11 @@ module Tagtical
     end
     alias << push
 
+    # Shorthand
+    def find(value)
+      detect { |t| t==value }
+    end
+
     ##
     # Add tags to the tag_list. Duplicate or blank tags will be ignored.
     # Use the <tt>:parse</tt> option to add an unparsed tag string.
@@ -120,26 +125,35 @@ module Tagtical
       args.flatten!
     end
 
+    # Returns an array by parsing the input.
     def extract(input, options={})
       case input
+      when Tagtical::Tag
+        TagValue.new(input.value, input.relevance)
       when String
-        if !input.include?(delimiter) || options[:parse]==false
-          [input]
-        else
-          input, arr = input.dup, []
-
-          # Parse the quoted tags
-          value_quotes.each do |value_quote|
-            input.gsub!(/(\A|#{delimiter})\s*#{value_quote}(.*?)#{value_quote}\s*(#{delimiter}\s*|\z)/) { arr << $2 ; $3 }
+        [].tap do |arr|
+          if !input.include?(delimiter) || options[:parse]==false
+            arr << input
+          else
+            input = input.dup
+
+            # Parse the quoted tags
+            value_quotes.each do |value_quote|
+              input.gsub!(/(\A|#{delimiter})\s*#{value_quote}(.*?)#{value_quote}\s*(#{delimiter}\s*|\z)/) { arr << $2 ; $3 }
+            end
+
+            # Parse the unquoted tags
+            input.split(delimiter).each { |word| arr << word.strip }
           end
-
-          # Parse the unquoted tags
-          arr.concat(input.split(delimiter).each(&:strip!))
         end
       when Hash
         input.map { |value, relevance| TagValue.new(value, relevance) }
       when Array
-        input
+        input.map { |value| extract(value) }
+      when Symbol # put at the end, rare case
+        extract(input.to_s)
+      else
+        raise("Cannot parse: #{input.inspect}")
       end
     end
 

data/lib/tagtical/taggable/cache.rb

@@ -39,8 +39,8 @@ 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)[{}]
-              self[tag_type.tag_list_name(:cached)] = tag_list.to_a.flatten.compact.join(', ')
+            if tag_list = tag_list_cache_on(tag_type)[[:children, :current]]
+              self[tag_type.tag_list_name(:cached)] = tag_list.to_s
             end
           end
         end

data/lib/tagtical/taggable/core.rb

@@ -83,7 +83,7 @@ module Tagtical::Taggable
       end
 
       def find_tag_type!(input)
-        tag_types.find { |t| t.match?(input) } || raise("Cannot find tag type:'#{input}' in #{tag_types.inspect}")
+        (@tag_type ||= {})[input] ||= tag_types.find { |t| t.match?(input) } || raise("Cannot find tag type:'#{input}' in #{tag_types.inspect}")
       end
 
       ##
@@ -206,11 +206,11 @@ module Tagtical::Taggable
       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)[scoping_options(context, *args)] = tag_list
+        tag_list_cache_on(context)[scopes_for_tag_list(context, *args)] = tag_list
       end
 
       def tag_list_on(context, *args)
-        tag_list_cache_on(context)[scoping_options(context, *args)] ||= Tagtical::TagList.new(tags_on(context, *args).map(&:value))
+        tag_list_cache_on(context)[scopes_for_tag_list(context, *args)] ||= Tagtical::TagList.new(tags_on(context, *args))
       end
 
       def tag_list_cache_on(context, prefix=nil)
@@ -219,7 +219,7 @@ module Tagtical::Taggable
       end
 
       def all_tags_list_on(context, *args)
-        tag_list_cache_on(context, :all)[scoping_options(context, *args)] ||= Tagtical::TagList.new(all_tags_on(context, *args).map(&:value)).freeze
+        tag_list_cache_on(context, :all)[scopes_for_tag_list(context, *args)] ||= Tagtical::TagList.new(all_tags_on(context, *args)).freeze
       end
 
       ##
@@ -254,17 +254,16 @@ 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 |scoping_options, tag_list|
+          (tag_list_cache_on(tag_type) || {}).each do |scopes, 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 }
             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
 
-            options = {:scope => [:current, :children]}.update(scoping_options)
-            options[:scope] = Array(options[:scope]) + [:parents] # add in the parents because we need them later on down.
-
-            current_tags = tags_on(tag_type, options)
+            current_tags = tags_on(tag_type, *[:parents].concat(scopes)) # add in the parents because we need them later on down.
             old_tags     = current_tags - tags
             new_tags     = tags         - current_tags
 
@@ -291,6 +290,9 @@ module Tagtical::Taggable
               taggings.create!(:tag_id => tag.id, :taggable => self, :relevance => tag_value_lookup[tag].relevance) # Create new taggings:
             end
           end
+          
+          # Force tag lists to reload to integrate any new tags from inheritance.
+          remove_tag_caches_on(tag_type)
         end
 
         true
@@ -298,18 +300,29 @@ module Tagtical::Taggable
 
       private
 
+      def remove_tag_caches_on(tag_type)
+        [nil, :all].each do |prefix|
+          ivar = tag_type.tag_list_ivar(prefix)
+          remove_instance_variable(ivar) if instance_variable_defined?(ivar)
+        end
+      end
+
       def tag_scope(input, *args)
         tags.where(find_tag_type!(input).finder_type_condition(*args))
       end
 
       def find_tag_type!(input)
-        (@tag_type ||= {})[input] ||= self.class.find_tag_type!(input)
+        self.class.find_tag_type!(input)
       end
 
-      def scoping_options(input, *args)
+      def finder_type_arguments_for_tag_list(input, *args)
         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
+      end
+
       # Lets say tag class A inherits from B and B has a tag with value "foo". If we tag A with value "foo",
       # we want B to have only one instance of "foo" and that tag should be an instance of A (a subclass of B).
       def update_tagging_with_inherited_tag!(tagging, tags, tag_value_lookup)
@@ -322,8 +335,9 @@ module Tagtical::Taggable
       # 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)
-        scoping_options = scoping_options(context, *args)
-        if (cascade = scoping_options.delete(:cascade)) && (tag_type = find_tag_type!(context)).klass
+        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
@@ -334,7 +348,7 @@ module Tagtical::Taggable
                   true
                 end
               end
-              tag_list_cache_on(t)[scoping_options.merge(:scope => :==)] = new_tag_list if !new_tag_list.empty?
+              tag_list_cache_on(t)[[:current]] = new_tag_list if !new_tag_list.empty?
             end
           end
         end

data/lib/tagtical/taggable.rb

@@ -29,21 +29,22 @@ module Tagtical
       else
         write_inheritable_attribute(:tag_types, tag_types)
         class_inheritable_reader(:tag_types)
+
+        has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "Tagtical::Tagging"
+        has_many :tags, :through => :taggings, :class_name => "Tagtical::Tag"
         
         class_eval do
-          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "Tagtical::Tagging"
-          has_many :tags, :through => :taggings, :class_name => "Tagtical::Tag"
-
           def self.taggable?
             true
           end
-        
-          include Tagtical::Taggable::Core
-          include Tagtical::Taggable::Collection
-          include Tagtical::Taggable::Cache
-          include Tagtical::Taggable::Ownership
-          include Tagtical::Taggable::Related
         end
+
+        include Tagtical::Taggable::Core
+        include Tagtical::Taggable::Collection
+        include Tagtical::Taggable::Cache
+        include Tagtical::Taggable::Ownership
+        include Tagtical::Taggable::Related
+        
       end
       
     end

data/spec/tagtical/tag_list_spec.rb

@@ -1,7 +1,11 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
 describe Tagtical::TagList do
-  before { @tag_list = Tagtical::TagList.new("awesome", "radical") }
+  before do
+    @klass = Tagtical::TagList
+    @tag_list = @klass.new("awesome", "radical")
+  end
+
   subject { @tag_list }
 
   it { should be_an Array }
@@ -70,8 +74,23 @@ describe Tagtical::TagList do
 
   it "should be able to add relevances with a string" do
     @tag_list.add("foo : 3.4, bar: 2.5")
-    @tag_list.detect { |t| t=="foo" }.relevance.should == 3.4
-    @tag_list.detect { |t| t=="bar" }.relevance.should == 2.5
+    @tag_list.find("foo").relevance.should == 3.4
+    @tag_list.find("bar").relevance.should == 2.5
+  end
+
+  it "should be able to add a symbol" do
+    @tag_list.add(:car)
+    @tag_list.find("car").should_not be_nil
+  end
+
+  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 }
+    end
+    @tag_list.add(tags)
+    tags.each do |tag|
+      @tag_list.find(tag.value).relevance.should == tag.relevance
+    end
   end
 
   it "should be able to remove words" do
@@ -92,7 +111,13 @@ describe Tagtical::TagList do
   its(:to_s) { should == "awesome, radical" }
 
   describe "#to_s" do
-    before { @tag_list = Tagtical::TagList.new("far", "awesome : 4", "radical : 3", "car, bar:10.3", :parse => false) }
+    before do
+      @tag_list = Tagtical::TagList.new("far", "awesome : 4", "radical : 3", "car, bar:10.3", :parse => false)
+      @taggable = TaggableModel.new("taggable")
+      @taggable.set_tag_list "retro: 6, car:4, nature, test: 2.7 ", :cascade => true
+      @taggable.save
+      @taggable.reload
+    end
     
     it "should contain relevance with the relevance delimiter" do
       @tag_list.to_s.should include("awesome:4.0, radical:3.0")
@@ -102,6 +127,10 @@ describe Tagtical::TagList do
       @tag_list.to_s.should include(%{"car, bar":10.3})
     end
 
+    it "should include relevance in string" do
+      @taggable.tag_list.to_s.should == "retro:6.0, car:4.0, nature:1.0, test:2.7"
+    end
+
   end
 
   it "should quote escape tags with commas in them" do

data/spec/tagtical/tag_spec.rb

@@ -338,7 +338,7 @@ describe Tagtical::Tag do
       end
     end
 
-    describe "#convert_type_options" do
+    describe "#convert_scope_options" do
       {:<=   => [:children, :current],
        :>=   => [:parents, :current],
        :"<>" => [:children, :parents],
@@ -348,7 +348,7 @@ describe Tagtical::Tag do
        :"<"  => [:children]
       }.each do |operator, expected|
         it "should convert #{operator.inspect} to #{expected.inspect}" do
-          subject.send(:convert_type_options, operator).should have_same_elements(expected)
+          subject.send(:convert_scope_options, operator).should have_same_elements(expected)
         end
       end
     end

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)[{}].should be_an_instance_of(Tagtical::TagList)
+    @taggable.tag_list_cache_on(:skill)[[:children, :current]].should be_an_instance_of(Tagtical::TagList)
 
     lambda { @taggable.save }.should change(Tagtical::Tag, :count).by(3)
 
@@ -127,7 +127,7 @@ describe Tagtical::Taggable do
     end
   end
 
-  describe "tag retrieval with finder type conditions" do
+  describe "tag_list scoping behavior" do
     before do
       @taggables[0].tag_list = "bob"
       @taggables[1].tag_list = "charlie"
@@ -136,15 +136,35 @@ describe Tagtical::Taggable do
       @taggables[0].craft_list = "knitting"
       @taggables[1].craft_list = "pottery"
       @taggables.each(&:save!)
+      @taggables.each(&:reload)
+    end
+
+    it "should empty out inheriting tags" do
+      @taggables[0].tag_list = []
+      @taggables[0].save!
+      @taggables[0].reload
+
+      @taggables[0].crafts.should be_empty
+    end
+
+    it "should not empty out 'tag' type when :current scope" do
+      @taggables[0].set_tag_list([], :current)
+      @taggables[0].save!
+      @taggables[0].reload
+
+      @taggables[0].tags.should_not be_empty
+      @taggables[0].tags(:current).should be_empty
+      @taggables[0].skills.should_not be_empty
+      @taggables[0].crafts.should_not be_empty
     end
 
     it "should be able to query tags" do
       @taggables[0].tags(:scope => :current).should have_only_tag_values %w{bob}
-      @taggables[0].tags(:scope => :==).should have_only_tag_values %w{bob}
+      @taggables[0].tags(:==).should have_only_tag_values %w{bob}
       @taggables[0].tags.should have_only_tag_values %w{bob knitting ruby}
       @taggables[0].tags(:scope => :children).should have_only_tag_values %w{knitting ruby}
       @taggables[0].tags(:scope => :<).should have_only_tag_values %w{knitting ruby}
-      @taggables[1].crafts(:scope => :parents).should have_only_tag_values %w{charlie css}
+      @taggables[1].crafts(:parents).should have_only_tag_values %w{charlie css}
       @taggables[1].crafts(:scope => :>).should have_only_tag_values %w{charlie css}
 
       @taggables[1].crafts(:scope => [:parents, :current]).should have_only_tag_values %w{charlie css pottery}
@@ -446,14 +466,22 @@ describe Tagtical::Taggable do
 
   describe "Associations" do
     before(:each) do
-      @taggable = TaggableModel.create(:tag_list => "awesome, epic")
+      @taggable = TaggableModel.create(:tag_list => "awesome, epic", :skill_list => "basketball, hiking, boxing")
     end
 
     it "should not remove tags when creating associated objects" do
       @taggable.untaggable_models.create!
       @taggable.reload
-      @taggable.tag_list.should have(2).items
+      @taggable.tag_list.should have(5).items
+    end
+
+    its "tag_list methods should accept scope arguments" do
+      @taggable.tag_list(:current).should have(2).items
+      @taggable.skill_list(:parents).should have(2).items
+      @taggable.skill_list(:current).should have(3).items
+      @taggable.tag_list(:current, :children).should have(5).items
     end
+
   end
 
   describe "grouped_column_names_for method" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tagtical
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-21 00:00:00.000000000Z
+date: 2011-07-22 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &2155967120 !ruby/object:Gem::Requirement
+  requirement: &2168459400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - <=
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.5
   type: :runtime
   prerelease: false
-  version_requirements: *2155967120
+  version_requirements: *2168459400
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2155983780 !ruby/object:Gem::Requirement
+  requirement: &2168476040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - <=
@@ -32,10 +32,10 @@ dependencies:
         version: 2.6.0
   type: :runtime
   prerelease: false
-  version_requirements: *2155983780
+  version_requirements: *2168476040
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &2155983300 !ruby/object:Gem::Requirement
+  requirement: &2168475560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2155983300
+  version_requirements: *2168475560
 - !ruby/object:Gem::Dependency
   name: mysql
-  requirement: &2155982820 !ruby/object:Gem::Requirement
+  requirement: &2168475080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2155982820
+  version_requirements: *2168475080
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2155982340 !ruby/object:Gem::Requirement
+  requirement: &2168474600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2155982340
+  version_requirements: *2168474600
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &2155981860 !ruby/object:Gem::Requirement
+  requirement: &2168474120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2155981860
+  version_requirements: *2168474120
 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.