muina 0.2.7 → 0.3.0

data/lib/muina/action.rb

@@ -1,73 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Two tracked result based operation
-  class Action
-    include T::Props
-    include T::Props::Constructor
-
-    class DoubleResultError < Error; end
-
-    class DoubleFailureError < Error; end
-
-    private_class_method :new
-
-    def self.steps
-      @steps ||= []
-    end
-
-    def self.extract(params)
-      new(TypedParams[parameters].new.extract!(ParamsFactory.build(params)).serialize.symbolize_keys)
-    end
-    private_class_method :extract
-
-    def self.result(&blk)
-      raise DoubleResultError if @__result_set__
-
-      steps << Step::Result.new(step: blk)
-
-      @__result_set__ = true
-    end
-    private_class_method :result
-
-    def self.failure(&blk)
-      raise DoubleFailureError if @__failure_set__
-
-      steps << Step::Failure.new(step: blk)
-
-      @__failure_set__ = true
-    end
-    private_class_method :failure
-
-    def self.command(_name = nil, &blk)
-      steps << Step::Command.new(step: blk)
-    end
-    private_class_method :command
-
-    def self.query(name, type = T.untyped, &blk)
-      const name, type
-      steps << Step::Query.new(name: name, step: blk)
-    end
-    private_class_method :query
-
-    def self.parameters(&blk)
-      @parameters ||= Class.new(T::Struct)
-      parameters.instance_eval(&blk) if blk
-      instance_eval(&blk) if blk
-      @parameters
-    end
-
-    def self.call(hash = {})
-      extract(hash).__send__(:perform)
-    end
-
-    private
-
-    def perform
-      self.class.steps.each { |step| step.call(self) }
-
-      @__result__ || @__failure__ || Result::Null()
-    end
-  end
-end

data/lib/muina/any.rb

@@ -1,7 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  Any = T.type_alias { T.untyped }
-  public_constant :Any
-end

data/lib/muina/classes.rb

@@ -1,7 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  Classes = T.type_alias { T.any(Class, T::Array[Class]) }
-  public_constant :Classes
-end

data/lib/muina/module.rb

@@ -1,6 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-class Module
-  include T::Sig
-end

data/lib/muina/parameters.rb

@@ -1,7 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  Parameters = T.type_alias { T.any(UntypedHash, ActionController::Parameters) }
-  public_constant :Parameters
-end

data/lib/muina/params.rb

@@ -1,19 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Typesafe parameters with extraction from ActionController::Parameters
-  class Params
-    include T::Props
-    include T::Props::Constructor
-
-    def self.extract(params)
-      params = ActionController::Parameters.new(params) if params.instance_of?(Hash)
-      TypedParams[self].new.extract!(params)
-    end
-
-    def self.<(other)
-      super || T::Struct <= other
-    end
-  end
-end

data/lib/muina/private_creation.rb

@@ -1,12 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Include this module to make `.allocate` and `.new` private
-  module PrivateCreation
-    def self.included(klass)
-      klass.private_class_method :allocate
-      klass.private_class_method :new
-    end
-  end
-end

data/lib/muina/result/factory.rb

@@ -1,37 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Result Monad
-  class Result < Value
-    # Typed Results Factory.
-    class Factory < T::Struct
-      prop :success_klass, T.any(Classes, T::Types::Base)
-      prop :error_klass,   T.any(Classes, T::Types::Base)
-
-      def success(value)
-        success_subclass.__send__(:new, value: value)
-      end
-
-      def failure(error)
-        failure_subclass.__send__(:new, error: error)
-      end
-
-      private
-
-      def success_subclass
-        klass_factory(Success, :value, success_klass)
-      end
-
-      def failure_subclass
-        klass_factory(Failure, :error, error_klass)
-      end
-
-      def klass_factory(klass, symbol, sklass)
-        iklass = T.unsafe(Class.new(klass)) # rubocop:disable Sorbet/ForbidTUnsafe
-        iklass.const symbol, sklass, override: true
-        iklass.__send__(:private, symbol)
-      end
-    end
-  end
-end

data/lib/muina/result/failure.rb

@@ -1,31 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  class Result < Value
-    # Right(wrong) side of the Result Monad
-    class Failure < self
-      class ValueCalledOnFailureError < Error; end
-
-      const :error, T.untyped
-      private :error
-
-      def value!
-        raise ValueCalledOnFailureError
-      end
-
-      def error!
-        error
-      end
-
-      def and_then(&_blk)
-        self
-      end
-
-      def or_else(&blk)
-        blk[error] if blk
-        self
-      end
-    end
-  end
-end

data/lib/muina/result/null.rb

@@ -1,25 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  class Result < Value
-    # Private null type for the Result Monad
-    class Null < self
-      def value!
-        raise Error
-      end
-
-      def error!
-        raise Error
-      end
-
-      def and_then(&_blk)
-        self
-      end
-
-      def or_else(&_blk)
-        self
-      end
-    end
-  end
-end

data/lib/muina/result/success.rb

@@ -1,31 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  class Result < Value
-    # Left(correct) side of the Result Monad
-    class Success < self
-      class ErrorCalledOnSuccessError < Error; end
-
-      const :value, T.untyped
-      private :value
-
-      def value!
-        value
-      end
-
-      def error!
-        raise ErrorCalledOnSuccessError
-      end
-
-      def and_then(&blk)
-        blk[value] if blk
-        self
-      end
-
-      def or_else(&_blk)
-        self
-      end
-    end
-  end
-end

data/lib/muina/result.rb

@@ -1,17 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Result Monad
-  class Result < Value
-    include PrivateCreation
-
-    def self.Null # rubocop:disable Naming/MethodName
-      Null.__send__(:new)
-    end
-
-    def self.[](success_klass, error_klass)
-      Factory.new(success_klass: success_klass, error_klass: error_klass)
-    end
-  end
-end

data/lib/muina/service.rb

@@ -1,37 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Simple Service Object compatible with MiniService::Base
-  class Service
-    include T::Props
-    include T::Props::Constructor
-    include PrivateCreation
-
-    def self.inherited(subklass) # rubocop:disable Metrics/MethodLength
-      super
-      # :nocov:
-      TracePoint.trace(:end) do |t|
-        if subklass < self && !subklass.instance_methods(false).include?(:perform) # rubocop:disable Style/MissingElse
-          Logger.new($stdout).fatal "#{subklass}#perfrom is not implemented"
-        end
-        t.disable
-      end
-      # :nocov:
-    end
-
-    def self.call(hash = {})
-      new(hash).__send__(:perform)
-    end
-    class << self; alias_method :[], :call; end
-
-    def self.arguments(*args, **opts)
-      args.each { |arg| const arg, T.untyped }
-      opts.each { |key, value| const key, T.untyped, default: value }
-    end
-
-    def perform
-      raise NotImplementedError, "Please implement the #{self.class}#perform method"
-    end
-  end
-end

data/lib/muina/symbol_hash.rb

@@ -1,7 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  SymbolHash = T.type_alias { T::Hash[Symbol, T.untyped] }
-  public_constant :SymbolHash
-end

data/lib/muina/unit.rb

@@ -1,10 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  class Unit
-    include Singleton
-  end
-  UNIT = T.let(Unit.instance, Unit)
-  public_constant :UNIT
-end

data/lib/muina/untyped_array.rb

@@ -1,7 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  UntypedArray = T.type_alias { T::Array[T.untyped] }
-  public_constant :UntypedArray
-end

data/lib/muina/untyped_hash.rb

@@ -1,7 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  UntypedHash = T.type_alias { T::Hash[T.untyped, T.untyped] }
-  public_constant :UntypedHash
-end

data/lib/muina/value.rb

@@ -1,16 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Immutable Value Object parent class
-  class Value
-    include T::Props
-    include T::Props::Constructor
-    include T::Struct::ActsAsComparable
-
-    def initialize(hash = {})
-      super(hash)
-      freeze
-    end
-  end
-end

data/muina.gemspec

@@ -1,35 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative 'lib/muina/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'muina'
-  spec.version       = Muina::VERSION
-  spec.authors       = ['vaporyhumo']
-  spec.email         = ['roanvilina@gmail.com']
-
-  spec.summary       = 'Rails and Sorbet compatible framework'
-  spec.description   = 'Useful parent classes for the Rails missing parts'
-  spec.homepage      = 'https://github.com/vaporyhumo/muina'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
-
-  spec.metadata['homepage_uri']    = spec.homepage
-  spec.metadata['source_code_uri'] = spec.homepage
-  spec.metadata['changelog_uri']   = spec.homepage
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
-  end
-  spec.bindir        = 'exe'
-  spec.executables   = ['muina']
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'actionpack'
-  spec.add_dependency 'sorbet-rails'
-  spec.add_dependency 'sorbet-runtime'
-  spec.add_dependency 'sorbet-struct-comparable'
-  spec.add_dependency 'zeitwerk'
-end

data/rbi/muina.rbi

@@ -1,268 +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(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

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