enumbler 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c41d00aedb09317c1c7d21627484d57e9d1d8f4f60e51370d56af7481e806fde
-  data.tar.gz: 5187426aefcb06364f1941bbf62932817800de1748646fb658c901afa58d1d6a
+  metadata.gz: 2943ee8d89898bb8164e0eccc955f51de0c0ba3d95c814f0a928f967bc82486b
+  data.tar.gz: bda8b04d4dd0c9f17a9cd0f0f05e700b4fde8b24d6bad394ac8c5ab5662064da
 SHA512:
-  metadata.gz: 64131fd59a8bd70b1897e554b266af9308378036e4d93817b50b95b0cb76bcc0d59c29153a7ccc42d5df1d556c4b3f4538a7499bb81b73c9f45e26823d1e5a30
-  data.tar.gz: 36789800d5e024417b10c872aadae7facaeb03691b289de8da0b5439ecc4c57153db5b4625255e855d39d402e0a086ac3b5d8585134d675684c768a697a93e16
+  metadata.gz: 5340c39fd43f724d13eb648349be08d2115d9fd0964adda1c39403fdb992620b5209e45435ccb222589f9891048630763ec340c1866141e204b633cc4e58da09
+  data.tar.gz: e2f243201a8621571bdf000d82ca3fa8a9c12070c9a8a11ae8ab1796f8742f75baee7aa4abcad102c3b35cd39473b806d8f9af0c94bd9657a30462ce11b0fcf3

data/Gemfile.lock

@@ -1,27 +1,27 @@
 PATH
   remote: .
   specs:
-    enumbler (0.4.0)
-      activerecord (~> 6.0.2)
-      activesupport (~> 6.0.2)
+    enumbler (0.6.0)
+      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

@@ -54,17 +54,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 +126,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

@@ -58,7 +58,7 @@ module Enumbler
       # @param **options [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 ||= []
+        @enumbles ||= Enumbler::Collection.new
         @enumbled_model = self
         @enumbler_label_column_name ||= :label
 
@@ -68,7 +68,7 @@ module Enumbler
           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 +97,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 +194,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, 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)
-        ids_from_enumbler(arg).first
+      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,44 +221,54 @@ 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 Enumble data.
+      # 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
 
-        max_id = max_enumble_id > max_database_id ? max_enumble_id : max_database_id
+        # 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
+        # records, we need to know the max database id.
+        iterator = if !delete_missing_records
+                     @enumbles.map(&:id)
+                   elsif max_enumble_id > max_database_id
+                     (1..max_enumble_id)
+                   else
+                     (1..max_database_id)
+                   end
 
         discarded_ids = []
 
-        (1..max_id).each do |id|
+        iterator.each do |id|
           enumble = @enumbles.find { |e| e.id == id }
 
           if enumble.nil?
@@ -165,7 +278,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
@@ -173,22 +286,29 @@ 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
     end
   end

data/lib/enumbler/enumble.rb

@@ -2,6 +2,9 @@
 
 module Enumbler
   # Class that holds each row of Enumble data.
+  #
+  # @todo We need to support additional options/attributes beyond the id/label
+  #   pairs.  Is on the backburner for a moment.
   class Enumble
     attr_reader :id, :enum, :label, :label_column_name, :options
 
@@ -25,9 +28,30 @@ module Enumbler
       }
     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.0'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,43 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: enumbler
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 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