deco_lite 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40f7b315deefbdf848f9d2743d27e672d3916da793f0bd32a705c7d34acac1f9
-  data.tar.gz: b283948784b3fd9b1a4eaef20b7f0ca26a7de9b2971042c04a01021be6195d10
+  metadata.gz: 8a87d5a79f738b49d45b51c0128b4c252853c683363e7525df836fc7c46e4953
+  data.tar.gz: 1f07c897d0f88cd3609a8e6a880d0ce91b71210ee8952eb29148370b2f49f092
 SHA512:
-  metadata.gz: 37a1083dfa95d51ab710fff1bab946edcc5b9fa825e37bf7f29c7a0174198d913469c8ac17f82b795949425f7e068236c73ca2ed9df50aba45bdfa3ef7cf1d18
-  data.tar.gz: f3fbb8ab71dad6720dae8dc25179977757d55f7b802c2016ffc673fcdd423b3f86d04a406bd9a4bade6233efb5120cad1d7c2d7176045f44ec78da911311419a
+  metadata.gz: afc6320e0a1e9060dda231249fe16e62bf62d56f11ad7ffa9c4c6a0f094ef866173655c4ee57a419b3c4b83d0d7b7639230db22459f3c2d81d78cc6c4da2dde2
+  data.tar.gz: 6db8e3cb9a634669667eb288f4a4343106ad9be71630c1a9e95af366649b86e88459d0b79f1c71e09345a75805e643aa1e1e3a2836e2045bd1191bd78484685c

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### 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>)`.

data/Gemfile.lock

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

@@ -188,24 +188,117 @@ model.wife_info_address     #=> 1 street, boonton, nj 07005
 
 #### 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) being validated that does not exist on the model, will raise a `NoMethodError` error:
+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
 
-model = Model.new(hash: { first: 'John', last: 'Doe' })
+# No :address
+model = Model.new(hash: { first: 'John', last: 'Doe', age: 25 })
+model.respond_to? :address
+#=> true
 
-# No :address; a NoMethodError error for :address will be raised.
-model.validate
-#=> undefined method 'address' for #<Model:0x00007f95931568c0 ... @field_names=[:first, :last], @first="John", @last="Doe", ...> (NoMethodError)
+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 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.

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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deco_lite
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Gene M. Angelo, Jr.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-26 00:00:00.000000000 Z
+date: 2022-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel