cmdx 0.1.0

data/lib/cmdx/validators/numeric.rb

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

data/lib/cmdx/validators/presence.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module CMDx
+  module Validators
+    module Presence
+
+      module_function
+
+      def call(value, options = {})
+        return if if value.is_a?(String)
+                    /\S/.match?(value)
+                  elsif value.respond_to?(:empty?)
+                    !value.empty?
+                  else
+                    !value.nil?
+                  end
+
+        message = options.dig(:presence, :message) if options[:presence].is_a?(Hash)
+        raise ValidationError, message || I18n.t(
+          "cmdx.validators.presence",
+          default: "cannot be empty"
+        )
+      end
+
+    end
+  end
+end

data/lib/cmdx/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module CMDx
+
+  VERSION = "0.1.0"
+
+end

data/lib/cmdx.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "i18n"
+require "json"
+require "logger"
+require "securerandom"
+require "time"
+require "timeout"
+
+require_relative "cmdx/version"
+require_relative "cmdx/core_ext/object"
+require_relative "cmdx/core_ext/hash"
+require_relative "cmdx/core_ext/module"
+require_relative "cmdx/log_formatters/json"
+require_relative "cmdx/log_formatters/key_value"
+require_relative "cmdx/log_formatters/line"
+require_relative "cmdx/log_formatters/logstash"
+require_relative "cmdx/log_formatters/raw"
+require_relative "cmdx/coercions/array"
+require_relative "cmdx/coercions/big_decimal"
+require_relative "cmdx/coercions/boolean"
+require_relative "cmdx/coercions/complex"
+require_relative "cmdx/coercions/date"
+require_relative "cmdx/coercions/date_time"
+require_relative "cmdx/coercions/float"
+require_relative "cmdx/coercions/hash"
+require_relative "cmdx/coercions/integer"
+require_relative "cmdx/coercions/rational"
+require_relative "cmdx/coercions/string"
+require_relative "cmdx/coercions/time"
+require_relative "cmdx/coercions/virtual"
+require_relative "cmdx/validators/custom"
+require_relative "cmdx/validators/exclusion"
+require_relative "cmdx/validators/format"
+require_relative "cmdx/validators/inclusion"
+require_relative "cmdx/validators/length"
+require_relative "cmdx/validators/numeric"
+require_relative "cmdx/validators/presence"
+require_relative "cmdx/utils/datetime_formatter"
+require_relative "cmdx/utils/method_name"
+require_relative "cmdx/utils/runtime"
+require_relative "cmdx/error"
+require_relative "cmdx/errors"
+require_relative "cmdx/fault"
+require_relative "cmdx/faults"
+require_relative "cmdx/logger"
+require_relative "cmdx/lazy_struct"
+require_relative "cmdx/configuration"
+require_relative "cmdx/context"
+require_relative "cmdx/run"
+require_relative "cmdx/run_serializer"
+require_relative "cmdx/run_inspector"
+require_relative "cmdx/parameter"
+require_relative "cmdx/parameter_value"
+require_relative "cmdx/parameter_validator"
+require_relative "cmdx/parameter_serializer"
+require_relative "cmdx/parameter_inspector"
+require_relative "cmdx/parameters"
+require_relative "cmdx/parameters_serializer"
+require_relative "cmdx/parameters_inspector"
+require_relative "cmdx/result"
+require_relative "cmdx/result_serializer"
+require_relative "cmdx/result_inspector"
+require_relative "cmdx/result_logger"
+require_relative "cmdx/task"
+require_relative "cmdx/task_hook"
+require_relative "cmdx/batch"
+require_relative "cmdx/immutator"
+
+if defined?(Rails::Generators)
+  require_relative "generators/cmdx/install_generator"
+  require_relative "generators/cmdx/task_generator"
+  require_relative "generators/cmdx/batch_generator"
+end
+
+# Load the Railtie last after everything else is required so we don't
+# need to load any CMDx components when we use this Railtie.
+require_relative "cmdx/railtie" if defined?(Rails::Railtie)

data/lib/generators/cmdx/batch_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cmdx
+  class BatchGenerator < Rails::Generators::NamedBase
+
+    source_root File.expand_path("templates", __dir__)
+    check_class_collision prefix: "Batch"
+
+    desc "Generates a batch task with the given NAME (if one does not exist)."
+
+    def copy_files
+      name = file_name.sub(/^batch_?/i, "")
+      path = File.join("app/cmds", class_path, "batch_#{name}.rb")
+      template("batch.rb.tt", path)
+    end
+
+    private
+
+    def class_name
+      @class_name ||= super.delete_prefix("Batch")
+    end
+
+    def parent_class_name
+      ApplicationBatch
+    rescue StandardError
+      CMDx::Batch
+    end
+
+  end
+end

data/lib/generators/cmdx/install_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Cmdx
+  class InstallGenerator < Rails::Generators::Base
+
+    source_root File.expand_path("templates", __dir__)
+
+    desc "Generates a CMDx configurations files for global settings."
+
+    def copy_initializer_file
+      copy_file("install.rb", "config/initializers/cmdx.rb")
+    end
+
+  end
+end

data/lib/generators/cmdx/task_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cmdx
+  class TaskGenerator < Rails::Generators::NamedBase
+
+    source_root File.expand_path("templates", __dir__)
+    check_class_collision suffix: "Task"
+
+    desc "Generates a task with the given NAME (if one does not exist)."
+
+    def copy_files
+      name = file_name.sub(/_?task$/i, "")
+      path = File.join("app/cmds", class_path, "#{name}_task.rb")
+      template("task.rb.tt", path)
+    end
+
+    private
+
+    def class_name
+      @class_name ||= super.end_with?("Task") ? super : "#{super}Task"
+    end
+
+    def parent_class_name
+      ApplicationTask
+    rescue StandardError
+      CMDx::Task
+    end
+
+  end
+end

data/lib/generators/cmdx/templates/batch.rb.tt

@@ -0,0 +1,7 @@
+<% module_namespacing do -%>
+  class <%= class_name %> < <%= parent_class_name %>
+
+    process # TODO
+
+  end
+<% end -%>

data/lib/generators/cmdx/templates/install.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+CMDx.configure do |config|
+  # Define which statuses a bang `call!` will halt and raise a fault.
+  # This option can accept an array of statuses.
+  config.task_halt = CMDx::Result::FAILED
+
+  # Enable task timeouts to prevent call execution beyond a defined threshold.
+  config.task_timeout = nil
+
+  # Define which statuses a batch task will halt execution from proceeding to the next step.
+  # By default skipped tasks are treated as a NOOP so processing is continued.
+  # This option can accept an array of statuses.
+  config.batch_halt = CMDx::Result::FAILED
+
+  # Enable batch timeouts to prevent call execution beyond a defined threshold.
+  # TIP: remember to account for all defined tasks when setting this value
+  config.batch_timeout = nil
+
+  # A list of available log formatter can be found at:
+  # https://github.com/drexed/cmdx/tree/main/lib/cmdx/log_formatters
+  config.logger = Logger.new($stdout, formatter: CMDx::LogFormatters::Line.new)
+end

data/lib/generators/cmdx/templates/task.rb.tt

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+  class <%= class_name %> < <%= parent_class_name %>
+
+    def call
+      # TODO
+    end
+
+  end
+<% end -%>

data/lib/locales/en.yml

@@ -0,0 +1,36 @@
+en:
+  cmdx:
+    coercions:
+      into_a: "could not coerce into a %{type}"
+      into_an: "could not coerce into an %{type}"
+      into_any: "could not coerce into one of: %{values}"
+      unknown: "unknown %{type} coercion type"
+    faults:
+      unspecified: no reason given
+    parameters:
+      required: is a required parameter
+      undefined: delegates to undefined method %{source}
+    validators:
+      custom: is not valid
+      exclusion:
+        of: "must not be one of: %{values}"
+        within: must not be within %{min} and %{max}
+      format: is an invalid format
+      inclusion:
+        of: "must be one of: %{values}"
+        within: must be within %{min} and %{max}
+      length:
+        is: length must be %{is}
+        is_not: length must not be %{is_not}
+        min: length must be at least %{min}
+        max: length must be at most %{max}
+        not_within: length must not be within %{min} and %{max}
+        within: length must be within %{min} and %{max}
+      numeric:
+        is: must be %{is}
+        is_not: must not be %{is_not}
+        min: must be at least %{min}
+        max: must be at most %{max}
+        not_within: must not be within %{min} and %{max}
+        within: must be within %{min} and %{max}
+      presence: cannot be empty

data/lib/locales/es.yml

@@ -0,0 +1,36 @@
+es:
+  cmdx:
+    coercions:
+      into_a: "no podía coacciona el valor a un %{type}"
+      into_an: "no podía coacciona el valor a un %{type}"
+      into_any: "no podía coacciona el valor a un: %{values}"
+      unknown: "%{type} tipo de coacciona desconocido"
+    faults:
+      unspecified: ninguna razón dada
+    parameters:
+      required: es un parámetro requerido
+      undefined: delegado al método indefinido %{source}
+    validators:
+      custom: no es válida
+      exclusion:
+        of: "no debe ser uno de: %{values}"
+        within: no debe estar dentro %{min} y %{max}
+      format: es un formato inválido
+      inclusion:
+        of: "debe ser uno de: %{values}"
+        within: debe estar dentro %{min} y %{max}
+      length:
+        is: tiene una longitud que debe ser %{is}
+        is_not: tiene una longitud no debe ser %{is}
+        min: tiene una longitud que debe ser menos de %{min}
+        max: tiene una longitud que debe ser mas de %{max}
+        not_within: tiene una longitud que no debe estar dentro %{min} y %{max}
+        within: tiene una longitud que debe estar dentro %{min} y %{max}
+      numeric:
+        is: debe ser %{is}
+        is_not: no debe ser %{is}
+        min: debe ser %{min} como minimo
+        max: debe ser %{max} como máximo
+        not_within: no debe estar dentro %{min} y %{max}
+        within: debe estar dentro %{min} y %{max}
+      presence: no puede estar vacío