pathway 0.9.1 → 0.11.3

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Pathway
+  module Plugins
+    module DryValidation
+      module V0_11
+        module ClassMethods
+          attr_reader :form_class, :form_options
+          attr_accessor :auto_wire_options
+
+          def form(base = nil, **opts, &block)
+            if block_given?
+              base ||= _base_form
+              self.form_class = _block_definition(base, opts, &block)
+            elsif base
+              self.form_class = _form_class(base)
+            else
+              raise ArgumentError, 'Either a form class or a block must be provided'
+            end
+          end
+
+          def form_class= klass
+            @builded_form = klass.options.empty? ? klass.new : nil
+            @form_class = klass
+            @form_options = klass.options.keys
+          end
+
+          def build_form(opts = {})
+            @builded_form || form_class.new(opts)
+          end
+
+          def inherited(subclass)
+            super
+            subclass.form_class = form_class
+            subclass.auto_wire_options = auto_wire_options
+          end
+
+          private
+
+          def _base_form
+            superclass.respond_to?(:form_class) ? superclass.form_class : Dry::Validation::Schema::Form
+          end
+
+          def _form_class(form)
+            form.is_a?(Class) ? form : form.class
+          end
+
+          def _form_opts(opts = {})
+            opts.merge(build: false)
+          end
+
+          def _block_definition(base, opts, &block)
+            Dry::Validation.Form(_form_class(base), _form_opts(opts), &block)
+          end
+        end
+
+        module InstanceMethods
+          extend Forwardable
+
+          delegate %i[build_form form_options auto_wire_options] => 'self.class'
+          alias :form :build_form
+
+          def validate(state, with: nil)
+            if auto_wire_options && form_options.any?
+              with ||= form_options.zip(form_options).to_h
+            end
+            opts = Hash(with).map { |opt, key| [opt, state[key]] }.to_h
+            validate_with(state[:input], opts)
+              .then { |params| state.update(params: params) }
+          end
+
+          def validate_with(params, opts = {})
+            val = form(opts).call(params)
+
+            val.success? ? wrap(val.output) : error(:validation, details: val.messages)
+          end
+        end
+
+        def self.apply(operation, auto_wire_options: false)
+          operation.form_class = Dry::Validation::Schema::Form
+          operation.auto_wire_options = auto_wire_options
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Pathway
+  module Plugins
+    module DryValidation
+      module V0_12
+        module ClassMethods
+          attr_reader :form_class, :form_options
+          attr_accessor :auto_wire_options
+
+          def form(base = nil, **opts, &block)
+            if block_given?
+              base ||= _base_form
+              self.form_class = _block_definition(base, opts, &block)
+            elsif base
+              self.form_class = _form_class(base)
+            else
+              raise ArgumentError, 'Either a form class or a block must be provided'
+            end
+          end
+
+          def form_class= klass
+            @builded_form = klass.options.empty? ? klass.new : nil
+            @form_class = klass
+            @form_options = klass.options.keys
+          end
+
+          def build_form(opts = {})
+            @builded_form || form_class.new(opts)
+          end
+
+          def inherited(subclass)
+            super
+            subclass.form_class = form_class
+            subclass.auto_wire_options = auto_wire_options
+          end
+
+          private
+
+          def _base_form
+            superclass.respond_to?(:form_class) ? superclass.form_class : Dry::Validation::Schema::Params
+          end
+
+          def _form_class(form)
+            form.is_a?(Class) ? form : form.class
+          end
+
+          def _form_opts(opts = {})
+            opts.merge(build: false)
+          end
+
+          def _block_definition(base, opts, &block)
+            Dry::Validation.Params(_form_class(base), _form_opts(opts), &block)
+          end
+        end
+
+        module InstanceMethods
+          extend Forwardable
+
+          delegate %i[build_form form_options auto_wire_options] => 'self.class'
+          alias :form :build_form
+
+          def validate(state, with: nil)
+            if auto_wire_options && form_options.any?
+              with ||= form_options.zip(form_options).to_h
+            end
+            opts = Hash(with).map { |opt, key| [opt, state[key]] }.to_h
+            validate_with(state[:input], opts)
+              .then { |params| state.update(params: params) }
+          end
+
+          def validate_with(params, opts = {})
+            val = form(opts).call(params)
+
+            val.success? ? wrap(val.output) : error(:validation, details: val.messages)
+          end
+        end
+
+        def self.apply(operation, auto_wire_options: false)
+          operation.form_class = Dry::Validation::Schema::Params
+          operation.auto_wire_options = auto_wire_options
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pathway
+  module Plugins
+    module DryValidation
+      module V1_0
+        module ClassMethods
+          attr_reader :contract_class, :contract_options
+          attr_accessor :auto_wire_options
+
+          def contract(base = nil, &block)
+            if block_given?
+              base ||= _base_contract
+              self.contract_class = Class.new(base, &block)
+            elsif base
+              self.contract_class = base
+            else
+              raise ArgumentError, 'Either a contract class or a block must be provided'
+            end
+          end
+
+          def params(*args, &block)
+            contract { params(*args, &block) }
+          end
+
+          def contract_class= klass
+            @contract_class = klass
+            @contract_options = (klass.dry_initializer.options - Dry::Validation::Contract.dry_initializer.options).map(&:target)
+            @builded_contract = @contract_options.empty? && klass.schema ? klass.new : nil
+          end
+
+          def build_contract(opts = {})
+            @builded_contract || contract_class.new(opts)
+          end
+
+          def inherited(subclass)
+            super
+            subclass.contract_class = contract_class
+            subclass.auto_wire_options = auto_wire_options
+          end
+
+          private
+
+          def _base_contract
+            superclass.respond_to?(:contract_class) ? superclass.contract_class : Dry::Validation::Contract
+          end
+        end
+
+        module InstanceMethods
+          extend Forwardable
+
+          delegate %i[build_contract contract_options auto_wire_options] => 'self.class'
+          alias :contract :build_contract
+
+          def validate(state, with: nil)
+            if auto_wire_options && contract_options.any?
+              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)
+              .then { |params| state.update(params: params) }
+          end
+
+          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
+        end
+
+        def self.apply(operation, auto_wire_options: false)
+          operation.contract_class = Dry::Validation::Contract
+          operation.auto_wire_options = auto_wire_options
+        end
+      end
+    end
+  end
+end

data/lib/pathway/plugins/responder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pathway
   module Plugins
     module Responder

data/lib/pathway/plugins/sequel_models.rb

@@ -1,25 +1,39 @@
+# frozen_string_literal: true
+
 require 'sequel/model'
 
 module Pathway
   module Plugins
     module SequelModels
       module DSLMethods
-        def transaction(&bl)
-          around(-> steps, _ {
-            db.transaction(savepoint: true) do
-              raise Sequel::Rollback if steps.call.failure?
-            end
-          }, &bl)
+        def transaction(step_name = nil, &bl)
+          fail 'must provide a step or a block but not both' if !step_name.nil? == block_given?
+
+          if step_name
+            transaction { step step_name }
+          else
+            around(-> steps, _ {
+              db.transaction(savepoint: true) do
+                raise Sequel::Rollback if steps.call.failure?
+              end
+            }, &bl)
+          end
         end
 
-        def after_commit(&bl)
-          around(-> steps, state {
-            dsl = self.class::DSL.new(State.new(self, state.to_h.dup), self)
+        def after_commit(step_name = nil, &bl)
+          fail 'must provide a step or a block but not both' if !step_name.nil? == block_given?
 
-            db.after_commit do
-              steps.call(dsl)
-            end
-          }, &bl)
+          if step_name
+            after_commit { step step_name }
+          else
+            around(-> steps, state {
+              dsl = self.class::DSL.new(State.new(self, state.to_h.dup), self)
+
+              db.after_commit do
+                steps.call(dsl)
+              end
+            }, &bl)
+          end
         end
       end
 
@@ -49,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

data/lib/pathway/plugins/simple_auth.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pathway
   module Plugins
     module SimpleAuth

data/lib/pathway/result.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pathway
   class Result
     extend Forwardable

data/lib/pathway/rspec.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'pathway/rspec/matchers'

data/lib/pathway/rspec/matchers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathway/rspec/matchers/succeed_on'
 require 'pathway/rspec/matchers/fail_on'
 require 'pathway/rspec/matchers/accept_optional_fields'

data/lib/pathway/rspec/matchers/accept_optional_fields.rb

@@ -1,30 +1,43 @@
+# frozen_string_literal: true
+
 require 'pathway/rspec/matchers/form_schema_helpers'
 
 RSpec::Matchers.define :accept_optional_fields do |*fields|
   match do |form|
     @form, @fields = form, fields
 
-    not_defined.empty? && not_optional.empty?
+    not_defined.empty? &&
+      not_optional.empty? &&
+      allowing_null_values_matches? &&
+      not_allowing_null_values_matches?
   end
 
   match_when_negated do |form|
+    raise NotImplementedError, 'expect().not_to accept_optional_fields.not_allowing_null_values is not supported.' if @allowing_null_values || @not_allowing_null_values
+
     @form, @fields = form, fields
 
     not_defined.empty? && optional.empty?
   end
 
   description do
-    "accept #{field_list} as optional #{pluralize_fields}"
+    null_value_allowed = @allowing_null_values ? ' allowing null values' : ''
+    null_value_disallowed = @not_allowing_null_values ? ' not allowing null values' : ''
+    "accept #{field_list} as optional #{pluralize_fields}#{null_value_allowed}#{null_value_disallowed}"
   end
 
   failure_message do
-    "Expected to accept #{field_list} as optional #{pluralize_fields} but " +
-      [not_optional_list, not_defined_list].compact.join("; and ")
+    null_value_allowed = @allowing_null_values ? ' allowing null values' : ''
+    null_value_disallowed = @not_allowing_null_values ? ' not allowing null values' : ''
+
+    "Expected to accept #{field_list} as optional #{pluralize_fields}#{null_value_allowed}#{null_value_disallowed} but " +
+      as_sentence([not_optional_list, not_defined_list, accepting_null_list, not_accepting_null_list].compact,
+                  connector: '; ', last_connector: '; and ')
   end
 
   failure_message_when_negated do
     "Did not expect to accept #{field_list} as optional #{pluralize_fields} but " +
-      [optional_list, not_defined_list].compact.join("; and ")
+      [optional_list, not_defined_list].compact.join('; and ')
   end
 
   include Pathway::Rspec::FormSchemaHelpers
@@ -34,7 +47,19 @@ RSpec::Matchers.define :accept_optional_fields do |*fields|
   end
 
   def not_optional_list
-    "#{as_list(not_required)} #{were_was(not_required)} not optional" if not_optional.any?
+    "#{as_list(not_optional)} #{were_was(not_optional)} not optional" if not_optional.any?
+  end
+
+  chain :allowing_null_values do
+    fail 'cannot use allowing_null_values and not_allowing_null_values at the same time' if @not_allowing_null_values
+
+    @allowing_null_values = true
+  end
+
+  chain :not_allowing_null_values do
+    fail 'cannot use allowing_null_values and not_allowing_null_values at the same time' if @allowing_null_values
+
+    @not_allowing_null_values = true
   end
 end
 

data/lib/pathway/rspec/matchers/fail_on.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathway/rspec/matchers/list_helpers'
 
 RSpec::Matchers.define :fail_on do |input|
@@ -38,20 +40,20 @@ RSpec::Matchers.define :fail_on do |input|
   alias :and_details :details
 
   description do
-    "fail" + (@type ? " with :#@type error" : '')
+    'fail' + (@type ? " with :#@type error" : '')
   end
 
   failure_message do
     if !failure?
       "Expected operation to fail but it didn't"
     else
-      "Expected failed operation to " +
+      'Expected failed operation to ' +
         as_sentence(failure_descriptions, connector: '; ', last_connector: '; and ')
     end
   end
 
   failure_message_when_negated do
-    "Did not to expected operation to fail but it did"
+    'Did not expected operation to fail but it did'
   end
 
   def failure?