sb-acts-as-taggable-on 6.5.0

data/lib/acts_as_taggable_on/engine.rb

@@ -0,0 +1,4 @@
+module ActsAsTaggableOn
+  class Engine < Rails::Engine
+  end
+end

data/lib/acts_as_taggable_on/generic_parser.rb

@@ -0,0 +1,19 @@
+module ActsAsTaggableOn
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  # tag_list = ActsAsTaggableOn::GenericParser.new.parse("One , Two, Three")
+  # tag_list # ["One", "Two", "Three"]
+  class GenericParser
+    def initialize(tag_list)
+      @tag_list = tag_list
+    end
+
+    def parse
+      TagList.new.tap do |tag_list|
+        tag_list.add @tag_list.split(',').map(&:strip).reject(&:empty?)
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/tag.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+module ActsAsTaggableOn
+  class Tag < ::ActiveRecord::Base
+    self.table_name = ActsAsTaggableOn.tags_table
+
+    ### ASSOCIATIONS:
+
+    has_many :taggings, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'
+
+    ### VALIDATIONS:
+
+    validates_presence_of :name
+    validates_uniqueness_of :name, if: :validates_name_uniqueness?, case_sensitive: true
+    validates_length_of :name, maximum: 255
+
+    # monkey patch this method if don't need name uniqueness validation
+    def validates_name_uniqueness?
+      true
+    end
+
+    ### SCOPES:
+    scope :most_used, ->(limit = 20) { order('taggings_count desc').limit(limit) }
+    scope :least_used, ->(limit = 20) { order('taggings_count asc').limit(limit) }
+
+    def self.named(name)
+      if ActsAsTaggableOn.strict_case_match
+        where(["name = #{binary}?", as_8bit_ascii(name)])
+      else
+        where(['LOWER(name) = LOWER(?)', as_8bit_ascii(unicode_downcase(name))])
+      end
+    end
+
+    def self.named_any(list)
+      clause = list.map { |tag|
+        sanitize_sql_for_named_any(tag).force_encoding('BINARY')
+      }.join(' OR ')
+      where(clause)
+    end
+
+    def self.named_like(name)
+      clause = ["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(name)}%"]
+      where(clause)
+    end
+
+    def self.named_like_any(list)
+      clause = list.map { |tag|
+        sanitize_sql(["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'", "%#{ActsAsTaggableOn::Utils.escape_like(tag.to_s)}%"])
+      }.join(' OR ')
+      where(clause)
+    end
+
+    def self.for_context(context)
+      joins(:taggings).
+        where(["#{ActsAsTaggableOn.taggings_table}.context = ?", context]).
+        select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
+    end
+
+    ### CLASS METHODS:
+
+    def self.find_or_create_with_like_by_name(name)
+      if ActsAsTaggableOn.strict_case_match
+        self.find_or_create_all_with_like_by_name([name]).first
+      else
+        named_like(name).first || create(name: name)
+      end
+    end
+
+    def self.find_or_create_all_with_like_by_name(*list)
+      list = Array(list).flatten
+
+      return [] if list.empty?
+
+      existing_tags = named_any(list)
+      list.map do |tag_name|
+        begin
+          tries ||= 3
+          comparable_tag_name = comparable_name(tag_name)
+          existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
+          existing_tag || create(name: tag_name)
+        rescue ActiveRecord::RecordNotUnique
+          if (tries -= 1).positive?
+            ActiveRecord::Base.connection.execute 'ROLLBACK'
+            existing_tags = named_any(list)
+            retry
+          end
+
+          raise DuplicateTagError.new("'#{tag_name}' has already been taken")
+        end
+      end
+    end
+
+    ### INSTANCE METHODS:
+
+    def ==(object)
+      super || (object.is_a?(Tag) && name == object.name)
+    end
+
+    def to_s
+      name
+    end
+
+    def count
+      read_attribute(:count).to_i
+    end
+
+    class << self
+
+      private
+
+      def comparable_name(str)
+        if ActsAsTaggableOn.strict_case_match
+          str
+        else
+          unicode_downcase(str.to_s)
+        end
+      end
+
+      def binary
+        ActsAsTaggableOn::Utils.using_mysql? ? 'BINARY ' : nil
+      end
+
+      def as_8bit_ascii(string)
+        string.to_s.mb_chars
+      end
+
+      def unicode_downcase(string)
+        as_8bit_ascii(string).downcase
+      end
+
+      def sanitize_sql_for_named_any(tag)
+        if ActsAsTaggableOn.strict_case_match
+          sanitize_sql(["name = #{binary}?", as_8bit_ascii(tag)])
+        else
+          sanitize_sql(['LOWER(name) = LOWER(?)', as_8bit_ascii(unicode_downcase(tag))])
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on/tag_list.rb

@@ -0,0 +1,106 @@
+
+require 'active_support/core_ext/module/delegation'
+
+module ActsAsTaggableOn
+  class TagList < Array
+    attr_accessor :owner
+    attr_accessor :parser
+
+    def initialize(*args)
+      @parser = ActsAsTaggableOn.default_parser
+      add(*args)
+    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.
+    #
+    # Example:
+    #   tag_list.add("Fun", "Happy")
+    #   tag_list.add("Fun, Happy", :parse => true)
+    def add(*names)
+      extract_and_apply_options!(names)
+      concat(names)
+      clean!
+      self
+    end
+
+    # Append---Add the tag to the tag_list. This
+    # expression returns the tag_list itself, so several appends
+    # may be chained together.
+    def <<(obj)
+      add(obj)
+    end
+
+    # Concatenation --- Returns a new tag list built by concatenating the
+    # two tag lists together to produce a third tag list.
+    def +(other_tag_list)
+      TagList.new.add(self).add(other_tag_list)
+    end
+
+    # Appends the elements of +other_tag_list+ to +self+.
+    def concat(other_tag_list)
+      super(other_tag_list).send(:clean!)
+      self
+    end
+
+    ##
+    # Remove specific tags from the tag_list.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.remove("Sad", "Lonely")
+    #   tag_list.remove("Sad, Lonely", :parse => true)
+    def remove(*names)
+      extract_and_apply_options!(names)
+      delete_if { |name| names.include?(name) }
+      self
+    end
+
+    ##
+    # Transform the tag_list into a tag string suitable for editing in a form.
+    # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+    #
+    # Example:
+    #   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!)
+
+      tags.map do |name|
+        d = ActsAsTaggableOn.delimiter
+        d = Regexp.new d.join('|') if d.kind_of? Array
+        name.index(d) ? "\"#{name}\"" : name
+      end.join(ActsAsTaggableOn.glue)
+    end
+
+    private
+
+    # Convert everything to string, remove whitespace, duplicates, and blanks.
+    def clean!
+      reject!(&:blank?)
+      map!(&:to_s)
+      map!(&:strip)
+      map! { |tag| tag.mb_chars.downcase.to_s } if ActsAsTaggableOn.force_lowercase
+      map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
+
+      ActsAsTaggableOn.strict_case_match ? uniq! : uniq!{ |tag| tag.downcase }
+      self
+    end
+
+
+    def extract_and_apply_options!(args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.assert_valid_keys :parse, :parser
+
+      parser = options[:parser] ? options[:parser] : @parser
+
+      args.map! { |a| parser.new(a).parse } if options[:parse] || options[:parser]
+
+      args.flatten!
+    end
+
+  end
+end
+

data/lib/acts_as_taggable_on/taggable.rb

@@ -0,0 +1,101 @@
+module ActsAsTaggableOn
+  module Taggable
+
+    def taggable?
+      false
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_taggable
+    #   end
+    def acts_as_taggable
+      acts_as_taggable_on :tags
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_ordered_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_ordered_taggable
+    #   end
+    def acts_as_ordered_taggable
+      acts_as_ordered_taggable_on :tags
+    end
+
+    ##
+    # Make a model taggable on specified contexts.
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_taggable_on :languages, :skills
+    #   end
+    def acts_as_taggable_on(*tag_types)
+      taggable_on(false, tag_types)
+    end
+
+    ##
+    # Make a model taggable on specified contexts
+    # and preserves the order in which tags are created
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_ordered_taggable_on :languages, :skills
+    #   end
+    def acts_as_ordered_taggable_on(*tag_types)
+      taggable_on(true, tag_types)
+    end
+
+    private
+
+      # Make a model taggable on specified contexts
+      # and optionally preserves the order in which tags are created
+      #
+      # Separate methods used above for backwards compatibility
+      # so that the original acts_as_taggable_on method is unaffected
+      # as it's not possible to add another argument to the method
+      # without the tag_types being enclosed in square brackets
+      #
+      # NB: method overridden in core module in order to create tag type
+      #     associations and methods after this logic has executed
+      #
+    def taggable_on(preserve_tag_order, *tag_types)
+      tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
+
+      if taggable?
+        self.tag_types = (self.tag_types + tag_types).uniq
+        self.preserve_tag_order = preserve_tag_order
+      else
+        class_attribute :tag_types
+        self.tag_types = tag_types
+        class_attribute :preserve_tag_order
+        self.preserve_tag_order = preserve_tag_order
+
+        class_eval do
+          has_many :taggings, as: :taggable, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'
+          has_many :base_tags, through: :taggings, source: :tag, class_name: '::ActsAsTaggableOn::Tag'
+
+          def self.taggable?
+            true
+          end
+        end
+      end
+
+      # each of these add context-specific methods and must be
+      # called on each call of taggable_on
+      include Core
+      include Collection
+      include Cache
+      include Ownership
+      include Related
+    end
+  end
+end

data/lib/acts_as_taggable_on/taggable/cache.rb

@@ -0,0 +1,90 @@
+module ActsAsTaggableOn::Taggable
+  module Cache
+    def self.included(base)
+      # When included, conditionally adds tag caching methods when the model
+      #   has any "cached_#{tag_type}_list" column
+      base.extend Columns
+    end
+
+    module Columns
+      # ActiveRecord::Base.columns makes a database connection and caches the
+      #   calculated columns hash for the record as @columns.  Since we don't
+      #   want to add caching methods until we confirm the presence of a
+      #   caching column, and we don't want to force opening a database
+      #   connection when the class is loaded, here we intercept and cache
+      #   the call to :columns as @acts_as_taggable_on_cache_columns
+      #   to mimic the underlying behavior.  While processing this first
+      #   call to columns, we do the caching column check and dynamically add
+      #   the class and instance methods
+      #   FIXME: this method cannot compile in rubinius
+      def columns
+        @acts_as_taggable_on_cache_columns ||= begin
+          db_columns = super
+          _add_tags_caching_methods if _has_tags_cache_columns?(db_columns)
+          db_columns
+        end
+      end
+
+      def reset_column_information
+        super
+        @acts_as_taggable_on_cache_columns = nil
+      end
+
+      private
+
+      # @private
+      def _has_tags_cache_columns?(db_columns)
+        db_column_names = db_columns.map(&:name)
+        tag_types.any? do |context|
+          db_column_names.include?("cached_#{context.to_s.singularize}_list")
+        end
+      end
+
+      # @private
+      def _add_tags_caching_methods
+        send :include, ActsAsTaggableOn::Taggable::Cache::InstanceMethods
+        extend ActsAsTaggableOn::Taggable::Cache::ClassMethods
+
+        before_save :save_cached_tag_list
+
+        initialize_tags_cache
+      end
+    end
+
+    module ClassMethods
+      def initialize_tags_cache
+        tag_types.map(&:to_s).each do |tag_type|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.caching_#{tag_type.singularize}_list?
+              caching_tag_list_on?("#{tag_type}")
+            end
+          RUBY
+        end
+      end
+
+      def acts_as_taggable_on(*args)
+        super(*args)
+        initialize_tags_cache
+      end
+
+      def caching_tag_list_on?(context)
+        column_names.include?("cached_#{context.to_s.singularize}_list")
+      end
+    end
+
+    module InstanceMethods
+      def save_cached_tag_list
+        tag_types.map(&:to_s).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).to_a.flatten.compact.join("#{ActsAsTaggableOn.delimiter} ")
+              self["cached_#{tag_type.singularize}_list"] = list
+            end
+          end
+        end
+
+        true
+      end
+    end
+  end
+end