lite-command 2.1.3 → 3.0.1

data/lib/lite/command/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_model" unless defined?(ActiveModel)
+
 module Lite
   module Command
     class Base
@@ -7,22 +9,23 @@ module Lite
       def self.inherited(base)
         super
 
-        base.include Lite::Command::Internals::Context
-        base.include Lite::Command::Internals::Call
-        base.include Lite::Command::Internals::Execute
-        base.include Lite::Command::Internals::Fault
-        base.include Lite::Command::Internals::Result
-
-        base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          # 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
+        base.include ActiveModel::Validations
+
+        base.include Lite::Command::Internals::Attributes
+        base.include Lite::Command::Internals::Calls
+        base.include Lite::Command::Internals::Executions
+        base.include Lite::Command::Internals::Faults
+        base.include Lite::Command::Internals::Results
+
+        if Lite::Command.configuration.raise_dynamic_faults # rubocop:disable Style/GuardClause
+          base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            #{base}::Fault   = Class.new(Lite::Command::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
+        end
       end
 
       attr_reader :context
@@ -30,7 +33,7 @@ module Lite
 
       def initialize(context = {})
         @context = Lite::Command::Context.build(context)
-        Utils.hook(self, :on_pending)
+        Utils.try(self, :on_pending)
       end
 
     end

data/lib/lite/command/configuration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Lite
+  module Command
+
+    class Configuration
+
+      attr_accessor :raise_dynamic_faults
+
+      def initialize
+        @raise_dynamic_faults = false
+      end
+
+    end
+
+    class << self
+
+      attr_writer :configuration
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+
+    end
+
+  end
+end

data/lib/lite/command/fault.rb

@@ -5,7 +5,7 @@ module Lite
 
     class Fault < StandardError
 
-      attr_reader :caused_by, :thrown_by, :reason, :metadata
+      attr_reader :reason, :metadata, :caused_by, :thrown_by
 
       def initialize(**params)
         @reason    = params.fetch(:reason)
@@ -16,23 +16,36 @@ module Lite
         super(reason)
       end
 
-      def self.build(type, command, thrown_exception, dynamic: false)
-        klass = dynamic ? command.class : Lite::Command
+      def self.build(type, catcher, thrower, dynamic: false)
+        klass = dynamic ? catcher.class : Lite::Command
         fault = klass.const_get(type.to_s)
         fault = fault.new(
-          reason: command.reason,
-          metadata: command.metadata,
-          caused_by: command.caused_by || command,
-          thrown_by: command
+          reason: catcher.reason,
+          metadata: catcher.metadata,
+          caused_by: catcher.caused_by,
+          thrown_by: catcher.thrown_by
         )
-        fault.set_backtrace(thrown_exception.backtrace) if thrown_exception.respond_to?(:backtrace)
+        fault.set_backtrace(thrower.backtrace) if thrower.respond_to?(:backtrace)
         fault
       end
 
+      def self.===(item)
+        klass0 = respond_to?(:new) ? self : self.class
+        klass1 = item.respond_to?(:new) ? item : item.class
+        return true if klass0 == klass1
+
+        klass0.ancestors.include?(klass1) || klass1.ancestors.include?(klass0)
+      end
+
       def type
         @type ||= self.class.name.split("::").last.downcase
       end
 
+      def ===(item)
+        klass = item.respond_to?(:new) ? item : item.class
+        is_a?(klass)
+      end
+
     end
 
     class Noop < Fault; end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Lite
+  module Command
+    module Internals
+      module Attributes
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+
+          def required(*attributes, from: :context, **options)
+            delegate(*attributes, from:)
+
+            validates_each(*attributes, **options) do |command, method_name, _attr_value|
+              next unless Utils.evaluate(command, options)
+              next if command.errors.added?(from, :undefined) || command.errors.added?(method_name, :required)
+
+              if !command.respond_to?(from, true)
+                command.errors.add(from, :undefined, message: "is an undefined argument")
+              elsif !command.send(from).respond_to?(method_name, true)
+                command.errors.add(method_name, :required, message: "is a required argument")
+              end
+            end
+          end
+
+          def optional(*attributes, from: :context, **_options)
+            delegate(*attributes, from:)
+          end
+
+          private
+
+          def delegate(*attributes, from: :context)
+            attributes.each do |method_name|
+              define_method(method_name) do
+                return unless respond_to?(from)
+
+                Utils.try(send(from), method_name)
+              end
+            end
+          end
+
+        end
+
+        def read_attribute_for_validation(method_name)
+          Utils.try(self, method_name)
+        rescue NameError
+          # Do nothing, fallback to :undefined error
+        end
+
+        private
+
+        def validate_context_attributes
+          return if errors.empty?
+
+          invalid!(errors.full_messages.join(". "), errors.messages)
+        end
+
+      end
+    end
+  end
+end

data/lib/lite/command/internals/{call.rb → calls.rb}

@@ -13,25 +13,25 @@ module Lite
     FAULTS = (STATUSES - [SUCCESS]).freeze
 
     module Internals
-      module Call
+      module Calls
 
         def self.included(base)
           base.extend ClassMethods
-          base.class_eval do
-            attr_reader :reason, :metadata
-          end
+          base.class_eval { attr_reader :reason, :metadata }
         end
 
         module ClassMethods
 
           def call(context = {})
             instance = send(:new, context)
+            instance.validate
             instance.send(:execute)
             instance
           end
 
           def call!(context = {})
             instance = send(:new, context)
+            instance.validate
             instance.send(:execute!)
             instance
           end
@@ -58,6 +58,10 @@ module Lite
           !success? && reason?(reason)
         end
 
+        def bad?(reason = nil)
+          ![SUCCESS, NOOP].include?(status) && reason?(reason)
+        end
+
         FAULTS.each do |f|
           # eg: noop? or failure?("idk")
           define_method(:"#{f}?") do |reason = nil|

data/lib/lite/command/internals/{execute.rb → executions.rb}

@@ -11,7 +11,7 @@ module Lite
     ].freeze
 
     module Internals
-      module Execute
+      module Executions
 
         def state
           @state || PENDING
@@ -35,15 +35,16 @@ module Lite
           increment_execution_index
           assign_execution_cmd_id
           start_monotonic_time
-          Utils.hook(self, :on_before_execution)
+          Utils.try(self, :on_before_validation)
           validate_context_attributes
+          Utils.try(self, :on_before_execution)
           executing!
-          Utils.hook(self, :on_executing)
+          Utils.try(self, :on_executing)
         end
 
         def after_execution
           send(:"#{success? ? COMPLETE : INTERRUPTED}!")
-          Utils.hook(self, :on_after_execution)
+          Utils.try(self, :on_after_execution)
           stop_monotonic_time
           append_execution_result
           freeze_execution_objects
@@ -57,25 +58,25 @@ module Lite
 
         def execute
           around_execution { call }
-          Utils.hook(self, :on_success)
+          Utils.try(self, :on_success)
         rescue StandardError => e
           fault(e, ERROR, metadata) unless e.is_a?(Lite::Command::Fault)
           after_execution
-          Utils.hook(self, :"on_#{status}", e)
+          Utils.try(self, :"on_#{status}", e)
         ensure
-          Utils.hook(self, :"on_#{state}")
+          Utils.try(self, :"on_#{state}")
         end
 
         def execute!
           around_execution { call }
-          Utils.hook(self, :on_success)
+          Utils.try(self, :on_success)
         rescue StandardError => e
           fault(e, ERROR, metadata) unless e.is_a?(Lite::Command::Fault)
           after_execution
-          Utils.hook(self, :"on_#{status}", e)
+          Utils.try(self, :"on_#{status}", e)
           raise(e)
         else
-          Utils.hook(self, :"on_#{state}")
+          Utils.try(self, :"on_#{state}")
         end
 
       end

data/lib/lite/command/internals/{fault.rb → faults.rb}

@@ -3,18 +3,24 @@
 module Lite
   module Command
     module Internals
-      module Fault
+      module Faults
 
-        def self.included(base)
-          base.class_eval do
-            attr_reader :caused_by, :thrown_by
-          end
+        def caused_by
+          return if success?
+
+          @caused_by || self
         end
 
         def caused_fault?
           caused_by == self
         end
 
+        def thrown_by
+          return if success?
+
+          @thrown_by || self
+        end
+
         def threw_fault?
           thrown_by == self
         end
@@ -32,7 +38,7 @@ module Lite
         end
 
         def raise_dynamic_faults?
-          false
+          Lite::Command.configuration.raise_dynamic_faults
         end
 
       end

data/lib/lite/command/internals/{result.rb → results.rb}

@@ -5,7 +5,7 @@ require "securerandom" unless defined?(SecureRandom)
 module Lite
   module Command
     module Internals
-      module Result
+      module Results
 
         def index
           @index ||= context.index ||= 0

data/lib/lite/command/sequence.rb

@@ -19,7 +19,7 @@ module Lite
           next unless step.run?(self)
 
           cmd = step.command.call(context)
-          throw!(cmd) unless cmd.ok?
+          throw!(cmd) if cmd.bad?
         end
       end
 

data/lib/lite/command/step.rb

@@ -12,13 +12,7 @@ module Lite
       end
 
       def run?(cmd)
-        if options[:if]
-          Utils.call(cmd, options[:if])
-        elsif options[:unless]
-          !Utils.call(cmd, options[:unless])
-        else
-          true
-        end
+        Utils.evaluate(cmd, options)
       end
 
     end

data/lib/lite/command/utils.rb

@@ -6,16 +6,12 @@ module Lite
 
       module_function
 
-      def try(object, method_name, *args, include_private: false)
+      def try(object, method_name, *args, include_private: true)
         return unless object.respond_to?(method_name, include_private)
 
         object.send(method_name, *args)
       end
 
-      def hook(object, method_name, *args)
-        try(object, method_name, *args, include_private: true)
-      end
-
       def call(object, argument)
         if argument.is_a?(Symbol) || argument.is_a?(String)
           object.send(argument)
@@ -26,6 +22,16 @@ module Lite
         end
       end
 
+      def evaluate(object, options = {})
+        if options[:if]
+          call(object, options[:if])
+        elsif options[:unless]
+          !call(object, options[:unless])
+        else
+          options.fetch(:default, true)
+        end
+      end
+
     end
   end
 end

data/lib/lite/command/version.rb

@@ -3,7 +3,7 @@
 module Lite
   module Command
 
-    VERSION = "2.1.3"
+    VERSION = "3.0.1"
 
   end
 end

data/lib/lite/command.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
-require "generators/rails/command_generator" if defined?(Rails::Generators)
+if defined?(Rails::Generators)
+  require "generators/lite/command/install_generator"
+  require "generators/rails/command_generator"
+end
 
 require "lite/command/version"
+require "lite/command/configuration"
 require "lite/command/utils"
 require "lite/command/context"
-require "lite/command/attribute"
-require "lite/command/attribute_validator"
 require "lite/command/fault"
 require "lite/command/fault_streamer"
-require "lite/command/internals/context"
-require "lite/command/internals/call"
-require "lite/command/internals/execute"
-require "lite/command/internals/fault"
-require "lite/command/internals/result"
+require "lite/command/internals/attributes"
+require "lite/command/internals/calls"
+require "lite/command/internals/executions"
+require "lite/command/internals/faults"
+require "lite/command/internals/results"
 require "lite/command/base"
 require "lite/command/step"
 require "lite/command/sequence"

data/lite-command.gemspec

@@ -37,6 +37,7 @@ 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,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lite-command
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 3.0.1
 platform: ruby
 authors:
 - Juan Gomez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-09 00:00:00.000000000 Z
+date: 2024-10-25 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
@@ -172,21 +186,22 @@ files:
 - _config.yml
 - bin/console
 - bin/setup
+- lib/generators/lite/command/install_generator.rb
+- lib/generators/lite/command/templates/install.rb
 - lib/generators/rails/USAGE
 - lib/generators/rails/command_generator.rb
 - lib/generators/rails/templates/command.rb.tt
 - lib/lite/command.rb
-- lib/lite/command/attribute.rb
-- lib/lite/command/attribute_validator.rb
 - lib/lite/command/base.rb
+- lib/lite/command/configuration.rb
 - lib/lite/command/context.rb
 - lib/lite/command/fault.rb
 - lib/lite/command/fault_streamer.rb
-- lib/lite/command/internals/call.rb
-- lib/lite/command/internals/context.rb
-- lib/lite/command/internals/execute.rb
-- lib/lite/command/internals/fault.rb
-- lib/lite/command/internals/result.rb
+- lib/lite/command/internals/attributes.rb
+- lib/lite/command/internals/calls.rb
+- lib/lite/command/internals/executions.rb
+- lib/lite/command/internals/faults.rb
+- lib/lite/command/internals/results.rb
 - lib/lite/command/sequence.rb
 - lib/lite/command/step.rb
 - lib/lite/command/utils.rb

data/lib/lite/command/attribute.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Command
-    class Attribute
-
-      attr_accessor :command
-      attr_reader :method_name, :options, :errors
-
-      def initialize(method_name, options)
-        @method_name = method_name
-        @options = options
-        @errors = []
-      end
-
-      def from
-        options[:from] || :context
-      end
-
-      def filled?
-        Utils.call(command, options[:filled]) || false
-      end
-
-      def required?
-        Utils.call(command, options[:required]) || false
-      end
-
-      def typed?
-        options.key?(:types) && types.any?
-      end
-
-      def types
-        @types ||= begin
-          t = Array(Utils.call(command, options[:types]))
-
-          if filled?
-            t.uniq - [NilClass]
-          else
-            t | [NilClass]
-          end
-        end
-      end
-
-      def validate!
-        validate_respond_attribute!
-        return unless errors.empty?
-
-        validate_required_attribute!
-        validate_attribute_type!
-        validate_attribute_filled!
-      end
-
-      def valid?
-        errors.empty?
-      end
-
-      def value
-        return @value if defined?(@value)
-
-        @value = command.send(from).public_send(method_name)
-      end
-
-      private
-
-      def validate_respond_attribute!
-        return if command.respond_to?(from, true)
-
-        @errors << "is not defined or an attribute"
-      end
-
-      def validate_required_attribute!
-        return unless required?
-        return if command.send(from).respond_to?(method_name)
-
-        @errors << "#{method_name} is required"
-      end
-
-      def validate_attribute_type!
-        return unless typed?
-        return if types.include?(value.class)
-
-        @errors << "#{method_name} type invalid"
-      end
-
-      def empty?
-        r = Utils.try(options[:filled], :[], :empty)
-        return false if r.nil? || r == true
-        return false unless value.respond_to?(:empty?)
-
-        value.empty?
-      end
-
-      def validate_attribute_filled!
-        return unless filled?
-        return unless value.nil? || empty?
-
-        @errors << "#{method_name} must be filled"
-      end
-
-    end
-  end
-end

data/lib/lite/command/attribute_validator.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Command
-    class AttributeValidator
-
-      attr_reader :command
-
-      def initialize(command)
-        @command = command
-      end
-
-      def attributes
-        @attributes ||=
-          command.class.attributes.map do |_method_name, attribute|
-            attribute.tap { |a| a.command = command }
-          end
-      end
-
-      def errors
-        @errors ||= attributes.each_with_object({}) do |attribute, h|
-          next if attribute.tap(&:validate!).valid?
-
-          h[attribute.from] ||= []
-          h[attribute.from] = h[attribute.from] | attribute.errors
-        end
-      end
-
-      def valid?
-        attributes.empty? || errors.empty?
-      end
-
-    end
-  end
-end