bcdd-result 0.6.0 → 0.8.0

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

@@ -1,37 +1,44 @@
 # frozen_string_literal: true
 
-class BCDD::Result::Expectations
-  module Mixin
+class BCDD::Result
+  module Expectations::Mixin
+    module Factory
+      def self.module!
+        ::Module.new do
+          def self.included(base); base.const_set(:ResultExpectationsMixin, self); end
+          def self.extended(base); base.const_set(:ResultExpectationsMixin, self); end
+        end
+      end
+    end
+
     METHODS = <<~RUBY
       def Success(...)
-        __expected::Success(...)
+        _Result.Success(...)
       end
 
       def Failure(...)
-        __expected::Failure(...)
+        _Result.Failure(...)
       end
 
       private
 
-      def __expected
-        @__expected ||= Expected.with(subject: self)
+      def _Result
+        @_Result ||= Result.with(subject: self)
       end
     RUBY
 
     module Addons
       module Continuable
         private def Continue(value)
-          ::BCDD::Result::Success.new(type: :continued, value: value, subject: self)
+          Success.new(type: :continued, value: value, subject: self)
         end
       end
 
-      OPTIONS = { Continue: Continuable }.freeze
+      OPTIONS = { continue: Continuable }.freeze
 
-      def self.options(names)
-        Array(names).filter_map { |name| OPTIONS[name] }
+      def self.options(config_flags)
+        Config::Options.addon(map: config_flags, from: OPTIONS)
       end
     end
   end
-
-  private_constant :Mixin
 end

data/lib/bcdd/result/expectations.rb

@@ -1,50 +1,65 @@
 # 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
+class BCDD::Result
+  class Expectations
+    require_relative 'expectations/mixin'
 
-  def self.evaluate(data, expectations)
-    expectations ||= Contract::NONE
+    def self.mixin(**options)
+      return mixin!(**options) if Config.instance.feature.enabled?(:expectations)
 
-    expectations.type_and_value!(data)
+      result_factory_without_expectations.mixin(**options.slice(:config))
+    end
 
-    TypeChecker.new(data.type, expectations: expectations)
-  end
+    def self.mixin!(success: nil, failure: nil, config: nil)
+      addons = mixin_module::Addons.options(config)
 
-  def initialize(subject: nil, success: nil, failure: nil, contract: nil)
-    @subject = subject
+      mod = mixin_module::Factory.module!
+      mod.const_set(:Result, new(success: success, failure: failure, config: config).freeze)
+      mod.module_eval(mixin_module::METHODS)
+      mod.send(:include, *addons) unless addons.empty?
+      mod
+    end
 
-    @contract = contract if contract.is_a?(Contract::Evaluator)
+    def self.mixin_module
+      Mixin
+    end
 
-    @contract ||= Contract.new(success: success, failure: failure).freeze
-  end
+    def self.result_factory_without_expectations
+      ::BCDD::Result
+    end
 
-  def Success(type, value = nil)
-    ::BCDD::Result::Success.new(type: type, value: value, subject: subject, expectations: contract)
-  end
+    def self.new(...)
+      return result_factory_without_expectations unless Config.instance.feature.enabled?(:expectations)
 
-  def Failure(type, value = nil)
-    ::BCDD::Result::Failure.new(type: type, value: value, subject: subject, expectations: contract)
-  end
+      instance = allocate
+      instance.send(:initialize, ...)
+      instance
+    end
 
-  def with(subject:)
-    self.class.new(subject: subject, contract: contract)
-  end
+    private_class_method :mixin!, :mixin_module, :result_factory_without_expectations
+
+    def initialize(subject: nil, success: nil, failure: nil, contract: nil, config: nil)
+      @subject = subject
 
-  private
+      @contract = contract if contract.is_a?(Contract::Evaluator)
 
-  attr_reader :subject, :contract
+      @contract ||= Contract.new(success: success, failure: failure, config: config).freeze
+    end
+
+    def Success(type, value = nil)
+      Success.new(type: type, value: value, subject: subject, expectations: contract)
+    end
+
+    def Failure(type, value = nil)
+      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
 end

data/lib/bcdd/result/failure/methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BCDD::Result::Failure::Methods
+  def success?(_type = nil)
+    false
+  end
+
+  def failure?(type = nil)
+    type.nil? || type_checker.allow_failure?([type])
+  end
+
+  def value_or
+    yield(value)
+  end
+
+  private
+
+  def name
+    :failure
+  end
+end

data/lib/bcdd/result/failure.rb

@@ -2,23 +2,9 @@
 
 class BCDD::Result
   class Failure < self
-    def success?(_type = nil)
-      false
-    end
+    require_relative 'failure/methods'
 
-    def failure?(type = nil)
-      type.nil? || type_checker.allow_failure?([type])
-    end
-
-    def value_or
-      yield
-    end
-
-    private
-
-    def name
-      :failure
-    end
+    include Methods
   end
 
   def self.Failure(type, value = nil)

data/lib/bcdd/result/mixin.rb

@@ -2,6 +2,15 @@
 
 class BCDD::Result
   module Mixin
+    module Factory
+      def self.module!
+        ::Module.new do
+          def self.included(base); base.const_set(:ResultMixin, self); end
+          def self.extended(base); base.const_set(:ResultMixin, self); end
+        end
+      end
+    end
+
     module Methods
       def Success(type, value = nil)
         Success.new(type: type, value: value, subject: self)
@@ -19,22 +28,31 @@ class BCDD::Result
         end
       end
 
-      OPTIONS = { Continue: Continuable }.freeze
+      OPTIONS = { continue: Continuable }.freeze
 
-      def self.options(names)
-        Array(names).filter_map { |name| OPTIONS[name] }
+      def self.options(config_flags)
+        Config::Options.addon(map: config_flags, from: OPTIONS)
       end
     end
   end
 
-  def self.mixin(with: nil)
-    addons = Mixin::Addons.options(with)
+  def self.mixin(config: nil)
+    addons = mixin_module::Addons.options(config)
 
-    mod = Module.new
-    mod.send(:include, Mixin::Methods)
+    mod = mixin_module::Factory.module!
+    mod.send(:include, mixin_module::Methods)
+    mod.const_set(:Result, result_factory)
     mod.send(:include, *addons) unless addons.empty?
     mod
   end
 
-  private_constant :Mixin
+  def self.mixin_module
+    Mixin
+  end
+
+  def self.result_factory
+    ::BCDD::Result
+  end
+
+  private_class_method :mixin_module, :result_factory
 end

data/lib/bcdd/result/success/methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BCDD::Result::Success::Methods
+  def success?(type = nil)
+    type.nil? || type_checker.allow_success?([type])
+  end
+
+  def failure?(_type = nil)
+    false
+  end
+
+  def value_or
+    value
+  end
+
+  private
+
+  def name
+    :success
+  end
+end

data/lib/bcdd/result/success.rb

@@ -2,23 +2,9 @@
 
 class BCDD::Result
   class Success < self
-    def success?(type = nil)
-      type.nil? || type_checker.allow_success?([type])
-    end
+    require_relative 'success/methods'
 
-    def failure?(_type = nil)
-      false
-    end
-
-    def value_or
-      value
-    end
-
-    private
-
-    def name
-      :success
-    end
+    include Methods
   end
 
   def self.Success(type, value = nil)

data/lib/bcdd/result/version.rb

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

data/lib/bcdd/result.rb

@@ -3,11 +3,14 @@
 require_relative 'result/version'
 require_relative 'result/error'
 require_relative 'result/data'
+require_relative 'result/config'
 require_relative 'result/handler'
 require_relative 'result/failure'
 require_relative 'result/success'
 require_relative 'result/mixin'
+require_relative 'result/contract'
 require_relative 'result/expectations'
+require_relative 'result/context'
 
 class BCDD::Result
   attr_accessor :unknown
@@ -18,10 +21,20 @@ class BCDD::Result
 
   private :unknown, :unknown=, :type_checker
 
+  def self.config
+    Config.instance
+  end
+
+  def self.configuration
+    yield(config)
+
+    config.freeze
+  end
+
   def initialize(type:, value:, subject: nil, expectations: nil)
     data = Data.new(name, type, value)
 
-    @type_checker = Expectations.evaluate(data, expectations)
+    @type_checker = Contract.evaluate(data, expectations)
     @subject = subject
     @data = data
 
@@ -69,7 +82,7 @@ class BCDD::Result
   def and_then(method_name = nil, context = nil)
     return self if failure?
 
-    method_name && block_given? and raise ArgumentError, 'method_name and block are mutually exclusive'
+    method_name && block_given? and raise ::ArgumentError, 'method_name and block are mutually exclusive'
 
     return call_subject_method(method_name, context) if method_name
 
@@ -129,7 +142,7 @@ class BCDD::Result
       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)
+      else raise Error::InvalidSubjectMethodArity.build(subject: subject, method: method, max_arity: 2)
       end
 
     ensure_result_object(result, origin: :method)
@@ -140,6 +153,6 @@ class BCDD::Result
 
     return result if result.subject.equal?(subject)
 
-    raise Error::WrongResultSubject.build(given_result: result, expected_subject: subject)
+    raise Error::InvalidResultSubject.build(given_result: result, expected_subject: subject)
   end
 end

data/lib/bcdd-result.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bcdd/result'