pathway 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb77df296a81bb4d0d277c4c802e990727f58e9c6fd5dee20ca3e0986aa954f2
-  data.tar.gz: 6921ad015f25c29bf669d815b86518eba9c11938da78f8f37aec9ab6d9a3ed4f
+  metadata.gz: a2a1f9207d8b2db81dbf655234010e4cb8c622299cb69c1dfaa9486f824a7e86
+  data.tar.gz: 25e380e764a1b1585b86ae847b2cbc107a83fa23f1a1205e4e1e5e1a2c021c50
 SHA512:
-  metadata.gz: 1f1d59e04131f194731a6890aa40cf498df3bd15fbe65818ed6e90b43e3a96a1ef94d647737bd94fa8e1e43eef3583a3bcc04df03c7e45ea155f7e6f998610a1
-  data.tar.gz: 222112d0f9a8a7c23499afa2d656f961fdef7e32df3de6c165e55fb81357d2db27605ea3882d1d7d2c1886165f25b27d9d272d6c493cd5fd5bfe5894ff25ae18
+  metadata.gz: 393014838fece86b27409c08ef0f5ccb9d7dacf5f5012d956bbf0e7ca3869175e4090c6dd23cf6c8f61bfcecd15839a738b87afcf911c226a06ea36e8cb91dc3
+  data.tar.gz: 1dd63c594d299837fb1b595f14fd2056ac39f81fdd508254c331fb9ef4b3a67262e0f47683bb5e0296708076d88c12aef0dd981c8864391d43f0bc6083ad9422

data/.github/workflows/tests.yml

@@ -0,0 +1,28 @@
+name: Tests
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: [2.6, 2.7, 3.0, 3.1]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rake
+    - name: Coveralls GitHub Action
+      if: matrix.ruby-version == '3.1'
+      uses: coverallsapp/github-action@1.1.3
+      with:
+        github-token: ${{ secrets.GITHUB_TOKEN }}

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [0.12.0] - 2022-05-31
+### Changed
+- Improve compatibility with Ruby 3.0
+- Add plugin `:auto_deconstruct_state` to help migrating old apps to Ruby 3.0
+
+## [0.11.3] - 2020-07-22
+### Changed
+- Use default error message on `:fetch_model` step, at `:sequel_models` plugin, if model type cannot be determined
+
+## [0.11.2] - 2020-07-22
+### Changed
+- Improve `from:` option for `:fetch_model` step, at `:sequel_models` plugin, to also accept a Sequel Dataset
+
 ## [0.11.1] - 2020-01-09
 ### Changed
 - Improve custom `rspec` matchers for testing field presence on schemas

data/README.md

@@ -1,7 +1,7 @@
 # Pathway
 
 [![Gem Version](https://badge.fury.io/rb/pathway.svg)](https://badge.fury.io/rb/pathway)
-[![CircleCI](https://circleci.com/gh/pabloh/pathway/tree/master.svg?style=shield)](https://circleci.com/gh/pabloh/pathway/tree/master)
+[![Tests](https://github.com/pabloh/pathway/workflows/Tests/badge.svg)](https://github.com/oabloh/pathway/actions?query=workflow%3ATests)
 [![Coverage Status](https://coveralls.io/repos/github/pabloh/pathway/badge.svg?branch=master)](https://coveralls.io/github/pabloh/pathway?branch=master)
 
 Pathway encapsulates your business logic into simple operation objects (AKA application services on the [DDD](https://en.wikipedia.org/wiki/Domain-driven_design) lingo).
@@ -91,36 +91,37 @@ end
 #### Error objects
 
 `Pathway::Error` is a helper class to represent the error description from an failed operation execution (and can be used also for pattern matching as we'll see later).
-It's use is completely optional, but provides you with a basic schema to communicate what when wrong. You can instantiate it by calling `new` on the class itself or using the helper method `error` provided in the operation class:
+Its use is completely optional, but provides you with a basic schema to communicate what when wrong. You can instantiate it by calling `new` on the class itself or using the helper method `error` provided by the operation class:
 
 ```ruby
 class CreateNugget < Pathway::Operation
   def call(input)
-    validation = Form.call(input)
+    validation = Validator.call(input)
 
     if validation.ok?
       success(Nugget.create(validation.values))
     else
-      error(type: :validation, message: 'Invalid input', details: validation.errors)
+      error(:validation, message: 'Invalid input', details: validation.errors)
     end
   end
 end
 ```
 
-As you can see `error(...)` expects `type:`, `message:` and `details` keyword arguments; `type:` is the only mandatory, the other ones can be omitted and have default values. Also `type` should be a `Symbol`, `message:` a `String` and `details:` can be a `Hash` or any other structure you see fit.
+As you can see `error(...)` expects the `type` as the first parameter (and only the mandatory) then `message:` and `details` keyword arguments; these 2 last ones can be omitted and have default values. The type parameter must be a `Symbol`, `message:` a `String` and `details:` can be a `Hash` or any other structure you see fit.
 
-You then have accessors available on the error object to get the values back:
+Finally, the `Error` object have three accessors available to get the values back:
 
 ```ruby
 result = CreateNugget.new.call(foo: 'foobar')
 if result.failure?
   puts "#{result.error.type} error: #{result.error.message}"
+  puts "Error details: #{result.error.details}"
 end
 
 ```
 
 Mind you, `error(...)` creates an `Error` object wrapped into a `Pathway::Failure` so you don't have to do it yourself.
-If you decide to use `Pathway::Error.new(...)` directly, the expected arguments will be the same, but you will have to wrap the object before returning it.
+If you decide to use `Pathway::Error.new(...)` directly, you will have to pass all the arguments as keywords (including `type:`), and you will have to wrap the object before returning it.
 
 #### Initialization context
 
@@ -135,7 +136,7 @@ class CreateNugget < Pathway::Operation
   context :current_user, notify: false
 
   def call(input)
-    validation = Form.call(input)
+    validation = Validator.call(input)
 
     if validation.valid?
       nugget = Nugget.create(owner: current_user, **validation.values)
@@ -143,7 +144,7 @@ class CreateNugget < Pathway::Operation
       Notifier.notify(:new_nugget, nugget) if @notify
       success(nugget)
     else
-      error(type: :validation, message: 'Invalid input', details: validation.errors)
+      error(:validation, message: 'Invalid input', details: validation.errors)
     end
   end
 end
@@ -266,17 +267,17 @@ class CreateNugget < Pathway::Operation
     if validation.ok?
       state[:params] = validation.values
     else
-      error(type: :validation, details: validation.errors)
+      error(:validation, details: validation.errors)
     end
   end
 
   def create_nugget(:params, **)
     Nugget.create(owner: current_user, **params)
-  def
+  end
 
   def notify(:nugget, **)
     Notifier.notify(:new_nugget, nugget)
-  else
+  end
 end
 ```
 
@@ -313,8 +314,8 @@ class SomeOperation < BaseOperation
 end
 ```
 
-The plugin name must be specified as a `Symbol` (or also as the `Module` where is implemented, but more on that later), and can it take parameters next to the plugin's name.
-When activated it will enrich your operations with new instance and class methods plus extra customs step for the process DSL.
+The plugin name must be specified as a `Symbol` (or also as the `Module` where is implemented, but more on that later), and it can take parameters next to the plugin's name.
+When activated it will enrich your operations with new instance and class methods plus extra customs step for the `process` DSL.
 
 Mind you, if you wish to activate a plugin for a number of operations you can activate it for all of them directly on the `Pathway::Operation` class, or you can create your own base operation and all its descendants will inherit the base class' plugins.
 
@@ -322,21 +323,23 @@ Mind you, if you wish to activate a plugin for a number of operations you can ac
 
 This plugin provides integration with the [dry-validation](http://dry-rb.org/gems/dry-validation/) gem. I won't explain in detail how to use this library since is already extensively documented on its official website, but instead I'll assume certain knowledge of it, nonetheless, as you'll see in a moment, its API pretty self-explanatory.
 
-`dry-validation` provides a very simple way to define form (or schema) objects to process and validate our input. The provided custom `:validate` step allows you to run your input though a form to check your data is valid before continuing. When the input is invalid it will return an error object with type `:validation` and the reasons the validation failed on the `details` attribute. Is commonly the first step any operation runs.
+`dry-validation` provides a very simple way to define contract objects (conceptually very similar to form objects) to process and validate input. The provided custom `:validate` step allows you to run your input though a contract to check if your data is valid before carrying on. When the input is invalid it will return an error object of type `:validation` and the reasons the validation failed will be available at the `details` attribute. Is usually the first step an operation runs.
 
-When using this plugin we'll have to provide an already defined form to the step to use or we can also define one inline.
+When using this plugin we can provide an already defined contract to the step to use or we can also define it within the operation.
 Let's see a few examples:
 
 ```ruby
-NuggetForm = Dry::Validation.Form do
-  required(:owner).filled(:str?)
-  required(:price).filled(:int?)
+class NuggetContract < Dry::Validation::Contract
+  params do
+    required(:owner).filled(:string)
+    required(:price).filled(:integer)
+  end
 end
 
 class CreateNugget < Pathway::Operation
   plugin :dry_validation
 
-  form NuggetForm
+  contract NuggetContract
 
   process do
     step :validate
@@ -347,15 +350,17 @@ class CreateNugget < Pathway::Operation
 end
 ```
 
-As it can be seen at the code above, the form is first created elsewhere, then is configured to be used by the operation (by calling `form NuggetForm`), and validate the input at the process block by calling `step :validate`.
+As is is shown above, the contract is defined first, then is configured it will be used by the operation by calling `contract NuggetContract`, and validate the input at the process block by placing the step `step :validate` inside the `process` block.
 
 ```ruby
 class CreateNugget < Pathway::Operation
   plugin :dry_validation
 
-  form do
-    required(:owner).filled(:str?)
-    required(:price).filled(:int?)
+  contract do
+    params do
+      required(:owner).filled(:string)
+      required(:price).filled(:integer)
+    end
   end
 
   process do
@@ -367,16 +372,36 @@ class CreateNugget < Pathway::Operation
 end
 ```
 
-Now, this second example is equivalent to the first one, but here we call `form` with a block instead and no parameter; this block will be use as definition body for a form object that will be stored internally. Thus keeping the form and operation at the same place, this is convenient when you have a rather simpler form and don't need to reuse it.
+Now, this second example is equivalent to the first one, but here we call `contract` with a block instead and no parameter; this block will be used as definition body for a contract class that will be stored internally. Thus keeping the contract and operation code at the same place, this is convenient when you have a rather simpler contract and don't need to reuse it.
+
+One interesting nuance to keep in mind regarding the inline block contract is that, when doing operation inheritance, if the parent operation already has a contract, the child operation will define a new one inheriting from the parent's. This is very useful to share validation logic among related operations in the same class hierarchy.
+
+As a side note, if your contract is simple enough and only have params, you can call the `params` method directly instead, the following code is essentially equivalent to previous example:
+
+```ruby
+class CreateNugget < Pathway::Operation
+  plugin :dry_validation
+
+  params do
+    required(:owner).filled(:string)
+    required(:price).filled(:integer)
+  end
+
+  process do
+    step :validate
+    step :create_nugget
+  end
 
-One interesting nuance to keep in mind regarding the inline block form is that, when doing operation inheritance, if the parent operation already has a form, the child operation will define a new one extending from the parent's. This is very useful to share form functionality among related operations in the same class hierarchy.
+  # ...
+end
+```
 
-##### Form options
+##### Contract options
 
-If you are familiar with `dry-validation` you probably know it provides a way to [inject options](http://dry-rb.org/gems/dry-validation/basics/working-with-schemas/#injecting-external-dependencies) before calling the form instance.
+If you are familiar with `dry-validation` you probably know it provides a way to [inject options](https://dry-rb.org/gems/dry-validation/1.4/external-dependencies/) before calling the contract.
 
-On those scenarios you must either use the `auto_wire_options: true` plugin argument, or specify how to map options from the execution state to the form when calling `step :validate`.
-Lets see and example for each case:
+On those scenarios you must either use the `auto_wire_options: true` plugin argument, or specify how to map options from the execution state to the contract when calling `step :validate`.
+Lets see and example for the first case:
 
 ```ruby
 class CreateNugget < Pathway::Operation
@@ -384,11 +409,17 @@ class CreateNugget < Pathway::Operation
 
   context :user_name
 
-  form do
-    configure { option :user_name }
+  contract do
+    option :user_name
+
+    params do
+      required(:owner).filled(:string)
+      required(:price).filled(:integer)
+    end
 
-    required(:owner).filled(:str?, :eql?: user_name)
-    required(:price).filled(:int?)
+    rule(:owner) do
+      key.failure("invalid owner") unless user_name == values[:owner]
+    end
   end
 
   process do
@@ -400,25 +431,33 @@ class CreateNugget < Pathway::Operation
 end
 ```
 
-Here the defined form needs a `:user_name` option, so we tell the operation to grab the attribute with the same name from the state by activating `:auto_wire_options`, afterwards, when the validation runs, the form will already have the user name available.
+Here the defined contract needs a `:user_name` option, so we tell the operation to grab the attribute with the same name from the state by activating `:auto_wire_options`, afterwards, when the validation runs, the contract will already have the user name available.
 
 Mind you, this option is `false` by default, so be sure to set it to `true` at `Pathway::Operation` if you'd rather have it enabled for all your operations.
 
+On the other hand, if for some reason the name of the contract's option and state attribute don't match, we can just pass `with: {...}` when calling to `step :validate`, indicating how to wire the attributes, the following example illustrates just that:
+
 ```ruby
 class CreateNugget < Pathway::Operation
   plugin :dry_validation
 
   context :current_user_name
 
-  form do
-    configure { option :user_name }
+  contract do
+    option :user_name
+
+    params do
+      required(:owner).filled(:string)
+      required(:price).filled(:integer)
+    end
 
-    required(:owner).filled(:str?, :eql?: user_name)
-    required(:price).filled(:int?)
+    rule(:owner) do
+      key.failure("invalid owner") unless user_name == values[:owner]
+    end
   end
 
   process do
-    step :validate, with: { user_name: :current_user_name } # Inject :user_name to the form object with the state's :current_user_name
+    step :validate, with: { user_name: :current_user_name } # Inject :user_name to the contract object with the state's :current_user_name
     step :create_nugget
   end
 
@@ -426,10 +465,12 @@ class CreateNugget < Pathway::Operation
 end
 ```
 
-On the other hand, if for some reason the name of the form's option and state attribute don't match, we can just pass `with: {...}` when calling to `step :validate`, indicating how to wire the attributes, the example above illustrates just that.
-
 The `with:` parameter can always be specified, at `step :validate`, and allows you to override the default mapping regardless if auto-wiring is active or not.
 
+##### Older versions of `dry-validation`
+
+Pathway supports the `dry-validation` gem down to version `0.11` (inclusive) in case you still have unmigrated code. When using versions bellow `1.0` the concept of contract is not present and instead of calling the `contract` method to setup your validation logic you must use the `form` method. Everything else remains the same except, obviously, that you would have to use `dry-definition`'s [old API](https://dry-rb.org/gems/dry-validation/0.13/) which is a bit different from the current one.
+
 #### `SimpleAuth` plugin
 
 This very simple plugin adds a custom step called `:authorize`, that can be used to check for permissions and halt the operation with a `:forbidden` error when they aren't fulfilled.
@@ -673,7 +714,7 @@ require 'pathway/rspec'
 
 #### Rspec matchers
 
-Pathway provide a few matchers in order to tests your operation easier.
+Pathway provides a few matchers in order to tests your operation easier.
 Let's go through a full example and break it up in the following subsections:
 
 ```ruby
@@ -682,10 +723,10 @@ Let's go through a full example and break it up in the following subsections:
 class CreateNugget < Pathway::Operation
   plugin :dry_validation
 
-  form do
-    required(:owner).filled(:str?)
-    required(:price).filled(:int?)
-    optional(:disabled).maybe(:bool?)
+  params do
+    required(:owner).filled(:string)
+    required(:price).filled(:integer)
+    optional(:disabled).maybe(:bool)
   end
 
   process do
@@ -721,8 +762,8 @@ describe CreateNugget do
     end
   end
 
-  describe '.form' do
-    subject(:form) { CreateNugget.form }
+  describe '.contract' do
+    subject(:contract) { CreateNugget.build_contract }
 
     it { is_expected.to require_fields(:owner, :price) }
     it { is_expected.to accept_optional_field(:disabled) }
@@ -739,13 +780,13 @@ The assertion it performs is simply is that the operation was successful, also y
 
 This second matcher is analog to `succeed_on` but it asserts that operation execution was a failure instead. Also if you return an error object, and you need to, you can assert the error type using the `type` chain method (aliased as `and_type` and `with_type`); the error message (`and_message`, `with_message` or `message`); and the error details (`and_details`, `with_details` or `details`). Mind you, the chain methods for the message and details accept nested matchers while the `type` chain can only test by equality.
 
-##### form matchers
+##### contract/form matchers
 
-Finally we can see that we are also testing the operation's form, implemented here with the `dry-validation` gem.
+Finally we can see that we are also testing the operation's contract (or form), implemented here with the `dry-validation` gem.
 
-Two more matchers are provided when we use this gem: `require_fields` (aliased `require_field`) to test when form is expected to define a required set of fields, and `accept_optional_fields` (aliased `accept_optional_field`) to test when a form must define certain set of optional fields.
+Two more matchers are provided: `require_fields` (aliased `require_field`) to test when a contract is expected to define a required set of fields, and `accept_optional_fields` (aliased `accept_optional_field`) to test when a contract must define a certain set of optional fields, both the contract class (at operation class method `contract_class`) or an instance (operation class method `build_contract`) can be provided.
 
-These matchers are only useful when using `dry-validation` and will very likely be extracted to its own gem in the future.
+These matchers are only useful when using `dry-validation` (on every version newer or equal to `0.11.0`) and will probably be extracted to their own gem in the future.
 
 ## Development
 

data/lib/pathway/plugins/auto_deconstruct_state/ruby3.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Pathway
+  module Plugins
+    module AutoDeconstructState
+      module DSLMethods
+        private
+
+        def _callable(callable)
+          if callable.is_a?(Symbol) && @operation.respond_to?(callable, true) &&
+            @operation.method(callable).parameters.all? { _1 in [:key|:keyreq|:keyrest|:block,*] }
+
+            -> state { @operation.send(callable, **state) }
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pathway/plugins/auto_deconstruct_state.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION =~ /^3\./
+  require 'pathway/plugins/auto_deconstruct_state/ruby3'
+end
+
+module Pathway
+  module Plugins
+    module AutoDeconstructState
+    end
+  end
+end

data/lib/pathway/plugins/dry_validation/v1_0.rb

@@ -19,7 +19,7 @@ module Pathway
             end
           end
 
-          def params(*args, &block)
+          ruby2_keywords def params(*args, &block)
             contract { params(*args, &block) }
           end
 
@@ -29,8 +29,8 @@ module Pathway
             @builded_contract = @contract_options.empty? && klass.schema ? klass.new : nil
           end
 
-          def build_contract(opts = {})
-            @builded_contract || contract_class.new(opts)
+          def build_contract(**opts)
+            @builded_contract || contract_class.new(**opts)
           end
 
           def inherited(subclass)
@@ -57,12 +57,12 @@ module Pathway
               with ||= contract_options.zip(contract_options).to_h
             end
             opts = Hash(with).map { |to, from| [to, state[from]] }.to_h
-            validate_with(state[:input], opts)
+            validate_with(state[:input], **opts)
               .then { |params| state.update(params: params) }
           end
 
-          def validate_with(input, opts = {})
-            result = contract(opts).call(input)
+          def validate_with(input, **opts)
+            result = contract(**opts).call(input)
 
             result.success? ? wrap(result.values.to_h) : error(:validation, details: result.errors.to_h)
           end

data/lib/pathway/plugins/responder.rb

@@ -4,8 +4,8 @@ module Pathway
   module Plugins
     module Responder
       module ClassMethods
-        def call(ctx, *params, &bl)
-          result = super(ctx, *params)
+        ruby2_keywords def call(*args, &bl)
+          result = super(*args)
           block_given? ? Responder.respond(result, &bl) : result
         end
       end

data/lib/pathway/plugins/sequel_models.rb

@@ -63,10 +63,11 @@ module Pathway
         delegate :db => :model_class
 
         def fetch_model(state, from: model_class, search_by: search_field, using: search_by, to: result_key, overwrite: false, error_message: nil)
-          error_message ||= if from != model_class
-                              Inflector.humanize(Inflector.underscore(Inflector.demodulize(from.name))) + ' not found'
-                            else
+          error_message ||= if (from == model_class)
                               model_not_found
+                            elsif from.respond_to?(:name) || from.respond_to?(:model)
+                              from_name = (from.respond_to?(:name) ? from : from.model).name
+                              Inflector.humanize(Inflector.underscore(Inflector.demodulize(from_name))) + ' not found'
                             end
 
           if state[to].nil? || overwrite
@@ -83,8 +84,8 @@ module Pathway
         end
       end
 
-      def self.apply(operation, model: nil, **args)
-        operation.model(model, args) if model
+      def self.apply(operation, model: nil, **kwargs)
+        operation.model(model, **kwargs) if model
       end
     end
   end

data/lib/pathway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pathway
-  VERSION = '0.11.1'
+  VERSION = '0.12.0'
 end

data/lib/pathway.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'ruby2_keywords'
 require 'forwardable'
 require 'dry/inflector'
 require 'contextualizer'
@@ -9,21 +10,23 @@ require 'pathway/result'
 module Pathway
   Inflector = Dry::Inflector.new
   class Operation
-    def self.plugin(name, *args)
-      require "pathway/plugins/#{Inflector.underscore(name)}" if name.is_a?(Symbol)
+    class << self
+      ruby2_keywords def plugin(name, *args)
+        require "pathway/plugins/#{Inflector.underscore(name)}" if name.is_a?(Symbol)
 
-      plugin = name.is_a?(Module) ? name : Plugins.const_get(Inflector.camelize(name))
+        plugin = name.is_a?(Module) ? name : Plugins.const_get(Inflector.camelize(name))
 
-      self.extend plugin::ClassMethods if plugin.const_defined? :ClassMethods
-      self.include plugin::InstanceMethods if plugin.const_defined? :InstanceMethods
-      self::DSL.include plugin::DSLMethods if plugin.const_defined? :DSLMethods
+        self.extend plugin::ClassMethods if plugin.const_defined? :ClassMethods
+        self.include plugin::InstanceMethods if plugin.const_defined? :InstanceMethods
+        self::DSL.include plugin::DSLMethods if plugin.const_defined? :DSLMethods
 
-      plugin.apply(self, *args) if plugin.respond_to?(:apply)
-    end
+        plugin.apply(self, *args) if plugin.respond_to?(:apply)
+      end
 
-    def self.inherited(subclass)
-      super
-      subclass.const_set :DSL, Class.new(self::DSL)
+      def inherited(subclass)
+        super
+        subclass.const_set :DSL, Class.new(self::DSL)
+      end
     end
 
     class DSL
@@ -90,7 +93,7 @@ module Pathway
           end
         end
 
-        def call(ctx, *params)
+        ruby2_keywords def call(ctx, *params)
           new(ctx).call(*params)
         end
 
@@ -137,7 +140,7 @@ module Pathway
         end
 
         # Execute step and preserve the former state
-        def step(callable, *args)
+        ruby2_keywords def step(callable, *args)
           bl = _callable(callable)
 
           @result = @result.tee { |state| bl.call(state, *args) }
@@ -190,9 +193,9 @@ module Pathway
         def _callable(callable)
           case callable
           when Proc
-            -> *args { @operation.instance_exec(*args, &callable) }
+            -> *args { @operation.instance_exec(*args, &callable) }.ruby2_keywords
           when Symbol
-            -> *args { @operation.send(callable, *args) }
+            -> *args { @operation.send(callable, *args) }.ruby2_keywords
           else
             callable
           end

data/pathway.gemspec

@@ -31,13 +31,15 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "dry-inflector", ">= 0.1.0"
   spec.add_dependency "contextualizer", "~> 0.0.4"
+  spec.add_dependency "ruby2_keywords"
 
   spec.add_development_dependency "dry-validation", ">= 0.11"
-  spec.add_development_dependency "bundler", ">= 1.14.0"
-  spec.add_development_dependency "sequel", "~> 5.25.0"
+  spec.add_development_dependency "bundler", "~> 2.3.7"
+  spec.add_development_dependency "sequel", "~> 5.0"
   spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "rspec", "~> 3.11"
+  spec.add_development_dependency "simplecov-lcov", '~> 0.8.0'
+  spec.add_development_dependency "simplecov"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "pry-doc"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pathway
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Pablo Herrero
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-09 00:00:00.000000000 Z
+date: 2022-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-inflector
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: ruby2_keywords
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dry-validation
   requirement: !ruby/object:Gem::Requirement
@@ -56,30 +70,30 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.14.0
+        version: 2.3.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.14.0
+        version: 2.3.7
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.25.0
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.25.0
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -100,16 +114,30 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: simplecov-lcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -171,7 +199,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".circleci/config.yml"
+- ".github/workflows/tests.yml"
 - ".gitignore"
 - ".rspec"
 - CHANGELOG.md
@@ -185,6 +213,8 @@ files:
 - bin/rspec
 - bin/setup
 - lib/pathway.rb
+- lib/pathway/plugins/auto_deconstruct_state.rb
+- lib/pathway/plugins/auto_deconstruct_state/ruby3.rb
 - lib/pathway/plugins/dry_validation.rb
 - lib/pathway/plugins/dry_validation/v0_11.rb
 - lib/pathway/plugins/dry_validation/v0_12.rb
@@ -225,7 +255,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Define your business logic in simple steps.

data/.circleci/config.yml

@@ -1,38 +0,0 @@
-version: 2.0
-shared: &shared
-    steps:
-      - checkout
-      - run:
-          name: Bundle gems
-          command: |
-            echo '--no-rdoc --no-ri' > '.gemrc'
-            bundle install --jobs=4 --retry=3 --path vendor/bundle
-      - run:
-          name: Run tests
-          command: bundle exec rspec --format documentation --color --format progress spec
-
-jobs:
-  "ruby-2.4":
-    <<: *shared
-    docker:
-      - image: circleci/ruby:2.4
-
-  "ruby-2.5":
-    <<: *shared
-    docker:
-      - image: circleci/ruby:2.5
-
-  "ruby-2.6":
-    <<: *shared
-    docker:
-      - image: circleci/ruby:2.6
-        environment:
-          REPORT_COVERAGE: 'true'
-
-workflows:
-  version: 2
-  build:
-    jobs:
-      - "ruby-2.4"
-      - "ruby-2.5"
-      - "ruby-2.6"