muina 0.2.8 → 0.4.0

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

@@ -1,35 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  class Action
-    class Step < Value
-      # Queries are meant to run side effect free code and return the resulting value wrapped in a Result::Success
-      class Query < self
-        const :name, Symbol
-
-        def call(action = Object.new) # rubocop:disable Metrics/MethodLength
-          return if action.instance_variable_get(:@__failure__)
-
-          case result = Muina::Result() { action.instance_eval(&step) }
-          when Muina::Result::Success then success(action, result)
-          when Muina::Result::Failure then failure(action, result)
-          # :nocov:
-          else T.absurd(result)
-            # :nocov:
-          end
-        end
-
-        private
-
-        def success(action, result)
-          action.instance_variable_set("@#{name}", result.value!)
-        end
-
-        def failure(action, result)
-          action.instance_variable_set(:@__failure__, result)
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  class Action
-    class Step < Value
-      # Final step of a successful Action
-      class Result < self
-        # Eval the step and save the result
-        class Caller
-          # Save result on succesful side
-          class Successful < self
-            def initialize(action, result)
-              super()
-              @action = action
-              @result = result
-            end
-
-            def call
-              @action.instance_variable_set(:@__result__, @result)
-            end
-          end
-
-          # Save result on failure side
-          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)
-            # :nocov:
-            else T.absurd(result)
-              # :nocov:
-            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

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

@@ -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/deprecator.rb

@@ -1,93 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Method deprecator
-  class Deprecator
-    class Error < StandardError; end
-
-    @instances = T.let(Hash.new { |h, k| h[k] = {} }, T::Hash[String, T.untyped])
-
-    class << self
-      sig { returns(T::Hash[String, T.untyped]) }
-      attr_reader :instances
-    end
-
-    sig { returns(T::Hash[String, T.untyped]) }
-    def self.renew_instances
-      @instances = Hash.new { |h, k| h[k] = {} }
-    end
-
-    sig { params(name: String).void }
-    def self.deactivate(name)
-      instances[name][:raise] = false
-    end
-
-    sig { params(name: String).void }
-    def self.activate(name)
-      instances[name][:raise] = true
-    end
-
-    sig { params(name: String).returns(T.nilable(T::Boolean)) }
-    def self.raise?(name)
-      instances[name][:raise]
-    end
-
-    sig { params(old: String, new: T.nilable(String), logger: T.untyped, raise: T::Boolean).void }
-    def self.call(old:, new: nil, logger: default_logger, raise: false)
-      new(new: new, old: old, logger: logger, raise: raise).perform
-    end
-
-    sig { returns(Logger) }
-    def self.default_logger
-      Logger.new($stdout)
-    end
-
-    sig { params(old: T.untyped, logger: T.untyped, new: T.untyped, raise: T.untyped).void }
-    def initialize(old:, logger:, new: nil, raise: false)
-      @new = T.let(new, T.nilable(String))
-      @old = T.let(old, String)
-      @logger = T.let(logger, T.untyped)
-      @raise = T.let(raise, T::Boolean)
-    end
-
-    sig { returns(T.nilable(String)) }
-    attr_reader :new
-
-    sig { returns(String) }
-    attr_reader :old
-
-    sig { returns(T.untyped) }
-    attr_reader :logger
-
-    sig { returns(T::Boolean) }
-    attr_reader :raise
-
-    sig { returns(T::Boolean) }
-    def raise?() @raise end # rubocop:disable Style/SingleLineMethods
-
-    sig { returns(NilClass) }
-    def perform # rubocop:disable Metrics/MethodLength
-      logger.warn message
-      case conf = self.class.raise?(old)
-      when nil then Kernel.raise Muina::Deprecator::Error, message if raise?
-      when true then Kernel.raise Muina::Deprecator::Error, message
-      when false then nil
-      # :nocov:
-      else T.absurd(conf)
-        # :nocov:
-      end
-    end
-
-    private
-
-    sig { returns(String) }
-    def message
-      if new
-        "Method: #{old} has been DEPRECATED, please use #{new} instead"
-      else
-        "Method: #{old} has been DEPRECATED with no replacement"
-      end
-    end
-  end
-end

data/lib/muina/entity.rb

@@ -1,20 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module Muina
-  # Immutable Value Object parent class
-  class Entity
-    include T::Props
-    include T::Props::Constructor
-
-    const :id, Integer
-
-    def serialize
-      self.class.props.keys.to_h { |prop| [prop, __send__(prop)] }
-    end
-
-    def with(hash = {})
-      self.class.new(serialize.merge(hash))
-    end
-  end
-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/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/service.rb

@@ -1,25 +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.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,24 +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
-
-    def serialize
-      self.class.props.keys.to_h { |prop| [prop, __send__(prop)] }
-    end
-
-    def with(hash = {})
-      self.class.new(serialize.merge(hash))
-    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