bcdd-result 0.4.0 → 0.6.0

data/lib/bcdd/result/error.rb

@@ -38,7 +38,15 @@ class BCDD::Result::Error < StandardError
 
   class WrongSubjectMethodArity < self
     def self.build(subject:, method:)
-      new("#{subject.class}##{method.name} has unsupported arity (#{method.arity}). Expected 0 or 1.")
+      new("#{subject.class}##{method.name} has unsupported arity (#{method.arity}). Expected 0, 1 or 2.")
+    end
+  end
+
+  class UnhandledTypes < self
+    def self.build(types:)
+      subject = types.size == 1 ? 'This was' : 'These were'
+
+      new("You must handle all cases. #{subject} not handled: #{types.map(&:inspect).join(', ')}")
     end
   end
 end

data/lib/bcdd/result/expectations/contract/disabled.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  module Contract::Disabled
+    extend Contract::Interface
+
+    EMPTY_SET = Set.new.freeze
+
+    def self.allowed_types
+      EMPTY_SET
+    end
+
+    def self.type?(_type)
+      true
+    end
+
+    def self.type!(type)
+      type
+    end
+
+    def self.type_and_value!(_data); end
+
+    private_constant :EMPTY_SET
+  end
+end

data/lib/bcdd/result/expectations/contract/evaluator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  class Contract::Evaluator
+    include Contract::Interface
+
+    attr_reader :allowed_types, :success, :failure
+
+    def initialize(success, failure)
+      @success = success
+      @failure = failure
+
+      @allowed_types = (success.allowed_types | failure.allowed_types).freeze
+    end
+
+    def type?(type)
+      success_disabled = success == Contract::Disabled
+      failure_disabled = failure == Contract::Disabled
+
+      return Contract::Disabled.type?(type) if success_disabled && failure_disabled
+
+      (!success_disabled && success.type?(type)) || (!failure_disabled && failure.type?(type))
+    end
+
+    def type!(type)
+      return type if type?(type)
+
+      raise Error::UnexpectedType.build(type: type, allowed_types: allowed_types)
+    end
+
+    def type_and_value!(data)
+      self.for(data).type_and_value!(data)
+    end
+
+    private
+
+    def for(data)
+      case data.name
+      when :unknown then Contract::Disabled
+      when :success then success
+      else failure
+      end
+    end
+  end
+end

data/lib/bcdd/result/expectations/contract/for_types.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  class Contract::ForTypes
+    include Contract::Interface
+
+    attr_reader :allowed_types
+
+    def initialize(types)
+      @allowed_types = Array(types).map(&:to_sym).to_set.freeze
+    end
+
+    def type?(type)
+      allowed_types.member?(type)
+    end
+
+    def type!(type)
+      return type if type?(type)
+
+      raise Error::UnexpectedType.build(type: type, allowed_types: allowed_types)
+    end
+
+    def type_and_value!(data)
+      type!(data.type)
+
+      nil
+    end
+  end
+end

data/lib/bcdd/result/expectations/contract/for_types_and_values.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  class Contract::ForTypesAndValues
+    include Contract::Interface
+
+    def initialize(types_and_values)
+      @types_and_values = types_and_values.transform_keys(&:to_sym)
+
+      @types_contract = Contract::ForTypes.new(@types_and_values.keys)
+    end
+
+    def allowed_types
+      @types_contract.allowed_types
+    end
+
+    def type?(type)
+      @types_contract.type?(type)
+    end
+
+    def type!(type)
+      @types_contract.type!(type)
+    end
+
+    def type_and_value!(data)
+      type = data.type
+      value = data.value
+      allowed_value = @types_and_values[type!(type)]
+
+      return value if allowed_value === value
+
+      raise Error::UnexpectedValue.build(type: type, value: value)
+    rescue NoMatchingPatternError
+      raise Error::UnexpectedValue.build(type: data.type, value: data.value)
+    end
+  end
+end

data/lib/bcdd/result/expectations/contract/interface.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  module Contract::Interface
+    def allowed_types
+      raise ::BCDD::Result::Error::NotImplemented
+    end
+
+    def type?(_type)
+      raise ::BCDD::Result::Error::NotImplemented
+    end
+
+    def type!(_type)
+      raise ::BCDD::Result::Error::NotImplemented
+    end
+
+    def type_and_value!(_data)
+      raise ::BCDD::Result::Error::NotImplemented
+    end
+  end
+end

data/lib/bcdd/result/expectations/contract.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  module Contract
+    require_relative 'contract/interface'
+    require_relative 'contract/evaluator'
+    require_relative 'contract/disabled'
+    require_relative 'contract/for_types'
+    require_relative 'contract/for_types_and_values'
+
+    NONE = Contract::Evaluator.new(Contract::Disabled, Contract::Disabled).freeze
+
+    ToEnsure = ->(spec) do
+      return Contract::Disabled if spec.nil?
+
+      spec.is_a?(Hash) ? Contract::ForTypesAndValues.new(spec) : Contract::ForTypes.new(Array(spec))
+    end
+
+    def self.new(success:, failure:)
+      Contract::Evaluator.new(ToEnsure[success], ToEnsure[failure])
+    end
+
+    private_constant :ToEnsure
+  end
+end

data/lib/bcdd/result/expectations/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations::Error < BCDD::Result::Error
+  class UnexpectedType < self
+    def self.build(type:, allowed_types:)
+      new("type :#{type} is not allowed. Allowed types: #{allowed_types.map(&:inspect).join(', ')}")
+    end
+  end
+
+  class UnexpectedValue < self
+    def self.build(type:, value:)
+      new("value #{value.inspect} is not allowed for :#{type} type")
+    end
+  end
+end

data/lib/bcdd/result/expectations/mixin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  module Mixin
+    METHODS = <<~RUBY
+      def Success(...)
+        __expected::Success(...)
+      end
+
+      def Failure(...)
+        __expected::Failure(...)
+      end
+
+      private
+
+      def __expected
+        @__expected ||= Expected.with(subject: self)
+      end
+    RUBY
+
+    module Addons
+      module Continuable
+        private def Continue(value)
+          ::BCDD::Result::Success.new(type: :continued, value: value, subject: self)
+        end
+      end
+
+      OPTIONS = { Continue: Continuable }.freeze
+
+      def self.options(names)
+        Array(names).filter_map { |name| OPTIONS[name] }
+      end
+    end
+  end
+
+  private_constant :Mixin
+end

data/lib/bcdd/result/expectations/type_checker.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  class TypeChecker
+    attr_reader :result_type, :expectations
+
+    def initialize(result_type, expectations:)
+      @result_type = result_type
+
+      @expectations = expectations
+    end
+
+    def allow?(types)
+      validate(types, expected: expectations, allow_empty: false)
+    end
+
+    def allow_success?(types)
+      validate(types, expected: expectations.success, allow_empty: true)
+    end
+
+    def allow_failure?(types)
+      validate(types, expected: expectations.failure, allow_empty: true)
+    end
+
+    private
+
+    def validate(types, expected:, allow_empty:)
+      (allow_empty && types.empty?) || types.any? { |type| expected.type!(type) == result_type }
+    end
+  end
+
+  private_constant :TypeChecker
+end

data/lib/bcdd/result/expectations.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class BCDD::Result::Expectations
+  require_relative 'expectations/mixin'
+  require_relative 'expectations/error'
+  require_relative 'expectations/contract'
+  require_relative 'expectations/type_checker'
+
+  def self.mixin(success: nil, failure: nil, with: nil)
+    addons = Mixin::Addons.options(with)
+
+    mod = Module.new
+    mod.const_set(:Expected, new(success: success, failure: failure).freeze)
+    mod.module_eval(Mixin::METHODS)
+    mod.send(:include, *addons) unless addons.empty?
+    mod
+  end
+
+  def self.evaluate(data, expectations)
+    expectations ||= Contract::NONE
+
+    expectations.type_and_value!(data)
+
+    TypeChecker.new(data.type, expectations: expectations)
+  end
+
+  def initialize(subject: nil, success: nil, failure: nil, contract: nil)
+    @subject = subject
+
+    @contract = contract if contract.is_a?(Contract::Evaluator)
+
+    @contract ||= Contract.new(success: success, failure: failure).freeze
+  end
+
+  def Success(type, value = nil)
+    ::BCDD::Result::Success.new(type: type, value: value, subject: subject, expectations: contract)
+  end
+
+  def Failure(type, value = nil)
+    ::BCDD::Result::Failure.new(type: type, value: value, subject: subject, expectations: contract)
+  end
+
+  def with(subject:)
+    self.class.new(subject: subject, contract: contract)
+  end
+
+  private
+
+  attr_reader :subject, :contract
+end

data/lib/bcdd/result/failure.rb

@@ -7,7 +7,7 @@ class BCDD::Result
     end
 
     def failure?(type = nil)
-      type.nil? || type == self.type
+      type.nil? || type_checker.allow_failure?([type])
     end
 
     def value_or

data/lib/bcdd/result/handler/allowed_types.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class Handler
+    class AllowedTypes
+      attr_reader :unchecked, :type_checker
+
+      def initialize(type_checker)
+        @type_checker = type_checker
+
+        @expectations = type_checker.expectations
+
+        @unchecked = @expectations.allowed_types.dup
+      end
+
+      def allow?(types)
+        check!(types, type_checker.allow?(types))
+      end
+
+      def allow_success?(types)
+        unchecked.subtract(@expectations.success.allowed_types) if types.empty?
+
+        check!(types, type_checker.allow_success?(types))
+      end
+
+      def allow_failure?(types)
+        unchecked.subtract(@expectations.failure.allowed_types) if types.empty?
+
+        check!(types, type_checker.allow_failure?(types))
+      end
+
+      def all_checked?
+        unchecked.empty?
+      end
+
+      private
+
+      def check!(types, checked)
+        unchecked.subtract(types) unless all_checked?
+
+        checked
+      end
+    end
+  end
+end

data/lib/bcdd/result/handler.rb

@@ -2,27 +2,30 @@
 
 class BCDD::Result
   class Handler
+    require_relative 'handler/allowed_types'
+
     UNDEFINED = ::Object.new
 
-    def initialize(result)
+    def initialize(result, type_checker:)
+      @allowed_types = AllowedTypes.new(type_checker)
+
       @outcome = UNDEFINED
 
-      @_type = result._type
       @result = result
     end
 
     def [](*types, &block)
       raise Error::MissingTypeArgument if types.empty?
 
-      self.outcome = block if _type.in?(types, allow_empty: false)
+      self.outcome = block if allowed_types.allow?(types)
     end
 
-    def failure(*types, &block)
-      self.outcome = block if result.failure? && _type.in?(types, allow_empty: true)
+    def success(*types, &block)
+      self.outcome = block if allowed_types.allow_success?(types) && result.success?
     end
 
-    def success(*types, &block)
-      self.outcome = block if result.success? && _type.in?(types, allow_empty: true)
+    def failure(*types, &block)
+      self.outcome = block if allowed_types.allow_failure?(types) && result.failure?
     end
 
     def unknown(&block)
@@ -33,7 +36,7 @@ class BCDD::Result
 
     private
 
-    attr_reader :_type, :result
+    attr_reader :result, :allowed_types
 
     def outcome?
       @outcome != UNDEFINED
@@ -44,6 +47,8 @@ class BCDD::Result
     end
 
     def outcome
+      allowed_types.all_checked? or raise Error::UnhandledTypes.build(types: allowed_types.unchecked)
+
       @outcome if outcome?
     end
   end

data/lib/bcdd/result/mixin.rb

@@ -2,12 +2,39 @@
 
 class BCDD::Result
   module Mixin
-    def Success(type, value = nil)
-      Success.new(type: type, value: value, subject: self)
+    module Methods
+      def Success(type, value = nil)
+        Success.new(type: type, value: value, subject: self)
+      end
+
+      def Failure(type, value = nil)
+        Failure.new(type: type, value: value, subject: self)
+      end
     end
 
-    def Failure(type, value = nil)
-      Failure.new(type: type, value: value, subject: self)
+    module Addons
+      module Continuable
+        private def Continue(value)
+          Success(:continued, value)
+        end
+      end
+
+      OPTIONS = { Continue: Continuable }.freeze
+
+      def self.options(names)
+        Array(names).filter_map { |name| OPTIONS[name] }
+      end
     end
   end
+
+  def self.mixin(with: nil)
+    addons = Mixin::Addons.options(with)
+
+    mod = Module.new
+    mod.send(:include, Mixin::Methods)
+    mod.send(:include, *addons) unless addons.empty?
+    mod
+  end
+
+  private_constant :Mixin
 end

data/lib/bcdd/result/success.rb

@@ -3,7 +3,7 @@
 class BCDD::Result
   class Success < self
     def success?(type = nil)
-      type.nil? || type == self.type
+      type.nil? || type_checker.allow_success?([type])
     end
 
     def failure?(_type = nil)

data/lib/bcdd/result/version.rb

@@ -2,6 +2,6 @@
 
 module BCDD
   class Result
-    VERSION = '0.4.0'
+    VERSION = '0.6.0'
   end
 end

data/lib/bcdd/result.rb

@@ -2,32 +2,38 @@
 
 require_relative 'result/version'
 require_relative 'result/error'
-require_relative 'result/type'
 require_relative 'result/data'
 require_relative 'result/handler'
 require_relative 'result/failure'
 require_relative 'result/success'
 require_relative 'result/mixin'
+require_relative 'result/expectations'
 
 class BCDD::Result
   attr_accessor :unknown
 
-  attr_reader :_type, :value, :subject
+  attr_reader :subject, :data, :type_checker
 
   protected :subject
 
-  private :unknown, :unknown=
+  private :unknown, :unknown=, :type_checker
 
-  def initialize(type:, value:, subject: nil)
-    @_type = Type.new(type)
-    @value = value
+  def initialize(type:, value:, subject: nil, expectations: nil)
+    data = Data.new(name, type, value)
+
+    @type_checker = Expectations.evaluate(data, expectations)
     @subject = subject
+    @data = data
 
     self.unknown = true
   end
 
   def type
-    _type.to_sym
+    data.type
+  end
+
+  def value
+    data.value
   end
 
   def success?(_type = nil)
@@ -45,25 +51,27 @@ class BCDD::Result
   def on(*types, &block)
     raise Error::MissingTypeArgument if types.empty?
 
-    tap { known(block) if _type.in?(types, allow_empty: false) }
+    tap { known(block) if type_checker.allow?(types) }
   end
 
   def on_success(*types, &block)
-    tap { known(block) if success? && _type.in?(types, allow_empty: true) }
+    tap { known(block) if type_checker.allow_success?(types) && success? }
   end
 
   def on_failure(*types, &block)
-    tap { known(block) if failure? && _type.in?(types, allow_empty: true) }
+    tap { known(block) if type_checker.allow_failure?(types) && failure? }
   end
 
   def on_unknown
     tap { yield(value, type) if unknown }
   end
 
-  def and_then(method_name = nil)
+  def and_then(method_name = nil, context = nil)
     return self if failure?
 
-    return call_subject_method(method_name) if method_name
+    method_name && block_given? and raise ArgumentError, 'method_name and block are mutually exclusive'
+
+    return call_subject_method(method_name, context) if method_name
 
     result = yield(value)
 
@@ -71,17 +79,13 @@ class BCDD::Result
   end
 
   def handle
-    handler = Handler.new(self)
+    handler = Handler.new(self, type_checker: type_checker)
 
     yield handler
 
     handler.send(:outcome)
   end
 
-  def data
-    Data.new(self)
-  end
-
   def ==(other)
     self.class == other.class && type == other.type && value == other.value
   end
@@ -108,7 +112,7 @@ class BCDD::Result
   private
 
   def name
-    raise Error::NotImplemented
+    :unknown
   end
 
   def known(block)
@@ -117,13 +121,14 @@ class BCDD::Result
     block.call(value, type)
   end
 
-  def call_subject_method(method_name)
+  def call_subject_method(method_name, context)
     method = subject.method(method_name)
 
     result =
       case method.arity
       when 0 then subject.send(method_name)
       when 1 then subject.send(method_name, value)
+      when 2 then subject.send(method_name, value, context)
       else raise Error::WrongSubjectMethodArity.build(subject: subject, method: method)
       end