deco_lite 0.2.5 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74286df21784817e45f4d615081bfeac44d90f13d8200bc8f066107e8d0f773f
-  data.tar.gz: 57dcc52147494eb3caf59159cbb21bc23bb6788d0b6315ebc1ddd8cf1868c779
+  metadata.gz: b5b5ed040bd367962dd57760a6a0e572b60485ba1d2d3630980ff1a090ca9075
+  data.tar.gz: 76402762f17d93fd53495ddabf86487803b0014971db007f61f505727e933f56
 SHA512:
-  metadata.gz: b79af6a65df899227821e4a02bf17587f1f423042a4280a54525c8469c1c3344f3dd2c3b16bd0de477c711d27ed04527295ca37e811c1c829037379509971ac6
-  data.tar.gz: 7d1b5dea80d0af672713d18675166207e2d62ab51aff84045411d02344529a32de513df76d394e3769dfb14a69d0742f18e850398dc9b4cc6bac10eb5c72ecec
+  metadata.gz: 584e1c07a160370bc9548e7a41dbaa9adcbee757a35a37925d02accf4ebe71d24cd9d2932e706724f5d8d64e8d98ff77f223224de27e5a0d817eb2675fea81ca
+  data.tar.gz: 6a49a3ab8bdcb947341697577e130dd667c508095578536e8d003cfa1424f8e090f3c40e9ddc1376a3337cdcc9a26a02e836bc901c0ae36da39a8acaaae8cc46

data/.gitignore

@@ -16,5 +16,5 @@
 /.vscode/
 *.code-workspace
 
-scratch.rb
+scratch*.rb
 readme.txt

data/.reek.yml

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

data/.rubocop.yml

@@ -13,7 +13,7 @@ AllCops:
     - '*.gemspec'
     - 'spec/**/*'
     - 'vendor/**/*'
-    - 'scratch.rb'
+    - 'scratch*.rb'
 
 # Align the elements of a hash literal if they span more than one line.
 Layout/HashAlignment:
@@ -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,3 +1,23 @@
+### 0.3.2
+* Changes
+  * Refactor FieldAssignable to remove call to FieldCreatable#create_field_accessor as this breaks single responsibility rule; which, in this case, makes sense to remove. FieldCreatable#create_field_accessor can be called wherever creation of a attr_accessor is needed.
+  * Refactor specs in keeping with above changes.
+  * README.md changes.
+* Bugs
+  * Fix bug where loading fields with the options: { fields: :strict } option raises an error for field that already exists.
+
+### 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.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    deco_lite (0.2.5)
+    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

@@ -13,19 +13,19 @@
 
 ## Introduction
 
-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.
+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 might try work out a reasonable solution for all this in future releases if the need is there.
 
-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 (e.g. options `fields: :merge` and `fields: :strict` for example; 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 initializer (`DecoLite::Model#new`) or 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,67 @@ 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, and assign the values:
 
 ```ruby
-name=, name #=> 'John Doe'
-age=, age #=> 35
-wife_name=, wife_name #=> 'Mary Doe'
-wife_age=, wife_age #=> 30
+# Or DecoLite::Model.new.load!(hash: family)
+model = DecoLite::Model.new(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.new(hash: family).
 ```
 
-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
@@ -79,9 +109,7 @@ class ViewModel < DecoLite::Model
   end
 end
 
-view_model = ViewModel.new
-
-view_model.load(hash: { first: 'John', last: 'Doe' })
+view_model = ViewModel.new(hash: { first: 'John', last: 'Doe' })
 
 view_model.valid?
 #=> true
@@ -96,23 +124,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 +166,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 +181,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
+```
+
+#### Validate whether or not certain fields were loaded
+
+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.
+
+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 Defining Attributes
+#### Manually define attributes (fields) on my model
 
-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.
+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 attributes on the model that could potentially be in conflict with fields loaded using `DecoLite::Model#load!`, do the following:
+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 +316,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_assignable.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'field_creatable'
 require_relative 'field_retrievable'
 
 module DecoLite
   # Defines methods to assign model field values dynamically.
   module FieldAssignable
-    include FieldCreatable
     include FieldRetrievable
 
     def set_field_values(hash:, field_info:, options:)
@@ -16,10 +14,10 @@ module DecoLite
       end
     end
 
+    # rubocop:disable Lint/UnusedMethodArgument
     def set_field_value(field_name:, value:, options:)
-      # Create our fields before we send.
-      create_field_accessor field_name: field_name, options: options
       send("#{field_name}=", value)
     end
+    # rubocop:enable Lint/UnusedMethodArgument
   end
 end

data/lib/deco_lite/field_conflictable.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'field_name_namespaceable'
+require_relative 'field_requireable'
 require_relative 'fields_optionable'
 
 module DecoLite
@@ -9,6 +10,7 @@ module DecoLite
   module FieldConflictable
     include FieldNameNamespaceable
     include FieldsOptionable
+    include FieldRequireable
 
     def validate_field_conflicts!(field_name:, options:)
       return unless field_conflict?(field_name: field_name, options: options)
@@ -19,7 +21,8 @@ module DecoLite
             ":#{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.).'
+            '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

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/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

@@ -2,11 +2,13 @@
 
 require 'mad_flatter'
 require_relative 'field_assignable'
+require_relative 'field_creatable'
 
 module DecoLite
   # Provides methods to load and return information about a given hash.
   module HashLoadable
     include FieldAssignable
+    include FieldCreatable
 
     private
 
@@ -16,8 +18,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,8 +4,12 @@ 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|
-        hash[field_name] = public_send field_name
+      field_names.each_with_object({}) do |field_name, hash|
+        field_value = public_send(field_name)
+
+        field_name, field_value = yield [field_name, field_value] if block_given?
+
+        hash[field_name] = field_value
       end
     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,13 +26,18 @@ module DecoLite
 
     validate :validate_required_fields
 
-    def initialize(options: {})
+    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: {})
@@ -40,7 +47,6 @@ module DecoLite
       # options while loading, but also provide option customization
       # of options when needed.
       options = Options.with_defaults(options, defaults: self.options)
-
       load_hash(hash: hash, deco_lite_options: options)
 
       self

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:)
@@ -45,5 +48,14 @@ module DecoLite
       raise ArgumentError, 'option :namespace value or type is invalid. A Symbol was expected, ' \
                            "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.5'
+  VERSION = '0.3.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deco_lite
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.2
 platform: ruby
 authors:
 - Gene M. Angelo, Jr.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-22 00:00:00.000000000 Z
+date: 2022-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -266,6 +266,7 @@ files:
 - 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
@@ -276,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: