acts-as-taggable-on-mongoid 6.0.1.1

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/acts-as-taggable-on-mongoid.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "acts_as_taggable_on_mongoid/version"
+
+Gem::Specification.new do |spec|
+  spec.name    = "acts-as-taggable-on-mongoid"
+  spec.version = ActsAsTaggableOnMongoid::VERSION
+  spec.authors = ["RealNobody"]
+  spec.email   = ["admin@cardtapp.com"]
+
+  spec.summary     = "A partial mongoid implementation of tagging based on/inspired by acts-as-taggable-on."
+  spec.description = "A partial mongoid implementation of tagging based on/inspired by acts-as-taggable-on."
+  spec.homepage    = "http://www.cardtapp.com"
+  spec.license     = "MIT"
+
+  # # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "http://RubyGems.org"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 4.2"
+  spec.add_dependency "mongoid", "~> 5.2"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "codecov", "~> 0.1", "~> 0.1.0"
+  spec.add_development_dependency "cornucopia"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "pronto"
+  spec.add_development_dependency "pronto-brakeman"
+  spec.add_development_dependency "pronto-circleci"
+  spec.add_development_dependency "pronto-fasterer"
+  spec.add_development_dependency "pronto-rails_best_practices"
+  spec.add_development_dependency "pronto-reek"
+  spec.add_development_dependency "pronto-rubocop"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-rcov"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "acts-as-taggable-on-mongoid"
+
+# 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/codecov.yml

@@ -0,0 +1,3 @@
+codecov:
+  ci:
+    - CircleCI

data/config/pronto-circleci.yml

@@ -0,0 +1,7 @@
+github:
+  org: "CardTapp"
+  repo: "acts-as-taggable-on-mongoid"
+pronto:
+  comments_on_diff: true
+  reviews_on_diff: true
+  report_status: true

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "acts_as_taggable_on_mongoid/version"
+
+# The base module for the gem under which all classes are namespaced.
+module ActsAsTaggableOnMongoid
+  extend ::ActiveSupport::Autoload
+
+  # rubocop:disable Metrics/BlockLength
+
+  eager_autoload do
+    autoload :Configuration
+    autoload :TagList
+    autoload :GenericParser
+    autoload :DefaultParser
+    # autoload :TagsHelper
+
+    autoload_under "taggable/tag_type_definition" do
+      autoload :Attributes
+      autoload "Changeable"
+      autoload :Names
+    end
+
+    autoload_under "taggable/utils" do
+      autoload :TagListDiff
+    end
+
+    autoload_under :Taggable do
+      #   autoload :Cache
+      #   autoload :Collection
+      autoload :Core
+      autoload :Changeable
+      autoload :TagTypeDefinition
+      autoload :ListTags
+      #   autoload :Ownership
+      #   autoload :Related
+    end
+
+    autoload :Taggable
+
+    autoload_under :Models do
+      autoload :Tag
+      autoload :Tagging
+      # autoload :Tagger
+    end
+
+    autoload_under :Errors do
+      autoload :DuplicateTagError
+    end
+
+    # autoload :Utils
+    # autoload :Compatibility
+  end
+
+  # rubocop:enable Metrics/BlockLength
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  # :reek:ManualDispatch
+  def self.method_missing(method_name, *args, &block)
+    configuration.respond_to?(method_name) ? configuration.public_send(method_name, *args, &block) : super
+  end
+
+  # :reek:BooleanParameter
+  # :reek:ManualDispatch
+  def self.respond_to_missing?(method_name, _include_private = false)
+    configuration.respond_to?(method_name) || super
+  end
+end
+
+::ActiveSupport.on_load(:mongoid) do
+  include ActsAsTaggableOnMongoid::Taggable
+  # include ActsAsTaggableOn::Tagger
+end

data/lib/acts_as_taggable_on_mongoid/configuration.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  # A configuration class for the ActsAsTaggableOnMongoid gem.
+  #
+  # These global configurations are default configuration settings for the gem and will drive individual
+  # tag definitions if the tag does not specify a different value when the tag is defined/added to a model.
+  #
+  # The configuration options are:
+  #   * force_lowercase     - If set, values stored into the tags and taggings table will be downcased before being saved.
+  #                           this allows for case-insensitive comparisons of values in the database.
+  #
+  #                           Because Mongo does not support methods on database calls like SQL does, the strict_case_match
+  #                           option from ActsAsTaggableOn is not supported.  All comparisons are done case sensitive.
+  #   * force_parameterize  - If set, values stored into the tags and taggings table will be parameterized before being saved.
+  #   * remove_unused_tags  - If set when a Tagging is destroyed, the correlated Tag will also be destroyed if there are no
+  #                           other Taggings associated with that Tag.
+  #   * default_parser      - The parser class to be used to convert strings to arrays of values and to convert arrays of
+  #                           values back to strings.  See GenericParser for details on creating your own parser.
+  #   * tags_table          - The model class to be used to store Tag objects.
+  #                           Custom classes can be used if you wish to store Tags in different tables for some tags if desired,
+  #                           but it is expected that the Tags table will have equivalent fields, scopes and methods as the
+  #                           ActsAsTaggableOn::Models::Tag class.  In most cases, you can derive from the Tag class and simply
+  #                           override the relations or methods to achieve any differences you want/need.
+  #   * taggings_table      - The model class to be used to store Tagging objects.
+  #                           Custom classes can be used if you wish to store Taggings in different tables for some tags if desired,
+  #                           but it is expected that the Taggings table will have equivalent fields, scopes and methods as the
+  #                           ActsAsTaggableOn::Models::Tagging class.  In most cases, you can derive from the Tagging class and simply
+  #                           override the relations or methods to achieve any differences you want/need.
+  #
+  # Unsupported configurations:
+  #   * strict_case_match - This is not supported.  Use the `forc_lowercase` option to achieve case insensitive data storage and
+  #                         comparisons.
+  #   * tags_counter      - This is defined in the Tags and Taggings models, and is not configured through the configuration
+  #                         nor tag defnitions.
+  #
+  #                         See spec tests for examples in creating your own Tag or Tagging models to customize this behavior.
+
+  # :reek:UtilityFunction
+  # :reek:Attribute
+  # :reek:TooManyInstanceVariables
+  class Configuration
+    attr_accessor :force_lowercase,
+                  :force_parameterize,
+                  :remove_unused_tags,
+                  :default_parser,
+                  :tags_table,
+                  :taggings_table,
+                  :preserve_tag_order
+
+    # For duck compatibility with ActsAsTaggableOn.  Do not use.
+    def tags_counter
+      Mongoid.logger.warn "tags_counter is not supported."
+      nil
+    end
+
+    def strict_case_match
+      Mongoid.logger.warn "strict_case_match= is not supported."
+      nil
+    end
+
+    # rubocop:disable Lint/Void
+
+    def tags_counter=(_value)
+      Mongoid.logger.warn "tags_counter is not supported."
+      nil
+    end
+
+    def strict_case_match=(_value)
+      Mongoid.logger.warn "strict_case_match= is not supported."
+      nil
+    end
+
+    # rubocop:enable Lint/Void
+
+    alias force_lowercase? force_lowercase
+    alias force_parameterize? force_parameterize
+    alias preserve_tag_order? preserve_tag_order
+    alias remove_unused_tags? remove_unused_tags
+    alias strict_case_match? strict_case_match
+    alias tags_counter? tags_counter
+
+    def initialize
+      @force_lowercase    = false
+      @force_parameterize = false
+      @preserve_tag_order = false
+      @remove_unused_tags = false
+      @tags_counter       = true
+      @default_parser     = ActsAsTaggableOnMongoid::DefaultParser
+      @tags_table         = ActsAsTaggableOnMongoid::Models::Tag
+      @taggings_table     = ActsAsTaggableOnMongoid::Models::Tagging
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/default_parser.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  ##
+  # Returns a new Array using the given tag string.
+  #
+  # Parsing is done based on an array of delimiters that is set at the class level.  Parsing will split
+  # on any delimiter value that is found.  By default strings are split by commas (,).
+  #
+  # To allow more complex strings, parsing will parse out quoted strings (either single or double quoted)as a block.
+  # (This is only partially implemented for quick not accurate/complete implementation that is
+  # "good enough" for most expected tags.)
+  #
+  # examples:
+  #
+  # # Delimiters
+  # # You can set the delimiters to a single value:
+  # DefaultParser.delimiter = "\\|"
+  #
+  # # You can set the delimiters to an array value:
+  # DefaultParser.delimiter = %w[\\| , break_here]
+  #
+  # # Parsing a string by multiple delimters
+  # DefaultParser.new("a|stupid,stringbreak_hereparses").parse
+  # # > ["a", "stupid", "string", "parses"]
+  #
+  # # Parsing works with simple quoted strings:
+  # DefaultParser.new("a,\"more,interesting\",string").parse
+  # # > ["a", "more,interesting", "string"]
+  class DefaultParser < GenericParser
+    class_attribute :delimiter
+
+    def parse
+      @tags = [].tap do |tag_list|
+        tags.each do |tag|
+          string = tag.to_s.dup
+
+          extract_quoted_strings(string, tag_list, double_quote_pattern)
+          extract_quoted_strings(string, tag_list, single_quote_pattern)
+
+          # split the string by the delimiter
+          # and add to the tag_list
+          tag_list.concat(string.split(delimiter_regex))
+        end
+      end.flatten
+    end
+
+    def to_s
+      tag_list = tags.frozen? ? tags.dup : tags
+
+      join_delimiter = ActsAsTaggableOnMongoid::DefaultParser.delimiters.first
+
+      tag_list.map do |name|
+        name.index(escape_regex) ? "\"#{name}\"" : name
+      end.join(join_delimiter)
+    end
+
+    def self.delimiters
+      Array.wrap(delimiter.presence || DEFAULT_DELIMITER)
+    end
+
+    private
+
+    def escape_regex
+      @escape_regex ||= Regexp.new((Array.wrap(ActsAsTaggableOnMongoid::DefaultParser.delimiters) + %w[" ']).join("|"))
+    end
+
+    # :reek:UtilityFunction
+    def extract_quoted_strings(string, tag_list, quote_pattern)
+      string.gsub!(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
+    end
+
+    def delimiter
+      # Parse the quoted tags
+      delimiter_list = self.class.delimiters
+      # Separate multiple delimiters by bitwise operator
+      delimiter_list = delimiter_list.join("|") if delimiter_list.is_a?(Array)
+      delimiter_list
+    end
+
+    def delimiter_regex
+      Regexp.new(delimiter)
+    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*  | delimiter_list # 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_mongoid/errors/duplicate_tag_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Errors
+    # Error raised if a Tag already exists but cannot be found appropriately when trying to create new tags.
+    class DuplicateTagError < StandardError
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/generic_parser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  ##
+  # Returns a new list of tags (array of strings) using the given tag string.
+  #
+  # Example:
+  # tag_list = ActsAsTaggableOn::GenericParser.new.parse("One , Two, Three")
+  # tag_list # ["One ", " Two", " Three"]
+  #
+  # All parsers are required to support two methods:
+  #   * parse - parse the tag_list into an array of strings
+  #   * to_s - return a parsed array of tags (may be passed in parsed) in a format that
+  #            is suitable for parsing.
+  #
+  #            NOTE:  The ablitity to parse a list of tags and convert it to a string then back to
+  #                   the same list of tags is dependent on the complexity of the parser.  This is
+  #                   not actually assumed to be true, though it is best if it is.
+  #
+  # Cleansing the list of tags for the tag is the responsibility of the tags TagList which knows
+  # if the tags need to be stripped, downcased, etc.  The parser need only return an array of
+  # strings that are split out.
+  class GenericParser
+    attr_reader :tags
+
+    DEFAULT_DELIMITER = ","
+
+    def initialize(*tag_list)
+      @tags = tag_list.flatten
+    end
+
+    def parse
+      @tags = [].tap do |tag_list|
+        tags.each do |tag|
+          tag_list.concat tag.split(DEFAULT_DELIMITER).map(&:strip).reject(&:empty?)
+        end
+      end.flatten
+    end
+
+    def to_s
+      tags.join(DEFAULT_DELIMITER)
+    end
+  end
+end