acts-as-taggable-on-mongoid 6.0.1.1 → 6.0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f6ce2d51035fb3fb89a0fb231fed320cf3e2cad
-  data.tar.gz: 97b5143f687988711ee7899914bd34524ead070c
+  metadata.gz: 8d93a7c1beb5fbe71abb708118e35b734203691f
+  data.tar.gz: 6ae2ad0b0060b5265c879338aa26d4684d551a26
 SHA512:
-  metadata.gz: 1a2f8d3abef2f906dc49195efb0220f3bc90edd0f10ff35296efaf365f113bbad7f0533bf14506b883a7b327a4d627b2169af6078df91402bbdcfa8c4b67409a
-  data.tar.gz: e26e1cc6db0bc21dc6341362e6789621410f651a61feb6e2ee34fe9550041ad8cf568ffd230e953f2dc03369d779d3300e04931717334fccd4e4a9d6ab515289
+  metadata.gz: e5ac3c342c801316fb57ace4fc70f143db77c1204ace3cc3ee7a192de608e64dd5d2737afa9bd6284a355719dda04d34d474105410ee3b07947df895d61de2cb
+  data.tar.gz: 13f2f14dd4cda732d427f4e0c71f3eaf8efacbaa9a8bc74417fbf7ad68edb1a0b9e72523ee9d3e26552682d9ed7c1045f63548e0b790384c658e03d9c8267658

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acts-as-taggable-on-mongoid (6.0.1.1)
+    acts-as-taggable-on-mongoid (6.0.1.2)
       activesupport (~> 4.2)
       mongoid (~> 5.2)
 
@@ -165,6 +165,7 @@ GEM
       unicode-display_width (~> 1.1, >= 1.1.1)
     thor (0.19.4)
     thread_safe (0.3.6)
+    timecop (0.9.1)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
     unicode-display_width (1.4.0)
@@ -198,6 +199,7 @@ DEPENDENCIES
   rubocop
   simplecov
   simplecov-rcov
+  timecop
 
 BUNDLED WITH
    1.16.4

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

@@ -51,4 +51,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "simplecov-rcov"
+  spec.add_development_dependency "timecop"
 end

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

@@ -25,6 +25,14 @@ module ActsAsTaggableOnMongoid
       autoload :TagListDiff
     end
 
+    autoload_under "taggable/tagged_with_query" do
+      autoload :Base
+      autoload :AllTagsQuery
+      autoload :AnyTagsQuery
+      autoload :ExcludeTagsQuery
+      autoload :MatchAllTagsQuery
+    end
+
     autoload_under :Taggable do
       #   autoload :Cache
       #   autoload :Collection
@@ -32,6 +40,8 @@ module ActsAsTaggableOnMongoid
       autoload :Changeable
       autoload :TagTypeDefinition
       autoload :ListTags
+      autoload :TaggedWith
+      autoload :TaggedWithQuery
       #   autoload :Ownership
       #   autoload :Related
     end

data/lib/acts_as_taggable_on_mongoid/tag_list.rb

@@ -46,7 +46,7 @@ module ActsAsTaggableOnMongoid
     #   tag_list.add("Fun", "Happy")
     #   tag_list.add("Fun, Happy", :parse => true)
     def add(*names)
-      extract_and_apply_options!(names)
+      names = extract_and_apply_options!(names)
       concat(names)
       clean!
 
@@ -154,16 +154,18 @@ module ActsAsTaggableOnMongoid
     # :reek:FeatureEnvy
     # :reek:DuplicateMethodCall
     def extract_and_apply_options!(args)
-      options = args.extract_options!
+      dup_args = args.dup
+      options  = dup_args.extract_options!.dup
       options.assert_valid_keys :parse, :parser
 
       options_parser = options[:parser]
       run_parser     = options_parser || tag_definition.parser
 
-      args.flatten!
-      args.map! { |argument| run_parser.new(argument).parse } if options[:parse] || options_parser
+      dup_args.flatten!
+      dup_args.map! { |argument| run_parser.new(argument).parse } if options[:parse] || options_parser
 
-      args.flatten!
+      dup_args.flatten!
+      dup_args
     end
   end
 end

data/lib/acts_as_taggable_on_mongoid/taggable.rb

@@ -83,9 +83,10 @@ module ActsAsTaggableOnMongoid
       #     acts_as_ordered_taggable_on :languages, :skills
       #   end
       def acts_as_ordered_taggable_on(*tag_types)
-        options = tag_types.extract_options!
+        dup_tag_types = tag_types.dup
+        options       = dup_tag_types.extract_options!.dup
 
-        taggable_on(*tag_types, options.merge(preserve_tag_order: true))
+        taggable_on(*dup_tag_types, options.merge(preserve_tag_order: true))
       end
 
       private
@@ -107,6 +108,7 @@ module ActsAsTaggableOnMongoid
         # and add hooks/callbacks that aren't needed without tags.
         [ActsAsTaggableOnMongoid::Taggable::Core,
          ActsAsTaggableOnMongoid::Taggable::Changeable,
+         ActsAsTaggableOnMongoid::Taggable::TaggedWith,
          # include Collection - not sure we will need as done here.  Need to think more on this one.
          # include Cache - TODO: Add this.
          # include Ownership - TODO: Add this.
@@ -115,10 +117,11 @@ module ActsAsTaggableOnMongoid
           include include_module unless included_modules.include?(include_module)
         end
 
-        options = tag_types.extract_options!
-        tag_types.flatten!
+        dup_tag_types = tag_types.dup
+        options       = dup_tag_types.extract_options!.dup
+        dup_tag_types.flatten!
 
-        tag_types.each do |tag_type|
+        dup_tag_types.each do |tag_type|
           next if tag_type.blank?
 
           define_tag tag_type, options

data/lib/acts_as_taggable_on_mongoid/taggable/core.rb

@@ -138,6 +138,7 @@ module ActsAsTaggableOnMongoid
           next if public_send(tag_list_name).present?
 
           public_send("#{tag_list_name}=", default)
+          changed_attributes.delete tag_list_name
         end
       end
 

data/lib/acts_as_taggable_on_mongoid/taggable/list_tags.rb

@@ -7,9 +7,17 @@ module ActsAsTaggableOnMongoid
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :tag_types
+        class_attribute :my_tag_types
 
-        self.tag_types ||= {}.with_indifferent_access
+        self.my_tag_types ||= {}.with_indifferent_access
+      end
+
+      def tag_types
+        klass = self.class
+
+        self.my_tag_types = klass.cleanup_tag_types(my_tag_types, klass)
+
+        my_tag_types
       end
 
       def tag_definition(tag_type)
@@ -19,6 +27,21 @@ module ActsAsTaggableOnMongoid
       end
 
       class_methods do
+        def tag_types
+          self.my_tag_types = cleanup_tag_types(my_tag_types, self)
+
+          my_tag_types
+        end
+
+        # :reek:UtilityFunction
+        def cleanup_tag_types(tag_types, klass)
+          return tag_types if tag_types.values.all? { |tag_definition| tag_definition.owner == klass }
+
+          tag_types.each_with_object({}.with_indifferent_access) do |(key, tag_definition), hash|
+            hash[key] = ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.copy_from(klass, tag_definition)
+          end
+        end
+
         # In order to allow dynamic tags, return a default tag_definition for any missing tag_type.
         # This means that any dynamic tag necessarily is created with the current defaults
         def define_tag(tag_type, options = {})
@@ -31,9 +54,9 @@ module ActsAsTaggableOnMongoid
           # tag_types is a class_attribute
           # As such, we have to replace it each time with a new array so that inherited classes and instances
           # are able to maintain separate lists if need be.
-          new_tag_types  = {}.with_indifferent_access.merge!(self.tag_types || {})
-          self.tag_types = new_tag_types
-          tag_definition = new_tag_types[tag_type] = ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.new(self, tag_type, options)
+          new_tag_types     = {}.with_indifferent_access.merge!(tag_types || {})
+          self.my_tag_types = new_tag_types
+          tag_definition    = new_tag_types[tag_type] = ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.new(self, tag_type, options)
 
           tag_definition.define_base_relations
           tag_definition.define_relations

data/lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition.rb

@@ -18,6 +18,8 @@ module ActsAsTaggableOnMongoid
       include ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition::Changeable
 
       def initialize(owner, tag_type, options = {})
+        options = options.dup
+
         options.assert_valid_keys(:parser,
                                   :preserve_tag_order,
                                   :cached_in_model,
@@ -30,15 +32,35 @@ module ActsAsTaggableOnMongoid
 
         self.default_value = options.delete(:default)
 
-        options.each do |key, value|
-          instance_variable_set("@#{key}", value)
-        end
+        save_options(options)
 
         @owner    = owner
         @tag_type = tag_type
       end
 
-      # rubocop:disable Layout/SpaceAroundOperators
+      def self.copy_from(klass, tag_definition)
+        dup_hash = %i[parser
+                      preserve_tag_order
+                      cached_in_model
+                      force_lowercase
+                      force_parameterize
+                      remove_unused_tags
+                      tags_table
+                      taggings_table].each_with_object({}) { |dup_key, opts_hash| opts_hash[dup_key] = tag_definition.public_send(dup_key) }
+
+        dup_hash[:default] = [tag_definition.default, parse: false]
+
+        ActsAsTaggableOnMongoid::Taggable::TagTypeDefinition.new klass,
+                                                                 tag_definition.tag_type,
+                                                                 dup_hash
+      end
+
+      def conflicts_with?(tag_definition)
+        %i[parser preserve_tag_order force_lowercase force_parameterize taggings_table].any? do |setting_name|
+          public_send(setting_name) != tag_definition.public_send(setting_name)
+        end
+      end
+
       # :reek:FeatureEnvy
 
       # I've defined the parser as being required to return an array of strings.
@@ -46,14 +68,13 @@ module ActsAsTaggableOnMongoid
       # to apply the rules to that list (like case sensitivity and parameterization, etc.) to get the final
       # list.
       def parse(*tag_list)
-        options          = tag_list.extract_options!
-        options[:parser] ||= parser if options.key?(:parse) || options.key?(:parser)
+        dup_tag_list     = tag_list.dup
+        options          = dup_tag_list.extract_options!.dup
+        options[:parser] ||= parser if options[:parse] || options.key?(:parser)
 
-        ActsAsTaggableOnMongoid::TagList.new(self, *tag_list, options)
+        ActsAsTaggableOnMongoid::TagList.new(self, *dup_tag_list, options)
       end
 
-      # rubocop:enable Layout/SpaceAroundOperators
-
       def taggings_order
         @taggings_order = if preserve_tag_order?
                             [:created_at.asc, :id.asc]
@@ -163,11 +184,11 @@ module ActsAsTaggableOnMongoid
 
         owner.taggable_mixin.module_eval do
           define_method("#{tag_definition.tag_list_name}=") do |new_tags|
-            new_tags        = Array.wrap(new_tags)
-            options         = new_tags.extract_options!
-            options[:parse] = true unless options.key?(:parse)
+            dup_tags        = Array.wrap(new_tags).dup
+            options         = dup_tags.extract_options!.dup
+            options[:parse] = options.fetch(:parse) { true }
 
-            new_list = tag_definition.parse(*new_tags, options)
+            new_list = tag_definition.parse(*dup_tags, options)
 
             mark_tag_list_changed(new_list)
             tag_list_set(new_list)
@@ -184,6 +205,14 @@ module ActsAsTaggableOnMongoid
           end
         end
       end
+
+      private
+
+      def save_options(options)
+        options.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
     end
   end
 end

data/lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition/attributes.rb

@@ -65,11 +65,11 @@ module ActsAsTaggableOnMongoid
         private
 
         def default_value=(value)
-          value           = Array.wrap(value)
-          options         = value.extract_options!
-          options[:parse] = true unless options.key?(:parse)
+          dup_value       = Array.wrap(value).dup
+          options         = dup_value.extract_options!.dup
+          options[:parse] = options.fetch(:parse) { true }
 
-          @default = ActsAsTaggableOnMongoid::TagList.new self, value, options
+          @default = ActsAsTaggableOnMongoid::TagList.new self, dup_value, options
         end
       end
     end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # Include methods and scopes to a Taggable class to allow searching for Taggable objects.
+    module TaggedWith
+      extend ActiveSupport::Concern
+
+      included do
+        ##
+        # Return a scope of objects that are tagged within the given context with the specified tags.
+        #
+        # @param tags The tags that we want to query for
+        # @param [Hash] options A hash of options to alter you query:
+        #                       * <tt>:on</tt> - The context to filter the query by. (default - all contexts)
+        #                                        To allow broader compatibility with `ActsAsTaggableOn`, context can be an array of values
+        #                                        for a set of tags that are equivalent enough (the parsing of the list is the same
+        #                                        and they use the same taggings table.)
+        #
+        #                                        If you are trying to find values for a tag that downcases and one that doesn't, the
+        #                                        code is unsure how to handle this and raises an exception.
+        #                       * <tt>:exclude</tt> - if set to true, return objects that are *NOT* tagged with the specified tags
+        #                       * <tt>:any</tt> - if set to true, return objects that are tagged with *ANY* of the specified tags
+        #                       * <tt>:match_all</tt> - if set to true, return objects that are tagged with *ONLY* the specified tags
+        #                       * <tt>:all</tt> - if set to true, return objects that are tagged with *ALL* of the specified tags
+        #                                         If none of :any, :eclude, or :all are set, :all is the default.
+        #                       * <tt>:start_at</tt> - Restrict the tags to those created on or after a certain time
+        #                       * <tt>:end_at</tt> - Restrict the tags to those created before a certain time
+        #                       * <tt>:wild</tt> - Match all passed in tags as a regex of /%tag%/
+        #                       * <tt>:parse</tt> - Indicates if the tags should be parsed or not.
+        #                       * <tt>:parser</tt> - The parser to be used to parse the tags.
+        #
+        #                 The following options are not currently supported yet:
+        #                       * <tt>:order_by_matching_tag_count</tt> - if set to true and used with :any, sort by objects matching the most tags,
+        #                                                                 descending
+        #                       * <tt>:owned_by</tt> - return objects that are *ONLY* owned by the owner
+        #                       * <tt>:order</tt> - Not supported because you cannot sort the results by
+        #                                           the taggings in this implementation and an order on the taggable
+        #                                           can easily be added by the consumer as needed.
+        #
+        # Example:
+        #   User.tagged_with("awesome", "cool", on: tags)                     # Users that are tagged with awesome and cool
+        #   User.tagged_with("awesome", "cool", on: tags, :exclude => true)   # Users that are not tagged with awesome or cool
+        #   User.tagged_with("awesome", "cool", on: tags, :any => true)       # Users that are tagged with awesome or cool
+        #   User.tagged_with("awesome", "cool", on: tags, :any => true, :order_by_matching_tag_count => true)  # Sort by users who match the most
+        #                                                                                                        tags, descending
+        #   User.tagged_with("awesome", "cool", on: tags, :match_all => true) # Users that are tagged with just awesome and cool
+        #   User.tagged_with("awesome", "cool", on: tags, :owned_by => foo ) # Users that are tagged with just awesome and cool by 'foo'
+        #   User.tagged_with("awesome", "cool", on: tags, :owned_by => foo, :start_at => Date.today ) # Users that are tagged with just awesome,
+        #                                                                                               cool by 'foo' and starting today
+
+        scope :tagged_with, (->(*tags) { where ::ActsAsTaggableOnMongoid::Taggable::TaggedWithQuery.new(self, *tags).build })
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    # A class finding all Taggable objects for the passed in tags based on the passed in parameters.
+    # Details for how the query will work are in the TaggedWith module.
+    class TaggedWithQuery
+      attr_reader :taggable_class,
+                  :tags,
+                  :options,
+                  :tag_definition
+
+      def initialize(taggable_class, *tags)
+        new_tags        = tags.dup
+        @taggable_class = taggable_class
+        @options        = new_tags.extract_options!.dup
+        @tags           = new_tags
+
+        cleanup_options
+
+        context         = on_context(*options[:on])
+        @tag_definition = taggable_class.tag_types[context]
+      end
+
+      def build
+        klass = if options[:exclude].present?
+                  ExcludeTagsQuery
+                elsif options[:any].present?
+                  AnyTagsQuery
+                elsif options[:match_all]
+                  MatchAllTagsQuery
+                else
+                  AllTagsQuery
+                end
+
+        klass.new(tag_definition, tag_list, options).build
+      end
+
+      private
+
+      def cleanup_options
+        options[:on]    = Array.wrap(options[:on] || options.delete(:context))
+        options[:parse] = options.fetch(:parse) { true } || options.key?(:parser)
+
+        validate_options
+      end
+
+      def validate_options
+        options.assert_valid_keys :parse,
+                                  :parser,
+                                  :wild,
+                                  :exclude,
+                                  :match_all,
+                                  :all,
+                                  :any,
+                                  :on,
+                                  :start_at,
+                                  :end_at
+      end
+
+      def on_context(*contexts)
+        test_contexts   = (contexts.presence || taggable_class.tag_types.keys).flatten
+        primary_context = test_contexts.first
+
+        test_contexts.each do |context|
+          raise "conflicting context definitions" if conflicting_context?(primary_context, context)
+        end
+
+        primary_context
+      end
+
+      # :reek:FeatureEnvy
+
+      def conflicting_context?(left, right)
+        return false if left == right
+
+        tag_types = taggable_class.tag_types
+
+        tag_types[left].conflicts_with? tag_types[right]
+      end
+
+      def tag_list
+        @tag_list ||= build_tag_list
+      end
+
+      def build_tag_list
+        return [] if tag_definition.blank?
+
+        tag_list = ActsAsTaggableOnMongoid::TagList.new(tag_definition, *tags, options.slice(:parse, :parser))
+        tag_list = tag_list.map { |tag| /#{tag}/ } if options[:wild]
+
+        tag_list
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/all_tags_query.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    class TaggedWithQuery
+      # A class finding all Taggable objects which include all of the passed in tags (may include other tags as well).
+      class AllTagsQuery < ActsAsTaggableOnMongoid::Taggable::TaggedWithQuery::Base
+        def build
+          { :id.in => included_ids }
+        end
+
+        def included_ids
+          selector         = Origin::Selector.new
+          selector[:count] = tag_list.count
+
+          build_ids_from(selector)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/any_tags_query.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    class TaggedWithQuery
+      # A class finding all Taggable objects which include any of the passed in tags.
+      class AnyTagsQuery < ActsAsTaggableOnMongoid::Taggable::TaggedWithQuery::Base
+        def build
+          { :id.in => included_ids }
+        end
+
+        def included_ids
+          selector         = Origin::Selector.new
+          selector[:count] = { "$gt" => 0 }
+
+          build_ids_from(selector)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/base.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    class TaggedWithQuery
+      # A base class with shared code for match queries.
+      class Base
+        attr_reader :taggable_model,
+                    :tag_definition,
+                    :tag_list,
+                    :options
+
+        def initialize(tag_definition, tag_list, options)
+          @tag_definition = tag_definition
+          @tag_list       = tag_list
+          @options        = options
+        end
+
+        private
+
+        # Any is relatively simple, but All and exclude are a bit more complicated.  To make the code simpler
+        # I'm treating all of them the same.
+        # We build an aggregation of all of the matching taggables whose key_name is in the list of tags with the
+        # count of the matching key names.  We then filter on that count.
+        #
+        # * All - count == tag_list count
+        # * Any - count > 0
+        # * Exclude - count > 0 (but anything that isn't in that count)
+        def build_ids_from(count_selector)
+          where_query = tagging_query.where(:tag_name.in => tag_list)
+          build_ids_from_query(where_query, count_selector)
+        end
+
+        def build_tagless_ids_from(count_selector)
+          build_ids_from_query(tagging_query, count_selector)
+        end
+
+        def build_ids_from_query(where_query, count_selector)
+          pipeline = where_query.
+              group(_id: { taggable_id: "$taggable_id", tag_name: "$tag_name" }).
+              group(_id: "$_id.taggable_id", :count.sum => 1).
+              pipeline.
+              concat(count_selector.to_pipeline)
+
+          tag_definition.taggings_table.collection.aggregate(pipeline).to_a.map { |counts| counts[:_id] }
+        end
+
+        def tagging_query
+          context       = options[:on]
+          tagging_query = tag_definition.taggings_table.where(taggable_type: tag_definition.owner.name)
+          tagging_query = tagging_query.where(:context.in => context) if context.present?
+
+          time_constraints tagging_query
+        end
+
+        def time_constraints(tagging_query)
+          start_at      = options[:start_at]
+          end_at        = options[:end_at]
+
+          tagging_query = tagging_query.where(:created_at.gte => start_at) if start_at.present?
+          tagging_query = tagging_query.where(:created_at.lt => end_at) if end_at.present?
+
+          tagging_query
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/exclude_tags_query.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    class TaggedWithQuery
+      # A class finding all Taggable objects which exclude all of the passed in tags.
+      class ExcludeTagsQuery < ActsAsTaggableOnMongoid::Taggable::TaggedWithQuery::Base
+        def build
+          { :id.in => included_ids }
+        end
+
+        def included_ids
+          selector         = Origin::Selector.new
+          selector[:count] = { "$gt" => 0 }
+
+          ids = build_ids_from(selector)
+          build_tagless_ids_from(selector) - ids
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/match_all_tags_query.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOnMongoid
+  module Taggable
+    class TaggedWithQuery
+      # A class finding all Taggable objects which include all and only all of the passed in tags.
+      class MatchAllTagsQuery < ActsAsTaggableOnMongoid::Taggable::TaggedWithQuery::Base
+        def build
+          { :id.in => included_ids }
+        end
+
+        def included_ids
+          selector         = Origin::Selector.new
+          selector[:count] = { "$ne" => tag_list.count }
+
+          AllTagsQuery.new(tag_definition, tag_list, options).included_ids -
+              build_tagless_ids_from(selector)
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_taggable_on_mongoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActsAsTaggableOnMongoid
-  VERSION = "6.0.1.1"
+  VERSION = "6.0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acts-as-taggable-on-mongoid
 version: !ruby/object:Gem::Version
-  version: 6.0.1.1
+  version: 6.0.1.2
 platform: ruby
 authors:
 - RealNobody
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-12 00:00:00.000000000 Z
+date: 2018-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -282,6 +282,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A partial mongoid implementation of tagging based on/inspired by acts-as-taggable-on.
 email:
 - admin@cardtapp.com
@@ -323,6 +337,13 @@ files:
 - lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition/attributes.rb
 - lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition/changeable.rb
 - lib/acts_as_taggable_on_mongoid/taggable/tag_type_definition/names.rb
+- lib/acts_as_taggable_on_mongoid/taggable/tagged_with.rb
+- lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query.rb
+- lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/all_tags_query.rb
+- lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/any_tags_query.rb
+- lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/base.rb
+- lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/exclude_tags_query.rb
+- lib/acts_as_taggable_on_mongoid/taggable/tagged_with_query/match_all_tags_query.rb
 - lib/acts_as_taggable_on_mongoid/taggable/utils/tag_list_diff.rb
 - lib/acts_as_taggable_on_mongoid/version.rb
 homepage: http://www.cardtapp.com