bcdd-process 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b912c6dd7bbc76a3a091da0e5d722fea38b97ff0ac93f61a4477e20e8ba7d26
-  data.tar.gz: c0161a5ccc0f6275b28187b822dd20dc9d35640b7461827bef8fcbe5beb9b491
+  metadata.gz: 60c6b5184edd4076e88382736efff9e0981be518c064ae290a75ad4d052d3196
+  data.tar.gz: ca15261b4991198f5277cddf5f2c2133458e7163f8388e39d5a0c18dad688bce
 SHA512:
-  metadata.gz: cf2fd171d9beae0ba6d90f768fbd4c8966f4a2e2d54d7c7ec9d220b35f0f0ab420cfeb3d786f6749165480eb888dacae9ae1a2a521c0e7d284b859addf618e4e
-  data.tar.gz: 65848285149f38f9d88114e8a1277e2b4f943237a056e7a519fb2fcaab4a7d17a47edaa0fdb351f4252d898ba56313ed27ad79401cb704be1f338589c53d863a
+  metadata.gz: 4dd1a4bf3e06a13060233215ea6ad8ee1f0a0a6a4be94d202a6126833fe62a68504a4af677f2f4a8b34abb39a3124a6b8d25009569dfa2d3050debaad45dbd9b
+  data.tar.gz: '08daaa2746fd38c0db77c1d131080923693c697d19577d2b33dded81f1a9675c4a841650bba799c46b24a2e8ba6de06c4370ba143ab7b65578ab0fb90eddac84'

data/.rubocop.yml

@@ -49,6 +49,9 @@ Style/ParallelAssignment:
 Style/SingleLineMethods:
   Enabled: false
 
+Style/FormatStringToken:
+  Enabled: false
+
 Style/MapToSet:
   Enabled: false
 
@@ -64,6 +67,10 @@ Naming/VariableName:
 Naming/MemoizedInstanceVariableName:
   Enabled: false
 
+Metrics/AbcSize:
+  Exclude:
+    - lib/bcdd/ext/value.rb
+
 Metrics/BlockLength:
   Exclude:
     - test/**/*.rb

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [0.4.0] - 2024-02-04
+
+### Added
+
+- Add `:value` input property to use a registered `BCDD::Value` to handle the input.
+  ```ruby
+  attribute :name, value: :name
+  ```
+
+- Add `:respond_to` input property to check if the value responds to a given method.
+  ```ruby
+  attribute :name, respond_to: :strip
+  ```
+
+### Changed
+
+- Use `:type` property to check if the normalize should be applied.
+  ```ruby
+  attribute :name, type: String, normalize: -> { _1.strip }
+  ```
+
 ## [0.3.1] - 2024-02-03
 
 ### Fixed

data/examples/business_processes/app/models/account/owner_creation.rb

@@ -5,7 +5,7 @@ class Account
     include BCDD::Result::RollbackOnFailure
 
     input do
-      attribute :uuid, contract: :is_uuid, normalize: -> { _1.strip.downcase }, default: -> { ::SecureRandom.uuid }
+      attribute :uuid, value: :uuid
       attribute :owner, type: ::Hash, contract: :is_present
     end
 

data/examples/business_processes/app/models/user/creation.rb

@@ -5,7 +5,7 @@ class User
     include BCDD::Result::RollbackOnFailure
 
     input do
-      attribute :uuid, contract: :is_uuid, normalize: -> { _1.strip.downcase }, default: -> { ::SecureRandom.uuid }
+      attribute :uuid, value: :uuid
       attribute :name, contract: :is_str, normalize: -> { _1.strip.gsub(/\s+/, ' ') }
       attribute :email, contract: :is_email, normalize: -> { _1.strip.downcase }
       attribute :password, contract: :is_password

data/examples/business_processes/config.rb

@@ -12,6 +12,7 @@ require 'db/setup'
 require 'lib/bcdd/result/rollback_on_failure'
 require 'lib/bcdd/result/transitions_record'
 require 'lib/bcdd/contracts'
+require 'lib/bcdd/values/uuid'
 require 'lib/runtime_breaker'
 
 module TransitionsListener

data/examples/business_processes/lib/bcdd/contracts.rb

@@ -4,14 +4,12 @@ module BCDD::Contracts
   HasSize = ->(min, max) { ->(val) { val.size.between?(min, max) or "must be >= #{min} and <= #{max} chars" } }
 
   is_str = contract[::String]
-  is_uuid = ->(val) { val.match?(/\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/) or '%p must be an UUID' }
   is_email = ->(val) { val.match?(::URI::MailTo::EMAIL_REGEXP) or '%p must be an email' }
   is_present = ->(val) { val.present? or '%p must be present' }
   is_persisted = ->(val) { val.persisted? or '%p must be persisted' }
 
   register(
     is_str: is_str,
-    is_uuid: is_str & is_present & is_uuid,
     is_email: is_str & is_present& is_email,
     is_present: is_present,
     is_password: is_str & is_present & HasSize[8, 72],

data/examples/business_processes/lib/bcdd/values/uuid.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../contracts'
+
+module BCDD
+  module Contracts
+    is_uuid = ->(val) { val.match?(/\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/) or '%p must be an UUID' }
+
+    register(is_uuid: contract[::String] & :is_present & is_uuid)
+  end
+
+  module Values
+    register(
+      name: :uuid,
+      type: ::String,
+      contract: :is_uuid,
+      normalize: -> { _1.strip.downcase },
+      default: -> { ::SecureRandom.uuid }
+    )
+  end
+end

data/lib/bcdd/ext/contract/respond_to.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BCDD::Contract
+  # TODO: Move to bcdd-contract
+  module RespondTo
+    class Checking
+      include Core::Checking
+
+      def initialize(method_names, value)
+        @value = value
+        @errors = []
+
+        validate(method_names, @errors)
+      end
+
+      def errors_message
+        valid? ? '' : errors[0]
+      end
+
+      private
+
+      def validate(method_names, errors)
+        return if method_names.all? { |method_name| value.respond_to?(method_name) }
+
+        errors << format('%p must respond to %p', value, method_names)
+      end
+    end
+
+    module Checker
+      include Core::Checker
+    end
+
+    def self.new(args)
+      args.is_a?(Array) or raise ::ArgumentError, format('%p must be an array', args)
+
+      raise ::ArgumentError, "Must provide at least one symbol #{args.inspect}" if args.empty? || !args.all?(::Symbol)
+
+      Core::Factory.new(Checker, Checking, args)
+    end
+  end
+
+  # TODO: Move to bcdd-contract
+  def self.respond_to(args)
+    RespondTo.new(args)
+  end
+
+  private_constant :RespondTo
+end

data/lib/bcdd/ext/contract.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bcdd/contract'
+
+require_relative 'contracts'
+require_relative 'contract/null'
+require_relative 'contract/respond_to'
+
+module BCDD::Contract
+  # TODO: Move to bcdd-contract
+  def self.type(arg)
+    arg.is_a?(::Module) or raise ::ArgumentError, format('%p must be a class OR module', arg)
+
+    unit(arg)
+  end
+end

data/lib/bcdd/ext/data.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'value'
+
+module BCDD
+  class Data
+    class Object
+      attr_reader :attributes, :errors
+
+      def initialize(**kargs)
+        properties = self.class::Properties
+        attributes = properties.map(kargs)
+
+        @errors = {}
+        @attributes =
+          if properties.contract?
+            attributes.each_with_object({}) do |(key, value), output|
+              output[key] = value.valid? ? value.value : (errors[key] = value.errors)
+            end
+          else
+            attributes.transform_values!(&:value)
+          end
+      end
+    end
+
+    class Properties
+      attr_reader :spec, :contract
+
+      def initialize
+        @spec = {}
+        @contract = false
+      end
+
+      def attribute(name, **options)
+        name.is_a?(Symbol) or raise ArgumentError, "#{name.inspect} must be a Symbol"
+
+        value_option = options[:value]
+
+        spec[name] =
+          if value_option
+            (value_option.is_a?(Value::Object) ? value_option : Value[value_option])::Properties
+          else
+            Value::Properties.new(options).freeze
+          end
+      end
+
+      def freeze
+        @contract = spec.any? { |_, properties| properties.contract? }
+
+        spec.freeze
+
+        super
+      end
+
+      def contract?
+        contract
+      end
+
+      def map(input)
+        spec.each_with_object({}) do |(name, properties), output|
+          output[name] = properties.map(input[name])
+        end
+      end
+    end
+
+    class Evaluator
+      # :nodoc:
+      attr_reader :properties
+
+      def initialize
+        @properties = Data::Properties.new
+      end
+
+      def attribute(name, **options)
+        properties.attribute(name, **options)
+      end
+
+      private
+
+      def contract
+        BCDD::Contract
+      end
+    end
+
+    def self.new(&block)
+      evaluator = Evaluator.new
+      evaluator.instance_eval(&block)
+
+      klass = ::Class.new(Object)
+      klass.const_set(:Properties, evaluator.properties.freeze)
+      klass
+    end
+  end
+end

data/lib/bcdd/ext/value.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module BCDD
+  class Value
+    class Object
+      attr_reader :value, :errors
+
+      def initialize(value = nil)
+        properties = self.class::Properties
+        contract = properties.map(value)
+
+        @errors = contract.errors
+        @value = contract.value
+      end
+    end
+
+    class Properties
+      module Contract
+        def self.[](options)
+          contract = compose(options)
+          required = options.fetch(:required, true)
+
+          if contract
+            required ? contract : (contract | nil)
+          elsif required
+            Contracts::NotNil
+          end
+        end
+
+        def self.compose(options)
+          type = ::BCDD::Contract.type(options[:type]) if options.key?(:type)
+          contract = ::BCDD::Contract[options[:contract]] if options.key?(:contract)
+          respond_to = ::BCDD::Contract.respond_to(Array(options[:respond_to])) if options.key?(:respond_to)
+
+          [type, contract, respond_to].compact!&.reduce(:&)
+        end
+      end
+
+      Default = ->(options) do
+        value = options[:default]
+
+        return value unless value.is_a?(Proc)
+        return value if value.lambda? && value.arity.zero?
+
+        raise ArgumentError, 'Default value must be a lambda with zero arity'
+      end
+
+      Normalize = ->(options) do
+        value = options[:normalize]
+
+        return value if value.is_a?(Proc)
+
+        raise ArgumentError, 'normalize value must be a lambda'
+      end
+
+      Type = ->(options) do
+        type = options[:type]
+
+        return type if type.is_a?(::Module)
+
+        raise ArgumentError, 'type must be a Module or a Class'
+      end
+
+      attr_reader :spec, :contract
+
+      def initialize(options)
+        @contract = false
+
+        contract = Contract[options]
+
+        @spec = {}
+        @spec[:type] = Type[options] if options.key?(:type)
+        @spec[:default] = Default[options] if options.key?(:default)
+        @spec[:contract] = contract if contract
+        @spec[:normalize] = Normalize[options] if options.key?(:normalize)
+      end
+
+      def freeze
+        @contract = spec.key?(:contract)
+
+        spec.freeze
+
+        super
+      end
+
+      def contract?
+        contract
+      end
+
+      def map(value)
+        if !value && spec.key?(:default)
+          default = spec[:default]
+
+          value = default.is_a?(::Proc) ? default.call : default
+        end
+
+        type = spec[:type]
+
+        value = spec[:normalize].call(value) if spec.key?(:normalize) && (!type || type === value)
+
+        spec.key?(:contract) ? spec[:contract][value] : Contract.null(value)
+      end
+    end
+
+    class Registry
+      include ::Singleton
+
+      attr_reader :registry
+
+      def initialize
+        @registry = {}
+      end
+
+      def self.write(options)
+        name = options.delete(:name)
+
+        name.is_a?(Symbol) or raise ArgumentError, "#{name.inspect} must be a Symbol"
+
+        instance.registry[name] = Value.new(**options)
+      end
+
+      def self.read(name)
+        value_object = instance.registry[name]
+
+        value_object or raise ArgumentError, "#{name.inspect} is not registered"
+      end
+    end
+
+    def self.new(**options)
+      klass = ::Class.new(Object)
+      klass.const_set(:Properties, Properties.new(options).freeze)
+      klass
+    end
+
+    def self.[](name)
+      Registry.read(name)
+    end
+  end
+
+  module Values
+    class << self
+      private
+
+      def register(**options)
+        Value::Registry.write(options)
+      end
+    end
+  end
+end

data/lib/bcdd/process/output.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module BCDD
+  class Process
+    module Output
+      # :nodoc:
+      class Properties
+        attr_reader :success
+
+        def initialize
+          @success = {}
+          @failure = {}
+        end
+
+        def success=(spec)
+          @success = spec.transform_values(&BCDD::Contract)
+        end
+
+        def failure=(spec)
+          @failure = spec.transform_values(&BCDD::Contract)
+        end
+
+        INVALID_INPUT = { invalid_input: ::Hash }.freeze
+
+        def failure
+          INVALID_INPUT.merge(@failure)
+        end
+      end
+
+      class Evaluator
+        # :nodoc:
+        attr_reader :__properties__
+
+        def initialize
+          @__properties__ = Properties.new
+        end
+
+        private
+
+        def Success(**spec)
+          __properties__.success = spec
+        end
+
+        def Failure(**spec)
+          __properties__.failure = spec
+        end
+
+        def contract
+          ::BCDD::Contract
+        end
+      end
+    end
+  end
+end

data/lib/bcdd/process/version.rb

@@ -2,6 +2,6 @@
 
 module BCDD
   class Process
-    VERSION = '0.3.1'
+    VERSION = '0.4.0'
   end
 end

data/lib/bcdd/process.rb

@@ -1,60 +1,59 @@
 # frozen_string_literal: true
 
 require 'bcdd/result'
-require 'bcdd/contract'
 
-require_relative 'contracts'
-require_relative 'contract/null'
+require_relative 'ext/contract'
+require_relative 'ext/data'
 
 require_relative 'process/version'
-require_relative 'process/caller'
-require_relative 'process/input_spec'
-require_relative 'process/output_spec'
+require_relative 'process/output'
 
 module BCDD
   class Process
-    class << self
-      attr_reader :__input__, :__input_contract__, :__output__
+    module Caller
+      def call(**kargs)
+        input = self.class::Input.new(**kargs)
 
-      def input(&block)
-        return @__input__ if defined?(@__input__)
+        Result.transitions(name: self.class.name) do
+          return Failure(:invalid_input, **input.errors) if input.errors.any?
 
-        spec = InputSpec.new
-        spec.instance_eval(&block)
-        spec.__result__.transform_values!(&:freeze).freeze
-
-        @__input_contract__ = spec.__result__.any? { |_key, value| value.key?(:contract) }
-        @__input__ = spec.__result__
+          super(**input.attributes)
+        end
       end
+    end
 
-      def output(expectations: true, &block)
-        @__output__ and raise ArgumentError, 'outputs already defined'
+    def self.input(&block)
+      return if const_defined?(:Input)
 
-        config = { addon: { given: true, continue: true } }
+      const_set(:Input, ::BCDD::Data.new(&block))
+    end
 
-        if expectations
-          spec = OutputSpec.new
-          spec.instance_eval(&block)
+    RESULT_CONFIG = { addon: { given: true, continue: true }.freeze }.freeze
 
-          output = spec.__result__
-          success = output[:success]
-          failure = output.fetch(:failure, {}).merge(invalid_input: ::Hash)
+    def self.output(expectations: true, &block)
+      return if const_defined?(:Result, false)
 
-          include(Result::Context::Expectations.mixin(config: config, success: success, failure: failure))
-        else
-          include(Result::Context.mixin(config: config))
-        end
+      if expectations
+        evaluator = Output::Evaluator.new
+        evaluator.instance_eval(&block)
 
-        @__output__ = { expectations: expectations }.freeze
-      end
+        success = evaluator.__properties__.success
+        failure = evaluator.__properties__.failure
 
-      def inherited(subclass)
-        subclass.prepend(Caller)
+        include(Result::Context::Expectations.mixin(config: RESULT_CONFIG, success: success, failure: failure))
+      else
+        include(Result::Context.mixin(config: RESULT_CONFIG))
       end
+    end
 
-      def call(**input)
-        new.call(**input)
-      end
+    def self.inherited(subclass)
+      subclass.prepend(Caller)
     end
+
+    def self.call(**input)
+      new.call(**input)
+    end
+
+    private_constant :Caller, :RESULT_CONFIG
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bcdd-process
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-02 00:00:00.000000000 Z
+date: 2024-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcdd-contract
@@ -68,15 +68,18 @@ files:
 - examples/business_processes/lib/bcdd/contracts.rb
 - examples/business_processes/lib/bcdd/result/rollback_on_failure.rb
 - examples/business_processes/lib/bcdd/result/transitions_record.rb
+- examples/business_processes/lib/bcdd/values/uuid.rb
 - examples/business_processes/lib/runtime_breaker.rb
 - examples/business_processes/lib/transitions_listener/stdout.rb
 - lib/bcdd-process.rb
-- lib/bcdd/contract/null.rb
-- lib/bcdd/contracts.rb
+- lib/bcdd/ext/contract.rb
+- lib/bcdd/ext/contract/null.rb
+- lib/bcdd/ext/contract/respond_to.rb
+- lib/bcdd/ext/contracts.rb
+- lib/bcdd/ext/data.rb
+- lib/bcdd/ext/value.rb
 - lib/bcdd/process.rb
-- lib/bcdd/process/caller.rb
-- lib/bcdd/process/input_spec.rb
-- lib/bcdd/process/output_spec.rb
+- lib/bcdd/process/output.rb
 - lib/bcdd/process/version.rb
 - sig/bcdd/process.rbs
 homepage: https://github.com/b-cdd/process

data/lib/bcdd/process/caller.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module BCDD
-  class Process
-    module Caller
-      PrepareInputs = ->(spec, input) do
-        spec.each_with_object({}) do |(name, options), result|
-          value = input.fetch(name) do
-            if options.key?(:default)
-              default = options[:default]
-
-              default.is_a?(::Proc) ? default.call : default
-            end
-          end
-
-          value = options[:normalize].call(value) if options.key?(:normalize)
-
-          result[name] = options.key?(:contract) ? options[:contract][value] : Contract.null(value)
-        end
-      end
-
-      def call(**inputs)
-        prepared_input = PrepareInputs[self.class.__input__, inputs]
-
-        Result.transitions(name: self.class.name) do
-          if self.class.__input_contract__
-            invalid_input = prepared_input.select { |_key, value| value.invalid? }
-
-            return Failure(:invalid_input, **invalid_input.transform_values(&:errors)) unless invalid_input.empty?
-          end
-
-          super(**prepared_input.transform_values!(&:value))
-        end
-      end
-    end
-  end
-end

data/lib/bcdd/process/input_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module BCDD
-  class Process
-    class InputSpec
-      module MapContract
-        def self.[](options)
-          required = options.fetch(:required, true)
-
-          if options.key?(:contract) || options.key?(:type) || options.key?(:validate)
-            resolve(options).then { required ? _1 : (_1 | nil) }
-          elsif required
-            Contracts::NotNil
-          end
-        end
-
-        def self.resolve(options)
-          type = ::BCDD::Contract.unit(options[:type]) if options.key?(:type)
-          contract = ::BCDD::Contract[options[:contract]] if options.key?(:contract)
-
-          type && contract ? (type & contract) : type || contract
-        end
-      end
-
-      MapDefault = ->(options) do
-        value = options[:default]
-
-        return value unless value.is_a?(Proc)
-        return value if value.lambda? && value.arity.zero?
-
-        raise ArgumentError, 'Default value must be a lambda with zero arity'
-      end
-
-      MapNormalize = ->(options) do
-        value = options[:normalize]
-
-        return value if value.is_a?(Proc)
-
-        raise ArgumentError, 'normalize value must be a lambda'
-      end
-
-      # :nodoc:
-      attr_reader :__result__
-
-      def initialize
-        @__result__ = {}
-      end
-
-      def attribute(name, **options)
-        name.is_a?(Symbol) or raise ArgumentError, "#{name.inspect} must be a Symbol"
-
-        spec = {}
-        spec[:default] = MapDefault[options] if options.key?(:default)
-        spec[:normalize] = MapNormalize[options] if options.key?(:normalize)
-
-        MapContract[options].then { spec[:contract] = _1 if _1 }
-
-        __result__[name] = spec
-      end
-
-      def contract
-        BCDD::Contract
-      end
-    end
-  end
-end

data/lib/bcdd/process/output_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module BCDD
-  class Process
-    class OutputSpec
-      def initialize
-        @success = {}
-        @failure = {}
-      end
-
-      def Success(**spec)
-        @success = spec.transform_values(&BCDD::Contract)
-      end
-
-      def Failure(**spec)
-        @failure = spec.transform_values(&BCDD::Contract)
-      end
-
-      # :nodoc:
-      def __result__
-        { success: @success, failure: @failure }
-      end
-
-      private
-
-      def contract
-        ::BCDD::Contract
-      end
-    end
-  end
-end