solid-result 2.0.0

data/lib/solid/result/event_logs/tree.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+class Solid::Result
+  module EventLogs
+    class Tree
+      class Node
+        attr_reader :id, :value, :parent, :normalizer, :children
+
+        def initialize(value, parent:, id:, normalizer:)
+          @normalizer = normalizer
+
+          @id = id
+          @value = normalizer.call(id, value)
+          @parent = parent
+
+          @children = []
+        end
+
+        def insert(value, id:)
+          node = self.class.new(value, parent: self, id: id, normalizer: normalizer)
+
+          @children << node
+
+          node
+        end
+
+        def root?
+          parent.nil?
+        end
+
+        def leaf?
+          children.empty?
+        end
+
+        def node?
+          !leaf?
+        end
+
+        def inspect
+          "#<#{self.class.name} id=#{id} children.size=#{children.size}>"
+        end
+      end
+
+      attr_reader :size, :root, :current
+
+      def initialize(value, normalizer: ->(_id, val) { val })
+        @size = 0
+
+        @root = Node.new(value, parent: nil, id: size, normalizer: normalizer)
+
+        @current = root
+      end
+
+      def root_value
+        root.value
+      end
+
+      def parent_value
+        current.parent&.value || root_value
+      end
+
+      def current_value
+        current.value
+      end
+
+      def insert(value)
+        @size += 1
+
+        current.insert(value, id: size)
+      end
+
+      def insert!(value)
+        move_to! insert(value)
+      end
+
+      def move_to!(node)
+        tap { @current = node }
+      end
+
+      def move_up!(level = 1)
+        tap { level.times { move_to!(current.parent || root) } }
+      end
+
+      def move_down!(level = 1, index: -1)
+        tap { level.times { current.children[index].then { |child| move_to!(child) if child } } }
+      end
+
+      def move_to_root!
+        move_to!(root)
+      end
+
+      Ids = ->(node) { [node.id, node.children.map(&Ids)] }
+
+      def ids
+        Ids[root]
+      end
+
+      def ids_list
+        ids.flatten
+      end
+
+      IdsMatrix = ->(tree, row, col, memo, previous) do
+        last_row = previous[0]
+
+        tree.each_with_index do |node, index|
+          row = [(index + 1), last_row].max
+
+          id, leaf = node
+
+          memo[id] = previous == [row, col] ? [row, col + 1] : [row, col]
+
+          previous = memo[id]
+
+          IdsMatrix[leaf, row, col + 1, memo, previous]
+        end
+      end
+
+      def ids_matrix
+        current = [0, 0]
+
+        memo = { 0 => current }
+
+        IdsMatrix[ids[1], 1, 1, memo, current]
+
+        memo
+      end
+
+      IdsLevelParent = ->((id, node), parent = 0, level = 0, memo = {}) do
+        memo[id] = [level, parent]
+
+        node.each { |leaf| IdsLevelParent[leaf, id, level + 1, memo] }
+
+        memo
+      end
+
+      def ids_level_parent
+        IdsLevelParent[ids]
+      end
+    end
+  end
+end

data/lib/solid/result/event_logs.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Solid::Result
+  module EventLogs
+    require_relative 'event_logs/listener'
+    require_relative 'event_logs/listeners'
+    require_relative 'event_logs/config'
+    require_relative 'event_logs/tree'
+    require_relative 'event_logs/tracking'
+
+    THREAD_VAR_NAME = :solid_result_event_logs_tracking
+
+    EnsureResult = ->(result) do
+      return result if result.is_a?(::Solid::Result)
+
+      raise Error::UnexpectedOutcome.build(outcome: result, origin: :event_logs)
+    end
+
+    def self.tracking
+      Thread.current[THREAD_VAR_NAME] ||= Tracking.instance
+    end
+  end
+
+  def self.event_logs(name: nil, desc: nil, &block)
+    EventLogs.tracking.exec(name, desc, &block)
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Solid::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
+
+    module Methods
+      BASE = <<~RUBY
+        def Success(...)
+          _Result.Success(...)
+        end
+
+        def Failure(...)
+          _Result.Failure(...)
+        end
+      RUBY
+
+      FACTORY = <<~RUBY
+        private def _Result
+          @_Result ||= Result.with(source: self, terminal: %<terminal>s)
+        end
+      RUBY
+
+      def self.to_eval(addons)
+        terminal = addons.key?(:continue) ? 'true' : 'nil'
+
+        "#{BASE}\n#{format(FACTORY, terminal: terminal)}"
+      end
+    end
+
+    module Addons
+      module Continue
+        private def Continue(value)
+          _Result.Success(IgnoredTypes::CONTINUE, value)
+        end
+      end
+
+      module Given
+        private def Given(value)
+          _Result.Success(IgnoredTypes::GIVEN, value)
+        end
+      end
+
+      OPTIONS = { continue: Continue, given: Given }.freeze
+
+      def self.options(config_flags)
+        Config::Options.addon(map: config_flags, from: OPTIONS)
+      end
+    end
+  end
+end

data/lib/solid/result/expectations.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class Solid::Result
+  class Expectations
+    require_relative 'expectations/mixin'
+
+    def self.mixin(**options)
+      return mixin!(**options) if Config.instance.feature.enabled?(:expectations)
+
+      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 self.mixin_module
+      Mixin
+    end
+
+    def self.result_factory_without_expectations
+      ::Solid::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(source: nil, contract: nil, terminal: nil, **options)
+      @terminal = terminal
+
+      @source = source
+
+      @contract = contract if contract.is_a?(Contract::Evaluator)
+
+      @contract ||= Contract.new(
+        success: options[:success],
+        failure: options[:failure],
+        config: options[:config]
+      ).freeze
+    end
+
+    def Success(type, value = nil)
+      _ResultAs(Success, type, value)
+    end
+
+    def Failure(type, value = nil)
+      _ResultAs(Failure, type, value)
+    end
+
+    def with(source:, terminal: nil)
+      self.class.new(source: source, terminal: terminal, contract: contract)
+    end
+
+    private
+
+    def _ResultAs(kind_class, type, value)
+      kind_class.new(type: type, value: value, source: source, expectations: contract, terminal: terminal)
+    end
+
+    attr_reader :source, :terminal, :contract
+  end
+end

data/lib/solid/result/failure.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Solid::Result
+  class Failure < self
+    include ::Solid::Failure
+  end
+
+  def self.Failure(type, value = nil)
+    Failure.new(type: type, value: value)
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Solid::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/solid/result/handler.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Solid::Result
+  class Handler
+    require_relative 'handler/allowed_types'
+
+    UNDEFINED = ::Object.new
+
+    def initialize(result, type_checker:)
+      @allowed_types = AllowedTypes.new(type_checker)
+
+      @outcome = UNDEFINED
+
+      @result = result
+    end
+
+    def [](*types, &block)
+      raise Error::MissingTypeArgument if types.empty?
+
+      self.outcome = block if allowed_types.allow?(types)
+    end
+
+    def success(*types, &block)
+      self.outcome = block if allowed_types.allow_success?(types) && result.success?
+    end
+
+    def failure(*types, &block)
+      self.outcome = block if allowed_types.allow_failure?(types) && result.failure?
+    end
+
+    def unknown(&block)
+      self.outcome = block unless outcome?
+    end
+
+    alias type []
+
+    private
+
+    attr_reader :result, :allowed_types
+
+    def outcome?
+      @outcome != UNDEFINED
+    end
+
+    def outcome=(block)
+      @outcome = block.call(result.value, result.type) unless outcome?
+    end
+
+    def outcome
+      allowed_types.all_checked? or raise Error::UnhandledTypes.build(types: allowed_types.unchecked)
+
+      @outcome if outcome?
+    end
+  end
+
+  private_constant :Handler
+end

data/lib/solid/result/ignored_types.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Solid::Result
+  module IgnoredTypes
+    LIST = ::Set[
+      GIVEN = :_given_,
+      CONTINUE = :_continue_
+    ].freeze
+
+    def self.include?(type)
+      LIST.member?(type)
+    end
+  end
+end

data/lib/solid/result/mixin.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class Solid::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)
+        _ResultAs(Success, type, value)
+      end
+
+      def Failure(type, value = nil)
+        _ResultAs(Failure, type, value)
+      end
+
+      private def _ResultAs(kind_class, type, value, terminal: nil)
+        kind_class.new(type: type, value: value, source: self, terminal: terminal)
+      end
+    end
+
+    module Addons
+      module Continue
+        def Success(type, value = nil)
+          _ResultAs(Success, type, value, terminal: true)
+        end
+
+        private def Continue(value)
+          _ResultAs(Success, IgnoredTypes::CONTINUE, value)
+        end
+      end
+
+      module Given
+        private def Given(value)
+          _ResultAs(Success, IgnoredTypes::GIVEN, value)
+        end
+      end
+
+      OPTIONS = { continue: Continue, given: Given }.freeze
+
+      def self.options(config_flags)
+        Config::Options.addon(map: config_flags, from: OPTIONS)
+      end
+    end
+  end
+
+  def self.mixin(config: nil)
+    addons = mixin_module::Addons.options(config)
+
+    mod = mixin_module::Factory.module!
+    mod.send(:include, mixin_module::Methods)
+    mod.const_set(:Result, result_factory)
+    mod.send(:include, *addons.values) unless addons.empty?
+    mod
+  end
+
+  def self.mixin_module
+    Mixin
+  end
+
+  def self.result_factory
+    ::Solid::Result
+  end
+
+  private_class_method :mixin_module, :result_factory
+end

data/lib/solid/result/success.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Solid::Result
+  class Success < self
+    include ::Solid::Success
+  end
+
+  def self.Success(type, value = nil)
+    Success.new(type: type, value: value)
+  end
+end

data/lib/solid/result/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Solid
+  class Result
+    VERSION = '2.0.0'
+  end
+end

data/lib/solid/result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Solid
+  require_relative 'success'
+  require_relative 'failure'
+
+  class Result
+    require_relative 'result/version'
+    require_relative 'result/error'
+    require_relative 'result/ignored_types'
+    require_relative 'result/event_logs'
+    require_relative 'result/callable_and_then'
+    require_relative 'result/data'
+    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/config'
+    require_relative 'result/_self'
+
+    require_relative 'output'
+  end
+end

data/lib/solid/success.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solid
+  module Success
+    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 kind
+      :success
+    end
+  end
+end

data/lib/solid-result.rb

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

data/sig/solid/failure.rbs

@@ -0,0 +1,13 @@
+module Solid
+  module Failure
+    def success?: (?Symbol type) -> bool
+    def failure?: (?Symbol type) -> bool
+    def value_or: { (untyped) -> untyped } -> untyped
+    def value: -> untyped
+
+    private
+
+    def kind: -> Symbol
+    def type_checker: -> Solid::Result::Contract::TypeChecker
+  end
+end