cmdx 0.1.0

data/lib/cmdx/result_serializer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module CMDx
+  module ResultSerializer
+
+    STRIP_FAILURE = proc do |h, r, k|
+      unless r.send(:"#{k}?")
+        # Strip caused/threw failures since its the same info as the log line
+        h[k] = r.send(k).to_h.except(:caused_failure, :threw_failure)
+      end
+    end.freeze
+
+    module_function
+
+    def call(result)
+      {
+        index: result.index,
+        run_id: result.run.id,
+        type: result.task.is_a?(Batch) ? "Batch" : "Task",
+        class: result.task.class.name,
+        id: result.task.id,
+        state: result.state,
+        status: result.status,
+        outcome: result.outcome,
+        metadata: result.metadata,
+        runtime: result.runtime,
+        tags: result.task.task_setting(:tags),
+        pid: Process.pid
+      }.tap do |hash|
+        if result.failed?
+          STRIP_FAILURE.call(hash, result, :caused_failure)
+          STRIP_FAILURE.call(hash, result, :threw_failure)
+        end
+      end
+    end
+
+  end
+end

data/lib/cmdx/run.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CMDx
+  class Run
+
+    __cmdx_attr_delegator :index, to: :results
+    __cmdx_attr_delegator :state, :status, :outcome, :runtime, to: :first_result
+
+    attr_reader :id, :results
+
+    def initialize(attributes = {})
+      @id      = attributes[:id] || SecureRandom.uuid
+      @results = Array(attributes[:results])
+    end
+
+    def to_h
+      RunSerializer.call(self)
+    end
+
+    def to_s
+      RunInspector.call(self)
+    end
+
+    private
+
+    def first_result
+      return @first_result if defined?(@first_result)
+
+      @first_result = @results.first
+    end
+
+  end
+end

data/lib/cmdx/run_inspector.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CMDx
+  module RunInspector
+
+    ORDERED_KEYS = %i[
+      state status outcome runtime
+    ].freeze
+
+    module_function
+
+    def call(run)
+      header = "Run: #{run.id}"
+      footer = ORDERED_KEYS.map { |key| "#{key}=#{run.send(key)}" }.join(" ")
+      spacer = "=" * [header.size, footer.size].max
+
+      run.results.map(&:to_s).unshift(header, spacer).push(spacer, footer).join("\n")
+    end
+
+  end
+end

data/lib/cmdx/run_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CMDx
+  module RunSerializer
+
+    module_function
+
+    def call(run)
+      {
+        id: run.id,
+        results: run.results.map(&:to_h)
+      }
+    end
+
+  end
+end

data/lib/cmdx/task.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module CMDx
+  class Task
+
+    HOOKS = [
+      :before_validation,
+      :after_validation,
+      :before_execution,
+      :after_execution,
+      *Result::STATUSES.map { |s| :"on_#{s}" },
+      *Result::STATES.map { |s| :"on_#{s}" }
+    ].freeze
+
+    __cmdx_attr_setting :task_settings, default: -> { CMDx.configuration.to_h.merge(tags: []) }
+    __cmdx_attr_setting :cmd_parameters, default: -> { Parameters.new }
+    __cmdx_attr_setting :cmd_hooks, default: {}
+
+    __cmdx_attr_delegator :task_setting, :task_setting?, to: :class
+    __cmdx_attr_delegator :skip!, :fail!, :throw!, to: :result
+
+    attr_reader :id, :errors, :context, :result, :run
+    alias ctx context
+    alias res result
+
+    private_class_method :new
+
+    def initialize(context = {})
+      @id      = SecureRandom.uuid
+      @errors  = Errors.new
+      @context = Context.build(context)
+      @run = @context.run || begin
+        run = Run.new(@context.delete!(:run).to_h)
+        @context.instance_variable_set(:@run, run)
+      end
+      @run.results << @result = Result.new(self)
+    end
+
+    class << self
+
+      HOOKS.each do |hook|
+        define_method(hook) do |*callables, **options, &block|
+          callables << block if block_given?
+          (cmd_hooks[hook] ||= []).push([callables, options]).uniq!
+        end
+      end
+
+      def task_setting(key)
+        __cmdx_yield(task_settings[key])
+      end
+
+      def task_setting?(key)
+        task_settings.key?(key)
+      end
+
+      def task_settings!(**options)
+        task_settings.merge!(options)
+      end
+
+      def optional(*attributes, **options, &)
+        parameters = Parameter.optional(*attributes, **options.merge(klass: self), &)
+        cmd_parameters.concat(parameters)
+      end
+
+      def required(*attributes, **options, &)
+        parameters = Parameter.required(*attributes, **options.merge(klass: self), &)
+        cmd_parameters.concat(parameters)
+      end
+
+      def call(...)
+        instance = send(:new, ...)
+        instance.send(:execute_call)
+        instance.result
+      end
+
+      def call!(...)
+        instance = send(:new, ...)
+        instance.send(:execute_call!)
+        instance.result
+      end
+
+    end
+
+    def call
+      raise UndefinedCallError, "call method not defined in #{self.class.name}"
+    end
+
+    private
+
+    def logger
+      Logger.call(self)
+    end
+
+    def before_call
+      TaskHook.call(self, :before_execution)
+
+      result.executing!
+      TaskHook.call(self, :on_executing)
+
+      TaskHook.call(self, :before_validation)
+      ParameterValidator.call(self)
+      TaskHook.call(self, :after_validation)
+    end
+
+    def after_call
+      result.send(result.success? ? :complete! : :interrupt!)
+      TaskHook.call(self, :"on_#{result.status}")
+      TaskHook.call(self, :"on_#{result.state}")
+
+      TaskHook.call(self, :after_execution)
+    end
+
+    def terminate_call
+      Immutator.call(self)
+      ResultLogger.call(result)
+    end
+
+    def execute_call
+      result.runtime do
+        before_call
+        call
+      rescue UndefinedCallError => e
+        raise(e)
+      rescue StandardError => e
+        result.fail!(reason: "[#{e.class}] #{e.message}", original_exception: e) unless e.is_a?(Fault)
+      ensure
+        after_call
+      end
+
+      terminate_call
+    end
+
+    def execute_call!
+      result.runtime do
+        before_call
+        call
+      rescue UndefinedCallError => e
+        raise(e)
+      rescue Fault => e
+        raise(e) if Array(task_setting(:task_halt)).include?(e.result.status)
+
+        after_call # HACK: treat as NO-OP
+      else
+        after_call # ELSE: treat as success
+      end
+
+      terminate_call
+    end
+
+  end
+end

data/lib/cmdx/task_hook.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CMDx
+  module TaskHook
+
+    module_function
+
+    def call(task, hook)
+      Array(task.class.cmd_hooks[hook]).each do |callables, options|
+        next unless task.__cmdx_eval(options)
+
+        hooks = Array(callables)
+        hooks.each { |h| task.__cmdx_try(h) }
+      end
+    end
+
+  end
+end

data/lib/cmdx/utils/datetime_formatter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Utils
+    module DatetimeFormatter
+
+      DATETIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%6N"
+
+      module_function
+
+      def call(time)
+        time.strftime(DATETIME_FORMAT)
+      end
+
+    end
+  end
+end

data/lib/cmdx/utils/method_name.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Utils
+    module MethodName
+
+      ROOTFIX = proc do |o, &block|
+        o == true ? block.call : o
+      end.freeze
+
+      module_function
+
+      def call(method_name, source, options = {})
+        options[:as] || begin
+          prefix = ROOTFIX.call(options[:prefix]) { "#{source}_" }
+          suffix = ROOTFIX.call(options[:suffix]) { "_#{source}" }
+
+          "#{prefix}#{method_name}#{suffix}".strip.to_sym
+        end
+      end
+
+    end
+  end
+end

data/lib/cmdx/utils/runtime.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Utils
+    module Runtime
+
+      module_function
+
+      def call(&)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+        yield
+        finish = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+        finish - start
+      end
+
+    end
+  end
+end

data/lib/cmdx/validators/custom.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Validators
+    module Custom
+
+      module_function
+
+      def call(value, options = {})
+        return if options.dig(:custom, :validator).call(value, options)
+
+        raise ValidationError, options.dig(:custom, :message) || I18n.t(
+          "cmdx.validators.custom",
+          default: "is not valid"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/validators/exclusion.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Validators
+    module Exclusion
+
+      extend self
+
+      def call(value, options = {})
+        values = options.dig(:exclusion, :in) ||
+                 options.dig(:exclusion, :within)
+
+        if values.is_a?(Range)
+          raise_within_validation_error!(values.begin, values.end, options) if values.cover?(value)
+        elsif Array(values).any? { |v| v === value } # rubocop:disable Style/CaseEquality
+          raise_of_validation_error!(values, options)
+        end
+      end
+
+      private
+
+      def raise_of_validation_error!(values, options)
+        values  = values.map(&:inspect).join(", ")
+        message = options.dig(:exclusion, :of_message) ||
+                  options.dig(:exclusion, :message)
+        message %= { values: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.exclusion.of",
+          values:,
+          default: "must not be one of: #{values}"
+        )
+      end
+
+      def raise_within_validation_error!(min, max, options)
+        message = options.dig(:exclusion, :in_message) ||
+                  options.dig(:exclusion, :within_message) ||
+                  options.dig(:exclusion, :message)
+        message %= { min:, max: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.exclusion.within",
+          min:,
+          max:,
+          default: "must not be within #{min} and #{max}"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/validators/format.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Validators
+    module Format
+
+      module_function
+
+      def call(value, options = {})
+        return if case options[:format]
+                  in { with: with, without: without }
+                    value.match?(with) && !value.match?(without)
+                  in { with: with }
+                    value.match?(with)
+                  in { without: without }
+                    !value.match?(without)
+                  end
+
+        raise ValidationError, options.dig(:format, :message) || I18n.t(
+          "cmdx.validators.format",
+          default: "is an invalid format"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/validators/inclusion.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Validators
+    module Inclusion
+
+      extend self
+
+      def call(value, options = {})
+        values = options.dig(:inclusion, :in) ||
+                 options.dig(:inclusion, :within)
+
+        if values.is_a?(Range)
+          raise_within_validation_error!(values.begin, values.end, options) unless values.cover?(value)
+        elsif Array(values).none? { |v| v === value } # rubocop:disable Style/CaseEquality
+          raise_of_validation_error!(values, options)
+        end
+      end
+
+      private
+
+      def raise_of_validation_error!(values, options)
+        values  = values.map(&:inspect).join(", ")
+        message = options.dig(:inclusion, :of_message) ||
+                  options.dig(:inclusion, :message)
+        message %= { values: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.inclusion.of",
+          values:,
+          default: "must be one of: #{values}"
+        )
+      end
+
+      def raise_within_validation_error!(min, max, options)
+        message = options.dig(:inclusion, :in_message) ||
+                  options.dig(:inclusion, :within_message) ||
+                  options.dig(:inclusion, :message)
+        message %= { min:, max: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.inclusion.within",
+          min:,
+          max:,
+          default: "must be within #{min} and #{max}"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/validators/length.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Validators
+    module Length
+
+      extend self
+
+      def call(value, options = {})
+        case options[:length]
+        in { within: within }
+          raise_within_validation_error!(within.begin, within.end, options) unless within.cover?(value.length)
+        in { not_within: not_within }
+          raise_not_within_validation_error!(not_within.begin, not_within.end, options) if not_within.cover?(value.length)
+        in { in: yn }
+          raise_within_validation_error!(yn.begin, yn.end, options) unless yn.cover?(value.length)
+        in { not_in: not_in }
+          raise_not_within_validation_error!(not_in.begin, not_in.end, options) if not_in.cover?(value.length)
+        in { min: min, max: max }
+          raise_within_validation_error!(min, max, options) unless value.length.between?(min, max)
+        in { min: min }
+          raise_min_validation_error!(min, options) unless min <= value.length
+        in { max: max }
+          raise_max_validation_error!(max, options) unless value.length <= max
+        in { is: is }
+          raise_is_validation_error!(is, options) unless value.length == is
+        in { is_not: is_not }
+          raise_is_not_validation_error!(is_not, options) if value.length == is_not
+        else
+          raise ArgumentError, "no known length validator options given"
+        end
+      end
+
+      private
+
+      def raise_within_validation_error!(min, max, options)
+        message = options.dig(:length, :within_message) ||
+                  options.dig(:length, :in_message) ||
+                  options.dig(:length, :message)
+        message %= { min:, max: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.length.within",
+          min:,
+          max:,
+          default: "length must be within #{min} and #{max}"
+        )
+      end
+
+      def raise_not_within_validation_error!(min, max, options)
+        message = options.dig(:length, :not_within_message) ||
+                  options.dig(:length, :not_in_message) ||
+                  options.dig(:length, :message)
+        message %= { min:, max: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.length.not_within",
+          min:,
+          max:,
+          default: "length must not be within #{min} and #{max}"
+        )
+      end
+
+      def raise_min_validation_error!(min, options)
+        message = options.dig(:length, :min_message) ||
+                  options.dig(:length, :message)
+        message %= { min: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.length.min",
+          min:,
+          default: "length must be at least #{min}"
+        )
+      end
+
+      def raise_max_validation_error!(max, options)
+        message = options.dig(:length, :max_message) ||
+                  options.dig(:length, :message)
+        message %= { max: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.length.max",
+          max:,
+          default: "length must be at most #{max}"
+        )
+      end
+
+      def raise_is_validation_error!(is, options)
+        message = options.dig(:length, :is_message) ||
+                  options.dig(:length, :message)
+        message %= { is: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.length.is",
+          is:,
+          default: "length must be #{is}"
+        )
+      end
+
+      def raise_is_not_validation_error!(is_not, options)
+        message = options.dig(:length, :is_not_message) ||
+                  options.dig(:length, :message)
+        message %= { is_not: } unless message.nil?
+
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.length.is_not",
+          is_not:,
+          default: "length must not be #{is_not}"
+        )
+      end
+
+    end
+  end
+end