light_service-validated_context 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22770c4c6eeee16f8c3705709e653810d114a94f798c9408f1e5d6cb31d69af2
-  data.tar.gz: 683201c0c625ebfa39b4cfeccbdb24d47fe4e246ea781fe32dd2ffc1983941b3
+  metadata.gz: 42b7fa071364c73605b8bd5fd1d374ea6942e575d386a714c477d67061ba8aeb
+  data.tar.gz: 7a9ee001a427055c2c30f90f982c98eadb0d8e3ee4209afd2acfa0e59c9da415
 SHA512:
-  metadata.gz: 8f33f7bd519557a9c3171b15312d4e902931c6ba8451cea28c6104b2ee490b0d44270d1e3678b06effd9e7dd9a75afd7738f853a11ef36df1ca4cd8692b23c33
-  data.tar.gz: 537103640214323d3b77a835e74f59a626486b152d185586a534e9300d290e95ce28fbb49dfa9a3d82f76144feebe2cfd45a396997e863aa8ca78ab8918208b1
+  metadata.gz: 78965b6a9605abf0e44e755be975c3277fdbc823df4d8296ab3850d38a2f62af053316dfdc86038b54540ce1348e68602541867fe6a268c500597be055b3d3a6
+  data.tar.gz: 43b9c95eb665b7667043ca18a36ad852cddfe3f5b6164176ac30c31f1f8697e390cdd242af069f6e82778e9eecfcb770c436ce650b9a4c2a0d42b518e5613ccf

data/.rubocop.yml

@@ -5,6 +5,7 @@ AllCops:
   TargetRubyVersion: 3.1
   Exclude:
     - "bin/*"
+    - 'vendor/bundle/**/*'
 
 Style/LambdaCall:
   Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    light_service-validated_context (0.1.1)
+    light_service-validated_context (0.2.0)
       dry-types (~> 1.7.0)
       light-service (>= 0.18.0)
       zeitwerk

data/README.md

@@ -1,5 +1,7 @@
 # LightService - ValidatedContext
 
+[![Ruby](https://github.com/pioneerskies/light_service-validated_context/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/pioneerskies/light_service-validated_context/actions/workflows/main.yml)
+
 This gem _patches_ `light-service` gem implementing validated keys
 for `expects` and `promises` action's macros.
 
@@ -37,16 +39,22 @@ And then execute:
 
     $ bundle install
 
+Would you need to manualy require the gem, here's the syntax:
+
+```ruby
+require 'light_service/validated_context'
+```
+
 ## Usage
 
 ```ruby
 class ActionOne
   extend LightService::Action
 
-  expects VK.(:email, Types::Strict::String)
-  expects VK.(:age, Types::Coercible::Integer.constrained(gt: 30))
-  expects VK.(:ary, Types::Array.of(Types::Strict::Symbol).constrained(min_size: 1))
-  promises VK.(:text, Types::Strict::String.constrained(max_size: 10).default('foobar'))
+  expects VK.new(:email, Types::Strict::String)
+  expects VK.new(:age, Types::Coercible::Integer.constrained(gt: 30))
+  expects VK.new(:ary, Types::Array.of(Types::Strict::Symbol).constrained(min_size: 1))
+  promises VK.new(:text, Types::Strict::String.constrained(max_size: 10).default('foobar'))
 
   executed do |context|
     # something happens
@@ -75,6 +83,70 @@ form to avoid name collisions.
 
 You can find more usage example in `spec/support/test_doubles.rb`
 
+## Why validation matters?
+
+In OO programming there's a rule (strict or "of thumb", IDK) that says to "never" instantiate an
+invalid object whenever the object self has the concept of _validity_ for itself. This rule takes
+sense to my eyes whenever I'm working with an object already initialized and in memory, but I cannot
+trust its internal status.
+
+Taken that `light-service` doesn't work on instances, but it works on classes and class methods
+having a more functional and stateless approach, side effects of having invalid state in the context
+(which is The state of an Action/Organizer) are mostly the same.
+
+Rewording: if I cannot trust the state, given
+the state is internal or delegated to a context object, I'll have to to a bunch of validation-oriented
+logical branches into my logic. E.g.:
+
+```ruby
+class HugAFriend
+  extend LightService::Action
+
+  expects :friend
+
+  executed do |context|
+    context.friend.hug if context.friend.respond_to?(:hug)
+  end
+end
+```
+
+The `if` in this uber-trivial example exists just due to lack of trust on the state.
+
+Let's re-imagine the code given an `executed` block that totally trusts the context:
+
+
+```ruby
+class HugAFriend
+  extend LightService::Action
+
+  expects VK.new(:friend, Types.Instance(Friend))
+  # Or a less usual approach could be to trust duck typing
+  # expects VK.new(:friend, Types::Interface(:hug))
+
+  executed do |context|
+    context.friend.hug
+  end
+end
+```
+
+## Comparison with similar gems
+
+This is a comparison table I've done using my own limited experience w/ other solutions
+and/or reading projects' READMEs. Don't take my word for it. And if I was wrong understanding
+some features, feel free to drop me a line on Mastodon [@alessandrofazzi@mastodon.uno](https://mastodon.uno/@alessandrofazzi)
+
+| Feature                   | adomokos/light-service | sunny/actor                                          | collectiveidea/interactor | AaronLasseigne/active_interaction | pioneerskies/light_service-validated_context/ |
+| ------------------------- | ---------------------- | ---------------------------------------------------- | ------------------------- | --------------------------------- | --------------------------------------------- |
+| presence                  | ✅                      | ✅                                                    | ❌                         | ⚠️ Only input, not output   | ✅                                             |
+| static default            | ✅                      | ✅                                                    | ❌                         | ✅                                 | ✅                                             |
+| dynamic default           | ✅                      | ✅                                                    | ❌                         | ✅                                 | ✅                                             |
+| raise or fail control     | ❌                      | ✅                                                    | ❌                         | ❓                                 | ❌                                             |
+| type check                | ❌                      | ✅                                                    | ❌                         | ✅                                 | ✅                                             |
+| data structure type check | ❌                      | ❌                                                    | ❌                         | ❌                                 | ✅                                             |
+| optional                  | ⚠️ through `default`    | ✅ through `allow_nil` (which defaults to `true` 🤔 ❓) | ❌                         | ⚠️ through `default`               | ✅                                             |
+| built-in                  | ✅                      | ✅                                                     | ❌                         | ❌ ActiveModel::Validation        | ❌ Dry::Types                                  |
+
+
 ## 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/lib/light_service/validated_context/context_overrides.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ValidatedContext
-  module ContextOverrides
+  module Context
     def define_accessor_methods_for_keys(keys)
       super keys.map(&:to_sym)
     end

data/lib/light_service/validated_context/expected_key_verifier.rb

@@ -3,15 +3,29 @@
 module ValidatedContext
   module ExpectedKeyVerifier
     def keys
+      keys_as_symbols
+    end
+
+    def keys_as_symbols
       action.expected_keys.map do |key|
         next key unless key.is_a?(LightService::Context::ValidatedKey)
 
-        key.label
+        key.to_sym
       end
     end
 
     def raw_keys
       action.expected_keys
     end
+
+    def throw_error_predicate(keys)
+      type_check_and_coerce_keys!(raw_keys)
+
+      keys_are_all_present = are_all_keys_in_context?(keys)
+
+      return false if are_all_keys_valid? && keys_are_all_present
+
+      true
+    end
   end
 end

data/lib/light_service/validated_context/key_verifier.rb

@@ -2,38 +2,28 @@
 
 module ValidatedContext
   module KeyVerifier
-    def are_all_keys_valid?(validated_keys)
+    def type_check_and_coerce_keys!(keys)
       errors = []
 
-      validated_keys.each do |key|
+      keys.each do |key|
         next unless key.is_a?(LightService::Context::ValidatedKey)
 
         begin
           context[key.label] = key.type[context[key.label] || Dry::Types::Undefined]
         rescue Dry::Types::CoercionError => e
-          errors << e.message
+          errors << "[#{action}][:#{key.label}] #{e.message}"
         end
       end
-
-      [errors.none?, errors]
+      # debugger
+      @validation_errors = errors
     end
 
-    def are_all_keys_in_context?(keys)
-      keys_are_all_valid, validation_errors = are_all_keys_valid?(raw_keys)
-
-      not_found_keys = keys_not_found(keys)
-      keys_are_all_present = not_found_keys.none?
-
-      return true if keys_are_all_valid && keys_are_all_present
-
-      msg = if !keys_are_all_present
-              error_message
-            elsif !keys_are_all_valid
-              validation_errors.join(', ')
-            end
+    def are_all_keys_valid?
+      @validation_errors.none?
+    end
 
-      LightService::Configuration.logger.error msg
-      raise error_to_throw, msg
+    def error_message
+      @validation_errors.join(', ')
     end
   end
 end

data/lib/light_service/validated_context/promised_key_verifier.rb

@@ -3,15 +3,29 @@
 module ValidatedContext
   module PromisedKeyVerifier
     def keys
-      action.promised_keys.map do |key|
+      keys_as_symbols
+    end
+
+    def keys_as_symbols
+      raw_keys.map do |key|
         next key unless key.is_a?(LightService::Context::ValidatedKey)
 
-        key.label
+        key.to_sym
       end
     end
 
     def raw_keys
       action.promised_keys
     end
+
+    def throw_error_predicate(keys)
+      type_check_and_coerce_keys!(raw_keys)
+
+      keys_are_all_present = are_all_keys_in_context?(keys)
+
+      return false if are_all_keys_valid? && keys_are_all_present
+
+      true
+    end
   end
 end

data/lib/light_service/validated_context/validated_key.rb

@@ -2,10 +2,6 @@
 
 module ValidatedContext
   ValidatedKey = Struct.new(:label, :type) do
-    def self.call(*args)
-      new(*args)
-    end
-
     def to_sym
       label.to_sym
     end

data/lib/light_service/validated_context/version.rb

@@ -2,6 +2,6 @@
 
 module LightService
   module ValidatedContext
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/lib/light_service/validated_context.rb

@@ -12,15 +12,17 @@ module ValidatedContext; end
 module LightService
   class Context
     ValidatedKey = ::ValidatedContext::ValidatedKey
-    prepend ::ValidatedContext::ContextOverrides
+    prepend ::ValidatedContext::Context
 
-    class ExpectedKeyVerifier
+    class KeyVerifier
       prepend ::ValidatedContext::KeyVerifier
+    end
+
+    class ExpectedKeyVerifier
       prepend ::ValidatedContext::ExpectedKeyVerifier
     end
 
     class PromisedKeyVerifier
-      prepend ::ValidatedContext::KeyVerifier
       prepend ::ValidatedContext::PromisedKeyVerifier
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light_service-validated_context
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - "'Alessandro Fazzi'"
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-29 00:00:00.000000000 Z
+date: 2022-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-types