muina 0.2.7

data/rbi/muina.rbi

@@ -0,0 +1,268 @@
+# typed: strong
+# frozen_string_literal: true
+
+M = Muina
+
+class Module
+  include T::Sig
+end
+
+module Muina
+  Any = T.type_alias { T.untyped }
+  Classes = T.type_alias { T.any(Class, T::Array[Class]) }
+  Parameters = T.type_alias { T.any(UntypedHash, ActionController::Parameters) }
+  SymbolHash = T.type_alias { T::Hash[Symbol, T.untyped] }
+  UntypedArray = T.type_alias { T::Array[T.untyped] }
+  UntypedHash = T.type_alias { T::Hash[T.untyped, T.untyped] }
+  UNIT = T.let(Unit.instance, Unit)
+  VERSION = '0.2.7'
+
+  class Error < StandardError; end
+
+  sig { params(value: T.untyped).returns(Muina::Result::Success) }
+  def self.Success(value); end
+
+  sig { params(error: T.untyped).returns(Muina::Result::Failure) }
+  def self.Failure(error); end
+
+  sig { params(blk: T.untyped).returns(Muina::Result) }
+  def self.Result(&blk); end
+
+  class Action
+    include T::Props
+    include T::Props::Constructor
+
+    class DoubleResultError < Error
+    end
+
+    @steps           = T.let(@steps, T.nilable(T::Array[Muina::Action::Step]))
+    @parameters      = T.let(@parameters, T.untyped)
+    @__result_set__  = T.let(@__result_set__, T::Boolean)
+    @__failure_set__ = T.let(@__failure_set__, T::Boolean)
+
+    def initialize(hash)
+      @__failure__ = T.let(@__failure__, T.nilable(Muina::Result::Failure))
+      @__result__  = T.let(@__result__, T.nilable(Muina::Result::Success))
+    end
+
+    sig { returns(T::Array[Muina::Action::Step]) }
+    def self.steps; end
+
+    sig { params(params: T.untyped).returns(T.untyped) }
+    def self.extract(params); end
+
+    sig { params(blk: T.untyped).returns(T.untyped) }
+    def self.result(&blk); end
+
+    sig { params(blk: T.untyped).returns(T.untyped) }
+    def self.failure(&blk); end
+
+    sig { params(_name: T.untyped, blk: T.untyped).returns(T.untyped) }
+    def self.command(_name = nil, &blk); end
+
+    sig { params(name: T.untyped, type: T.untyped, blk: T.untyped).returns(T.untyped) }
+    def self.query(name, type, &blk); end
+
+    sig { params(blk: T.untyped).returns(T.untyped) }
+    def self.parameters(&blk); end
+
+    sig { params(hash: SymbolHash).returns(T.untyped) }
+    def self.call(hash = {}); end
+
+    sig { returns(T.untyped) }
+    def perform; end
+
+    module ParamsFactory
+      sig { params(params: T.untyped).returns(T.untyped) }
+      def self.build(params); end
+    end
+
+    class Step < Value
+      const :step, T.untyped
+
+      sig { params(action: T.untyped).returns(T.untyped) }
+      def call(action); end
+
+      class Command < self
+        sig { params(action: T.untyped).returns(T.untyped) }
+        def call(action); end
+
+        private
+
+        sig { void }
+        def success; end
+
+        sig { params(action: T.untyped, result: T.untyped).void }
+        def failure(action, result); end
+      end
+
+      class Failure < self
+        sig { params(action: T.untyped).returns(T.untyped) }
+        def call(action); end
+      end
+
+      class Query < self
+        const :name, Symbol
+
+        sig { params(action: T.untyped).void }
+        def call(action); end
+
+        private
+
+        sig { params(action: T.untyped, result: T.untyped).void }
+        def success(action, result); end
+
+        sig { params(action: T.untyped, result: T.untyped).void }
+        def failure(action, result); end
+      end
+
+      class Result < self
+        sig { params(action: T.untyped).void }
+        def call(action); end
+
+        private
+
+        sig { params(action: T.untyped, value: T.untyped).void }
+        def success(action, value); end
+
+        sig { params(action: T.untyped, value: T.untyped).void }
+        def failure(action, value); end
+      end
+    end
+  end
+
+  class Params
+    include T::Props
+    include T::Props::Constructor
+
+    sig { params(params: Parameters).returns(T.attached_class) }
+    def self.extract(params); end
+
+    sig { params(other: Class).returns(T::Boolean) }
+    def self.<(other); end
+  end
+
+  module PrivateCreation
+    sig { params(klass: Class).void }
+    def self.included(klass); end
+  end
+
+  class Result < Value
+    include PrivateCreation
+
+    sig { returns(Muina::Result::Null) }
+    def self.Null; end
+
+    sig { params(success_klass: T.untyped, error_klass: T.untyped).returns(T.untyped) }
+    def self.[](success_klass, error_klass); end
+
+    sig { returns(T.untyped) }
+    def value!; end
+
+    class Factory < T::Struct
+      prop :success_klass, T.any(Classes, T::Types::Base)
+      prop :error_klass,   T.any(Classes, T::Types::Base)
+
+      sig { params(value: T.untyped).returns(Success) }
+      def success(value); end
+
+      sig { params(error: T.untyped).returns(Failure) }
+      def failure(error); end
+
+      private
+
+      sig { returns(Class) }
+      def success_subclass; end
+
+      sig { returns(Class) }
+      def failure_subclass; end
+
+      sig { params(klass: Class, symbol: Symbol, sklass: T.untyped).returns(Class) }
+      def klass_factory(klass, symbol, sklass); end
+    end
+
+    class Failure < self
+      ValueCalledOnFailureError = Class.new(Error)
+
+      const :error, T.untyped
+
+      sig { returns(T.noreturn) }
+      def value!; end
+
+      sig { returns(T.untyped) }
+      def error!; end
+
+      sig { params(_block: T.untyped).returns(Muina::Result::Failure) }
+      def and_then(&_block); end
+
+      sig { params(block: T.untyped).returns(Muina::Result::Failure) }
+      def or_else(&block); end
+    end
+
+    class Null < self
+      sig { returns(T.noreturn) }
+      def value!; end
+
+      sig { returns(T.noreturn) }
+      def error!; end
+
+      sig { returns(Null) }
+      def and_then(&_block); end
+
+      sig { returns(Null) }
+      def or_else(&_block); end
+    end
+
+    class Success < self
+      ErrorCalledOnSuccessError = Class.new(Error)
+
+      const :value, T.untyped
+
+      sig { returns(T.untyped) }
+      def value!; end
+
+      sig { returns(T.noreturn) }
+      def error!; end
+
+      sig { params(block: T.untyped).returns(T.untyped) }
+      def and_then(&block); end
+
+      sig { params(_block: T.untyped).returns(T.untyped) }
+      def or_else(&_block); end
+    end
+  end
+
+  class Service
+    include T::Props
+    include T::Props::Constructor
+    include PrivateCreation
+
+    sig { params(subklass: Class).void }
+    def self.inherited(subklass); end
+
+    sig { params(hash: SymbolHash).returns(T.untyped) }
+    def self.call(hash = {}); end
+    class << self; alias_method :[], :call; end
+
+    sig { params(args: Symbol, opts: T.untyped).void }
+    def self.arguments(*args, **opts); end
+
+    private
+
+    sig { returns(T.untyped) }
+    def perform; end
+  end
+
+  class Unit
+    include Singleton
+  end
+
+  class Value
+    include T::Props
+    include T::Props::Constructor
+    include T::Struct::ActsAsComparable
+
+    sig { params(hash: SymbolHash).void }
+    def initialize(hash = {}); end
+  end
+end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.