acts-as-taggable-on 2.0.0.pre5 → 3.5.0

data/gemfiles/activerecord_4.0.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", :github => "rails/rails", :branch => "4-0-stable"
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+  gem "byebug", :platform => :mri_21
+end
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.1.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", :github => "rails/rails", :branch => "4-1-stable"
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+  gem "byebug", :platform => :mri_21
+end
+
+gemspec :path => "../"

data/gemfiles/activerecord_4.2.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "railties", :github => "rails/rails", :branch => "4-2-stable"
+gem "activerecord", :github => "rails/rails", :branch => "4-2-stable"
+
+group :local_development do
+  gem "guard"
+  gem "guard-rspec"
+  gem "appraisal"
+  gem "rake"
+  gem "byebug", :platform => :mri_21
+end
+
+gemspec :path => "../"

data/lib/acts-as-taggable-on.rb

@@ -1,30 +1,125 @@
-require "active_record"
-require "action_view"
+require 'active_record'
+require 'active_record/version'
+require 'active_support/core_ext/module'
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+require_relative 'acts_as_taggable_on/engine'  if defined?(Rails)
 
-require "acts_as_taggable_on/compatibility/active_record_backports" if ActiveRecord::VERSION::MAJOR < 3
+require 'digest/sha1'
 
-require "acts_as_taggable_on/acts_as_taggable_on"
-require "acts_as_taggable_on/acts_as_taggable_on/core"
-require "acts_as_taggable_on/acts_as_taggable_on/collection"
-require "acts_as_taggable_on/acts_as_taggable_on/cache"
-require "acts_as_taggable_on/acts_as_taggable_on/ownership"
-require "acts_as_taggable_on/acts_as_taggable_on/related"
+module ActsAsTaggableOn
+  extend ActiveSupport::Autoload
 
-require "acts_as_taggable_on/acts_as_tagger"
-require "acts_as_taggable_on/tag"
-require "acts_as_taggable_on/tag_list"
-require "acts_as_taggable_on/tags_helper"
-require "acts_as_taggable_on/tagging"
+  autoload :Tag
+  autoload :TagList
+  autoload :GenericParser
+  autoload :DefaultParser
+  autoload :TagListParser
+  autoload :Taggable
+  autoload :Tagger
+  autoload :Tagging
+  autoload :TagsHelper
+  autoload :VERSION
 
-$LOAD_PATH.shift
+  autoload_under 'taggable' do
+    autoload :Cache
+    autoload :Collection
+    autoload :Core
+    autoload :Dirty
+    autoload :Ownership
+    autoload :Related
+  end
 
-if defined?(ActiveRecord::Base)
-  ActiveRecord::Base.extend ActsAsTaggableOn::Taggable
-  ActiveRecord::Base.send :include, ActsAsTaggableOn::Tagger
+  autoload :Utils
+  autoload :Compatibility
+
+
+  class DuplicateTagError < StandardError
+  end
+
+  def self.setup
+    @configuration ||= Configuration.new
+    yield @configuration if block_given?
+  end
+
+  def self.method_missing(method_name, *args, &block)
+    @configuration.respond_to?(method_name) ?
+        @configuration.send(method_name, *args, &block) : super
+  end
+
+  def self.respond_to?(method_name, include_private=false)
+    @configuration.respond_to? method_name
+  end
+
+  def self.glue
+    setting = @configuration.delimiter
+    delimiter = setting.kind_of?(Array) ? setting[0] : setting
+    delimiter.ends_with?(' ') ? delimiter : "#{delimiter} "
+  end
+
+  class Configuration
+    attr_accessor :delimiter, :force_lowercase, :force_parameterize,
+                  :strict_case_match, :remove_unused_tags, :default_parser,
+                  :tags_counter
+
+    def initialize
+      @delimiter = ','
+      @force_lowercase = false
+      @force_parameterize = false
+      @strict_case_match = false
+      @remove_unused_tags = false
+      @tags_counter = true
+      @default_parser = DefaultParser
+      @force_binary_collation = false
+    end
+
+    def strict_case_match=(force_cs)
+      if @force_binary_collation == false
+        @strict_case_match = force_cs
+      end
+    end
+
+    def delimiter=(string)
+      ActiveRecord::Base.logger.warn <<WARNING
+ActsAsTaggableOn.delimiter is deprecated \
+and will be removed from v4.0+, use  \
+a ActsAsTaggableOn.default_parser instead
+WARNING
+      @delimiter = string
+    end
+
+    def force_binary_collation=(force_bin)
+      if Utils.using_mysql?
+        if force_bin == true
+          Configuration.apply_binary_collation(true)
+          @force_binary_collation = true
+          @strict_case_match = true
+        else
+          Configuration.apply_binary_collation(false)
+          @force_binary_collation = false
+        end
+      end
+    end
+
+    def self.apply_binary_collation(bincoll)
+      if Utils.using_mysql?
+        coll = 'utf8_general_ci'
+        if bincoll == true
+          coll = 'utf8_bin'
+        end
+        ActiveRecord::Migration.execute("ALTER TABLE tags MODIFY name varchar(255) CHARACTER SET utf8 COLLATE #{coll};")
+      end
+    end
+
+  end
+
+  setup
 end
 
-if defined?(ActionView::Base)
-  ActionView::Base.send :include, TagsHelper
-end
+ActiveSupport.on_load(:active_record) do
+  extend ActsAsTaggableOn::Compatibility
+  extend ActsAsTaggableOn::Taggable
+  include ActsAsTaggableOn::Tagger
+end
+ActiveSupport.on_load(:action_view) do
+  include ActsAsTaggableOn::TagsHelper
+end

data/lib/acts_as_taggable_on/compatibility.rb

@@ -0,0 +1,35 @@
+module ActsAsTaggableOn::Compatibility
+  def has_many_with_taggable_compatibility(name, options = {}, &extention)
+    if ActsAsTaggableOn::Utils.active_record4?
+      scope, opts = build_taggable_scope_and_options(options)
+      has_many(name, scope, opts, &extention)
+    else
+      has_many(name, options, &extention)
+    end
+  end
+
+  def build_taggable_scope_and_options(opts)
+    scope_opts, opts = parse_taggable_options(opts)
+
+    unless scope_opts.empty?
+      scope = -> {
+        scope_opts.inject(self) { |result, hash| result.send(*hash) }
+      }
+      return [scope, opts]
+    end
+
+    [nil, opts]
+  end
+
+  def parse_taggable_options(opts)
+    scope_opts = {}
+    [:order, :having, :select, :group, :limit, :offset, :readonly].each do |o|
+      scope_opts[o] = opts.delete o if opts[o]
+    end
+    scope_opts[:where] = opts.delete :conditions if opts[:conditions]
+    scope_opts[:joins] = opts.delete :include if opts [:include]
+    scope_opts[:distinct] = opts.delete :uniq if opts[:uniq]
+
+    [scope_opts, opts]
+  end
+end

data/lib/acts_as_taggable_on/default_parser.rb

@@ -0,0 +1,79 @@
+module ActsAsTaggableOn
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  #   tag_list = ActsAsTaggableOn::DefaultParser.parse("One , Two,  Three")
+  #   tag_list # ["One", "Two", "Three"]
+  class DefaultParser < GenericParser
+
+    def parse
+      string = @tag_list
+
+      string = string.join(ActsAsTaggableOn.glue) if string.respond_to?(:join)
+      TagList.new.tap do |tag_list|
+        string = string.to_s.dup
+
+        string.gsub!(double_quote_pattern) {
+          # Append the matched tag to the tag list
+          tag_list << Regexp.last_match[2]
+          # Return the matched delimiter ($3) to replace the matched items
+          ''
+        }
+
+        string.gsub!(single_quote_pattern) {
+          # Append the matched tag ($2) to the tag list
+          tag_list << Regexp.last_match[2]
+          # Return an empty string to replace the matched items
+          ''
+        }
+
+        # split the string by the delimiter
+        # and add to the tag_list
+        tag_list.add(string.split(Regexp.new delimiter))
+      end
+    end
+
+
+    # private
+    def delimiter
+      # Parse the quoted tags
+      d = ActsAsTaggableOn.delimiter
+      # Separate multiple delimiters by bitwise operator
+      d = d.join('|') if d.kind_of?(Array)
+      d
+    end
+
+    # (             # Tag start delimiter ($1)
+    # \A       |  # Either string start or
+    # #{delimiter}        # a delimiter
+    # )
+    # \s*"          # quote (") optionally preceded by whitespace
+    # (.*?)         # Tag ($2)
+    # "\s*          # quote (") optionally followed by whitespace
+    # (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
+    # #{delimiter}\s*  |  # Either a delimiter optionally followed by whitespace or
+    # \z          # string end
+    # )
+    def double_quote_pattern
+      /(\A|#{delimiter})\s*"(.*?)"\s*(?=#{delimiter}\s*|\z)/
+    end
+
+    # (             # Tag start delimiter ($1)
+    # \A       |  # Either string start or
+    # #{delimiter}        # a delimiter
+    # )
+    # \s*'          # quote (') optionally preceded by whitespace
+    # (.*?)         # Tag ($2)
+    # '\s*          # quote (') optionally followed by whitespace
+    # (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
+    # #{delimiter}\s*  | d # Either a delimiter optionally followed by whitespace or
+    # \z          # string end
+    # )
+    def single_quote_pattern
+      /(\A|#{delimiter})\s*'(.*?)'\s*(?=#{delimiter}\s*|\z)/
+    end
+
+  end
+
+end

data/lib/acts_as_taggable_on/engine.rb

@@ -0,0 +1,5 @@
+require 'rails/engine'
+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

@@ -1,65 +1,141 @@
-class Tag < ActiveRecord::Base
-  include ActsAsTaggableOn::ActiveRecord::Backports if ActiveRecord::VERSION::MAJOR < 3
-  
-  attr_accessible :name
+# encoding: utf-8
+module ActsAsTaggableOn
+  class Tag < ::ActiveRecord::Base
 
-  ### ASSOCIATIONS:
+    attr_accessible :name if defined?(ActiveModel::MassAssignmentSecurity)
 
-  has_many :taggings, :dependent => :destroy
-
-  ### VALIDATIONS:
-
-  validates_presence_of :name
-  validates_uniqueness_of :name
-
-  ### SCOPES:
-
-  def self.named(name)
-    where(["name LIKE ?", name])
-  end
-  
-  def self.named_any(list)
-    where(list.map { |tag| sanitize_sql(["name LIKE ?", tag.to_s]) }.join(" OR "))
-  end
-  
-  def self.named_like(name)
-    where(["name LIKE ?", "%#{name}%"])
-  end
-
-  def self.named_like_any(list)
-    where(list.map { |tag| sanitize_sql(["name LIKE ?", "%#{tag.to_s}%"]) }.join(" OR "))
-  end
-
-  ### CLASS METHODS:
-
-  def self.find_or_create_with_like_by_name(name)
-    named_like(name).first || create(:name => name)
-  end
-
-  def self.find_or_create_all_with_like_by_name(*list)
-    list = [list].flatten
-
-    return [] if list.empty?
-
-    existing_tags = Tag.named_any(list).all
-    new_tag_names = list.reject { |name| existing_tags.any? { |tag| tag.name.downcase == name.downcase } }
-    created_tags  = new_tag_names.map { |name| Tag.create(:name => name) }
-
-    existing_tags + created_tags
-  end
-
-  ### INSTANCE METHODS:
-
-  def ==(object)
-    super || (object.is_a?(Tag) && name == object.name)
-  end
-
-  def to_s
-    name
+    ### ASSOCIATIONS:
+
+    has_many :taggings, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'
+
+    ### VALIDATIONS:
+
+    validates_presence_of :name
+    validates_uniqueness_of :name, if: :validates_name_uniqueness?
+    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
+
+    ### 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|
+        comparable_tag_name = comparable_name(tag_name)
+        existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
+        begin
+          existing_tag || create(name: tag_name)
+        rescue ActiveRecord::RecordNotUnique
+          # Postgres aborts the current transaction with
+          # PG::InFailedSqlTransaction: ERROR:  current transaction is aborted, commands ignored until end of transaction block
+          # so we have to rollback this transaction
+          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 unicode_downcase(string)
+        if ActiveSupport::Multibyte::Unicode.respond_to?(:downcase)
+          ActiveSupport::Multibyte::Unicode.downcase(string)
+        else
+          ActiveSupport::Multibyte::Chars.new(string).downcase.to_s
+        end
+      end
+
+      def as_8bit_ascii(string)
+        if defined?(Encoding)
+          string.to_s.dup.force_encoding('BINARY')
+        else
+          string.to_s.mb_chars
+        end
+      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
-
-  def count
-    read_attribute(:count).to_i
-  end
-
 end