bcdd-result 0.9.0 → 0.10.0

data/sig/bcdd/result/handler.rbs

@@ -0,0 +1,47 @@
+class BCDD::Result
+  class Handler
+    UNDEFINED: Object
+
+    def initialize: (
+      BCDD::Result,
+      type_checker: BCDD::Result::Contract::TypeChecker
+    ) -> void
+
+    def []: (*Symbol) { (untyped, Symbol) -> void } -> untyped
+    def failure: (*Symbol) { (untyped, Symbol) -> void } -> untyped
+    def success: (*Symbol) { (untyped, Symbol) -> void } -> untyped
+    def unknown: () { (untyped, Symbol) -> void } -> untyped
+
+    alias type []
+
+    private
+
+    attr_reader result: BCDD::Result
+    attr_reader allowed_types: BCDD::Result::Handler::AllowedTypes
+
+    def outcome?: -> bool
+    def outcome=: (Proc) -> void
+    def outcome: -> untyped
+  end
+end
+
+class BCDD::Result::Handler
+  class AllowedTypes
+    attr_reader unchecked: Set[Symbol]
+    attr_reader type_checker: BCDD::Result::Contract::TypeChecker
+
+    def initialize: (
+      BCDD::Result::Contract::TypeChecker
+    ) -> void
+
+    def allow?: (Array[Symbol]) -> bool
+    def allow_success?: (Array[Symbol]) -> bool
+    def allow_failure?: (Array[Symbol]) -> bool
+
+    def all_checked?: -> bool
+
+    private
+
+    def check!: (Array[Symbol], bool) -> bool
+  end
+end

data/sig/bcdd/result/mixin.rbs

@@ -0,0 +1,37 @@
+class BCDD::Result
+  module Mixin
+    module Factory
+      def self.module!: -> Module
+    end
+
+    module Methods
+      def Success: (Symbol type, ?untyped value) -> BCDD::Result::Success
+
+      def Failure: (Symbol type, ?untyped value) -> BCDD::Result::Failure
+
+      private
+
+      def _ResultAs: (singleton(BCDD::Result), Symbol, untyped, ?halted: bool) -> untyped
+    end
+
+    module Addons
+      module Continuable
+        include BCDD::Result::Mixin::Methods
+
+        private
+
+        def Continue: (untyped) -> BCDD::Result::Success
+      end
+
+      OPTIONS: Hash[Symbol, Module]
+
+      def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
+    end
+  end
+
+  def self.mixin: (?config: Hash[Symbol, Hash[Symbol, bool]]) -> Module
+
+  def self.mixin_module: -> singleton(BCDD::Result::Mixin)
+
+  def self.result_factory: -> singleton(BCDD::Result)
+end

data/sig/bcdd/result/transitions.rbs

@@ -0,0 +1,89 @@
+class BCDD::Result
+  module Transitions
+    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) -> Node
+      def move_up!: (?Integer level) -> Tree
+      def move_down!: (?Integer level) -> Tree
+      def move_to_root!: () -> Tree
+
+      NestedIds: ^(Node) -> Array[untyped]
+
+      def nested_ids: () -> Array[untyped]
+    end
+
+    module Tracking
+      EMPTY_ARRAY: Array[untyped]
+      EMPTY_HASH: Hash[untyped, untyped]
+      EMPTY_TREE: Transitions::Tree
+      VERSION: Integer
+      EMPTY: Hash[Symbol, untyped]
+
+      class Enabled
+        private attr_accessor tree: Transitions::Tree
+        private attr_accessor records: Array[Hash[Symbol, untyped]]
+        private attr_accessor root_started_at: Integer
+
+        def start: (name: String, desc: String) -> void
+        def finish: (result: BCDD::Result) -> void
+        def reset!: () -> void
+        def record: (BCDD::Result) -> void
+        def record_and_then: ((untyped), untyped, untyped) { () -> BCDD::Result } -> BCDD::Result
+
+        private
+
+        TreeNodeValueNormalizer: ^(Integer, Array[untyped]) -> untyped
+
+        def root_start: (Array[untyped]) -> void
+
+        def track: (BCDD::Result, time: Time) -> void
+
+        def now_in_milliseconds: () -> Integer
+      end
+
+      module Disabled
+        def self.start: (name: String, desc: String) -> void
+        def self.finish: (result: BCDD::Result) -> void
+        def self.reset!: () -> void
+        def self.record: (BCDD::Result) -> void
+        def self.record_and_then: ((untyped), untyped, untyped) { () -> BCDD::Result } -> BCDD::Result
+      end
+
+      def self.instance: () -> (Enabled | singleton(Disabled))
+    end
+
+    THREAD_VAR_NAME: Symbol
+
+    def self.tracking: () -> (Tracking::Enabled | singleton(Tracking::Disabled))
+  end
+end

data/sig/bcdd/result/version.rbs

@@ -0,0 +1,5 @@
+module BCDD
+  class Result
+    VERSION: String
+  end
+end