muina 0.2.7

data/lib/muina/action/step/result.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Muina
+  class Action
+    class Step < Value
+      # Final step of a successful Action
+      class Result < self
+        class Caller
+          class Successful < self
+            def initialize(action, result)
+              super()
+              @action = action
+              @result = result
+            end
+
+            def call
+              @action.instance_variable_set(:@__result__, @result)
+            end
+          end
+
+          class Failed < self
+            def initialize(action, result)
+              super()
+              @action = action
+              @result = result
+            end
+
+            def call
+              @action.instance_variable_set(:@__failure__, @result)
+            end
+          end
+
+          def self.for(action, step)
+            case result = Muina::Result() { action.instance_eval(&step) }
+            when Muina::Result::Success then Caller::Successful.new(action, result)
+            when Muina::Result::Failure then Caller::Failed.new(action, result)
+            else T.absurd(result)
+            end
+          end
+        end
+
+        def call(action = Object.new)
+          return if action.instance_variable_get(:@__failure__)
+
+          Caller.for(action, step).call
+        end
+      end
+    end
+  end
+end

data/lib/muina/action/step.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Muina
+  class Action
+    # Base class for diferent kind of action steps
+    class Step < Value
+      const :step, T.untyped
+
+      def call(instance); end
+    end
+  end
+end

data/lib/muina/action.rb

@@ -0,0 +1,73 @@
+# 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

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

data/lib/muina/classes.rb

@@ -0,0 +1,7 @@
+# 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

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

data/lib/muina/parameters.rb

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +1,19 @@
+# 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

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,37 @@
+# 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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,37 @@
+# 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

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +1,7 @@
+# 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

@@ -0,0 +1,16 @@
+# 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/lib/muina/version.rb

@@ -0,0 +1,7 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Muina
+  VERSION = '0.2.7'
+  public_constant :VERSION
+end

data/lib/muina.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+# Load dependencies
+require 'action_controller'
+require 'action_controller/metal/exceptions'
+require 'sorbet-runtime'
+require 'sorbet-rails/typed_params'
+require 'sorbet-struct-comparable'
+
+# Require Module monkeypatch
+require 'muina/module'
+
+# Setup zeitwork loader
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+module_ext = "#{__dir__}/muina/module.rb"
+loader.ignore(module_ext)
+loader.setup
+
+# Top level module
+module Muina
+  class Error < StandardError; end
+
+  def self.Success(value) # rubocop:disable Naming/MethodName
+    Result::Success.__send__(:new, value: value)
+  end
+
+  def self.Failure(error) # rubocop:disable Naming/MethodName
+    Result::Failure.__send__(:new, error: error)
+  end
+
+  def self.Result(&blk) # rubocop:disable Naming/MethodName
+    Success(blk[])
+  rescue StandardError => e
+    Failure(e)
+  end
+end
+M = Muina
+
+# Eager load all code
+loader.eager_load

data/muina.gemspec

@@ -0,0 +1,35 @@
+# 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