lite-command 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 340d00e30b3a4ca140aaff5ee354c8c48d43e03a35533a69ea349afb8c429435
-  data.tar.gz: f05f29f0fcc6d55c2afe9cb4debb309491374db238f9bfdcbe3833169c5caeeb
+  metadata.gz: 1a841431a363de96b59d32abaa1bc733c04046a5d2f33b1c544e85b8b89cdcd9
+  data.tar.gz: 11dd1cd8c8e19cc8d58a631f94f647eb4d7a6b2effe2591d04eaea4c693ecdee
 SHA512:
-  metadata.gz: e504efb0c085b59b57cbc05fb344c9568ee0ad18a275af25efef9cd3db6e5f6dde9b25dfbf971e1b34cab864c486c6efd6dabd015cb23f5ee1199abc0d85956f
-  data.tar.gz: 5ee4f05437705a5ed44a529cf776f32f0b5b049f020f7de8615c0aa1a1e47601db6b4d54cc381cd2280238e4e5d00f2b626c07688aa65795955cdc8092279f15
+  metadata.gz: ae2440d1e33ddf601c42996a513f66771fb06af24a6f60534329b3337335bb714e3be2e9fd5b43d5f71e26ff8d2bc5bbe7bc9a07d275b259491858f6f8864e9b
+  data.tar.gz: 873edb0d145a80033180e0a33072dd80da38512511d718af17e4e91ddc65d90118bd63d8a341d22278a1d026751b0cf867df708dafde21be54fc54ef0c821f47

data/CHANGELOG.md

@@ -6,7 +6,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [2.0.0] - 2024-09-22
+## [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
+
+## [2.0.0] - 2024-09-27
 ### Changed
 - Rewrite app to use interactor pattern
 

data/Gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: .
   specs:
-    lite-command (2.0.0)
-      activemodel
+    lite-command (2.0.2)
       ostruct
 
 GEM
@@ -25,8 +24,6 @@ GEM
       erubi (~> 1.11)
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
-    activemodel (7.2.1)
-      activesupport (= 7.2.1)
     activesupport (7.2.1)
       base64
       bigdecimal

data/lib/lite/command/base.rb

@@ -9,6 +9,7 @@ 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
@@ -25,6 +26,7 @@ module Lite
       end
 
       attr_reader :context
+      alias ctx context
 
       def initialize(context = {})
         @context = Lite::Command::Context.build(context)
@@ -32,10 +34,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,18 +3,15 @@
 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 :caused_by, :thrown_by, :reason
 
-      def initialize(faulter, thrower, reason)
+      def initialize(caused_by, thrown_by, reason)
         super(reason)
 
-        @faulter = faulter
-        @thrower = thrower
+        @caused_by = caused_by
+        @thrown_by = thrown_by
         @reason = reason
       end
 
@@ -28,26 +25,9 @@ module Lite
 
     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 = [
+    STATUSES = [
+      SUCCESS = "success",
       NOOP = "noop",
       INVALID = "invalid",
       FAILURE = "failure",
       ERROR = "error"
     ].freeze
-    STATUSES = [
-      *FAULTS,
-      SUCCESS = "success"
-    ].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)
+          # eg: error(fault_or_string)
+          define_method(:"#{f}") do |fault_or_string|
+            derive_fault_from(fault_or_string)
+            @status = f
           end
 
-          # eg: invalid!(object)
-          define_method(:"#{f}!") do |object|
-            send(:"#{f}", object)
-            raise_fault(Lite::Command.const_get(f.capitalize), object)
+          # eg: invalid!(fault_or_string)
+          define_method(:"#{f}!") do |fault_or_string|
+            send(:"#{f}", fault_or_string)
+            raise_fault(Lite::Command.const_get(f.capitalize), fault_or_string)
           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,9 +3,6 @@
 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",
@@ -45,7 +42,7 @@ module Lite
         end
 
         STATES.each do |s|
-          # eg: running?
+          # eg: executing?
           define_method(:"#{s}?") { state == s }
 
           # eg: dnf!

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

@@ -0,0 +1,88 @@
+# 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(fault_or_string)
+          (fault_or_string.caused_by if fault_or_string.respond_to?(:caused_by)) || self
+        end
+
+        def derive_thrown_by_from(fault_or_string)
+          if fault_or_string.respond_to?(:executed?) && fault_or_string.executed?
+            fault_or_string
+          else
+            (fault_or_string.thrown_by if fault_or_string.respond_to?(:thrown_by)) || caused_by
+          end
+        end
+
+        def derive_reason_from(fault_or_string)
+          if fault_or_string.respond_to?(:reason)
+            fault_or_string.reason
+          elsif fault_or_string.respond_to?(:message)
+            "[#{fault_or_string.class.name}] #{fault_or_string.message}".chomp(".")
+          else
+            fault_or_string
+          end
+        end
+
+        def derive_fault_from(fault_or_string)
+          @caused_by ||= derive_caused_by_from(fault_or_string)
+          @thrown_by ||= derive_thrown_by_from(fault_or_string)
+          @reason ||= derive_reason_from(fault_or_string)
+        end
+
+        # eg: Lite::Command::Noop.new(...)
+        def raise_fault(klass, thrower)
+          exception = klass.new(caused_by, self, reason)
+          exception.set_backtrace(thrower.backtrace) if thrower.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
+
+      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.0"
+    VERSION = "2.0.2"
 
   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"

data/lite-command.gemspec

@@ -37,7 +37,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = %w[lib]
 
-  spec.add_dependency "activemodel"
   spec.add_dependency "ostruct"
 
   spec.add_development_dependency "bundler"

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: lite-command
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - Juan Gomez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-27 00:00:00.000000000 Z
+date: 2024-09-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activemodel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: ostruct
   requirement: !ruby/object:Gem::Requirement
@@ -210,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
@@ -233,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)