solid-result 2.0.0

data/sig/solid/output.rbs

@@ -0,0 +1,175 @@
+class Solid::Output < Solid::Result
+  EXPECTED_OUTCOME: String
+
+  SourceMethodArity: ^(Method) -> Integer
+
+  attr_reader memo: Hash[Symbol, untyped]
+
+  def initialize: (
+    type: Symbol,
+    value: untyped,
+    ?source: untyped,
+    ?expectations: Solid::Result::Contract::Evaluator,
+    ?terminal: bool
+  ) -> void
+
+  def and_then: (?Symbol, **untyped) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped
+
+  def and_then!: (untyped, **untyped) -> untyped
+
+  private
+
+  def call_and_then_source_method: (Symbol, Hash[Symbol, untyped]) -> Solid::Output
+
+  def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> Solid::Output
+
+  def ensure_result_object: (untyped, origin: Symbol) -> Solid::Output
+
+  def raise_unexpected_outcome_error: (Solid::Output | untyped, Symbol) -> void
+end
+
+class Solid::Output
+  class Error < Solid::Result::Error
+    class InvalidExposure < Solid::Output::Error
+    end
+  end
+end
+
+class Solid::Output
+  class Success < Solid::Output
+    include Solid::Success
+
+    FetchValues: Proc
+
+    def and_expose: (Symbol, Array[Symbol], terminal: bool) -> Solid::Output::Success
+  end
+
+  def self.Success: (Symbol, **untyped) -> Solid::Output::Success
+end
+
+module Solid::Output::CallableAndThen
+  class Caller < Solid::Result::CallableAndThen::Caller
+    module KeyArgs
+      def self.parameters?: (untyped) -> bool
+
+      def self.invalid_arity: (untyped, Symbol) -> Solid::Result::CallableAndThen::Error::InvalidArity
+    end
+
+    def self.call: (
+      untyped source,
+      value: untyped,
+      injected_value: untyped,
+      method_name: (Symbol | nil),
+    ) -> Solid::Output
+
+    private
+
+    def self.call_proc!: (
+      untyped source,
+      Hash[Symbol, untyped] value,
+      nil injected_value
+    ) -> Solid::Output
+
+    def self.call_method!: (
+      untyped source,
+      Method method,
+      Hash[Symbol, untyped] value,
+      nil injected_value
+    ) -> Solid::Output
+
+    def self.callable_method: (
+      untyped source,
+      (Symbol | nil) method_name
+    ) -> ::Method
+
+    def self.ensure_result_object: (
+      untyped source,
+      untyped value,
+      Solid::Output result
+    ) -> Solid::Output
+
+    def self.expected_result_object: () -> singleton(Solid::Output)
+
+    def self.expected_outcome: () -> String
+  end
+end
+
+class Solid::Output
+  class Failure < Solid::Output
+    include Solid::Failure
+
+    def and_expose: (Symbol, Array[Symbol], **untyped) -> Solid::Output::Failure
+  end
+
+  def self.Failure: (Symbol, **untyped) -> Solid::Output::Failure
+end
+
+class Solid::Output
+  module Mixin
+    Factory: singleton(Solid::Result::Mixin::Factory)
+
+    module Methods
+      def Success: (Symbol, **untyped) -> Solid::Output::Success
+
+      def Failure: (Symbol, **untyped) -> Solid::Output::Failure
+
+      private
+
+      def _ResultAs: (singleton(Solid::Output), Symbol, untyped, ?terminal: bool) -> untyped
+    end
+
+    module Addons
+      module Continue
+        include Solid::Output::Mixin::Methods
+
+        private
+
+        def Continue: (**untyped) -> Solid::Output::Success
+      end
+
+      module Given
+        include Solid::Output::Mixin::Methods
+
+        private
+
+        def Given: (*untyped) -> Solid::Output::Success
+      end
+
+      OPTIONS: Hash[Symbol, Module]
+
+      def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
+    end
+  end
+
+  def self.mixin_module: -> singleton(Solid::Output::Mixin)
+
+  def self.result_factory: -> singleton(Solid::Output)
+end
+
+class Solid::Output::Expectations < Solid::Result::Expectations
+  def self.mixin_module: -> singleton(Solid::Output::Expectations::Mixin)
+
+  def self.result_factory_without_expectations: -> singleton(Solid::Result)
+
+  def Success: (Symbol, **untyped) -> Solid::Output::Success
+  def Failure: (Symbol, **untyped) -> Solid::Output::Failure
+end
+
+module Solid::Output::Expectations::Mixin
+  Methods: singleton(Solid::Result::Expectations::Mixin::Methods)
+  Factory: singleton(Solid::Result::Expectations::Mixin::Factory)
+
+  module Addons
+    module Continue
+      private def Continue: (**untyped) -> Solid::Output::Success
+    end
+
+    module Given
+      private def Given: (*untyped) -> Solid::Output::Success
+    end
+
+    OPTIONS: Hash[Symbol, Module]
+
+    def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
+  end
+end

data/sig/solid/result/callable_and_then.rbs

@@ -0,0 +1,60 @@
+module Solid::Result::CallableAndThen
+  class Config
+    attr_accessor default_method_name_to_call: Symbol
+
+    def initialize: -> void
+
+    def options: () -> Hash[Symbol, untyped]
+  end
+
+  class Error < Solid::Result::Error
+  end
+
+  class Error::InvalidArity < Error
+    def self.build: (
+      source: untyped,
+      method: Symbol,
+      arity: String
+    ) -> Error::InvalidArity
+  end
+
+  class Caller
+    def self.call: (
+      untyped source,
+      value: untyped,
+      injected_value: untyped,
+      method_name: (Symbol | nil)
+    ) -> Solid::Result
+
+    private
+
+    def self.call_proc!: (
+      untyped source,
+      untyped value,
+      untyped injected_value
+    ) -> Solid::Result
+
+    def self.call_method!: (
+      untyped source,
+      Method method,
+      untyped value,
+      untyped injected_value
+    ) -> Solid::Result
+
+    def self.callable_method: (
+      untyped source,
+      (Symbol | nil) method_name
+    ) -> ::Method
+
+    def self.ensure_result_object: (
+      untyped source,
+      untyped value,
+      Solid::Result result
+    ) -> Solid::Result
+
+    def self.expected_result_object: () -> singleton(Solid::Result)
+
+    def self.expected_outcome: () -> String
+  end
+end
+

data/sig/solid/result/config.rbs

@@ -0,0 +1,102 @@
+class Solid::Result::Config
+  ADDON: Hash[Symbol, Hash[Symbol, untyped]]
+  FEATURE: Hash[Symbol, Hash[Symbol, untyped]]
+  PATTERN_MATCHING: Hash[Symbol, Hash[Symbol, untyped]]
+
+  attr_reader addon: Solid::Result::Config::Switcher
+  attr_reader feature: Solid::Result::Config::Switcher
+  attr_reader constant_alias: Solid::Result::Config::Switcher
+  attr_reader pattern_matching: Solid::Result::Config::Switcher
+
+  def self.instance: -> Solid::Result::Config
+
+  def initialize: -> void
+
+  def and_then!: () -> Solid::Result::CallableAndThen::Config
+  def event_logs: () -> Solid::Result::EventLogs::Config
+
+  def freeze: -> Solid::Result::Config
+  def options: -> Hash[Symbol, Solid::Result::Config::Switcher]
+  def to_h: -> Hash[Symbol, Hash[Symbol | String, bool]]
+end
+
+module Solid::Result::Config::Options
+  def self.with_defaults: (
+    Hash[Symbol, Hash[Symbol, bool]],
+    Symbol
+  ) -> Hash[Symbol, bool]
+
+  def self.select: (
+    Hash[Symbol, Hash[Symbol, bool]],
+    config: Symbol,
+    from: Hash[Symbol, untyped]
+  ) -> Hash[Symbol, untyped]
+
+  def self.addon: (
+    map: Hash[Symbol, Hash[Symbol, bool]],
+    from: Hash[Symbol, Module]
+  ) -> Hash[Symbol, Module]
+end
+
+class Solid::Result::Config::Switcher
+  private attr_reader _affects: Hash[Symbol | String, Array[String]]
+  private attr_reader _options: Hash[Symbol | String, bool]
+  private attr_reader listener: Proc
+
+  def initialize: (
+    options: Hash[Symbol | String, Hash[Symbol, untyped]],
+    ?listener: Proc
+  ) -> void
+
+  def freeze: -> Solid::Result::Config::Switcher
+
+  def to_h: -> Hash[Symbol | String, bool]
+
+  def options: -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  def enabled?: (Symbol | String) -> bool
+
+  def enable!: (*(Symbol | String)) -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  def disable!: (*(Symbol | String)) -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  private
+
+  def set_many: (Array[Symbol | String], to: bool) -> Hash[Symbol | String, Hash[Symbol, untyped]]
+
+  def set_one: (Symbol | String, bool) -> void
+
+  def require_option!: (Array[Symbol | String]) -> void
+
+  def validate_option!: (Symbol | String) -> void
+
+  def available_options_message: -> String
+end
+
+module Solid::Result::Config::Addons
+  AFFECTS: Array[String]
+  OPTIONS: Hash[String, Hash[Symbol, untyped]]
+
+  def self.switcher: -> Solid::Result::Config::Switcher
+end
+
+module Solid::Result::Config::ConstantAliases
+  MAPPING: Hash[String, Hash[Symbol, untyped]]
+  OPTIONS: Hash[String, Hash[Symbol, untyped]]
+  Listener: Proc
+
+  def self.switcher: -> Solid::Result::Config::Switcher
+end
+
+module Solid::Result::Config::Features
+  OPTIONS: Hash[String, Hash[Symbol, untyped]]
+  Listener: Proc
+
+  def self.switcher: -> Solid::Result::Config::Switcher
+end
+
+module Solid::Result::Config::PatternMatching
+  OPTIONS: Hash[String, Hash[Symbol, untyped]]
+
+  def self.switcher: -> Solid::Result::Config::Switcher
+end

data/sig/solid/result/contract.rbs

@@ -0,0 +1,120 @@
+module Solid::Result::Contract
+  NONE: Solid::Result::Contract::Evaluator
+
+  def self.evaluate: (
+    Solid::Result::Data,
+    Solid::Result::Contract::Evaluator
+  ) -> Solid::Result::Contract::TypeChecker
+
+  ToEnsure: ^(Hash[Symbol, untyped] | Array[Symbol], Hash[Symbol, Hash[Symbol, bool]])
+    -> Solid::Result::Contract::Interface
+
+  def self.new: (
+    success: Hash[Symbol, untyped] | Array[Symbol],
+    failure: Hash[Symbol, untyped] | Array[Symbol],
+    config: Hash[Symbol, Hash[Symbol, bool]]
+  ) -> Solid::Result::Contract::Evaluator
+end
+
+module Solid::Result::Contract
+  class TypeChecker
+    attr_reader result_type: Symbol
+    attr_reader expectations: Solid::Result::Contract::Evaluator
+
+    def initialize: (
+      Symbol,
+      expectations: Solid::Result::Contract::Evaluator
+    ) -> void
+
+    def allow!: (Symbol) -> Symbol
+    def allow?: (Array[Symbol]) -> bool
+    def allow_success?: (Array[Symbol]) -> bool
+    def allow_failure?: (Array[Symbol]) -> bool
+
+    private
+
+    def validate: (
+      Array[Symbol],
+      expected: Solid::Result::Contract::Interface,
+      allow_empty: bool
+    ) -> bool
+  end
+end
+
+class Solid::Result::Contract::Error < Solid::Result::Error
+  class UnexpectedType < Solid::Result::Contract::Error
+    def self.build: (type: Symbol, allowed_types: Set[Symbol])
+        -> Solid::Result::Contract::Error::UnexpectedType
+  end
+
+  class UnexpectedValue < Solid::Result::Contract::Error
+    def self.build: (type: Symbol, value: untyped, ?cause: Exception)
+      -> Solid::Result::Contract::Error::UnexpectedValue
+  end
+end
+
+module Solid::Result::Contract
+  module Interface
+    def ==: (Solid::Result::Contract::Interface) -> bool
+
+    def allowed_types: -> Set[Symbol]
+
+    def type?: (Symbol) -> bool
+
+    def type!: (Symbol) -> Symbol
+
+    def type_and_value!: (Solid::Result::Data) -> void
+
+    def !=: (untyped) -> bool
+  end
+end
+
+module Solid::Result::Contract
+  module Disabled
+    extend Interface
+
+    EMPTY_SET: Set[Symbol]
+  end
+end
+
+module Solid::Result::Contract
+  class ForTypes
+    include Interface
+
+    def initialize: (Array[Symbol]) -> void
+  end
+end
+
+module Solid::Result::Contract
+  class ForTypesAndValues
+    include Interface
+
+    def initialize: (
+      Hash[Symbol, untyped],
+      Hash[Symbol, Hash[Symbol, bool]]
+    ) -> void
+
+    private
+
+    def nil_as_valid_value_checking?: -> bool
+  end
+end
+
+module Solid::Result::Contract
+  class Evaluator
+    include Interface
+
+    attr_reader allowed_types: Set[Symbol]
+    attr_reader success: Solid::Result::Contract::Interface
+    attr_reader failure: Solid::Result::Contract::Interface
+
+    def initialize: (
+      Solid::Result::Contract::Interface,
+      Solid::Result::Contract::Interface
+    ) -> void
+
+    private
+
+    def for: (Solid::Result::Data) -> Solid::Result::Contract::Interface
+  end
+end

data/sig/solid/result/data.rbs

@@ -0,0 +1,16 @@
+class Solid::Result
+  class Data
+    attr_reader kind: Symbol
+    attr_reader type: Symbol
+    attr_reader value: untyped
+    attr_reader to_h: Hash[Symbol, untyped]
+    attr_reader to_a: [Symbol, Symbol, untyped]
+
+    def initialize: (Symbol, Symbol, untyped) -> void
+
+    def inspect: -> String
+
+    alias to_ary to_a
+    alias to_hash to_h
+  end
+end

data/sig/solid/result/error.rbs

@@ -0,0 +1,34 @@
+class Solid::Result
+  class Error < StandardError
+    def self.build: (**untyped) -> Solid::Result::Error
+
+    class NotImplemented < Solid::Result::Error
+    end
+
+    class MissingTypeArgument < Solid::Result::Error
+    end
+
+    class UnexpectedOutcome < Solid::Result::Error
+      def self.build: (outcome: untyped, origin: Symbol, ?expected: String)
+          -> Solid::Result::Error::UnexpectedOutcome
+    end
+
+    class InvalidResultSource < Solid::Result::Error
+      def self.build: (given_result: Solid::Result, expected_source: untyped)
+          -> Solid::Result::Error::InvalidResultSource
+    end
+
+    class InvalidSourceMethodArity < Solid::Result::Error
+      def self.build: (source: untyped, method: Method, max_arity: Integer)
+        -> Solid::Result::Error::InvalidSourceMethodArity
+    end
+
+    class UnhandledTypes < Solid::Result::Error
+      def self.build: (types: Set[Symbol])
+        -> Solid::Result::Error::UnhandledTypes
+    end
+
+    class CallableAndThenDisabled < Solid::Result::Error
+    end
+  end
+end

data/sig/solid/result/event_logs.rbs

@@ -0,0 +1,189 @@
+class Solid::Result
+  module EventLogs
+    module Listener
+      module ClassMethods
+        def around_and_then?: () -> bool
+        def around_event_logs?: () -> bool
+      end
+
+      extend ClassMethods
+
+      def around_event_logs: (scope: Hash[Symbol, untyped]) { () -> untyped } -> untyped
+
+      def on_start: (scope: Hash[Symbol, untyped]) -> untyped
+
+      def around_and_then: (scope: Hash[Symbol, untyped], and_then: Hash[Symbol, untyped]) { () -> untyped } -> untyped
+
+      def on_record: (record: Hash[Symbol, untyped] ) -> untyped
+
+      def on_finish: (event_logs: Hash[Symbol, untyped] ) -> untyped
+
+      def before_interruption: (exception: ::Exception, event_logs: Hash[Symbol, untyped]) -> untyped
+    end
+
+    class Listeners
+      class Chain
+        include Listener
+
+        attr_reader listeners: Hash[Symbol, untyped]
+
+        def initialize: (Array[untyped]) -> void
+
+        def new: () -> Listeners
+
+        private
+
+        def listener?: (untyped, untyped) -> bool
+      end
+
+      def self.[]: (*untyped) -> Chain
+
+      private attr_reader listeners: Array[Listener]
+      private attr_reader around_and_then_listener: untyped
+      private attr_reader around_event_logs_listener: untyped
+
+      def initialize: (Array[Listener], untyped, untyped) -> void
+
+      def around_event_logs: (scope: Hash[Symbol, untyped]) { () -> untyped } -> untyped
+
+      def on_start: (scope: Hash[Symbol, untyped]) -> untyped
+
+      def around_and_then: (scope: Hash[Symbol, untyped], and_then: Hash[Symbol, untyped]) { () -> untyped } -> untyped
+
+      def on_record: (record: Hash[Symbol, untyped] ) -> untyped
+
+      def on_finish: (event_logs: Hash[Symbol, untyped] ) -> untyped
+
+      def before_interruption: (exception: ::Exception, event_logs: Hash[Symbol, untyped]) -> untyped
+    end
+
+    module Listener::Null
+      extend Listener
+
+      def self.new: () -> untyped
+    end
+
+    class Config
+      attr_reader listener: untyped
+      attr_reader trace_id: ::Proc
+
+      def self.instance: -> Config
+
+      def initialize: -> void
+
+      def listener=: (Listener) -> void
+      def trace_id=: (::Proc) -> void
+    end
+
+    class Tree
+      class Node
+        attr_reader id: Integer
+        attr_reader value: untyped
+        attr_reader parent: (Node | nil)
+        attr_reader normalizer: ^(Integer, Array[untyped]) -> untyped
+        attr_reader children: Array[Node]
+
+        def initialize: (
+          untyped value,
+          parent: (Node | nil),
+          id: Integer,
+          normalizer: ^(Integer, Array[untyped]) -> untyped
+        ) -> void
+
+        def insert: (untyped, id: Integer) -> Node
+
+        def root?: () -> bool
+        def leaf?: () -> bool
+        def node?: () -> bool
+        def inspect: () -> String
+      end
+
+      attr_reader size: Integer
+      attr_reader root: Node
+      attr_reader current: Node
+
+      def initialize: (untyped, ?normalizer: ^(Integer, Array[untyped]) -> untyped) -> void
+      def root_value: () -> untyped
+      def parent_value: () -> untyped
+      def current_value: () -> untyped
+      def insert: (untyped) -> Node
+      def insert!: (untyped) -> Tree
+      def move_to!: (Node) -> Tree
+      def move_up!: (?Integer level) -> Tree
+      def move_down!: (?Integer level) -> Tree
+      def move_to_root!: () -> Tree
+
+      Ids: ^(Node) -> Array[untyped]
+      IdsMatrix: ::Proc
+      IdsLevelParent: ::Proc
+
+      def ids: () -> Array[untyped]
+      def ids_list: () -> Array[Integer]
+      def ids_matrix: () -> untyped
+      def ids_level_parent: () -> untyped
+    end
+
+    module Tracking
+      EMPTY_ARRAY: Array[untyped]
+      EMPTY_HASH: Hash[untyped, untyped]
+      EMPTY_TREE: EventLogs::Tree
+      EMPTY_IDS: Hash[untyped, untyped]
+      VERSION: Integer
+      EMPTY: Hash[Symbol, untyped]
+
+      class Enabled
+        private attr_accessor tree: EventLogs::Tree
+        private attr_accessor records: Array[Hash[Symbol, untyped]]
+        private attr_accessor listener: untyped
+        private attr_accessor root_started_at: Integer
+
+        def exec: (untyped, untyped) { () -> untyped } -> untyped
+        def err!: (::Exception, untyped) -> void
+        def reset!: () -> void
+        def record: (Solid::Result) -> void
+        def record_and_then: ((untyped), untyped) { () -> untyped } -> untyped
+        def reset_and_then!: () -> void
+
+        private
+
+        def start: (String, String) -> [EventLogs::Tree::Node, Hash[Symbol, untyped]]
+        def finish: (untyped) -> untyped
+
+        TreeNodeValueNormalizer: ^(Integer, Array[untyped]) -> untyped
+
+        def root_start: (Array[untyped]) -> void
+
+        def track: (Solid::Result, time: Time) -> void
+        def track_record: (Solid::Result, Time) -> Hash[Symbol, untyped]
+
+        def now_in_milliseconds: () -> Integer
+
+        def map_event_logs: () -> Hash[Symbol, untyped]
+
+        def build_listener: () -> Listener
+      end
+
+      module Disabled
+        def self.exec: (untyped, untyped) { () -> untyped } -> untyped
+        def self.err!: (::Exception) -> void
+        def self.reset!: () -> void
+        def self.record: (Solid::Result) -> void
+        def self.record_and_then: ((untyped), untyped) { () -> Solid::Result } -> Solid::Result
+        def self.reset_and_then!: () -> void
+
+        private
+
+        def self.start: (String, String) -> void
+        def self.finish: (untyped) -> untyped
+      end
+
+      def self.instance: () -> (Enabled | singleton(Disabled))
+    end
+
+    THREAD_VAR_NAME: Symbol
+
+    EnsureResult: ^(untyped) -> Solid::Result
+
+    def self.tracking: () -> (Tracking::Enabled | singleton(Tracking::Disabled))
+  end
+end