cmdx 0.1.0

data/lib/cmdx/coercions/date.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module Date
+
+      ANALOG_TYPES = %w[Date DateTime Time].freeze
+
+      module_function
+
+      def call(value, options = {})
+        return value if ANALOG_TYPES.include?(value.class.name)
+        return ::Date.strptime(value, options[:format]) if options[:format]
+
+        ::Date.parse(value)
+      rescue TypeError, ::Date::Error
+        raise CoercionError, I18n.t(
+          "cmdx.coercions.into_a",
+          type: "date",
+          default: "could not coerce into a date"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/date_time.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module DateTime
+
+      ANALOG_TYPES = %w[Date DateTime Time].freeze
+
+      module_function
+
+      def call(value, options = {})
+        return value if ANALOG_TYPES.include?(value.class.name)
+        return ::DateTime.strptime(value, options[:format]) if options[:format]
+
+        ::DateTime.parse(value)
+      rescue TypeError, ::Date::Error
+        raise CoercionError, I18n.t(
+          "cmdx.coercions.into_a",
+          type: "datetime",
+          default: "could not coerce into a datetime"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/float.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module Float
+
+      module_function
+
+      def call(value, _options = {})
+        Float(value)
+      rescue ArgumentError, TypeError
+        raise CoercionError, I18n.t(
+          "cmdx.coercions.into_a",
+          type: "float",
+          default: "could not coerce into a float"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/hash.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module Hash
+
+      extend self
+
+      def call(value, _options = {})
+        case value.class.name
+        when "Hash", "ActionController::Parameters" then value
+        when "Array" then ::Hash[*value]
+        else raise_coercion_error!
+        end
+      rescue ArgumentError, TypeError
+        raise_coercion_error!
+      end
+
+      private
+
+      def raise_coercion_error!
+        raise CoercionError, I18n.t(
+          "cmdx.coercions.into_a",
+          type: "hash",
+          default: "could not coerce into a hash"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/integer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module Integer
+
+      module_function
+
+      def call(value, _options = {})
+        Integer(value)
+      rescue ArgumentError, TypeError
+        raise CoercionError, I18n.t(
+          "cmdx.coercions.into_an",
+          type: "integer",
+          default: "could not coerce into an integer"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/rational.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module Rational
+
+      module_function
+
+      def call(value, _options = {})
+        Rational(value)
+      rescue ArgumentError, TypeError
+        raise CoercionError, I18n.t(
+          "cmdx.coercions.into_a",
+          type: "rational",
+          default: "could not coerce into a rational"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/string.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module String
+
+      module_function
+
+      def call(value, _options = {})
+        String(value)
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/time.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module Time
+
+      ANALOG_TYPES = %w[Date DateTime Time].freeze
+
+      module_function
+
+      def call(value, options = {})
+        return value if ANALOG_TYPES.include?(value.class.name)
+        return ::Time.strptime(value, options[:format]) if options[:format]
+
+        ::Time.parse(value)
+      rescue ArgumentError, TypeError
+        raise CoercionError, I18n.t(
+          "cmdx.coercions.into_a",
+          type: "time",
+          default: "could not coerce into a time"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/coercions/virtual.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Coercions
+    module Virtual
+
+      module_function
+
+      def call(value, _options = {})
+        value
+      end
+
+    end
+  end
+end

data/lib/cmdx/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CMDx
+
+  module_function
+
+  def configuration
+    @configuration || reset_configuration!
+  end
+
+  def configure
+    yield(configuration)
+  end
+
+  def reset_configuration!
+    @configuration = LazyStruct.new(
+      logger: ::Logger.new($stdout, formatter: CMDx::LogFormatters::Line.new),
+      task_halt: CMDx::Result::FAILED,
+      task_timeout: nil,
+      batch_halt: CMDx::Result::FAILED,
+      batch_timeout: nil
+    )
+  end
+
+end

data/lib/cmdx/context.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CMDx
+  class Context < LazyStruct
+
+    attr_reader :run
+
+    def self.build(context = {})
+      return context if context.is_a?(self) && !context.frozen?
+
+      new(context)
+    end
+
+  end
+end

data/lib/cmdx/core_ext/hash.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CMDx
+  module CoreExt
+    module HashExtensions
+
+      def __cmdx_fetch(key)
+        case key
+        when Symbol then fetch(key) { self[key.to_s] }
+        when String then fetch(key) { self[key.to_sym] }
+        else self[key]
+        end
+      end
+
+      def __cmdx_key?(key)
+        key?(key) || key?(
+          case key
+          when Symbol then key.to_s
+          when String then key.to_sym
+          end
+        )
+      rescue NoMethodError
+        false
+      end
+
+      def __cmdx_respond_to?(key, include_private = false)
+        respond_to?(key.to_sym, include_private) || __cmdx_key?(key)
+      rescue NoMethodError
+        __cmdx_key?(key)
+      end
+
+    end
+  end
+end
+
+Hash.include(CMDx::CoreExt::HashExtensions)

data/lib/cmdx/core_ext/module.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module CMDx
+  module CoreExt
+    module ModuleExtensions
+
+      def __cmdx_attr_delegator(*methods, **options)
+        methods.each do |method|
+          method_name = Utils::MethodName.call(method, options.fetch(:to), options)
+
+          define_method(method_name) do |*args, **kwargs, &block|
+            object = (options[:to] == :class ? self.class : send(options[:to]))
+
+            unless options[:allow_missing] || object.respond_to?(method, true)
+              raise NoMethodError,
+                    "undefined method `#{method}' for #{options[:to]}"
+            end
+
+            object.send(method, *args, **kwargs, &block)
+          end
+
+          case options
+          in { protected: true } then send(:protected, method_name)
+          in { private: true } then send(:private, method_name)
+          else # Leave public
+          end
+        end
+      end
+
+      def __cmdx_attr_setting(method, **options)
+        define_singleton_method(method) do
+          @cmd_facets ||= {}
+          return @cmd_facets[method] if @cmd_facets.key?(method)
+
+          value = superclass.__cmdx_try(method)
+          return @cmd_facets[method] = value.dup unless value.nil?
+
+          default = options[:default]
+          value   = default.__cmdx_call
+          @cmd_facets[method] = default.is_a?(Proc) ? value : value.dup
+        end
+      end
+
+    end
+  end
+end
+
+Module.include(CMDx::CoreExt::ModuleExtensions)

data/lib/cmdx/core_ext/object.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CMDx
+  module CoreExt
+    module ObjectExtensions
+
+      alias __cmdx_respond_to? respond_to?
+
+      def __cmdx_try(key, ...)
+        if key.is_a?(Proc)
+          return instance_eval(&key) unless is_a?(Module) || key.inspect.include?("(lambda)")
+
+          key.call(...)
+        elsif respond_to?(key, true)
+          send(key, ...)
+        elsif is_a?(Hash)
+          __cmdx_fetch(key)
+        end
+      end
+
+      def __cmdx_eval(options = {})
+        if options[:if] && options[:unless]
+          __cmdx_try(options[:if]) && !__cmdx_try(options[:unless])
+        elsif options[:if]
+          __cmdx_try(options[:if])
+        elsif options[:unless]
+          !__cmdx_try(options[:unless])
+        else
+          options.fetch(:default, true)
+        end
+      end
+
+      def __cmdx_yield(key, ...)
+        if key.is_a?(Symbol) || key.is_a?(String)
+          return key unless respond_to?(key, true)
+
+          send(key, ...)
+        elsif is_a?(Hash) || key.is_a?(Proc)
+          __cmdx_try(key, ...)
+        else
+          key
+        end
+      end
+
+      def __cmdx_call(...)
+        return self unless respond_to?(:call)
+
+        call(...)
+      end
+
+    end
+  end
+end
+
+Object.include(CMDx::CoreExt::ObjectExtensions)

data/lib/cmdx/error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CMDx
+
+  # Base of all CMDx errors
+  Error = Class.new(StandardError)
+
+  # Raised when value could not be coerced to defined type
+  CoercionError = Class.new(Error)
+
+  # Raised when call execution time exceeds max allowed
+  TimeoutError = Class.new(Interrupt)
+
+  # Raised when call method not defined in implementing class
+  UndefinedCallError = Class.new(Error)
+
+  # Raised when unknown coercion type
+  UnknownCoercionError = Class.new(Error)
+
+  # Raised when value failed a validation
+  ValidationError = Class.new(Error)
+
+end

data/lib/cmdx/errors.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module CMDx
+  class Errors
+
+    __cmdx_attr_delegator :clear, :delete, :each, :empty?, :key?, :keys, :size, :values, to: :errors
+
+    attr_reader :errors
+
+    alias attribute_names keys
+    alias blank? empty?
+    alias valid? empty?
+    alias has_key? key?
+    alias include? key?
+
+    def initialize
+      @errors = {}
+    end
+
+    def add(key, value)
+      errors[key] ||= []
+      errors[key] << value
+      errors[key].uniq!
+    end
+    alias []= add
+
+    def added?(key, val)
+      return false unless key?(key)
+
+      errors[key].include?(val)
+    end
+    alias of_kind? added?
+
+    def each
+      errors.each_key do |key|
+        errors[key].each { |val| yield(key, val) }
+      end
+    end
+
+    def full_message(key, value)
+      "#{key} #{value}"
+    end
+
+    def full_messages
+      errors.each_with_object([]) do |(key, arr), memo|
+        arr.each { |val| memo << full_message(key, val) }
+      end
+    end
+    alias to_a full_messages
+
+    def full_messages_for(key)
+      return [] unless key?(key)
+
+      errors[key].map { |val| full_message(key, val) }
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def merge!(hash)
+      errors.merge!(hash) do |_, arr1, arr2|
+        arr3 = arr1 + arr2
+        arr3.uniq!
+        arr3
+      end
+    end
+
+    def messages_for(key)
+      return [] unless key?(key)
+
+      errors[key]
+    end
+    alias [] messages_for
+
+    def present?
+      !blank?
+    end
+
+    def to_hash(full_messages = false)
+      return errors unless full_messages
+
+      errors.each_with_object({}) do |(key, arr), memo|
+        memo[key] = arr.map { |val| full_message(key, val) }
+      end
+    end
+    alias messages to_hash
+    alias group_by_attribute to_hash
+    alias as_json to_hash
+
+  end
+end

data/lib/cmdx/fault.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CMDx
+  class Fault < Error
+
+    __cmdx_attr_delegator :task, :run, :context, to: :result
+
+    attr_reader :result
+
+    def initialize(result)
+      @result = result
+      super(result.metadata[:reason] || I18n.t("cmdx.faults.unspecified", default: "no reason given"))
+    end
+
+    class << self
+
+      def build(result)
+        fault = CMDx.const_get(result.status.capitalize)
+        fault.new(result)
+      end
+
+      def for?(*tasks)
+        temp_fault = Class.new(self) do
+          def self.===(other)
+            other.is_a?(superclass) && @tasks.any? { |task| other.task.is_a?(task) }
+          end
+        end
+
+        temp_fault.tap { |c| c.instance_variable_set(:@tasks, tasks) }
+      end
+
+      def matches?(&block)
+        raise ArgumentError, "a block is required" unless block_given?
+
+        temp_fault = Class.new(self) do
+          def self.===(other)
+            other.is_a?(superclass) && @block.call(other)
+          end
+        end
+
+        temp_fault.tap { |c| c.instance_variable_set(:@block, block) }
+      end
+
+    end
+
+  end
+end

data/lib/cmdx/faults.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CMDx
+
+  # Raised when halting task processing with skipped context
+  Skipped = Class.new(Fault)
+
+  # Raised when halting task processing with failed context
+  Failed = Class.new(Fault)
+
+end

data/lib/cmdx/immutator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Immutator
+
+    module_function
+
+    def call(task)
+      # Stubbing on frozen objects is not allowed
+      return if (ENV.fetch("RAILS_ENV", nil) || ENV.fetch("RACK_ENV", nil)) == "test"
+
+      task.freeze
+      task.result.freeze
+      return unless task.result.index.zero?
+
+      task.context.freeze
+      task.run.freeze
+    end
+
+  end
+end

data/lib/cmdx/lazy_struct.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module CMDx
+  class LazyStruct
+
+    def initialize(args = {})
+      unless args.respond_to?(:to_h)
+        raise ArgumentError,
+              "must be respond to `to_h`"
+      end
+
+      @table = args.transform_keys(&:to_sym)
+    end
+
+    def [](key)
+      @table[key.to_sym]
+    end
+
+    def fetch!(key, ...)
+      @table.fetch(key.to_sym, ...)
+    end
+
+    def store!(key, value)
+      @table[key.to_sym] = value
+    end
+    alias []= store!
+
+    def merge!(args = {})
+      args.to_h.each { |key, value| store!(key, value) }
+      self
+    end
+
+    def delete!(key, &)
+      @table.delete(key.to_sym, &)
+    end
+    alias delete_field! delete!
+
+    def eql?(other)
+      other.is_a?(self.class) && (to_h == other.to_h)
+    end
+    alias == eql?
+
+    def dig(key, *keys)
+      begin
+        key = key.to_sym
+      rescue NoMethodError
+        raise TypeError, "#{key} is not a symbol nor a string"
+      end
+
+      @table.dig(key, *keys)
+    end
+
+    def each_pair(&)
+      @table.each_pair(&)
+    end
+
+    def to_h(&)
+      @table.to_h(&)
+    end
+
+    def inspect
+      "#<#{self.class}#{@table.map { |key, value| ":#{key}=#{value.inspect}" }.join(' ')}>"
+    end
+    alias to_s inspect
+
+    private
+
+    def method_missing(method_name, *args, **_kwargs, &)
+      @table.fetch(method_name.to_sym) do
+        store!(method_name[0..-2], args.first) if method_name.end_with?("=")
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @table.key?(method_name.to_sym) || super
+    end
+
+  end
+end

data/lib/cmdx/log_formatters/json.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CMDx
+  module LogFormatters
+    class Json
+
+      def call(_severity, _time, _progname, message)
+        JSON.dump(message)
+      end
+
+    end
+  end
+end

data/lib/cmdx/log_formatters/key_value.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CMDx
+  module LogFormatters
+    class KeyValue
+
+      def call(_severity, _time, _progname, message)
+        message.map { |k, v| "#{k}=#{v}" }.join(" ")
+      end
+
+    end
+  end
+end