bcdd-result 0.7.0 → 0.9.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,35 @@
+# frozen_string_literal: true
+
+class BCDD::Result
+  class Config
+    module ConstantAlias
+      MAPPING = {
+        'Result' => { target: ::Object, name: :Result, value: ::BCDD::Result },
+        'Context' => { target: ::Object, name: :Context, value: ::BCDD::Result::Context },
+        'BCDD::Context' => { target: ::BCDD, name: :Context, value: ::BCDD::Result::Context }
+      }.transform_values!(&:freeze).freeze
+
+      OPTIONS = MAPPING.to_h do |option_name, mapping|
+        affects = mapping.fetch(:target).name.freeze
+
+        [option_name, { default: false, affects: [affects].freeze }]
+      end.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,27 @@
+# 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.select(all_flags, config:, from:)
+        with_defaults(all_flags, config)
+          .filter_map { |name, truthy| [name, from[name]] if truthy }
+          .to_h
+      end
+
+      def self.addon(map:, from:)
+        select(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,41 +1,25 @@
 # 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)
+      _ResultAs(Success, type, value)
     end
 
     def Failure(type, **value)
-      Failure.new(type: type, value: value, subject: subject, expectations: contract)
+      _ResultAs(Failure, type, value)
     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,37 +2,48 @@
 
 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)
+        _ResultAs(Success, type, value)
       end
 
       def Failure(type, **value)
-        Failure.new(type: type, value: value, subject: self)
+        _ResultAs(Failure, type, value)
+      end
+
+      private def _ResultAs(kind_class, type, value, halted: nil)
+        kind_class.new(type: type, value: value, subject: self, halted: halted)
       end
     end
 
     module Addons
       module Continuable
+        def Success(type, **value)
+          _ResultAs(Success, type, value, halted: true)
+        end
+
         private def Continue(**value)
-          Success.new(type: :continued, value: value, subject: self)
+          _ResultAs(Success, :continued, value)
         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/context.rb

@@ -15,7 +15,7 @@ class BCDD::Result
       Failure.new(type: type, value: value)
     end
 
-    def initialize(type:, value:, subject: nil, expectations: nil)
+    def initialize(type:, value:, subject: nil, expectations: nil, halted: nil)
       value.is_a?(::Hash) or raise ::ArgumentError, 'value must be a Hash'
 
       @acc = {}

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

@@ -35,7 +35,7 @@ class BCDD::Result
     private
 
     def for(data)
-      case data.name
+      case data.kind
       when :unknown then Contract::Disabled
       when :success then success
       else failure

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/data.rb

@@ -2,26 +2,26 @@
 
 class BCDD::Result
   class Data
-    attr_reader :name, :type, :value
+    attr_reader :kind, :type, :value
 
-    def initialize(name, type, value)
-      @name = name
+    def initialize(kind, type, value)
+      @kind = kind
       @type = type.to_sym
       @value = value
     end
 
     def to_h
-      { name: name, type: type, value: value }
+      { kind: kind, type: type, value: value }
     end
 
     def to_a
-      [name, type, value]
+      [kind, type, value]
     end
 
     def inspect
       format(
-        '#<%<class_name>s name=%<name>p type=%<type>p value=%<value>p>',
-        class_name: self.class.name, name: name, type: type, value: value
+        '#<%<class_name>s kind=%<kind>p type=%<type>p value=%<value>p>',
+        class_name: self.class.name, kind: kind, type: type, value: value
       )
     end
 

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

@@ -2,21 +2,38 @@
 
 class BCDD::Result
   module Expectations::Mixin
-    METHODS = <<~RUBY
-      def Success(...)
-        _Result.Success(...)
+    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
 
-      def Failure(...)
-        _Result.Failure(...)
-      end
+    module Methods
+      BASE = <<~RUBY
+        def Success(...)
+          _Result.Success(...)
+        end
+
+        def Failure(...)
+          _Result.Failure(...)
+        end
+      RUBY
 
-      private
+      FACTORY = <<~RUBY
+        private def _Result
+          @_Result ||= Result.with(subject: self, halted: %<halted>s)
+        end
+      RUBY
+
+      def self.to_eval(addons)
+        halted = addons.key?(:continue) ? 'true' : 'nil'
 
-      def _Result
-        @_Result ||= Result.with(subject: self)
+        "#{BASE}\n#{format(FACTORY, halted: halted)}"
       end
-    RUBY
+    end
 
     module Addons
       module Continuable
@@ -25,17 +42,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,38 +4,72 @@ 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)
-      mod.send(:include, *addons) unless addons.empty?
+      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.to_eval(addons), __FILE__, __LINE__ + 1)
+      mod.send(:include, *addons.values) 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, contract: nil, halted: nil, **options)
+      @halted = halted
+
       @subject = subject
 
       @contract = contract if contract.is_a?(Contract::Evaluator)
 
-      @contract ||= Contract.new(success: success, failure: failure).freeze
+      @contract ||= Contract.new(
+        success: options[:success],
+        failure: options[:failure],
+        config: options[:config]
+      ).freeze
     end
 
     def Success(type, value = nil)
-      Success.new(type: type, value: value, subject: subject, expectations: contract)
+      _ResultAs(Success, type, value)
     end
 
     def Failure(type, value = nil)
-      Failure.new(type: type, value: value, subject: subject, expectations: contract)
+      _ResultAs(Failure, type, value)
     end
 
-    def with(subject:)
-      self.class.new(subject: subject, contract: contract)
+    def with(subject:, halted: nil)
+      self.class.new(subject: subject, halted: halted, contract: contract)
     end
 
     private
 
-    attr_reader :subject, :contract
+    def _ResultAs(kind_class, type, value)
+      kind_class.new(type: type, value: value, subject: subject, expectations: contract, halted: halted)
+    end
+
+    attr_reader :subject, :halted, :contract
   end
 end

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

@@ -15,7 +15,7 @@ module BCDD::Result::Failure::Methods
 
   private
 
-  def name
+  def kind
     :failure
   end
 end