muina 0.2.8 → 0.3.0

data/rbi/muina.rbi

@@ -1,311 +0,0 @@
-# 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(T.any(Muina::Result::Success, Muina::Result::Failure)) }
-  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
-        class Caller
-          class Successful
-            sig { params(action: T.untyped, result: T.untyped).void }
-            def initialize(action, result)
-              @action = T.let(@action, Muina::Action)
-              @result = T.let(@result, Muina::Result)
-            end
-
-            sig { void }
-            def call; end
-          end
-
-          class Failed
-            sig { params(action: T.untyped, result: T.untyped).void }
-            def initialize(action, result)
-              @action = T.let(@action, Muina::Action)
-              @result = T.let(@result, Muina::Result)
-            end
-
-            sig { void }
-            def call; end
-          end
-
-          sig do
-            params(action: T.untyped, step: T.untyped)
-              .returns(
-                T.any(Muina::Action::Step::Result::Caller::Successful, Muina::Action::Step::Result::Caller::Failed)
-              )
-          end
-          def self.for(action, step); end
-        end
-
-        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 Entity
-    sig { returns(Muina::SymbolHash) }
-    def serialize; end
-
-    sig { params(hash: SymbolHash).returns(Muina::Entity) }
-    def with(hash); 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(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
-
-    sig { returns(Muina::SymbolHash) }
-    def serialize; end
-
-    sig { params(hash: SymbolHash).returns(Muina::Value) }
-    def with(hash); end
-  end
-end

data/sorbet/config

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