enumbler 0.4.1 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1e8239bdeb583c52ed7bfa0fd8b5fe0b707157a643964d4c4ed8ee135dd2766
-  data.tar.gz: 4835a99186e5afd7e991bf4398423b1485f90bf2bf5736b63741ff6a7340807c
+  metadata.gz: b196f7e09065d7f461c8f0c4ae87e25d849600dfa38840b2aba5b9f2d75c2d7b
+  data.tar.gz: f187980e2ba0a7b79dc9657c1469e205aa1e3efb7439190d2d5592d5df0851b9
 SHA512:
-  metadata.gz: ea2dac5af53985305dbb8eee459c0887a3e92b2a8eef292d8095e0eed5c3e6efd865f59523f2932a0273c583e90a290fc12bf1b6de274a3b862652d8d3ecb714
-  data.tar.gz: 8b799c83ce8d7304e6a257faaed2dfecd5c6bbb83ea9d1959d5065d6a9c2ba32bf8b389c0bd4d3212fffcb88fccc8dd800511da83dfae9f15f2f077812c2ce83
+  metadata.gz: 43c6e81c18303961b9e1ea530282f70fff80d76b57bf57eeef347f014a3bc6918d525748a0e0ea216bd4aed31579b9c133d43dd085a0cca42dbab4c19ab5f839
+  data.tar.gz: 96635852aa098120cc7a93e30d8e51c865e0be220ae73b93f06cca1af783feaa9776cb2295d02f5a3cfbc4abff6c2d1495c0b4951c9b06755f444a2db3cc931d

data/Gemfile.lock

@@ -1,27 +1,27 @@
 PATH
   remote: .
   specs:
-    enumbler (0.4.1)
-      activerecord (~> 6.0.2)
-      activesupport (~> 6.0.2)
+    enumbler (0.6.1)
+      activerecord (>= 5.2.3, < 6.1)
+      activesupport (>= 5.2.3, < 6.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.2.2)
-      activesupport (= 6.0.2.2)
-    activerecord (6.0.2.2)
-      activemodel (= 6.0.2.2)
-      activesupport (= 6.0.2.2)
-    activesupport (6.0.2.2)
+    activemodel (6.0.3.1)
+      activesupport (= 6.0.3.1)
+    activerecord (6.0.3.1)
+      activemodel (= 6.0.3.1)
+      activesupport (= 6.0.3.1)
+    activesupport (6.0.3.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
+      zeitwerk (~> 2.2, >= 2.2.2)
     ast (2.4.0)
     concurrent-ruby (1.1.6)
-    database_cleaner (1.8.4)
+    database_cleaner (1.8.5)
     database_cleaner-active_record (1.8.0)
       activerecord
       database_cleaner (~> 1.8.0)
@@ -32,9 +32,9 @@ GEM
     i18n (1.8.2)
       concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.4)
-    minitest (5.14.0)
+    minitest (5.14.1)
     parallel (1.19.1)
-    parser (2.7.1.0)
+    parser (2.7.1.3)
       ast (~> 2.4.0)
     rainbow (3.0.0)
     rake (12.3.3)
@@ -43,15 +43,15 @@ GEM
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
       rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.1)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
+    rspec-support (3.9.3)
     rubocop (0.81.0)
       jaro_winkler (~> 1.5.1)
       parallel (~> 1.10)

data/README.md

@@ -26,6 +26,7 @@ Suppose you have a `House` and you want to add some `colors` to the house.  You
 ActiveRecord::Schema.define do
   create_table :colors|t|
     t.string :label, null: false, index: { unique: true }
+    t.string :hex, null: true
   end
 
   create_table :houses|t|
@@ -42,8 +43,8 @@ end
 class Color < ApplicationRecord
   include Enumbler::Enabler
 
-  enumble :black, 1
-  enumble :white, 2
+  enumble :black, 1, hex: '000000'
+  enumble :white, 2, hex: 'ffffff'
   enumble :dark_brown, 3
   enumble :infinity, 4, label: 'Infinity - and beyond!'
 end
@@ -54,17 +55,45 @@ class House < ApplicationRecord
 end
 
 # This gives you some power:
-Color::BLACK           # => 1
-Color.black            # => equivalent to Color.find(1)
-Color.black.black?     # => true
-Color.black.is_black   # => true
-Color.white.not_black? # => true
+Color::BLACK               # => 1
+Color.black                # => equivalent to Color.find(1)
+Color.black.black?         # => true
+Color.black.is_black       # => true
+Color.white.not_black?     # => true
+
+# Get attributes without hitting the database
+Color.black(:id)           # => 1
+Color.black(:enum)         # => :black
+Color.black(:label)        # => 'black'
+Color.black(:graphql_enum) # => 'BLACK'
+
+# Get an Enumble object from an id, label, enum, or ActiveRecord model
+Color.find_enumbles(:black, 'white') # => [Enumbler::Enumble<:black>, Enumbler::Enumble<:white>]
+Color.find_enumbles(:black, 'does-not-exist') # => [Enumbler::Enumble<:black>, nil]
+
+Color.find_enumble(:black) # => Enumbler::Enumble<:black>
+
+# raises errors if none found
+Color.find_enumbles!!(:black, 'does-no-exist') # => raises Enumbler::Error
+Color.find_enumble!(:does_not_exist) # => raises Enumbler::Error
+
+# Get ids flexibly, without raising an error if none found
+Color.ids_from_enumbler(:black, 'white') # => [1, 2]
+Color.ids_from_enumbler(:black, 'does-no-exist') # => [1, nil]
+
+# Raise an error if none found
+Color.ids_from_enumbler!(:black, 'does-no-exist') # => raises Enumbler::Error
+Color.id_from_enumbler!(:does_not_exist) # => raises Enumbler::Error
+
+# Get enumble object by id
 
 house = House.create!(color: Color.black)
 house.black?
 house.not_black?
 
-House.color(:black) # => [house]
+house2 = House.create!(color: Color.white)
+House.color(:black, :white)      # => ActiveRecord::Relation<house, house2>
+House.color(Color.black, :white) # => ActiveRecord::Relation<house, house2>
 ```
 
 ### Use a column other than `label`
@@ -98,7 +127,8 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Roadmap
 
-Ideally, we could make this work more like a traditional `enum`; for example, overriding the `.where` method by allowing something like: `House.where(color: :blue)` instead of `House.where_color(:blue)`.  But right now am in a rush and not sure how to go about doing that properly.
+* We need to add in support for additional attributes/columns in the enumbled table.  For example, following the `Color` concept, we may want to have a column which is `hex` and stores the colors `hex` value (e.g., `FFFFFF`).  This should be supported.
+* Ideally, we could make this work more like a traditional `enum`; for example, overriding the `.where` method by allowing something like: `House.where(color: :blue)` instead of `House.where_color(:blue)`.  But right now am in a rush and not sure how to go about doing that properly.
 
 ## Contributing
 

data/enumbler.gemspec

@@ -29,8 +29,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activerecord', '~> 6.0.2'
-  spec.add_dependency 'activesupport', '~> 6.0.2'
+  spec.add_dependency 'activerecord', ['>= 5.2.3', '< 6.1']
+  spec.add_dependency 'activesupport', ['>= 5.2.3', '< 6.1']
 
   spec.add_development_dependency 'database_cleaner-active_record', '~> 1.8.0'
   spec.add_development_dependency 'fuubar', '~> 2.5'

data/lib/enumbler.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'enumbler/collection'
 require 'enumbler/enumble'
 require 'enumbler/enabler'
 require 'enumbler/version'
@@ -85,6 +86,10 @@ module Enumbler
         where(column_name => enumbled_model.ids_from_enumbler(args))
       end
 
+      define_singleton_method("#{cmethod}!") do |*args|
+        where(column_name => enumbled_model.ids_from_enumbler!(args))
+      end
+
       enumbled_model.enumbles.each do |enumble|
         method_name = prefix ? "#{model_name}_#{enumble.enum}?" : "#{enumble.enum}?"
         not_method_name = prefix ? "#{model_name}_not_#{enumble.enum}?" : "not_#{enumble.enum}?"

data/lib/enumbler/collection.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Enumbler
+  # Not sure if this will be needed but was leaning toward a custom wrapper for
+  # our array holding the `enumbles` for our model.  As it is, allows you to
+  # query them based on the enum:
+  #
+  # ```
+  # Color.enumbles.black # => [Enumbler::Enumble]
+  # ```
+  class Collection < Array
+    def method_missing(method_name, *args, &block)
+      enumble = find { |e| e.enum == method_name }
+      return enumble if enumble.present?
+
+      super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      enumble = find { |e| e.enum == method_name }
+      enumble.present? || super
+    end
+  end
+end

data/lib/enumbler/enabler.rb

@@ -40,8 +40,8 @@ module Enumbler
       #   class Color < ApplicationRecord
       #     include Enumbler::Enabler
       #
-      #     enumble :black, 1
-      #     enumble :white, 2
+      #     enumble :black, 1, hex: '000000'
+      #     enumble :white, 2, hex: 'ffffff'
       #     enumble :dark_brown, 3, # label: 'dark-brown'
       #     enumble :black_hole, 3, label: 'Oh my! It is a black hole!'
       #   end
@@ -55,20 +55,22 @@ module Enumbler
       # @param enum [Symbol] the enum representation
       # @param id [Integer] the primary key value
       # @param label [String] optional: label for humans
-      # @param **options [Hash] optional: additional attributes and values that
+      # @param **attributes [Hash] optional: additional attributes and values that
       #   will be saved to the database for this enumble record
-      def enumble(enum, id, label: nil, **options)
-        @enumbles ||= []
+      def enumble(enum, id, label: nil, **attributes)
+        @enumbles ||= Enumbler::Collection.new
         @enumbled_model = self
         @enumbler_label_column_name ||= :label
 
-        enumble = Enumble.new(enum, id, label: label, label_column_name: @enumbler_label_column_name, **options)
+        raise_error_if_model_does_not_support_attributes(attributes)
+
+        enumble = Enumble.new(enum, id, label: label, label_column_name: @enumbler_label_column_name, **attributes)
 
         if @enumbles.include?(enumble)
           raise Error, "You cannot add the same Enumble twice! Attempted to add: #{enum}, #{id}."
         end
 
-        define_dynamic_methods_and_constants_for_enumbled_model(enum, id)
+        define_dynamic_methods_and_constants_for_enumbled_model(enumble)
 
         @enumbles << enumble
       end
@@ -97,6 +99,93 @@ module Enumbler
         @enumbler_label_column_name = label_column_name
       end
 
+      # See {.find_enumbles}.  Simply returns the first object.  Use when you
+      # want one argument to be found and not returned in an array.
+      # @raise [Error] when there is no [Enumbler::Enumble] to be found and
+      #   `raise_error: true`
+      # @param args [Integer, String, Symbol]
+      # @param case_sensitive [Boolean] should a String search be case sensitive
+      #   (default: false)
+      # @param raise_error [Boolean] raise an error if not found (default:
+      #   false)
+      # @return [Enumbler::Enumble]
+      def find_enumble(arg, case_sensitive: false, raise_error: false)
+        find_enumbles(arg, case_sensitive: case_sensitive, raise_error: raise_error).first
+      end
+
+      # See {.find_enumbles}.  Simply returns the first object.  Use when you
+      # want one argument to be found and not returned in an array. Raises error
+      # if none found.
+      # @raise [Error] when there is no [Enumbler::Enumble] to be found and
+      #   `raise_error: true`
+      # @param args [Integer, String, Symbol]
+      # @param case_sensitive [Boolean] should a String search be case sensitive
+      #   (default: false)
+      # @return [Enumbler::Enumble]
+      def find_enumble!(arg, case_sensitive: false)
+        find_enumbles(arg, case_sensitive: case_sensitive, raise_error: true).first
+      end
+
+      # Finds an array of {Enumbler::Enumble} objects matching the given
+      # argument. Accepts an Integer, String, Symbol, or ActiveRecord instance.
+      #
+      # This method is designed to let you get information about the record
+      # without having to hit the database.  Returns `nil` when none found
+      # unless `raise_error` is `true`.
+      #
+      #    Color.find_enumbles(:black, 'white', 'not-found')
+      #      #=> [Enumbler::Enumble<:black>, Enumbler::Enumble<:white>, nil]
+      #
+      # @raise [Error] when there is no [Enumbler::Enumble] to be found and
+      #   `raise_error: true`
+      # @param args [Integer, String, Symbol]
+      # @param case_sensitive [Boolean] should a String search be case sensitive
+      #   (default: false)
+      # @param raise_error [Boolean] raise an error if not found (default:
+      #   false)
+      # @return [Array<Enumbler::Enumble>]
+      def find_enumbles(*args, case_sensitive: false, raise_error: false)
+        args.flatten.compact.uniq.map do |arg|
+          err = "Unable to find a #{@enumbled_model}#enumble with #{arg}"
+
+          begin
+            arg = Integer(arg) # raises Type error if not a real integer
+            enumble = @enumbled_model.enumbles.find { |e| e.id == arg }
+          rescue TypeError, ArgumentError
+            enumble =
+              if arg.is_a?(Symbol)
+                @enumbled_model.enumbles.find { |e| e.enum == arg }
+              elsif arg.is_a?(String)
+                @enumbled_model.enumbles.find do |e|
+                  case_sensitive ? e.label == arg : arg.casecmp?(e.label)
+                end
+              elsif arg.instance_of?(@enumbled_model)
+                arg.enumble
+              end
+          end
+
+          if enumble.present?
+            enumble
+          else
+            raise Error if raise_error
+
+            nil
+          end
+        rescue Error
+          raise Error, err
+        end
+      end
+
+      # See {.find_enumbles}.  Same method, only raises error when none found.
+      # @raise [Error] when there is no [Enumbler::Enumble] to be found
+      # @param args [Integer, String, Symbol]
+      # @param case_sensitive [Boolean] should a String search be case sensitive
+      #   (default: false)
+      # @return [Array<Enumbler::Enumble>]
+      def find_enumbles!(*args, case_sensitive: false)
+        find_enumbles(*args, case_sensitive: case_sensitive, raise_error: true)
+      end
+
       # Return the record id for a given argument.  Can accept an Integer, a
       # Symbol, or an instance of Enumbled model.  This lookup is a database-free
       # lookup.
@@ -107,9 +196,25 @@ module Enumbler
       #
       # @raise [Error] when there is no enumble to be found
       # @param arg [Integer, Symbol, Class]
+      # @param case_sensitive [Boolean] should a string search be performed with
+      #   case sensitivity (default: false)
+      # @param raise_error [Boolean] raise an error if not found (default:
+      #   false)
       # @return [Integer]
-      def id_from_enumbler(arg)
-        ids_from_enumbler(arg).first
+      def id_from_enumbler(arg, case_sensitive: false, raise_error: false)
+        ids_from_enumbler(arg, case_sensitive: case_sensitive, raise_error: raise_error).first
+      end
+
+      # See {.ids_from_enumbler}.  Raises error if none found.
+      # @raise [Error] when there is no enumble to be found
+      # @param arg [Integer, Symbol, Class]
+      # @param case_sensitive [Boolean] should a string search be performed with
+      #   case sensitivity (default: false)
+      # @param raise_error [Boolean] raise an error if not found (default:
+      #   false)
+      # @return [Integer]
+      def id_from_enumbler!(arg, case_sensitive: false)
+        ids_from_enumbler(arg, case_sensitive: case_sensitive, raise_error: true).first
       end
 
       # Return the record id(s) based on different argument types.  Can accept
@@ -118,38 +223,39 @@ module Enumbler
       #
       #   Color.ids_from_enumbler(1, 2) # => [1, 2]
       #   Color.ids_from_enumbler(:black, :white) # => [1, 2]
+      #   Color.ids_from_enumbler('black', :white) # => [1, 2]
       #   Color.ids_from_enumbler(Color.black, Color.white) # => [1, 2]
       #
       # @raise [Error] when there is no enumble to be found
       # @param *args [Integer, Symbol, Class]
+      # @param case_sensitive [Boolean] should a string search be performed with
+      #   case sensitivity (default: false)
+      # @param raise_error [Boolean] raise an error if not found (default:
+      #   false)
       # @return [Array<Integer>]
-      def ids_from_enumbler(*args)
-        args.flatten.compact.uniq.map do |arg|
-          err = "Unable to find a #{@enumbled_model}#enumble with #{arg}"
-
-          begin
-            arg = Integer(arg) # raises Type error if not a real integer
-            enumble = @enumbled_model.enumbles.find { |e| e.id == arg }
-          rescue TypeError
-            enumble = if arg.is_a?(Symbol)
-                        @enumbled_model.enumbles.find { |e| e.enum == arg }
-                      elsif arg.instance_of?(@enumbled_model)
-                        arg.enumble
-                      end
-          end
+      def ids_from_enumbler(*args, case_sensitive: false, raise_error: false)
+        enumbles = find_enumbles(*args, case_sensitive: case_sensitive, raise_error: raise_error)
+        enumbles.map { |e| e&.id }
+      end
 
-          enumble&.id || raise(Error, err)
-        rescue Error
-          raise Error, err
-        end
+      # See {.ids_from_enumbler}.  Raises error when none found.
+      # @raise [Error] when there is no enumble to be found
+      # @param *args [Integer, Symbol, Class]
+      # @param case_sensitive [Boolean] should a string search be performed with
+      #   case sensitivity (default: false)
+      # @return [Array<Integer>]
+      def ids_from_enumbler!(*args, case_sensitive: false)
+        enumbles = find_enumbles!(*args, case_sensitive: case_sensitive)
+        enumbles.map(&:id)
       end
 
       # Seeds the database with the Enumbler data.
       # @param delete_missing_records [Boolean] remove any records that are no
       #   longer defined (default: false)
-      def seed_the_enumbler(delete_missing_records: false)
+      # @param validate [Boolean] validate on save?
+      def seed_the_enumbler(delete_missing_records: false, validate: true)
         max_database_id = all.order('id desc').take&.id || 0
-        max_enumble_id = enumbles.map(&:id).max
+        max_enumble_id = @enumbles.map(&:id).max
 
         # If we are not deleting records, we just need to update each listed
         # enumble and skip anything else in the database.  If we are deleting
@@ -174,7 +280,7 @@ module Enumbler
 
           record = find_or_initialize_by(id: id)
           record.attributes = enumble.attributes
-          record.save!
+          record.save!(validate: validate)
         end
 
         where(id: discarded_ids).delete_all if delete_missing_records
@@ -182,22 +288,40 @@ module Enumbler
 
       # Seeds the database with the Enumble data, removing any records that are no
       # longer defined.
-      def seed_the_enumbler!
-        seed_the_enumbler(delete_missing_records: true)
+      # @param validate [Boolean] validate on save?
+      def seed_the_enumbler!(validate: true)
+        seed_the_enumbler(delete_missing_records: true, validate: validate)
       end
 
       private
 
-      def define_dynamic_methods_and_constants_for_enumbled_model(enum, id)
-        method_name = "#{enum}?"
-        not_method_name = "not_#{enum}?"
-        alias_method_name = "is_#{enum}"
+      def define_dynamic_methods_and_constants_for_enumbled_model(enumble)
+        method_name = "#{enumble.enum}?"
+        not_method_name = "not_#{enumble.enum}?"
+        alias_method_name = "is_#{enumble.enum}"
 
-        const_set(enum.to_s.upcase, id)
-        define_method(method_name) { self.id == id }
-        define_method(not_method_name) { self.id != id }
+        const_set(enumble.enum.to_s.upcase, enumble.id)
+        define_method(method_name) { id == enumble.id }
+        define_method(not_method_name) { id != enumble.id }
         alias_method alias_method_name, method_name
-        define_singleton_method(enum) { find(id) }
+        define_singleton_method(enumble.enum) do |attr = nil|
+          return find(enumble.id) if attr.nil?
+
+          enumble.send(attr)
+        rescue NoMethodError
+          raise Enumbler::Error, "The attribute #{attr} is not supported on this Enumble."
+        end
+      end
+
+      def raise_error_if_model_does_not_support_attributes(attributes)
+        return if attributes.blank?
+
+        unsupported_attrs = attributes.reject { |key, _value| has_attribute?(key) }
+
+        return if unsupported_attrs.blank?
+
+        raise Enumbler::Error,
+          "The model #{self} does not support the attribute(s): #{unsupported_attrs.keys.map(&:to_s).to_sentence}"
       end
     end
   end

data/lib/enumbler/enumble.rb

@@ -3,14 +3,14 @@
 module Enumbler
   # Class that holds each row of Enumble data.
   class Enumble
-    attr_reader :id, :enum, :label, :label_column_name, :options
+    attr_reader :id, :enum, :label, :label_column_name
 
-    def initialize(enum, id, label: nil, label_column_name: :label, **options)
+    def initialize(enum, id, label: nil, label_column_name: :label, **attributes)
       @id = id
       @enum = enum
       @label = label || enum.to_s.dasherize
       @label_column_name = label_column_name
-      @options = options
+      @additional_attributes = attributes || {}
     end
 
     def ==(other)
@@ -19,15 +19,36 @@ module Enumbler
     end
 
     def attributes
-      {
+      @additional_attributes.merge({
         id: id,
         label_column_name => label,
-      }
+      })
+    end
+
+    # Used to return itself from a class method.
+    #
+    # ```
+    # Color.black(:enumble) #=> <Enumble:0x00007fb4396a78c8>
+    # ```
+    # @return [Enumbler::Enumble]
+    def enumble
+      self
     end
 
     def eql?(other)
       other.class == self.class &&
         (other.id == id || other.enum == enum || other.label == label)
     end
+
+    # Standardizing the enum for a GraphQL schema with an uppercase string
+    # value.
+    # @return [String]
+    def graphql_enum
+      enum.to_s.upcase
+    end
+
+    def to_s
+      enum
+    end
   end
 end

data/lib/enumbler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Enumbler
-  VERSION = '0.4.1'
+  VERSION = '0.6.1'
 end

metadata

@@ -1,43 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: enumbler
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.1
 platform: ruby
 authors:
 - Damon Timm
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-21 00:00:00.000000000 Z
+date: 2020-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.2
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.2
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.2
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.3
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.2
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
@@ -144,6 +156,7 @@ files:
 - bin/setup
 - enumbler.gemspec
 - lib/enumbler.rb
+- lib/enumbler/collection.rb
 - lib/enumbler/enabler.rb
 - lib/enumbler/enumble.rb
 - lib/enumbler/version.rb