tagtical 1.0.8 → 1.1.0

data/README.rdoc

@@ -13,8 +13,8 @@ as a designator for the STI class. Subsequently, you could also add a "relevance
 that mood is.
 
 Tagtical allows for an arbitrary number of Tag subclasses, each of which can be extended to the needs
-of the application. However, a tag subclass is not required! If you have many custom tag types that you
-create on the fly, you can wait until a later time to create a tag subclass.
+of the application. Note: Tag subclasses are required! You cannot do custom "contexts" as you could in
+acts_as_taggable_on/
 
 Here are the main differences between tagtical and acts_as_taggable_on:
 
@@ -28,6 +28,14 @@ could be a serialized field of long and lat if you wanted.
 5. Support a config/tagtical.yml to further configure the application. For example, since most people
 usually have one User class for their application, there is no reason to do polymorphic on "tagger",
 so I give the user the option to specify the class_name specifically for tagger.
+6. :parse option to tag_list is inverted. Specify :parse => false if you don't want your tag values
+parsed.
+
+  Example:
+    # would give you a tag of "red, blue" instead of "red" and "blue".
+    tag_list.add("red, blue", :parse => false)
+
+7. Custom contexts are *not* supported since we use STI.
 
 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.
@@ -90,6 +98,10 @@ rake spec:plugins
       class Activity < Tagtical::Tag
       end
       class Sport < Activity
+
+        # You can also set the possible values for a specific tag type
+        self.possible_values = %w{boxing basketball tennis hockey footabll soccer}
+
         def ball?
           value=~/ball$/i
         end
@@ -102,6 +114,11 @@ rake spec:plugins
     @user.activity_list                      # => ["joking","clowning","boxing"] as TagList
     @user.save
 
+    # Cascade tag_list setters =)
+    @user.set_activity_list(["clowning", "boxing"], :cascade => true)
+    @user.save!
+    @user.sport_list  # => ["boxing"]
+
     @user.tags # => [<Tag value:"awesome">,<Tag value:"slick">,<Tag value:"hefty">]
     @user.activities # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">,<Tag::Activity value:"boxing">]
     @user.activities.first.athletic? # => false
@@ -114,15 +131,19 @@ rake spec:plugins
                                          # from Activity to Sport and give it a relevance of 4.5.
     @user.save
 
+    @user.sport_list = {"chess"}
+    @user.save! # <=== will throw an error, chess is not a sport!
+
     @user.activities # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">,<Tag::Sport value:"boxing">]
-    @user.activities(:type => :children) # => [<Tag::Sport value:"boxing">] - look at only the STI subclasses
-    @user.activities(:type => :<) # => [<Tag::Sport value:"boxing">] - look at only the STI subclasses
-    @user.activities(:type => :current) # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">] - look at only the current STI class
-    @user.activities(:type => :==) # => [<Tag::Activity value:"joking">,<Tag::Activity value:"clowning">] - look at only the current STI class
+    @user.activities(:scope => :children) # => [<Tag::Sport value:"boxing">] - look at only the STI subclasses
+    @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
 
     @user.activities.first.athletic? # => false
     @user.sports.all(&:ball?) # => true
 
+
 --- Defining Subclasses
 
 There is a lot of flexibility when it comes to naming subclasses. Lets say the type column had a value

data/VERSION

@@ -1 +1 @@
-1.0.8
+1.1.0

data/lib/tagtical/tag.rb

@@ -1,22 +1,22 @@
 module Tagtical
   class Tag < ::ActiveRecord::Base
-    
+
     attr_accessible :value
 
     has_many :taggings, :dependent => :destroy, :class_name => 'Tagtical::Tagging'
 
     scope(:type, lambda do |context, *args|
-      options = args.extract_options!
-      options[:type] = args[0] if args[0]
-      Type[context].scoping(options)
+      Type.cache[Type.send(:sanitize, context)].inject(nil) do |scoping, tag_type|
+        scope = tag_type.scoping(*args)
+        scoping ? scoping.merge(scope) : scope
+      end
     end)
 
     validates :value, :uniqueness => {:scope => :type}, :presence => true # type is not required, it can be blank
 
     class_attribute :possible_values
+    before_validation :ensure_possible_values
     validate :validate_possible_values
-    
-    self.store_full_sti_class = false
 
     ### CLASS METHODS:
 
@@ -35,7 +35,7 @@ module Tagtical
         connection.adapter_name=='PostgreSQL'
       end
 
-      # Use this for case insensitive 
+      # Use this for case insensitive
       def where_any_like(list, options={})
         where_any(list, options.update(:case_insensitive => true))
       end
@@ -52,41 +52,49 @@ module Tagtical
         tag_list = [tag_list].flatten
         return {} if tag_list.empty?
 
-        existing_tags  = where_any_like(tag_list).all
+        existing_tags = where_any_like(tag_list).all
         tag_list.each_with_object({}) do |value, tag_lookup|
           tag_lookup[detect_comparable(existing_tags, value) || create!(:value => value)] = value
         end
       end
 
+        # Save disc space by not having to put in "Tagtical::Tag" repeatedly
       def sti_name
-        return @sti_name if instance_variable_defined?(:@sti_name)
-        @sti_name = Tagtical::Tag==self ? nil : Type[name.demodulize].to_sti_name
+        Tagtical::Tag==self ? nil : super
       end
 
       def define_scope_for_type(tag_type)
-        scope(tag_type.scope_name, lambda { |*args| type(tag_type, *args) }) unless respond_to?(tag_type.scope_name)
+        scope(tag_type.scope_name, lambda { |*args| type(tag_type.to_s, *args) }) unless respond_to?(tag_type.scope_name)
+      end
+
+        # Checks to see if a tags value is present in a set of tags and returns that tag.
+      def detect_comparable(objects, value)
+        value = comparable_value(value)
+        objects.detect { |obj| comparable_value(obj) == value }
+      end
+
+      def detect_possible_value(value)
+        detect_comparable(possible_values, value) if possible_values
       end
 
       protected
 
       def compute_type(type_name)
-        @@compute_type ||= {}
-        # super is required when it gets called from a reflection.
-        @@compute_type[type_name] || super
-      rescue Exception => e
-        @@compute_type[type_name] = Type.new(type_name).klass!
+        type_name.nil? ? Tagtical::Tag : super
       end
 
       private
-      
-      # Checks to see if a tags value is present in a set of tags and returns that tag.
-      def detect_comparable(tags, value)
-        value = comparable_value(value)
-        tags.detect { |tag| comparable_value(tag.value) == value }
-      end
 
-      def comparable_value(str)
-        RUBY_VERSION >= "1.9" ? str.downcase : str.mb_chars.downcase
+      if RUBY_VERSION >= "1.9"
+        def comparable_value(str)
+          str = str.value if str.is_a?(self)
+          str.downcase
+        end
+      else
+        def comparable_value(str)
+          str = str.value if str.is_a?(self)
+          str.mb_chars.downcase
+        end
       end
 
     end
@@ -101,7 +109,7 @@ module Tagtical
       (v = self[:relevance]) && v.to_f
     end
 
-    # Try to sort by the relevance if provided.
+      # Try to sort by the relevance if provided.
     def <=>(tag)
       if (r1 = relevance) && (r2 = tag.relevance)
         r1 <=> r2
@@ -120,11 +128,6 @@ module Tagtical
       end
     end
 
-    # We return nil if we are *not* an STI class.
-    def type
-      (type = self[:type]) && Type.new(type)
-    end
-
     def count
       self[:count].to_i
     end
@@ -132,17 +135,24 @@ module Tagtical
     private
 
     def method_missing(method_name, *args, &block)
-      if method_name[-1]=="?"
-        lambda = (klass = Type.new(method_name[0..-2]).klass) ?
-          lambda { is_a?(klass) } :
-          lambda { method_name[0..-2]==type }
-        self.class.send(:define_method, method_name, &lambda)
+      if method_name[-1]=="?" && (types = Type.cache[method_name[0..-2]])
+        self.class.send(:define_method, method_name) do
+          types.any? { |type| is_a?(type.klass) }
+        end
         send(method_name)
       else
         super
       end
     end
 
+      # Ensure that the value follows the case-sensitivity from the possible_values.
+    def ensure_possible_values
+      if value = self.class.detect_possible_value(self.value)
+        self.value = value
+      end
+      true
+    end
+
     def validate_possible_values
       if possible_values && !possible_values.include?(value)
         errors.add(:value, %{Value "#{value}" not found in list: #{possible_values.inspect}})
@@ -154,24 +164,59 @@ module Tagtical
       # "tag" should always correspond with demodulize name of the base Tag class (ie Tagtical::Tag).
       BASE = "tag".freeze
 
+      attr_reader :taggable_class
+
+      def initialize(str, taggable_class, options={})
+        options.each { |k, v| instance_variable_set("@#{k}", v) }
+        @taggable_class = taggable_class
+        super(str)
+      end
+
+      @@cache = {}
+      cattr_reader :cache
+
       class << self
-        def find(input)
-          return input.map { |c| self[c] } if input.is_a?(Array)
-          input.is_a?(self) ? input : new(sanitize(input))
+        def find(input, taggable_class)
+          case input
+          when self then input
+          when String, Symbol then new(sanitize(input), taggable_class)
+          when Hash  then input.map { |input, klass| new(sanitize(input), taggable_class, :klass => klass) }
+          when Array then input.map { |c| find(c, taggable_class) }.flatten
+          end
         end
         alias :[] :find
 
+        # Stores the tag types in memory
+        def register(inputs, taggable_class)
+          find(inputs, taggable_class).each do |tag_type|
+            cache[tag_type] ||= []
+            cache[tag_type] << tag_type unless cache[tag_type].include?(tag_type)
+          end
+        end
+
         private
 
-        # Sanitize the input for type name consistency.
+        # Sanitize the input for type name consistency and klass.
         def sanitize(input)
           input.to_s.singularize.underscore.gsub(/_tag$/, '')
         end
       end
 
-      # The STI name for the Tag model is the same as the tag type.
-      def to_sti_name
-        self
+      # Matches the string against the type after sanitizing it.
+      def match?(input)
+        self==self.class.send(:sanitize, input)
+      end
+
+      def comparable_array
+        [to_s, klass]
+      end
+
+      def ==(input)
+        case input
+        when self.class then comparable_array==input.comparable_array
+        when String then input==self
+        else false
+        end
       end
 
       # Leverages current type_condition logic from ActiveRecord while also allowing for type conditions
@@ -181,8 +226,9 @@ module Tagtical
       #   <tt>sql</tt> - Set to true to return sql string. Set to :append to return a sql string which can be appended as a condition.
       #   <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(options={})
-        type = convert_type_options(options[:type])
+      def finder_type_condition(*args)
+        options = convert_finder_type_arguments(*args)
+        type = convert_type_options(options[:scope])
 
         # 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
@@ -194,7 +240,7 @@ module Tagtical
 
         sti_names = []
         if type.include?(:current)
-          sti_names << (klass ? klass.sti_name : to_sti_name)
+          sti_names << klass.sti_name
         end
         if type.include?(:children) && klass
           sti_names.concat(klass.descendants.map(&:sti_name))
@@ -212,7 +258,7 @@ module Tagtical
           cond = sti_column.eq(sti_name)
           conds.nil? ? cond : conds.or(cond)
         end
-        
+
         if condition && options[:sql]
           condition = condition.to_sql
           condition.insert(0, " AND ") if options[:sql]==:append
@@ -220,11 +266,14 @@ module Tagtical
         condition
       end
 
-      def scoping(options={}, &block)
-        finder_type_condition = finder_type_condition(options)
+      # Accepts:
+      #   scoping(:<=)
+      #   scoping(:scoping => :<=)
+      def scoping(*args, &block)
+        finder_type_condition = finder_type_condition(*args)
         if block_given?
           if finder_type_condition
-            Tagtical::Tag.send(:with_scope, :find => Tagtical::Tag.where(finder_type_condition), :create => {:type => self}) do
+            Tagtical::Tag.send(:with_scope, :find => Tagtical::Tag.where(finder_type_condition), :create => {:type => klass.sti_name}) do
               Tagtical::Tag.instance_exec(&block)
             end
           else
@@ -234,15 +283,14 @@ module Tagtical
           Tagtical::Tag.send(*(finder_type_condition ? [:where, finder_type_condition] : :unscoped))
         end
       end
-      
+
       # Return the Tag subclass
       def klass
-        instance_variable_get(:@klass) || instance_variable_set(:@klass, find_tag_class)
+        @klass ||= find_tag_class!
       end
 
-      # Return the Tag class or return top-level
-      def klass!
-        klass || Tagtical::Tag
+      def base?
+        BASE==self
       end
 
       def has_many_name
@@ -250,14 +298,6 @@ module Tagtical
       end
       alias scope_name has_many_name
 
-      def base?
-        !!klass && klass.descends_from_active_record?
-      end
-
-      def ==(val)
-        super(self.class[val])
-      end
-
       def tag_list_name(prefix=nil)
         prefix = prefix.to_s.dup
         prefix << "_" unless prefix.blank?
@@ -271,7 +311,7 @@ module Tagtical
       # Returns the level from which it extends from Tagtical::Tag
       def active_record_sti_level
         @active_record_sti_level ||= begin
-          count, current_class = 0, klass!
+          count, current_class = 0, klass
           while !current_class.descends_from_active_record?
             current_class = current_class.superclass
             count += 1
@@ -285,12 +325,13 @@ module Tagtical
       # Returns an array of potential class names for this specific type.
       def derive_class_candidates
         [].tap do |arr|
-          [classify, "#{classify}Tag"].each do |name| # support Interest and InterestTag class names.
+          suffixes = [classify, "#{classify}Tag", "#{taggable_class}::#{classify}", "#{taggable_class}::#{classify}Tag"]
+          suffixes.each do |name| # support Interest and InterestTag class names.
             "Tagtical::Tag".tap do |longest_candidate|
               longest_candidate << "::#{name}" unless name=="Tag"
             end.scan(/^|::/) { arr << $' } # Klass, Tag::Klass, Tagtical::Tag::Klass
           end
-        end
+        end.uniq.sort_by { |candidate| -candidate.split("::").size } # more nested classnames first
       end
 
       # Take operator types (ie <, >, =) and convert them into :children, :current, or :parents.
@@ -306,19 +347,11 @@ module Tagtical
         end.flatten.uniq
       end
 
-      def find_tag_class
-        candidates = derive_class_candidates
+      def find_tag_class!
+        return Tagtical::Tag if base?
 
-        # Attempt to find the preloaded class instead of having to do NameError catching below.
-        candidates.each do |candidate|
-          constants = ActiveSupport::Dependencies::Reference.send(:class_variable_get, :@@constants)
-          if constants.key?(candidate) && (constant = constants[candidate]) <= Tagtical::Tag # must check for key first, do not want to trigger default proc.
-            return constant
-          end
-        end
-        
         # Logic comes from ActiveRecord::Base#compute_type.
-        candidates.each do |candidate|
+        derive_class_candidates.each do |candidate|
           begin
             constant = ActiveSupport::Dependencies.constantize(candidate)
             return constant if candidate == constant.to_s && constant <= Tagtical::Tag
@@ -329,9 +362,15 @@ module Tagtical
           end
         end
 
-        nil
+        raise("Cannot find tag class for type: #{self} with taggable class: #{taggable_class}")
       end
-    end
 
+      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
+      end
+
+    end
   end
 end

data/lib/tagtical/tag_list.rb

@@ -1,45 +1,43 @@
 module Tagtical
   class TagList < Array
     class TagValue < String
+
       attr_accessor :relevance
-      def initialize(value, relevance=nil)
-        @relevance = relevance
-        super(value.to_s)
+
+      cattr_accessor :relevance_delimiter
+      self.relevance_delimiter = ':'
+
+      def initialize(value="", relevance=nil)
+        @relevance = relevance.to_f if relevance
+        super(value)
       end
+
+      def self.parse(input)
+        new(*input.to_s.split(relevance_delimiter, 2).each(&:strip!))
+      end
+      
     end
-    
+
     cattr_accessor :delimiter
     self.delimiter = ','
 
+    cattr_accessor :value_quotes
+    self.value_quotes = ["'", "\""]
+
     attr_accessor :owner
 
     def initialize(*args)
-      add(*args)
+      add(*args) unless args.empty?
     end
-  
+
     ##
     # Returns a new TagList using the given tag string.
     #
     # Example:
     #   tag_list = TagList.from("One , Two,  Three")
-    #   tag_list # ["One", "Two", "Three"]
-    def self.from(string)
-      if string.is_a?(Hash)
-        new(string)
-      else
-        glue   = delimiter.ends_with?(" ") ? delimiter : "#{delimiter} "
-        string = string.join(glue) if string.respond_to?(:join)
-
-        new.tap do |tag_list|
-          string = string.to_s.dup
-
-          # Parse the quoted tags
-          string.gsub!(/(\A|#{delimiter})\s*"(.*?)"\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
-          string.gsub!(/(\A|#{delimiter})\s*'(.*?)'\s*(#{delimiter}\s*|\z)/) { tag_list << $2; $3 }
-
-          tag_list.add(string.split(delimiter))
-        end
-      end
+    #   tag_list # ["One", "Two", "Three"] <=== as TagValue
+    def self.from(*args)
+      new(*args)
     end
 
     def concat(values)
@@ -57,12 +55,13 @@ module Tagtical
     #
     # Example:
     #   tag_list.add("Fun", "Happy")
-    #   tag_list.add("Fun, Happy", :parse => true)
+    #   tag_list.add("Fun, Happy")
     #   tag_list.add("Fun" => "0.546", "Happy" => 0.465) # add relevance
     def add(*values)
       extract_and_apply_options!(values)
-      concat(values)
-      clean!
+      clean!(values) do
+        concat(values)
+      end
       self
     end
 
@@ -72,7 +71,7 @@ module Tagtical
     #
     # Example:
     #   tag_list.remove("Sad", "Lonely")
-    #   tag_list.remove("Sad, Lonely", :parse => true)
+    #   tag_list.remove("Sad, Lonely")
     def remove(*values)
       extract_and_apply_options!(values)
       delete_if { |value| values.include?(value) }
@@ -87,12 +86,13 @@ module Tagtical
     #   tag_list = TagList.new("Round", "Square,Cube")
     #   tag_list.to_s # 'Round, "Square,Cube"'
     def to_s
-      tags = frozen? ? self.dup : self
-      tags.send(:clean!)
+      tag_list = frozen? ? self.dup : self
+      tag_list.send(:clean!)
 
-      tags.map do |value|
-        value.include?(delimiter) ? "\"#{value}\"" : value
-      end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+      tag_list.map do |tag_value|
+        value = tag_value.include?(delimiter) ? %{"#{tag_value}"} : tag_value
+        [value, tag_value.relevance].compact.join(TagValue.relevance_delimiter)
+      end.join(delimiter.gsub(/(\S)$/, '\1 '))
     end
 
     # Builds an option statement for an ActiveRecord table.
@@ -102,31 +102,49 @@ module Tagtical
     end
 
     private
-  
+
     # Remove whitespace, duplicates, and blanks.
-    def clean!
+    def clean!(values=nil)
+      delete_if { |value| values.include?(value) } if values.present? # Allow editing of relevance
+      yield if block_given?
       reject!(&:blank?)
       each(&:strip!)
       uniq!(&:downcase)
     end
 
     def extract_and_apply_options!(args)
-      if args.size==1 && args[0].is_a?(Hash)
-        args.replace(args[0].map { |value, relevance| TagValue.new(value, relevance) })
-      else
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        options.assert_valid_keys :parse
-
-        if options[:parse]
-          args.map! { |a| self.class.from(a) }
-        end
+      options = args.last.is_a?(Hash) && args.size > 1 ? args.pop : {}
+      options.assert_valid_keys :parse
+      
+      args.map! { |a| extract(a, options) }
+      args.flatten!
+    end
+
+    def extract(input, options={})
+      case input
+      when String
+        if !input.include?(delimiter) || options[:parse]==false
+          [input]
+        else
+          input, arr = input.dup, []
 
-        args.flatten!
+          # 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
+          arr.concat(input.split(delimiter).each(&:strip!))
+        end
+      when Hash
+        input.map { |value, relevance| TagValue.new(value, relevance) }
+      when Array
+        input
       end
     end
 
     def convert_tag_value(value)
-      value.is_a?(TagValue) ? value : TagValue.new(value)
+      value.is_a?(TagValue) ? value : TagValue.parse(value)
     end
 
   end

data/lib/tagtical/taggable/cache.rb

@@ -16,12 +16,12 @@ module Tagtical::Taggable
     
     module ClassMethods
       def initialize_tagtical_cache
-        tag_types.map(&:to_s).each do |tag_type|
-          class_eval %(
+        tag_types.each do |tag_type|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def self.caching_#{tag_type.singularize}_list?
               caching_tag_list_on?("#{tag_type}")
-            end        
-          )
+            end  
+          RUBY
         end        
       end
       
@@ -34,14 +34,13 @@ module Tagtical::Taggable
         column_names.include?("cached_#{context.to_s.singularize}_list")
       end
     end
-    
+
     module InstanceMethods      
       def save_cached_tag_list
         tag_types.each do |tag_type|
           if self.class.send("caching_#{tag_type.singularize}_list?")
-            if tag_list_cache_set_on?(tag_type)
-              list = tag_list_cache_on(tag_type.singularize).to_a.flatten.compact.join(', ')
-              self["cached_#{tag_type.singularize}_list"] = list
+            if tag_list = tag_list_cache_on(tag_type)[{}]
+              self[tag_type.tag_list_name(:cached)] = tag_list.to_a.flatten.compact.join(', ')
             end
           end
         end

data/lib/tagtical/taggable/collection.rb

@@ -68,7 +68,7 @@ module Tagtical::Taggable
         taggable_conditions  = sanitize_sql(["#{Tagtical::Tagging.table_name}.taggable_type = ?", base_class.name])
         taggable_conditions  << sanitize_sql([" AND #{Tagtical::Tagging.table_name}.taggable_id = ?", options.delete(:id)])  if options[:id]
 
-        sti_conditions = Tagtical::Tag::Type[options[:on]].finder_type_condition if options[:on]
+        sti_conditions = find_tag_type!(options[:on]).finder_type_condition if options[:on]
 
         tagging_conditions = [
           taggable_conditions,