enumbler 0.5.1 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da174585a626032f772439eea6f3a252ebaec0862f5fd47e151eac2db8403d15
-  data.tar.gz: 4e4d0f45f98074d5ee58df06ff57d825ee479fb3bdc3853b1e115f752474203c
+  metadata.gz: 96cdeb24ac43db515f90d6cf857e497281066c7dad0f5c2cf93d3aada54265dc
+  data.tar.gz: 13247cd26aa94ad10fe7f739fc8c3690d6e3702c59d77caceb80242a9df722d3
 SHA512:
-  metadata.gz: a816d2d6b87a981167d55435031e1a1c5044385c76787d5fe9295e61c40041d5347f23c5710a6d6dcc2cbff78c543740438b30040818304e3b77ab68afca2cf5
-  data.tar.gz: 597f0bf8a11264b2543e8ed9f7142c952a9a5595510823328c630ebc75937b07e4a6a09f37dfba4bbab2e8fa4c7f5358a61f4ea26a1dc08f06ab2c92f451e2ac
+  metadata.gz: 57cf510621d28df43bca6d5e7715e6bd9c1452a7a7457a1fd6ef3ae0f47425927deec6bc16e34dd2ccb94781cdb37f358d62825c8c64aed0294ffcd247fd6a93
+  data.tar.gz: 007d1e7c93fcf129ec0b13d037edd045e4e18b9d453a6dadc2381425a73f9b64424a83e4d976b0bd316a593ccf3c5e9d3f986c1cbb2bed35f7a9cb1f4dfc94b5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    enumbler (0.5.1)
+    enumbler (0.6.4)
       activerecord (>= 5.2.3, < 6.1)
       activesupport (>= 5.2.3, < 6.1)
 

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
@@ -60,17 +61,43 @@ 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?
+
+# These are all db-free lookups
+house.color_label        # => 'black'
+house.color_enum         # => :black
+house.color_graphql_enum # => 'BLACK'
+house.black?             # => true
+house.not_black?         # => false
 
 house2 = House.create!(color: Color.white)
-House.color(:black, :white) # => [house, house2]
+House.color(:black, :white)      # => ActiveRecord::Relation<house, house2>
+House.color(Color.black, :white) # => ActiveRecord::Relation<house, house2>
 ```
 
 ### Use a column other than `label`

data/lib/enumbler.rb

@@ -65,6 +65,7 @@ module Enumbler
 
       belongs_to(name, scope, **options)
 
+      define_helper_attributes(name)
       define_dynamic_methods_for_enumbled_to_models(enumbled_model, prefix: prefix, scope_prefix: scope_prefix)
     rescue NameError
       raise Error, "The model #{class_name} cannot be found.  Uninitialized constant."
@@ -86,6 +87,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}?"
@@ -93,5 +98,16 @@ module Enumbler
         define_method(not_method_name) { self[column_name] != enumble.id }
       end
     end
+
+    # Add the attirbutes:
+    #
+    #   house.color_label #=> 'black'
+    #   house.color_enum  #=> :black
+    #   house.color_graphql_enum #=> 'BLACK'
+    def define_helper_attributes(name)
+      %i[label enum graphql_enum].each do |sym|
+        define_method("#{name}_#{sym}") { send(name).enumble.send(sym) }
+      end
+    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,14 +55,18 @@ 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)
+      def enumble(enum, id, label: nil, **attributes)
+        raise_error_if_model_does_not_support_attributes(attributes)
+
+        id = validate_id_is_numeric(enum, id)
+
         @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)
+        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}."
@@ -97,6 +101,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 +198,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,30 +225,30 @@ 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.
@@ -150,7 +257,7 @@ module Enumbler
       # @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
@@ -207,6 +314,29 @@ module Enumbler
           raise Enumbler::Error, "The attribute #{attr} is not supported on this Enumble."
         end
       end
+
+      # I accidentally forgot to provide an id one time and it was confusing as
+      # the last argument became the hash of options.  This should help.
+      def validate_id_is_numeric(enum, id)
+        Integer(id)
+      rescue ArgumentError, TypeError
+        raise Enumbler::Error,
+          "You must provide a numeric primary key, like: `enumble :#{enum}, 1 `"
+      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}"
+      rescue ActiveRecord::StatementInvalid
+        warn "[Enumbler Warning] => Unable to find a table for #{self}."\
+          'This is to be expected if there is a pending migration; however, if there is not then something is amiss.'
+      end
     end
   end
 end

data/lib/enumbler/enumble.rb

@@ -2,18 +2,15 @@
 
 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
+    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)
@@ -22,10 +19,20 @@ 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)

data/lib/enumbler/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enumbler
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.4
 platform: ruby
 authors:
 - Damon Timm
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-26 00:00:00.000000000 Z
+date: 2020-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord