bcdd-result 0.7.0 → 0.8.0

data/Rakefile

@@ -3,10 +3,16 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
+Rake::TestTask.new(:test_configuration) do |t|
+  t.libs += %w[lib test]
+
+  t.test_files = FileList.new('test/**/configuration_test.rb')
+end
+
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  t.test_files = FileList['test/**/*_test.rb']
+  t.libs += %w[lib test]
+
+  t.test_files = FileList.new('test/**/*_test.rb')
 end
 
 require 'rubocop/rake_task'

data/Steepfile

@@ -10,7 +10,7 @@ target :lib do
   # check 'app/models/**/*.rb'        # Glob
   # ignore 'lib/templates/*.rb'
 
-  # library 'pathname'              # Standard libraries
+  library 'singleton'               # Standard libraries
   # library 'strong_json'           # Gems
 
   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)

data/lib/bcdd/result/config/constant_alias.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class Config
+    module ConstantAlias
+      RESULT = 'Result'
+
+      OPTIONS = {
+        RESULT => { default: false, affects: %w[Object] }
+      }.transform_values!(&:freeze).freeze
+
+      MAPPING = {
+        RESULT => { target: ::Object, name: :Result, value: ::BCDD::Result }
+      }.transform_values!(&:freeze).freeze
+
+      Listener = ->(option_name, boolean) do
+        mapping = MAPPING.fetch(option_name)
+
+        target, name, value = mapping.fetch_values(:target, :name, :value)
+
+        defined = target.const_defined?(name, false)
+
+        boolean ? defined || target.const_set(name, value) : defined && target.send(:remove_const, name)
+      end
+
+      def self.switcher
+        Switcher.new(options: OPTIONS, listener: Listener)
+      end
+    end
+
+    private_constant :ConstantAlias
+  end
+end

data/lib/bcdd/result/config/options.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class Config
+    module Options
+      def self.with_defaults(all_flags, config)
+        all_flags ||= {}
+
+        default_flags = Config.instance.to_h.fetch(config)
+
+        config_flags = all_flags.fetch(config, {})
+
+        default_flags.merge(config_flags).slice(*default_flags.keys)
+      end
+
+      def self.filter_map(all_flags, config:, from:)
+        with_defaults(all_flags, config)
+          .filter_map { |name, truthy| from[name] if truthy }
+      end
+
+      def self.addon(map:, from:)
+        filter_map(map, config: :addon, from: from)
+      end
+    end
+  end
+end

data/lib/bcdd/result/config/switcher.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class Config
+    class Switcher
+      attr_reader :_options, :_affects, :listener
+
+      private :_options, :_affects, :listener
+
+      def initialize(options:, listener: nil)
+        @_options = options.transform_values { _1.fetch(:default) }
+        @_affects = options.transform_values { _1.fetch(:affects) }
+        @listener = listener
+      end
+
+      def inspect
+        "#<#{self.class.name} options=#{_options.inspect}>"
+      end
+
+      def freeze
+        _options.freeze
+        super
+      end
+
+      def to_h
+        _options.dup
+      end
+
+      def options
+        _affects.to_h { |name, affects| [name, { enabled: _options[name], affects: affects }] }
+      end
+
+      def enabled?(name)
+        _options[name] || false
+      end
+
+      def enable!(*names)
+        set_many(names, to: true)
+      end
+
+      def disable!(*names)
+        set_many(names, to: false)
+      end
+
+      private
+
+      def set_many(names, to:)
+        require_option!(names)
+
+        names.each do |name|
+          set_one(name, to)
+
+          listener&.call(name, to)
+        end
+
+        options.slice(*names)
+      end
+
+      def set_one(name, boolean)
+        validate_option!(name)
+
+        _options[name] = boolean
+      end
+
+      def require_option!(names)
+        raise ::ArgumentError, "One or more options required. #{available_options_message}" if names.empty?
+      end
+
+      def validate_option!(name)
+        return if _options.key?(name)
+
+        raise ::ArgumentError, "Invalid option: #{name.inspect}. #{available_options_message}"
+      end
+
+      def available_options_message
+        "Available options: #{_options.keys.map(&:inspect).join(', ')}"
+      end
+    end
+
+    private_constant :Switcher
+  end
+end

data/lib/bcdd/result/config.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+require_relative 'config/options'
+require_relative 'config/switcher'
+require_relative 'config/constant_alias'
+
+class BCDD::Result
+  class Config
+    include Singleton
+
+    ADDON = {
+      continue: {
+        default: false,
+        affects: %w[BCDD::Result BCDD::Result::Context BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+      }
+    }.transform_values!(&:freeze).freeze
+
+    FEATURE = {
+      expectations: {
+        default: true,
+        affects: %w[BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+      }
+    }.transform_values!(&:freeze).freeze
+
+    PATTERN_MATCHING = {
+      nil_as_valid_value_checking: {
+        default: false,
+        affects: %w[BCDD::Result::Expectations BCDD::Result::Context::Expectations]
+      }
+    }.transform_values!(&:freeze).freeze
+
+    attr_reader :addon, :feature, :constant_alias, :pattern_matching
+
+    def initialize
+      @addon = Switcher.new(options: ADDON)
+      @feature = Switcher.new(options: FEATURE)
+      @constant_alias = ConstantAlias.switcher
+      @pattern_matching = Switcher.new(options: PATTERN_MATCHING)
+    end
+
+    def freeze
+      addon.freeze
+      feature.freeze
+      constant_alias.freeze
+      pattern_matching.freeze
+
+      super
+    end
+
+    def options
+      {
+        addon: addon,
+        feature: feature,
+        constant_alias: constant_alias,
+        pattern_matching: pattern_matching
+      }
+    end
+
+    def to_h
+      options.transform_values(&:to_h)
+    end
+
+    def inspect
+      "#<#{self.class.name} options=#{options.keys.sort.inspect}>"
+    end
+
+    private_constant :ADDON, :FEATURE, :PATTERN_MATCHING
+  end
+end

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

@@ -2,21 +2,9 @@
 
 class BCDD::Result::Context
   module Expectations::Mixin
-    METHODS = <<~RUBY
-      def Success(...)
-        _Result::Success(...)
-      end
-
-      def Failure(...)
-        _Result::Failure(...)
-      end
+    Factory = BCDD::Result::Expectations::Mixin::Factory
 
-      private
-
-      def _Result
-        @_Result ||= Result.with(subject: self)
-      end
-    RUBY
+    METHODS = BCDD::Result::Expectations::Mixin::METHODS
 
     module Addons
       module Continuable
@@ -25,10 +13,10 @@ class BCDD::Result::Context
         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)
+        ::BCDD::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
       end
     end
   end

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

@@ -1,27 +1,19 @@
 # frozen_string_literal: true
 
 class BCDD::Result::Context
-  class Expectations
+  class Expectations < BCDD::Result::Expectations
     require_relative 'expectations/mixin'
 
-    def self.mixin(success: nil, failure: nil, with: nil)
-      addons = Mixin::Addons.options(with)
-
-      mod = ::BCDD::Result::Expectations::Mixin.module!
-      mod.const_set(:Result, new(success: success, failure: failure).freeze)
-      mod.module_eval(Mixin::METHODS)
-      mod.send(:include, *addons) unless addons.empty?
-      mod
+    def self.mixin_module
+      Mixin
     end
 
-    def initialize(subject: nil, success: nil, failure: nil, contract: nil)
-      @subject = subject
-
-      @contract = contract if contract.is_a?(::BCDD::Result::Contract::Evaluator)
-
-      @contract ||= ::BCDD::Result::Contract.new(success: success, failure: failure).freeze
+    def self.result_factory_without_expectations
+      ::BCDD::Result::Context
     end
 
+    private_class_method :mixin!, :mixin_module, :result_factory_without_expectations
+
     def Success(type, **value)
       Success.new(type: type, value: value, subject: subject, expectations: contract)
     end
@@ -29,13 +21,5 @@ class BCDD::Result::Context
     def Failure(type, **value)
       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/context/mixin.rb

@@ -2,6 +2,8 @@
 
 class BCDD::Result::Context
   module Mixin
+    Factory = BCDD::Result::Mixin::Factory
+
     module Methods
       def Success(type, **value)
         Success.new(type: type, value: value, subject: self)
@@ -19,20 +21,21 @@ class BCDD::Result::Context
         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)
+        ::BCDD::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
       end
     end
   end
 
-  def self.mixin(with: nil)
-    addons = Mixin::Addons.options(with)
+  def self.mixin_module
+    Mixin
+  end
 
-    mod = ::BCDD::Result::Mixin.module!
-    mod.send(:include, Mixin::Methods)
-    mod.send(:include, *addons) unless addons.empty?
-    mod
+  def self.result_factory
+    ::BCDD::Result::Context
   end
+
+  private_class_method :mixin_module, :result_factory
 end

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

@@ -4,7 +4,12 @@ class BCDD::Result
   class Contract::ForTypesAndValues
     include Contract::Interface
 
-    def initialize(types_and_values)
+    def initialize(types_and_values, config)
+      @nil_as_valid_value_checking =
+        Config::Options
+          .with_defaults(config, :pattern_matching)
+          .fetch(:nil_as_valid_value_checking)
+
       @types_and_values = types_and_values.transform_keys(&:to_sym)
 
       @types_contract = Contract::ForTypes.new(@types_and_values.keys)
@@ -29,7 +34,7 @@ class BCDD::Result
 
       checking_result = value_checking === value
 
-      return value if checking_result || (Contract.nil_as_valid_value_checking? && checking_result.nil?)
+      return value if checking_result || (checking_result.nil? && @nil_as_valid_value_checking)
 
       raise Contract::Error::UnexpectedValue.build(type: type, value: value)
     rescue ::NoMatchingPatternError => e

data/lib/bcdd/result/contract.rb

@@ -19,24 +19,14 @@ module BCDD::Result::Contract
     TypeChecker.new(data.type, expectations: contract)
   end
 
-  ToEnsure = ->(spec) do
+  ToEnsure = ->(spec, config) do
     return Disabled if spec.nil?
 
-    spec.is_a?(::Hash) ? ForTypesAndValues.new(spec) : ForTypes.new(Array(spec))
+    spec.is_a?(::Hash) ? ForTypesAndValues.new(spec, config) : ForTypes.new(Array(spec))
   end
 
-  def self.new(success:, failure:)
-    Evaluator.new(ToEnsure[success], ToEnsure[failure])
-  end
-
-  @nil_as_valid_value_checking = false
-
-  def self.nil_as_valid_value_checking!(enabled: true)
-    @nil_as_valid_value_checking = enabled
-  end
-
-  def self.nil_as_valid_value_checking?
-    @nil_as_valid_value_checking
+  def self.new(success:, failure:, config:)
+    Evaluator.new(ToEnsure[success, config], ToEnsure[failure, config])
   end
 
   private_constant :ToEnsure

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

@@ -2,6 +2,15 @@
 
 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(...)
         _Result.Success(...)
@@ -25,17 +34,10 @@ class BCDD::Result
         end
       end
 
-      OPTIONS = { Continue: Continuable }.freeze
-
-      def self.options(names)
-        Array(names).filter_map { |name| OPTIONS[name] }
-      end
-    end
+      OPTIONS = { continue: Continuable }.freeze
 
-    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
+      def self.options(config_flags)
+        Config::Options.addon(map: config_flags, from: OPTIONS)
       end
     end
   end

data/lib/bcdd/result/expectations.rb

@@ -4,22 +4,46 @@ class BCDD::Result
   class Expectations
     require_relative 'expectations/mixin'
 
-    def self.mixin(success: nil, failure: nil, with: nil)
-      addons = Mixin::Addons.options(with)
+    def self.mixin(**options)
+      return mixin!(**options) if Config.instance.feature.enabled?(:expectations)
 
-      mod = Mixin.module!
-      mod.const_set(:Result, new(success: success, failure: failure).freeze)
-      mod.module_eval(Mixin::METHODS)
+      result_factory_without_expectations.mixin(**options.slice(:config))
+    end
+
+    def self.mixin!(success: nil, failure: nil, config: nil)
+      addons = mixin_module::Addons.options(config)
+
+      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
 
-    def initialize(subject: nil, success: nil, failure: nil, contract: nil)
+    def self.mixin_module
+      Mixin
+    end
+
+    def self.result_factory_without_expectations
+      ::BCDD::Result
+    end
+
+    def self.new(...)
+      return result_factory_without_expectations unless Config.instance.feature.enabled?(:expectations)
+
+      instance = allocate
+      instance.send(:initialize, ...)
+      instance
+    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
 
       @contract = contract if contract.is_a?(Contract::Evaluator)
 
-      @contract ||= Contract.new(success: success, failure: failure).freeze
+      @contract ||= Contract.new(success: success, failure: failure, config: config).freeze
     end
 
     def Success(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,27 +28,31 @@ class BCDD::Result
         end
       end
 
-      OPTIONS = { Continue: Continuable }.freeze
-
-      def self.options(names)
-        Array(names).filter_map { |name| OPTIONS[name] }
-      end
-    end
+      OPTIONS = { continue: Continuable }.freeze
 
-    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
+      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 = Mixin.module!
-    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
+
+  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/version.rb

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

data/lib/bcdd/result.rb

@@ -3,6 +3,7 @@
 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'
@@ -20,6 +21,16 @@ 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)
 

data/lib/bcdd-result.rb

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