make_taggable 0.6.3

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "make_taggable"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/db/migrate/1_create_make_taggable_tags.rb

@@ -0,0 +1,10 @@
+class CreateMakeTaggableTags < ActiveRecord::Migration[5.2]
+  def change
+    create_table MakeTaggable.tags_table do |t|
+      t.string :name
+      t.integer :taggings_count, default: 0
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/2_create_make_taggable_taggings.rb

@@ -0,0 +1,12 @@
+class CreateMakeTaggableTaggings < ActiveRecord::Migration[5.2]
+  def change
+    create_table MakeTaggable.taggings_table do |t|
+      t.references :tag, foreign_key: {to_table: MakeTaggable.tags_table}
+      t.references :taggable, polymorphic: true
+      t.references :tagger, polymorphic: true
+      t.string :context, limit: 128
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/3_add_index_to_tags.rb

@@ -0,0 +1,5 @@
+class AddIndexToTags < ActiveRecord::Migration[5.2]
+  def change
+    add_index MakeTaggable.tags_table, :name, unique: true
+  end
+end

data/db/migrate/4_add_index_to_taggings.rb

@@ -0,0 +1,12 @@
+class AddIndexToTaggings < ActiveRecord::Migration[5.2]
+  def change
+    add_index MakeTaggable.taggings_table, :taggable_id
+    add_index MakeTaggable.taggings_table, :tagger_id
+    add_index MakeTaggable.taggings_table, :taggable_type
+    add_index MakeTaggable.taggings_table, :context
+    add_index MakeTaggable.taggings_table, [:tagger_id, :tagger_type]
+    add_index MakeTaggable.taggings_table, [:tag_id, :taggable_id, :taggable_type, :context, :tagger_id, :tagger_type], unique: true, name: "taggings_idx"
+    add_index MakeTaggable.taggings_table, [:taggable_id, :taggable_type, :context], name: "taggings_taggable_context_idx"
+    add_index MakeTaggable.taggings_table, [:taggable_id, :taggable_type, :tagger_id, :context], name: "taggings_idy"
+  end
+end

data/gemfiles/rails_5.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "byebug", group: [:development, :test]
+gem "listen", group: [:development, :test]
+gem "rails", "~> 5.2.0"
+
+gemspec path: "../"

data/gemfiles/rails_6.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "byebug", group: [:development, :test]
+gem "listen", group: [:development, :test]
+gem "rails", "~> 6.0.0"
+
+gemspec path: "../"

data/gemfiles/rails_master.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "byebug", group: [:development, :test]
+gem "listen", group: [:development, :test]
+gem "rails", git: "https://github.com/rails/rails.git"
+
+gemspec path: "../"

data/lib/make_taggable.rb

@@ -0,0 +1,134 @@
+require "make_taggable/version"
+require "active_record"
+require "active_record/version"
+require "active_support/core_ext/module"
+
+begin
+  require "rails/engine"
+  require "make_taggable/engine"
+rescue LoadError
+end
+
+require "digest/sha1"
+
+module MakeTaggable
+  extend ActiveSupport::Autoload
+
+  autoload :Tag
+  autoload :TagList
+  autoload :GenericParser
+  autoload :DefaultParser
+  autoload :Taggable
+  autoload :Tagger
+  autoload :Tagging
+  autoload :TagsHelper
+  autoload :VERSION
+
+  autoload_under "taggable" do
+    autoload :Cache
+    autoload :Collection
+    autoload :Core
+    autoload :Dirty
+    autoload :Ownership
+    autoload :Related
+    autoload :TagListType
+  end
+
+  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)
+    if @configuration.respond_to?(method_name)
+      @configuration.send(method_name, *args, &block)
+    else
+      super
+    end
+  end
+
+  def self.respond_to_missing?(method_name, include_private = false)
+    @configuration.respond_to? method_name
+  end
+
+  def self.glue
+    setting = @configuration.delimiter
+    delimiter = setting.is_a?(Array) ? setting[0] : setting
+    delimiter.ends_with?(" ") ? delimiter : "#{delimiter} "
+  end
+
+  class Configuration
+    attr_accessor :force_lowercase, :force_parameterize,
+      :remove_unused_tags, :default_parser,
+      :tags_counter, :tags_table,
+      :taggings_table
+    attr_reader :delimiter, :strict_case_match
+
+    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
+      @tags_table = :tags
+      @taggings_table = :taggings
+    end
+
+    def strict_case_match=(force_cs)
+      @strict_case_match = force_cs unless @force_binary_collation
+    end
+
+    def delimiter=(string)
+      ActiveRecord::Base.logger.warn <<~WARNING
+        MakeTaggable.delimiter is deprecated \
+        and will be removed from v4.0+, use  \
+        a MakeTaggable.default_parser instead
+      WARNING
+      @delimiter = string
+    end
+
+    def force_binary_collation=(force_bin)
+      if Utils.using_mysql?
+        if force_bin
+          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"
+        coll = "utf8_bin" if bincoll
+        begin
+          ActiveRecord::Migration.execute("ALTER TABLE #{Tag.table_name} MODIFY name varchar(255) CHARACTER SET utf8 COLLATE #{coll};")
+        rescue => e
+          puts "Trapping #{e.class}: collation parameter ignored while migrating for the first time."
+        end
+      end
+    end
+  end
+  setup
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend MakeTaggable::Taggable
+  include MakeTaggable::Tagger
+end
+
+ActiveSupport.on_load(:action_view) do
+  include MakeTaggable::TagsHelper
+end

data/lib/make_taggable/default_parser.rb

@@ -0,0 +1,75 @@
+module MakeTaggable
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  #   tag_list = MakeTaggable::DefaultParser.parse("One , Two,  Three")
+  #   tag_list # ["One", "Two", "Three"]
+  class DefaultParser < GenericParser
+    def parse
+      string = @tag_list
+
+      string = string.join(MakeTaggable.glue) if string.respond_to?(:join)
+      TagList.new.tap do |tag_list|
+        string = string.to_s.dup
+
+        string.gsub!(double_quote_pattern) do
+          # Append the matched tag to the tag list
+          tag_list << Regexp.last_match[2]
+          # Return the matched delimiter ($3) to replace the matched items
+          ""
+        end
+
+        string.gsub!(single_quote_pattern) do
+          # Append the matched tag ($2) to the tag list
+          tag_list << Regexp.last_match[2]
+          # Return an empty string to replace the matched items
+          ""
+        end
+
+        # 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 = MakeTaggable.delimiter
+      # Separate multiple delimiters by bitwise operator
+      d = d.join("|") if d.is_a?(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/make_taggable/engine.rb

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

data/lib/make_taggable/generic_parser.rb

@@ -0,0 +1,19 @@
+module MakeTaggable
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  # tag_list = MakeTaggable::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/make_taggable/tag.rb

@@ -0,0 +1,131 @@
+module MakeTaggable
+  class Tag < ::ActiveRecord::Base
+    self.table_name = MakeTaggable.tags_table
+
+    ### ASSOCIATIONS:
+    has_many :taggings, dependent: :destroy, class_name: "::MakeTaggable::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 MakeTaggable.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 #{MakeTaggable::Utils.like_operator} ? ESCAPE '!'", "%#{MakeTaggable::Utils.escape_like(name)}%"]
+      where(clause)
+    end
+
+    def self.named_like_any(list)
+      clause = list.map { |tag|
+        sanitize_sql(["name #{MakeTaggable::Utils.like_operator} ? ESCAPE '!'", "%#{MakeTaggable::Utils.escape_like(tag.to_s)}%"])
+      }.join(" OR ")
+      where(clause)
+    end
+
+    def self.for_context(context)
+      joins(:taggings)
+        .where(["#{MakeTaggable.taggings_table}.context = ?", context])
+        .select("DISTINCT #{MakeTaggable.tags_table}.*")
+    end
+
+    ### CLASS METHODS:
+    def self.find_or_create_with_like_by_name(name)
+      if MakeTaggable.strict_case_match
+        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|
+        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
+
+    ### INSTANCE METHODS:
+    def ==(other)
+      super || (other.is_a?(Tag) && name == other.name)
+    end
+
+    def to_s
+      name
+    end
+
+    def count
+      read_attribute(:count).to_i
+    end
+
+    class << self
+      private
+
+      def comparable_name(str)
+        if MakeTaggable.strict_case_match
+          str
+        else
+          unicode_downcase(str.to_s)
+        end
+      end
+
+      def binary
+        MakeTaggable::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 MakeTaggable.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