deco_lite 0.2.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d360b0607d72711264a19f807ad4367237f0e5e69efb385728ccbda66e72e05
-  data.tar.gz: f90e61477cc9dfa1ba8d19070c1490fcccfce413533436ed93b532d4933fad08
+  metadata.gz: 8a87d5a79f738b49d45b51c0128b4c252853c683363e7525df836fc7c46e4953
+  data.tar.gz: 1f07c897d0f88cd3609a8e6a880d0ce91b71210ee8952eb29148370b2f49f092
 SHA512:
-  metadata.gz: 87d78e241cd8aada8c09c8adbcb20cdb5997e96ff4f17cc8dd3a494e973fd10f13fe73927edb604e2125209119bd881522c79995753768fc0f64d049632d1751
-  data.tar.gz: d4ae03338d636d82d6a67996cea9e2143a07b0319a9ad6f3a1f1e4a508b2f9a4262ec5cb7e68c8cb2b7d29a8f0e046413ad7f9470f4a20c6fa470c20d9e3c907
+  metadata.gz: afc6320e0a1e9060dda231249fe16e62bf62d56f11ad7ffa9c4c6a0f094ef866173655c4ee57a419b3c4b83d0d7b7639230db22459f3c2d81d78cc6c4da2dde2
+  data.tar.gz: 6db8e3cb9a634669667eb288f4a4343106ad9be71630c1a9e95af366649b86e88459d0b79f1c71e09345a75805e643aa1e1e3a2836e2045bd1191bd78484685c

data/.reek.yml

@@ -1,6 +1,7 @@
 exclude_paths:
   - vendor
   - spec
+  - scratch.rb
 detectors:
   # TooManyInstanceVariables:
   #  exclude:

data/.rubocop.yml

@@ -116,7 +116,7 @@ Layout/LineLength:
 # Avoid methods longer than 15 lines of code.
 Metrics/MethodLength:
   Max: 20
-  IgnoredMethods:
+  AllowedMethods:
     - swagger_path
     - operation
 

data/CHANGELOG.md

@@ -1,24 +1,44 @@
+### 0.3.1
+* Changes
+  * Added `DecoLite::FieldRequireable::MISSING_REQUIRED_FIELD_ERROR_TYPE` for required field type errors.
+  * Update README.md with more examples.
+
+### 0.3.0
+* Changes
+  * `DecoLite::Model#new` how accepts a :hash named parameter that will load the Hash as if calling `DecoLite::Model.new.load!(hash: <hash>)`.
+  * `DecoLite::Model#new now creates attr_accessors (fields) for any attribute that has an ActiveModel validator associated with it. This prevents errors raised when #validate is called before data is #load!ed.
+  * `DecoLite::Model#new` now creates attr_accessors (fields) for any field returned from `DecoLite::Model#reqired_fields` IF the required_fields: :auto option is set.
+  * bin/console now starts a pry-byebug session.
+
+### 0.2.5
+* Changes
+  * Remove init of `@field_names = []` in `Model#initialize` as unnecessary - FieldNamesPersistable takes care of this.
+* Bug fixes
+  * Fix but that does not take into account option :namespace when determining whether or not a field name conflicts with an existing attribute (already exists).
+
 ### 0.2.4
 * Changes
   * Change DecoLite::Model#load to #load! as it alters the object, give deprecation warning when calling #load.
   * FieldConflictable now expliticly prohibits loading fields that conflict with attributes that are native to the receiver. In other words, you cannot load fields with names like :to_s, :tap, :hash, etc.
   * FieldCreatable now creates attr_accessors on the instance using #define_singleton_method, not at the class level (i.e. self.class.attr_accessor) (see bug fixes).
-* bug fixes
+* Bug fixes
   * Fix bug that used self.class.attr_accessor in DecoLite::FieldCreatable to create attributes, which forced every object of that class subsequently created have the accessors created which caused field name conflicts across DecoLite::Model objects.
 
 ### 0.2.3
-* Fix bug that added duplcate field names to Model#field_names.
+* Bug fixes
+  * Fix bug that added duplcate field names to Model#field_names.
 
 ### 0.2.2
-* Fix bug requiring support codez in lib/deco_lite.rb.
+* Bug fixes
+  * Fix bug requiring support codez in lib/deco_lite.rb.
 
 ### 0.2.1
-* changes
+* Changes
   * Add mad_flatter gem runtime dependency.
   * Refactor to let mad_flatter handle the Hash flattening.
 
 ### 0.1.1
-* changes
+* Changes
   * Update gems and especially rake gem version to squash CVE-2020-8130, see https://github.com/advisories/GHSA-jppv-gw3r-w3q8.
   * Fix rubocop violations.
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    deco_lite (0.2.4)
+    deco_lite (0.3.1)
       activemodel (~> 7.0, >= 7.0.3.1)
       activesupport (~> 7.0, >= 7.0.3.1)
       immutable_struct_ex (~> 0.2.0)

data/README.md

@@ -15,17 +15,17 @@
 
 DecoLite is in development. I wouldn't expect breaking changes before v1.0.0; however, I can't completely rule this out. Currently, DecoLite only supports Hashes whose keys are `Symbols`, contain no embedded spaces, and conform to Ruby `attr_accessor` naming conventions. However, I'll certainly work out a solution for all this in future releases.
 
-TBD: Documentation regarding `DecoLite::Model` options, `DecoLite::Model#load` options: how these work, and how they play together (in the meantime, see the specs).
+TBD: Documentation regarding `DecoLite::Model` options, `DecoLite::Model#load!` options: how these work, and how they play together (in the meantime, see the specs).
 
 _Deco_ is a little gem that allows you to use the provided `DecoLite::Model` class (`include ActiveModel::Model`) to create Decorator classes which can be instantiated and used. Inherit from `DecoLite::Model` to create your own unique classes with custom functionality. A `DecoLite::Model` includes `ActiveModel::Model`, so validation can be applied using [ActiveModel validation helpers](https://api.rubyonrails.org/v6.1.3/classes/ActiveModel/Validations/HelperMethods.html) you are familiar with; or, you can roll your own - just like any other ActiveModel.
 
-A `DecoLite::Model` will allow you to consume a Ruby Hash that you supply via the `DecoLite::Model#load` method. Your supplied Ruby Hashes are used to create `attr_accessor` attributes (_"fields"_) on the model. Each attribute created, is then assigned its value from the Hash loaded.
+A `DecoLite::Model` will allow you to consume a Ruby Hash that you supply via the `DecoLite::Model#load!` method. Your supplied Ruby Hashes are used to create `attr_accessor` attributes (_"fields"_) on the model. Each attribute created, is then assigned its value from the Hash loaded.
 
 `attr_accessor` names created are _mangled_ to include namespacing. This creates unique attribute names for nested Hashes that may include non-unique keys. For example:
 
 ```ruby
 # NOTE: keys :name and :age are not unique across this Hash.
-{
+family = {
   name: 'John Doe',
   age: 35,
   wife: {
@@ -34,37 +34,66 @@ A `DecoLite::Model` will allow you to consume a Ruby Hash that you supply via th
   }
 }
 ```
-Given the above example, DecoLite will produce the following `attr_accessors` on the `DecoLite::Model` object when loaded (`DecoLite::Model#load`), and assign the values:
+Given the above example, DecoLite will produce the following `attr_accessors` on the `DecoLite::Model` object when loaded (`DecoLite::Model#load!`), and assign the values:
 
 ```ruby
-name=, name #=> 'John Doe'
-age=, age #=> 35
-wife_name=, wife_name #=> 'Mary Doe'
-wife_age=, wife_age #=> 30
+model = DecoLite::Model.new.load!(hash: family)
+
+model.name #=> 'John Doe'
+model.respond_to? :name= #=> true
+
+model.age #=> 35
+model.respond_to? :age= #=> true
+
+model.wife_name #=> 'Mary Doe'
+model.respond_to? :wife_name= #=> true
+
+model.wife_age #=> 30
+model.respond_to? :wife_age= #=> true
 ```
 
-`DecoLite::Model#load` can be called _multiple times_, on the same model, with different Hashes. This could potentially cause `attr_accessor` name clashes. In order to ensure unique `attr_accessor` names, a _"namespace"_ may be _explicitly_ provided to ensure uniqueness. For example, continuing from the previous example; if we were to call `DecoLite::Model#load` a _second time_ with the following Hash, it would produce `attr_accessor` name clashes:
+`DecoLite::Model#load!` can be called _multiple times_, on the same model, with different Hashes. This could potentially cause `attr_accessor` name clashes. In order to ensure unique `attr_accessor` names, a _"namespace"_ may be _explicitly_ provided to ensure uniqueness. For example, continuing from the previous example; if we were to call `DecoLite::Model#load!` a _second time_ with the following Hash, it would produce `attr_accessor` name clashes:
 
 ```ruby
-{
+grandpa = {
   name: 'Henry Doe',
   age: 85,
 }
+# The :name and :age Hash keys above will produce :name/:name= and :age/:age= attr_accessors and clash because these were already added to the model when "John Doe" was loaded with the first call to DecoLite::Model#load!.
 ```
 
-However, passing a `namespace: :grandpa` option to the `DecoLite::Model#load` method, would produce the following `attr_accessors`, ensuring uniquess:
+However, passing a `namespace:` option (for example `namespace: :grandpa`) to the `DecoLite::Model#load!` method, would produce the following `attr_accessors`, ensuring their uniqueness:
+
 ```ruby
-# Unique now that the namespace "grandpa" has been applied.
-grandpa_name=, grandpa_name #=> 'Henry Doe'
-grandpa_age=, grandpa_age #=> 85
+model.load!(hash: grandpa, options: { namespace: :grandpa })
+
+# Unique now that the namespace: :grandpa has been applied:
+model.grandpa_name #=> 'Henry Doe'
+model.respond_to? :grandpa_name= #=> true
+
+model.grandpa_age #=> 85
+model.respond_to? :grandpa_age= #=> true
+
+# All the other attributes on the model remain the same, and unique:
+model.name #=> 'John Doe'
+model.respond_to? :name= #=> true
+
+model.age #=> 35
+model.respond_to? :age= #=> true
+
+model.wife_name #=> 'Mary Doe'
+model.respond_to? :wife_name= #=> true
+
+model.wife_age #=> 30
+model.respond_to? :wife_age= #=> true
 ```
-## Use Cases
+## Use cases
 
 ### General
-_Deco_ would _most likely_ thrive where the structure of the Hashe(s) consumed by the `DecoLite::Model#load` method is known. This is because of the way _Deco_ mangles loaded Hash key names to create unique `attr_accessor` names (see the Introduction section) although, I'm sure there are some metaprogramming geniuses out there that might prove me wrong. Assuming this is the case, _Deco_ would be ideal to handle Model attributes, Webservice JSON results (converted to Ruby Hash), JSON Web Token (JWT) payload, etc..
+_Deco_ would _most likely_ thrive where the structure of the Hashe(s) consumed by the `DecoLite::Model#load!` method is known. This is because of the way _Deco_ mangles loaded Hash key names to create unique `attr_accessor` names (see the Introduction section); although, I'm sure there are some metaprogramming geniuses out there that might prove me wrong. Assuming this is the case, _Deco_ would be ideal to handle Model attributes, Webservice JSON results (converted to Ruby Hash), JSON Web Token (JWT) payload, etc..
 
 ### Rails
-Because `DecoLite::Model` includes `ActiveModel::Model`, it could also be ideal for use as a model in Rails applications, where a _decorator pattern_ can be used, and methods provided for use in Rails views; for example:
+Because `DecoLite::Model` includes `ActiveModel::Model`, it could also be ideal for use as a model in Rails applications, where a _decorator pattern_ might be used, and decorator methods provided for use in Rails views; for example:
 
 ```ruby
 class ViewModel < DecoLite::Model
@@ -81,7 +110,7 @@ end
 
 view_model = ViewModel.new
 
-view_model.load(hash: { first: 'John', last: 'Doe' })
+view_model.load!(hash: { first: 'John', last: 'Doe' })
 
 view_model.valid?
 #=> true
@@ -96,23 +125,7 @@ view_model.salutation
 
 Get creative. Please pop me an email and let me know how _you're_ using _Deco_.
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'deco_lite'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install deco_lite
-
-## Examples and Usage
+## Examples and usage
 
 ```ruby
 require 'deco_lite'
@@ -154,8 +167,8 @@ end
 
 couple = Couple.new
 
-couple.load(hash: husband, options: { namespace: :husband })
-couple.load(hash: wife, options: { namespace: :wife })
+couple.load!(hash: husband, options: { namespace: :husband })
+couple.load!(hash: wife, options: { namespace: :wife })
 
 # Will produce the following:
 model.live_together?        #=> true
@@ -169,17 +182,128 @@ model.wife_name             #=> Amy Doe
 model.wife_info_age         #=> 20
 model.wife_info_address     #=> 1 street, boonton, nj 07005
 ```
+## More examples and usage
+
+### I want to...
+
+#### Add validators to my model
+
+Simply add your `ActiveModel` validators just like you would any other `ActiveModel::Model` validator. However, be aware that (currently), any attribute (field) having an _explicit validation_ associated with it, will automatically cause an `attr_accessor` to be created for that field; this is to avoid `NoMethodErrors` when calling a validation method on the model (e.g. `#valid?`, `#validate`, etc.):
+
+```ruby
+class Model < DecoLite::Model
+  validates :first, :last, :address, presence: true
+  validates :age, numericality: true
+end
+
+# No :address
+model = Model.new(hash: { first: 'John', last: 'Doe', age: 25 })
+model.respond_to? :address
+#=> true
+
+model.valid?
+#=> false
+model.errors.full_messages
+#=> ["Address can't be blank"]
+
+model.load!(hash: { address: '123 park road, anytown, nj 01234' })
+model.validate
+#=> true
+```
 
-### Manually Defining Attributes
+#### Validate whether or not certain fields were loaded
 
-Manually defining attributes on your subclass is possible; however, you
-must add your attr_reader name to the `DecoLite::Model@field_names` array, or an error will be reaised _if_ there are any conflicting field names being loaded
-using `DecoLite::Model#load!`, regardless of setting the `{ fields: :merge }`
-option. This is because DecoLite assumes any existing attributes not added to
-the model via `load!`to be native to the object created, and therefore will not
-allow you to create attr_accessors for existing attributes, as this can potentially be dangerous.
+To be clear, this has nothing to do with the _data_ associated with the fields loaded; rather, this has to do with whether or not the _fields themselves_ were created as attributes on your model as a result of loading data into your model. If you simply want to validate the _data_ loaded into your model, simply add `ActiveModel` validation, just like you would any other `ActiveModel` model, see the [Add validators to my model](#add-validators-to-my-model) section.
 
-To avoid errors when manually defining attributes on the model that could potentially be in conflict with fields loaded using `DecoLite::Model#load!`, do the following:
+If you want to validate whether or not particular _fields_ were added to your model as attributes (i.e. `attr_accessor`), as a result of `#load!`ing data into your model, you need to do a few things:
+  - Create a `DecoLite::Model` subclass.
+  - Override the `DecoLite::Model#required_fields` method to return the field names you want to validate.
+  - Use the `required_fields: nil` option when instantiating your model object.
+  - DO NOT add `ActiveModel` validators that _explicitly_ reference any field returned from `DecoLite::Model#required_fields`; this will cause `attr_accessors` to be created for these fields; consequently, `DecoLite::FieldRequireable#validate_required_fields` will _never_ return any errors because these fields will exist as attributes on your model. In other words, do not add `validates :first, :last, :address, presence: true` to your model if you need to validate whether or not the data you load into your model included fields :first, :last and :address.
+
+For example:
+
+```ruby
+class Model < DecoLite::Model
+  # :age field is optional and it's value is optional.
+  validates :age, numericality: { only_integer: true }, allow_blank: true
+
+  def required_fields
+    # We want to ensure attr_accessors are created for these fields.
+    %i(first last address)
+  end
+end
+
+# Option "required_fields: :auto" is the default which will automatically create
+# attr_accessors for fields returned from DecoLite::Model#required_fields, so we
+# need to set this option to nil (i.e. required_fields: nil).
+model = Model.new(options: { required_fields: nil })
+
+model.validate
+#=> false
+model.errors.full_messages
+#=> ["First field is missing", "Last field is missing", "Address field is missing"]
+
+user = { first: 'John', last: 'Doe', address: '123 anystreet, anytown, nj 01234'}
+model.load!(hash: user)
+model.validate
+#=> false
+model.errors.full_messages
+#=> ["Age is not a number"]
+```
+#### Validate whether or not certain fields were loaded _and_ validate the data associated with these same fields
+
+If you simply want to validate the _data_ loaded into your model, simply add `ActiveModel` validation, just like you would any other `ActiveModel` model, see the [Add validators to my model](#add-validators-to-my-model) section.
+
+If you want to validate whether or not particular fields were loaded _and_ field data associated with these same fields, you'll have to use custom validation (e.g. override `DecoLite::FieldRequireable#validate_required_fields` and manually add your own validation and errors). This is because `DecoLite::Model#new` will automatically create `attr_accessors` for any attribute (field) that has an _explicit_ `ActiveModel` validation associated with it, and return false positives when you validate your model. In addition to this, you will need to do several other things outlined in the [Validate whether or not certain fields were loaded](#validate-whether-or-not-certain-fields-were-loaded) section.
+
+For example:
+
+```ruby
+class Model < DecoLite::Model
+  def required_fields
+    %i(first last address age)
+  end
+
+  def validate_required_fields
+    super
+
+    first = self.try(:first)
+    errors.add(:first, "can't be blank") if first.nil?
+
+    last = self.try(:last)
+    errors.add(:last, "can't be blank") if last.nil?
+
+    address = self.try(:address)
+    errors.add(:address, "can't be blank") if address.nil?
+
+    age = self.try(:age)
+    errors.add(:age, "can't be blank") if age.nil?
+    errors.add(:age, 'is not a number') unless /\d+/ =~ age
+  end
+end
+model = Model.new(options: { required_fields: nil })
+
+model.validate
+#=> false
+
+model.errors.full_messages
+#=> ["First field is missing",
+ "Last field is missing",
+ "Address field is missing",
+ "Age field is missing",
+ "First can't be blank",
+ "Last can't be blank",
+ "Address can't be blank",
+ "Age can't be blank",
+ "Age is not a number"]
+```
+
+#### Manually define attributes (fields) on my model
+
+Manually defining attributes on your subclass is possible, although there doesn't seem a valid reason to do so, since you can just use `DecoLite::Model#load!` to wire all this up for you automatically. However, if there _were_ a need to do this, you must add your `attr_reader` to the `DecoLite::Model@field_names` array, or an error will be raised _provided_ there are any conflicting field names being loaded using `DecoLite::Model#load!`. Note that the aforementioned error will be raised regardless of whether or not you set `options: { fields: :merge }`. This is because DecoLite considers any existing model attributes _not_ added to the model via `load!`to be native to the model object, and therefore will not allow you to create attr_accessors for existing model attributes because this can potentially be dangerous.
+
+To avoid errors when manually defining model attributes that could potentially conflict with fields loaded using `DecoLite::Model#load!`, do the following:
 
 ```ruby
 class JustBecauseYouCanDoesntMeanYouShould < DecoLite::Model
@@ -193,6 +317,35 @@ class JustBecauseYouCanDoesntMeanYouShould < DecoLite::Model
 end
 ```
 
+However, the above is unnecessary as this can be easily accomplished using `DecoLite::Model#load!`:
+```ruby
+model = Class.new(DecoLite::Model).new.load!(hash:{ existing_field: :existing_field_value })
+
+model.field_names
+#=> [:existing_field]
+
+model.existing_field
+#=> :existing_field_value
+
+model.respond_to? :existing_field=
+#=> true
+```
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'deco_lite'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install deco_lite
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/console

@@ -10,6 +10,5 @@ require 'deco_lite'
 # (If you use this, don't forget to add pry to your Gemfile!)
 # require "pry"
 # Pry.start
-
-require 'irb'
-IRB.start(__FILE__)
+require 'pry-byebug'
+Pry.start

data/lib/deco_lite/field_conflictable.rb

@@ -1,43 +1,50 @@
 # frozen_string_literal: true
 
+require_relative 'field_name_namespaceable'
 require_relative 'fields_optionable'
 
 module DecoLite
   # Defines methods to to manage fields that conflict with
   # existing model attributes.
   module FieldConflictable
+    include FieldNameNamespaceable
     include FieldsOptionable
 
     def validate_field_conflicts!(field_name:, options:)
       return unless field_conflict?(field_name: field_name, options: options)
 
+      field_name = field_name_or_field_name_with_namespace field_name: field_name, options: options
+
       raise "Field :#{field_name} conflicts with existing method(s) " \
-        ":#{field_name} and/or :#{field_name}=; " \
-        'this will raise an error when loading using strict mode ' \
-        "(i.e. options: { #{OPTION_FIELDS}: :#{OPTION_FIELDS_STRICT} }) " \
-        'or if the method(s) are native to the object (e.g :to_s, :==, etc.).'
+            ":#{field_name} and/or :#{field_name}=; " \
+            'this will raise an error when loading using strict mode ' \
+            "(i.e. options: { #{OPTION_FIELDS}: :#{OPTION_FIELDS_STRICT} }) " \
+            'or if the method(s) are native to the object (e.g :to_s, :==, etc.). ' \
+            "Current options are: options: #{options.to_h}."
     end
 
     # This method returns true
     def field_conflict?(field_name:, options:)
       # If field_name was already added using Model#load, there is only a
       # conflict if options.strict? is true.
-      if field_names_include?(field_name: field_name)
-        return options.strict?
-      end
+      return options.strict? if field_names_include?(field_name: field_name, options: options)
 
       # If we get here, we know that :field_name does not exist as an
       # attribute on the model. If the attribute already exists on the
       # model, this is a conflict because we cannot override an attribute
       # that already exists on the model
-      attr_accessor_exist?(field_name: field_name)
+      attr_accessor_exist?(field_name: field_name, options: options)
     end
 
-    def field_names_include?(field_name:)
+    def field_names_include?(field_name:, options:)
+      field_name = field_name_or_field_name_with_namespace field_name: field_name, options: options
+
       field_names.include? field_name
     end
 
-    def attr_accessor_exist?(field_name:)
+    def attr_accessor_exist?(field_name:, options:)
+      field_name = field_name_or_field_name_with_namespace field_name: field_name, options: options
+
       respond_to?(field_name) || respond_to?(:"#{field_name}=")
     end
   end

data/lib/deco_lite/field_creatable.rb

@@ -30,6 +30,7 @@ module DecoLite
 
     private
 
+    # rubocop:disable Lint/UnusedMethodArgument
     def create_field_getter(field_name:, options:)
       define_singleton_method(field_name) do
         instance_variable_get "@#{field_name}"
@@ -41,5 +42,6 @@ module DecoLite
         instance_variable_set "@#{field_name}", value
       end
     end
+    # rubocop:enable Lint/UnusedMethodArgument
   end
 end

data/lib/deco_lite/field_name_namespaceable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DecoLite
+  # Defines methods to transform a field name into a field name
+  # with a namespace.
+  module FieldNameNamespaceable
+    def field_name_or_field_name_with_namespace(field_name:, options:)
+      return field_name unless options.namespace?
+
+      field_name_with_namespace(field_name: field_name, namespace: options.namespace)
+    end
+
+    def field_name_with_namespace(field_name:, namespace:)
+      "#{namespace}_#{field_name}"
+    end
+  end
+end

data/lib/deco_lite/field_requireable.rb

@@ -4,6 +4,8 @@ module DecoLite
   # Provides methods to manage fields that must be defined from
   # the dynamically loaded data.
   module FieldRequireable
+    MISSING_REQUIRED_FIELD_ERROR_TYPE = :missing_required_field
+
     # Returns field names that will be used to validate the presence of
     # dynamically created fields from loaded objects.
     #
@@ -23,7 +25,7 @@ module DecoLite
       required_fields.each do |field_name|
         next if required_field_exist? field_name: field_name
 
-        errors.add(field_name, 'field is missing', type: :missing_required_field)
+        errors.add(field_name, 'field is missing', type: MISSING_REQUIRED_FIELD_ERROR_TYPE)
       end
     end
 

data/lib/deco_lite/field_validatable.rb

@@ -3,14 +3,14 @@
 module DecoLite
   # Defines methods validate field (attribute) names.
   module FieldValidatable
-    FIELD_NAME_REGEX = /\A(?:[a-z_]\w*[?!=]?|\[\]=?|<<|>>|\*\*|[!~+\*\/%&^|-]|[<>]=?|<=>|={2,3}|![=~]|=~)\z/i.freeze
+    FIELD_NAME_REGEX = %r{\A(?:[a-z_]\w*[?!=]?|\[\]=?|<<|>>|\*\*|[!~+*/%&^|-]|[<>]=?|<=>|={2,3}|![=~]|=~)\z}i
 
     module_function
 
+    # rubocop:disable Lint/UnusedMethodArgument
     def validate_field_name!(field_name:, options: nil)
-      unless field_name =~ FIELD_NAME_REGEX
-        raise "field_name '#{field_name}' is not a valid field name."
-      end
+      raise "field_name '#{field_name}' is not a valid field name." unless FIELD_NAME_REGEX.match?(field_name)
     end
+    # rubocop:enable Lint/UnusedMethodArgument
   end
 end

data/lib/deco_lite/fields_auto_attr_accessable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DecoLite
+  # Defines fields that may have attr_accessors automatically created for them
+  # on the model.
+  module FieldsAutoloadable
+    private
+
+    def auto_attr_accessors?
+      auto_attr_accessors.present?
+    end
+
+    # This method returns a Hash of fields that are implicitly defined either
+    # through ActiveModel validators or by returning them from the
+    # #required_fields Array.
+    def auto_attr_accessors
+      return @auto_attr_accessors.dup if defined?(@auto_attr_accessors)
+
+      @auto_attr_accessors = self.class.validators.map(&:attributes)
+      @auto_attr_accessors.concat(required_fields) if options.required_fields_auto?
+      @auto_attr_accessors = auto_attr_accessors_assign
+    end
+
+    def auto_attr_accessors_assign
+      @auto_attr_accessors.flatten.uniq.each_with_object({}) do |field_name, auto_attr_accessors_hash|
+        auto_attr_accessors_hash[field_name] = nil
+      end
+    end
+  end
+end

data/lib/deco_lite/hash_loadable.rb

@@ -16,8 +16,8 @@ module DecoLite
       return {} if hash.blank?
 
       load_service_options = merge_with_load_service_options deco_lite_options: deco_lite_options
-      load_service.execute(hash: hash, options: load_service_options).tap do |h|
-        h.each_pair do |field_name, value|
+      load_service.execute(hash: hash, options: load_service_options).tap do |service_hash|
+        service_hash.each_pair do |field_name, value|
           create_field_accessor field_name: field_name, options: deco_lite_options
           field_names << field_name unless field_names.include? field_name
           set_field_value(field_name: field_name, value: value, options: deco_lite_options)

data/lib/deco_lite/hashable.rb

@@ -4,7 +4,7 @@ module DecoLite
   # Provides methods to convert the object to a Hash.
   module Hashable
     def to_h
-      field_names.each.each_with_object({}) do |field_name, hash|
+      field_names.each_with_object({}) do |field_name, hash|
         hash[field_name] = public_send field_name
       end
     end

data/lib/deco_lite/model.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 require 'active_model'
-require_relative 'field_creatable'
-require_relative 'field_requireable'
+require_relative 'field_assignable'
 require_relative 'field_names_persistable'
+require_relative 'field_requireable'
+require_relative 'fields_auto_attr_accessable'
 require_relative 'hash_loadable'
 require_relative 'hashable'
 require_relative 'model_nameable'
@@ -14,9 +15,10 @@ module DecoLite
   # dynamic models that can be used as decorators.
   class Model
     include ActiveModel::Model
-    include FieldCreatable
+    include FieldAssignable
     include FieldNamesPersistable
     include FieldRequireable
+    include FieldsAutoloadable
     include HashLoadable
     include Hashable
     include ModelNameable
@@ -24,15 +26,18 @@ module DecoLite
 
     validate :validate_required_fields
 
-    def initialize(options: {})
-      @field_names = []
-
+    def initialize(hash: {}, options: {})
       # Accept whatever options are sent, but make sure
       # we have defaults set up. #options_with_defaults
       # will merge options into OptionsDefaultable::DEFAULT_OPTIONS
       # so we have defaults for any options not passed in through
       # options.
       self.options = Options.with_defaults options
+
+      hash ||= {}
+
+      auto_fields = auto_attr_accessors.merge(hash)
+      load!(hash: auto_fields, options: options) if hash.present? || auto_attr_accessors?
     end
 
     def load!(hash:, options: {})
@@ -49,10 +54,10 @@ module DecoLite
     end
 
     def load(hash:, options: {})
-      puts 'WARNING: DecoLite::Model#load will be deprecated in a future release;' \
-        ' use DecoLite::Model#load! instead!'
+      puts 'WARNING: DecoLite::Model#load will be deprecated in a future release; ' \
+           'use DecoLite::Model#load! instead!'
 
-        load!(hash: hash, options: options)
+      load!(hash: hash, options: options)
     end
   end
 end

data/lib/deco_lite/options.rb

@@ -24,6 +24,10 @@ module DecoLite
           def namespace?
             namespace.present? || false
           end
+
+          def required_fields_auto?
+            required_fields == OPTION_REQUIRED_FIELDS_AUTO
+          end
         end
         validate_options! options: immutable_struct_ex.to_h
         immutable_struct_ex

data/lib/deco_lite/options_defaultable.rb

@@ -2,16 +2,19 @@
 
 require_relative 'fields_optionable'
 require_relative 'namespace_optionable'
+require_relative 'required_fields_optionable'
 
 module DecoLite
   # Defines default options and their optionn values.
   module OptionsDefaultable
     include DecoLite::FieldsOptionable
     include DecoLite::NamespaceOptionable
+    include DecoLite::RequiredFieldsOptionable
 
     DEFAULT_OPTIONS = {
       OPTION_FIELDS => OPTION_FIELDS_DEFAULT,
-      OPTION_NAMESPACE => OPTION_NAMESPACE_DEFAULT
+      OPTION_NAMESPACE => OPTION_NAMESPACE_DEFAULT,
+      OPTION_REQUIRED_FIELDS => OPTION_REQUIRED_FIELDS_DEFAULT
     }.freeze
   end
 end

data/lib/deco_lite/options_validatable.rb

@@ -2,14 +2,16 @@
 
 require_relative 'fields_optionable'
 require_relative 'namespace_optionable'
+require_relative 'required_fields_optionable'
 
 module DecoLite
   # Methods to validate options.
   module OptionsValidatable
     include DecoLite::FieldsOptionable
     include DecoLite::NamespaceOptionable
+    include DecoLite::RequiredFieldsOptionable
 
-    OPTIONS = [OPTION_FIELDS, OPTION_NAMESPACE].freeze
+    OPTIONS = [OPTION_FIELDS, OPTION_NAMESPACE, OPTION_REQUIRED_FIELDS].freeze
 
     def validate_options!(options:)
       raise ArgumentError, 'options is not a Hash' unless options.is_a? Hash
@@ -17,8 +19,9 @@ module DecoLite
       validate_options_present! options: options
 
       validate_option_keys! options: options
-      validate_option_fields! fields: options[:fields]
-      validate_option_namespace! namespace: options[:namespace]
+      validate_option_fields! fields: options[OPTION_FIELDS]
+      validate_option_namespace! namespace: options[OPTION_NAMESPACE]
+      validate_option_required_fields! required_fields: options[OPTION_REQUIRED_FIELDS]
     end
 
     def validate_options_present!(options:)
@@ -35,7 +38,7 @@ module DecoLite
 
       raise ArgumentError,
         "option :fields value or type is invalid. #{OPTION_FIELDS_VALUES} (Symbol) " \
-          "was expected, but '#{fields}' (#{fields.class}) was received."
+        "was expected, but '#{fields}' (#{fields.class}) was received."
     end
 
     def validate_option_namespace!(namespace:)
@@ -43,7 +46,16 @@ module DecoLite
       return if namespace.blank? || namespace.is_a?(Symbol)
 
       raise ArgumentError, 'option :namespace value or type is invalid. A Symbol was expected, ' \
-        "but '#{namespace}' (#{namespace.class}) was received."
+                           "but '#{namespace}' (#{namespace.class}) was received."
+    end
+
+    def validate_option_required_fields!(required_fields:)
+      # :required_fields is optional.
+      return if required_fields.blank? || OPTION_REQUIRED_FIELDS_VALUES.include?(required_fields)
+
+      raise ArgumentError,
+        "option :fields_required value or type is invalid. #{OPTION_REQUIRED_FIELDS_VALUES} (Symbol) " \
+        "was expected, but '#{required_fields}' (#{required_fields.class}) was received."
     end
   end
 end

data/lib/deco_lite/required_fields_optionable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DecoLite
+  # Defines the fields option hash key and acceptable hash key values.
+  module RequiredFieldsOptionable
+    # The option hash key for this option.
+    OPTION_REQUIRED_FIELDS = :required_fields
+    # The valid option values for this option key.
+    OPTION_REQUIRED_FIELDS_AUTO = :auto
+    # The default value for this option.
+    OPTION_REQUIRED_FIELDS_DEFAULT = OPTION_REQUIRED_FIELDS_AUTO
+    # The valid option key values for this option.
+    OPTION_REQUIRED_FIELDS_VALUES = [OPTION_REQUIRED_FIELDS_AUTO].freeze
+  end
+end

data/lib/deco_lite/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the version of this gem.
 module DecoLite
-  VERSION = '0.2.4'
+  VERSION = '0.3.1'
 end

data/lib/deco_lite.rb

@@ -3,6 +3,7 @@
 require_relative 'deco_lite/field_assignable'
 require_relative 'deco_lite/field_conflictable'
 require_relative 'deco_lite/field_creatable'
+require_relative 'deco_lite/field_name_namespaceable'
 require_relative 'deco_lite/field_names_persistable'
 require_relative 'deco_lite/field_requireable'
 require_relative 'deco_lite/field_retrievable'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deco_lite
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.1
 platform: ruby
 authors:
 - Gene M. Angelo, Jr.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-21 00:00:00.000000000 Z
+date: 2022-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -261,10 +261,12 @@ files:
 - lib/deco_lite/field_assignable.rb
 - lib/deco_lite/field_conflictable.rb
 - lib/deco_lite/field_creatable.rb
+- lib/deco_lite/field_name_namespaceable.rb
 - lib/deco_lite/field_names_persistable.rb
 - lib/deco_lite/field_requireable.rb
 - lib/deco_lite/field_retrievable.rb
 - lib/deco_lite/field_validatable.rb
+- lib/deco_lite/fields_auto_attr_accessable.rb
 - lib/deco_lite/fields_optionable.rb
 - lib/deco_lite/hash_loadable.rb
 - lib/deco_lite/hashable.rb
@@ -275,6 +277,7 @@ files:
 - lib/deco_lite/options.rb
 - lib/deco_lite/options_defaultable.rb
 - lib/deco_lite/options_validatable.rb
+- lib/deco_lite/required_fields_optionable.rb
 - lib/deco_lite/version.rb
 homepage: https://github.com/gangelo/deco_lite
 licenses: