lite-command 2.0.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71f2852f73f09542e278f594b692dd02c8e10f54fee85e1e9493d565520e5fc6
-  data.tar.gz: 668b62c1be78ee8b18ad06469ddbabf703497777bc73536395c6608fe8e26614
+  metadata.gz: b21cf35a72b7a37760d250919ee052e3800bfe09083709e9d9f65593612d8826
+  data.tar.gz: b2b55e457b95ce878aab140537ba1f28aa5310c4e257d0e2b11948ed9ee7f9c2
 SHA512:
-  metadata.gz: 18815326f8e22082e906c0142dd0b157a910a9d1755a56e67869b58cfe39ce4394beccb7c48565969ac291569005eb35d0a365ca9854bd9adf383def93ec8c8f
-  data.tar.gz: 3cba4a2e8fa9f780e7546e5934b38a5c3d3aadc318bca455824a8058aa5855cf47026c7c7813cfca8c2f390702b3fdb8d260139613853936d8e59cf68d6e8437
+  metadata.gz: f8ab004280e1c00026dacc92a7d652dc2859c68f6648e31210ccfa1c16a1aba9ba31e57843910bf90d4b94677e8cd8c4c651989c2e2f1983556f33ff786e6514
+  data.tar.gz: aed6da43c95926071114ef9692b17c4fa2b5a3215629e473c8bd70a552fdd624f189095cfa1744da6aa427cbcf80cfb6adb6db81c5b754f4ff81bfee500d046d

data/CHANGELOG.md

@@ -6,6 +6,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.3] - 2024-09-30
+### Changed
+- Simplify error building
+- Reduced recalling error since we can just throw it once
+- Rename `fault_name` to `type`
+
+## [2.0.2] - 2024-09-29
+### Added
+- faultable module
+### Changed
+- Simplified status variable check
+- Simplified context merge
+- Fixed invalid looking at wrong variable
+- Renamed `fault` and `thrower` to `caused_by` and `thrown_by` respectively
+- Removed unused `additional_result_data` method
+### Removed
+- Removed context init
+
 ## [2.0.1] - 2024-09-27
 ### Removed
 - Activemodel dependency

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lite-command (2.0.1)
+    lite-command (2.0.3)
       ostruct
 
 GEM

data/README.md

@@ -94,7 +94,7 @@ command.context.result #=> 8
 
 #### States
 State represents the state of the executable code. Once `execute`
-is ran, it will always `complete` or `dnf` if a fault is thrown by a
+is ran, it will always `complete` or `interrupted` if a fault is thrown by a
 child command.
 
 - `pending`
@@ -103,7 +103,7 @@ child command.
     - Command objects actively executing code.
 - `complete`
     - Command objects that executed to completion.
-- `dnf`
+- `interrupted`
     - Command objects that could NOT be executed to completion.
       This could be as a result of a fault/exception on the
       object itself or one of its children.

data/lib/lite/command/base.rb

@@ -9,22 +9,23 @@ module Lite
 
         base.include Lite::Command::Internals::Callable
         base.include Lite::Command::Internals::Executable
+        base.include Lite::Command::Internals::Faultable
         base.include Lite::Command::Internals::Resultable
 
         base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          # eg: Users::ResetPassword::Fault
-          class #{base}::Fault < Lite::Command::Fault; end
+          # eg: Users::ResetPassword::Fault < Lite::Command::Fault
+          #{base}::Fault = Class.new(Lite::Command::Fault)
+
+          # eg: Users::ResetPassword::Noop < Users::ResetPassword::Fault
+          #{base}::Noop    = Class.new(#{base}::Fault)
+          #{base}::Invalid = Class.new(#{base}::Fault)
+          #{base}::Failure = Class.new(#{base}::Fault)
+          #{base}::Error   = Class.new(#{base}::Fault)
         RUBY
-
-        FAULTS.each do |f|
-          base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            # eg: Users::ResetPassword::Noop < Users::ResetPassword::Fault
-            class #{base}::#{f.capitalize} < #{base}::Fault; end
-          RUBY
-        end
       end
 
       attr_reader :context
+      alias ctx context
 
       def initialize(context = {})
         @context = Lite::Command::Context.build(context)
@@ -32,10 +33,6 @@ module Lite
 
       private
 
-      def additional_result_data
-        {} # Define in your class to add additional info to result hash
-      end
-
       def on_before_execution
         # Define in your class to run code before execution
       end

data/lib/lite/command/context.rb

@@ -6,25 +6,20 @@ module Lite
   module Command
     class Context < OpenStruct
 
-      def self.init(attributes = {})
+      def self.build(attributes = {})
+        return attributes if attributes.is_a?(self) && !attributes.frozen?
+
         # To save memory and speed up the access to an attribute, the accessor methods
         # of an attribute are lazy loaded at certain points. This means that the methods
         # are defined only when a set of defined actions are triggered. This allows context
         # to only define the minimum amount of required methods to make your data structure work
-        os = new(attributes)
+        os = new(attributes.to_h)
         os.methods(false)
         os
       end
 
-      def self.build(attributes = {})
-        return attributes if attributes.is_a?(self) && !attributes.frozen?
-
-        init(attributes.to_h)
-      end
-
       def merge!(attributes = {})
-        attrs = attributes.is_a?(self.class) ? attributes.to_h : attributes
-        attrs.each { |k, v| self[k] = v }
+        attributes.to_h.each { |k, v| self[k] = v }
       end
 
     end

data/lib/lite/command/fault.rb

@@ -3,51 +3,27 @@
 module Lite
   module Command
 
-    # Fault represent a stoppage of a call execution. This error should
-    # not be raised directly since it wont provide any context. Use
-    # `Noop`, `Invalid`, `Failure`, and `Error` to signify severity.
     class Fault < StandardError
 
-      attr_reader :faulter, :thrower, :reason
+      attr_reader :reason, :caused_by, :thrown_by
 
-      def initialize(faulter, thrower, reason)
+      def initialize(reason, caused_by, thrown_by)
         super(reason)
 
-        @faulter = faulter
-        @thrower = thrower
         @reason = reason
+        @caused_by = caused_by
+        @thrown_by = thrown_by
       end
 
-      def fault_klass
-        @fault_klass ||= self.class.name.split("::").last
-      end
-
-      def fault_name
-        @fault_name ||= fault_klass.downcase
+      def type
+        @type ||= self.class.name.split("::").last.downcase
       end
 
     end
 
-    # Noop represents skipping completion of call execution early
-    # an unsatisfied condition or logic check where there is no
-    # point on proceeding.
-    # eg: account is sample: skip since its a non-alterable record
     class Noop < Fault; end
-
-    # Invalid represents a stoppage of call execution due to
-    # missing, bad, or corrupt data.
-    # eg: user not found: stop since rest of the call cant be executed
     class Invalid < Fault; end
-
-    # Failure represents a stoppage of call execution due to
-    # an unsatisfied condition or logic check where it blocks
-    # proceeding any further.
-    # eg: record not found: stop since there is nothing todo
     class Failure < Fault; end
-
-    # Error represents a caught exception for a call execution
-    # that could not complete.
-    # eg: ApiServerError: stop since there was a 3rd party issue
     class Error < Fault; end
 
   end

data/lib/lite/command/internals/callable.rb

@@ -3,28 +3,20 @@
 module Lite
   module Command
 
-    # Status represents the state of the callable code. If no fault
-    # is thrown then a status of SUCCESS is returned even if `call`
-    # has not been executed.
-    FAULTS = [
-      NOOP = "noop",
+    STATUSES = [
+      SUCCESS = "success",
+      NOOP    = "noop",
       INVALID = "invalid",
       FAILURE = "failure",
-      ERROR = "error"
-    ].freeze
-    STATUSES = [
-      *FAULTS,
-      SUCCESS = "success"
+      ERROR   = "error"
     ].freeze
+    FAULTS = (STATUSES - [SUCCESS]).freeze
 
     module Internals
       module Callable
 
         def self.included(base)
           base.extend ClassMethods
-          base.class_eval do
-            attr_reader :faulter, :thrower, :reason
-          end
         end
 
         module ClassMethods
@@ -43,109 +35,44 @@ module Lite
           raise NotImplementedError, "call method not defined in #{self.class}"
         end
 
-        def success?
-          !fault?
-        end
-
-        def fault?(message = nil)
-          FAULTS.any? { |f| send(:"#{f}?", message) }
-        end
-
         def status
-          STATUSES.find { |s| send(:"#{s}?") }
-        end
-
-        def faulter?
-          faulter == self
+          @status || SUCCESS
         end
 
-        def thrower?
-          thrower == self
+        def success?
+          status == SUCCESS
         end
 
-        def thrown_fault?
-          fault? && !faulter?
+        def fault?(str = nil)
+          !success? && reason?(str)
         end
 
         FAULTS.each do |f|
-          # eg: error?(message = nil)
-          define_method(:"#{f}?") do |message = nil|
-            fault_result = instance_variable_get(:"@#{f}") || false
-            return fault_result if message.nil?
-
-            reason == message
+          # eg: noop? or failure?("idk")
+          define_method(:"#{f}?") do |str = nil|
+            status == f && reason?(str)
           end
         end
 
         private
 
-        def derive_faulter_from(object)
-          (object.faulter if object.respond_to?(:faulter)) || self
-        end
-
-        def derive_thrower_from(object)
-          if object.respond_to?(:executed?) && object.executed?
-            object
-          else
-            (object.thrower if object.respond_to?(:thrower)) || faulter
-          end
-        end
-
-        def derive_reason_from(object)
-          if object.respond_to?(:reason)
-            object.reason
-          elsif object.respond_to?(:message)
-            "[#{object.class.name}] #{object.message}".chomp(".")
-          else
-            object
-          end
-        end
-
-        def fault(object)
-          @faulter ||= derive_faulter_from(object)
-          @thrower ||= derive_thrower_from(object)
-          @reason ||= derive_reason_from(object)
-        end
-
-        # eg: Lite::Command::Noop.new(...)
-        def raise_fault(klass, object)
-          exception = klass.new(faulter, self, reason)
-          exception.set_backtrace(object.backtrace) if object.respond_to?(:backtrace)
-          raise(exception)
-        end
-
-        # eg: Users::ResetPassword::Noop.new(...)
-        def raise_dynamic_fault(exception)
-          fault_klass = self.class.const_get(exception.fault_klass)
-          raise_fault(fault_klass, exception)
-        end
-
-        def raise_dynamic_faults?
-          false
-        end
-
-        def throw!(command)
-          return if command.success?
-
-          send(:"#{command.status}!", command)
-        end
-
         FAULTS.each do |f|
           # eg: error(object)
           define_method(:"#{f}") do |object|
-            fault(object)
-            instance_variable_set(:"@#{f}", true)
+            derive_fault_from(object)
+            @status = f
           end
 
           # eg: invalid!(object)
           define_method(:"#{f}!") do |object|
             send(:"#{f}", object)
-            raise_fault(Lite::Command.const_get(f.capitalize), object)
+            raise fault(f.capitalize, object)
           end
 
           # eg: on_noop(exception)
           define_method(:"on_#{f}") do |_exception|
-            # Define in your class to run code when a StandardError happens
+            # Define in your class to run code when a
+            # Lite::Command::Fault or StandardError happens
           end
         end
 

data/lib/lite/command/internals/executable.rb

@@ -3,14 +3,11 @@
 module Lite
   module Command
 
-    # State represents the state of the executable code. Once `execute`
-    # is ran, it will always complete or dnf if a fault is thrown by a
-    # child command.
     STATES = [
-      PENDING = "pending",
-      EXECUTING = "executing",
-      COMPLETE = "complete",
-      DNF = "dnf"
+      PENDING     = "pending",
+      EXECUTING   = "executing",
+      COMPLETE    = "complete",
+      INTERRUPTED = "interrupted"
     ].freeze
 
     module Internals
@@ -19,21 +16,18 @@ module Lite
         def execute
           around_execution { call }
         rescue StandardError => e
-          fn = e.respond_to?(:fault_name) ? e.fault_name : ERROR
+          f = e.respond_to?(:type) ? e.type : ERROR
 
-          send(:"#{fn}", e)
+          send(:"#{f}", e)
           after_execution
-          send(:"on_#{fn}", e)
+          send(:"on_#{f}", e)
         end
 
         def execute!
           around_execution { call }
         rescue StandardError => e
           after_execution
-
-          raise(e) unless raise_dynamic_faults? && e.is_a?(Lite::Command::Fault)
-
-          raise_dynamic_fault(e)
+          raise(e)
         end
 
         def state
@@ -41,14 +35,14 @@ module Lite
         end
 
         def executed?
-          dnf? || complete?
+          complete? || interrupted?
         end
 
         STATES.each do |s|
-          # eg: running?
+          # eg: executing?
           define_method(:"#{s}?") { state == s }
 
-          # eg: dnf!
+          # eg: interrupted!
           define_method(:"#{s}!") { @state = s }
         end
 
@@ -63,7 +57,7 @@ module Lite
         end
 
         def after_execution
-          fault? ? dnf! : complete!
+          fault? ? interrupted! : complete!
           on_after_execution
           stop_monotonic_time
           append_execution_result

data/lib/lite/command/internals/faultable.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Lite
+  module Command
+    module Internals
+      module Faultable
+
+        def self.included(base)
+          base.class_eval do
+            attr_reader :caused_by, :thrown_by, :reason
+          end
+        end
+
+        def reason?(str)
+          return true if str.nil?
+
+          reason == str
+        end
+
+        def caused_fault?
+          caused_by == self
+        end
+
+        def threw_fault?
+          thrown_by == self
+        end
+
+        def thrown?
+          fault? && !caused_fault?
+        end
+
+        private
+
+        def throw!(command)
+          return if command.success?
+
+          send(:"#{command.status}!", command)
+        end
+
+        def derive_caused_by_from(object)
+          (object.caused_by if object.respond_to?(:caused_by)) || self
+        end
+
+        def derive_thrown_by_from(object)
+          if object.respond_to?(:executed?) && object.executed?
+            object
+          else
+            (object.thrown_by if object.respond_to?(:thrown_by)) || caused_by
+          end
+        end
+
+        def derive_reason_from(object)
+          if object.respond_to?(:reason)
+            object.reason
+          elsif object.respond_to?(:message)
+            "[#{object.class.name}] #{object.message}".chomp(".")
+          else
+            object
+          end
+        end
+
+        def derive_fault_from(object)
+          @caused_by ||= derive_caused_by_from(object)
+          @thrown_by ||= derive_thrown_by_from(object)
+          @reason ||= derive_reason_from(object)
+        end
+
+        def raise_dynamic_faults?
+          false
+        end
+
+        # eg: Lite::Command::Noop.new(...) or Users::ResetPassword::Noop.new(...)
+        def fault(type, thrower)
+          klass = raise_dynamic_faults? ? self.class : Lite::Command
+          fault = klass.const_get(type.to_s).new(reason, caused_by, self)
+          fault.set_backtrace(thrower.backtrace) if thrower.respond_to?(:backtrace)
+          fault
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/command/internals/resultable.rb

@@ -16,7 +16,7 @@ module Lite
         end
 
         def outcome
-          return state if pending? || thrown_fault?
+          return state if pending? || thrown?
 
           status
         end
@@ -34,8 +34,8 @@ module Lite
             state:,
             status:,
             reason:,
-            fault: faulter&.index,
-            throw: thrower&.index,
+            caused_by: caused_by&.index,
+            thrown_by: thrown_by&.index,
             runtime:
           }.compact
         end

data/lib/lite/command/version.rb

@@ -3,7 +3,7 @@
 module Lite
   module Command
 
-    VERSION = "2.0.1"
+    VERSION = "2.0.3"
 
   end
 end

data/lib/lite/command.rb

@@ -5,6 +5,7 @@ require "generators/rails/command_generator" if defined?(Rails::Generators)
 require "lite/command/version"
 require "lite/command/internals/callable"
 require "lite/command/internals/executable"
+require "lite/command/internals/faultable"
 require "lite/command/internals/resultable"
 require "lite/command/fault"
 require "lite/command/context"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lite-command
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.3
 platform: ruby
 authors:
 - Juan Gomez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-27 00:00:00.000000000 Z
+date: 2024-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -196,6 +196,7 @@ files:
 - lib/lite/command/fault.rb
 - lib/lite/command/internals/callable.rb
 - lib/lite/command/internals/executable.rb
+- lib/lite/command/internals/faultable.rb
 - lib/lite/command/internals/resultable.rb
 - lib/lite/command/version.rb
 - lite-command.gemspec
@@ -219,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.19
+rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
 summary: Ruby Command based framework (aka service objects)