cmdx 1.20.0 → 2.0.0

data/lib/cmdx/utils/condition.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  module Utils
-    # Provides conditional evaluation utilities for CMDx tasks and workflows.
-    #
-    # This module handles conditional logic evaluation with support for `if` and `unless`
-    # conditions using various callable types including symbols, procs, and objects
-    # responding to `call`.
-    module Condition
-
-      extend self
-
-      # @rbs EVAL: Proc
-      EVAL = proc do |target, callable, *args, **kwargs, &block|
-        case callable
-        when NilClass, FalseClass, TrueClass then !!callable
-        when Symbol then target.send(callable, *args, **kwargs, &block)
-        when Proc then target.instance_exec(*args, **kwargs, &callable)
-        else
-          raise "cannot evaluate #{callable.inspect}" unless callable.respond_to?(:call)
-
-          callable.call(*args, **kwargs, &block)
-        end
-      end.freeze
-      private_constant :EVAL
-
-      # Evaluates conditional logic based on provided options.
-      #
-      # Supports both `if` and `unless` conditions, with `unless` taking precedence
-      # when both are specified. Returns true if no conditions are provided.
-      #
-      # @param target [Object] The target object to evaluate conditions against
-      # @param options [Hash] Conditional options hash
-      # @option options [Object] :if Condition that must be true for evaluation to succeed
-      # @option options [Object] :unless Condition that must be false for evaluation to succeed
-      #
-      # @return [Boolean] true if conditions are met, false otherwise
-      #
-      # @raise [RuntimeError] When a callable cannot be evaluated
-      #
-      # @example Basic if condition
-      #   Condition.evaluate(user, if: :active?)
-      #   # => true if user.active? returns true
-      # @example Unless condition
-      #   Condition.evaluate(user, unless: :blocked?)
-      #   # => true if user.blocked? returns false
-      # @example Combined conditions
-      #   Condition.evaluate(user, if: :verified?, unless: :suspended?)
-      #   # => true if user.verified? is true AND user.suspended? is false
-      # @example With arguments and block
-      #   Condition.evaluate(user, if: ->(u) { u.has_permission?(:admin) }, :admin)
-      #   # => true if the proc returns true when called with user and :admin
-      #
-      # @rbs (untyped target, Hash[Symbol, untyped] options, *untyped) ?{ () -> untyped } -> bool
-      def evaluate(target, options, ...)
-        case options
-        in if: if_cond, unless: unless_cond
-          EVAL.call(target, if_cond, ...) && !EVAL.call(target, unless_cond, ...)
-        in if: if_cond
-          EVAL.call(target, if_cond, ...)
-        in unless: unless_cond
-          !EVAL.call(target, unless_cond, ...)
-        else
-          true
-        end
-      end
-
-    end
-  end
-end

data/lib/cmdx/utils/format.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  module Utils
-    # Utility module for formatting data structures into log-friendly strings
-    # and converting messages to appropriate formats for logging
-    module Format
-
-      extend self
-
-      # @rbs FORMATTER: Proc
-      FORMATTER = proc do |key, value|
-        "#{key}=#{value.inspect}"
-      end.freeze
-      private_constant :FORMATTER
-
-      # Converts a message to a format suitable for logging
-      #
-      # @param message [Object] The message to format
-      #
-      # @return [Hash, Object] Returns a hash if the message responds to to_h and is a CMDx object, otherwise returns the original message
-      #
-      # @example Hash like objects
-      #   Format.to_log({user_id: 123, action: "login"})
-      #   # => {user_id: 123, action: "login"}
-      # @example Simple message
-      #   Format.to_log("simple message")
-      #   # => "simple message"
-      # @example CMDx object
-      #   Format.to_log(CMDx::Task.new(name: "task1"))
-      #   # => {name: "task1"}
-      #
-      # @rbs (untyped message) -> untyped
-      def to_log(message)
-        if message.respond_to?(:to_h) && cmdx_based_object?(message.class)
-          message.to_h
-        else
-          message
-        end
-      end
-
-      # Converts a hash to a formatted string using a custom formatter
-      #
-      # @param hash [Hash] The hash to convert to string
-      # @param block [Proc, nil] Optional custom formatter block
-      # @option block [String] :key The hash key
-      # @option block [Object] :value The hash value
-      #
-      # @return [String] Space-separated formatted key-value pairs
-      #
-      # @example Default formatter
-      #   Format.to_str({user_id: 123, status: "active"})
-      #   # => "user_id=123 status=\"active\""
-      # @example Custom formatter
-      #   Format.to_str({count: 5, total: 100}) { |k, v| "#{k}:#{v}" }
-      #   # => "count:5 total:100"
-      #
-      # @rbs (Hash[untyped, untyped] hash) ?{ (untyped, untyped) -> String } -> String
-      def to_str(hash, &block)
-        block ||= FORMATTER
-        hash.map(&block).join(" ")
-      end
-
-      private
-
-      # Checks if a class belongs to the CMDx namespace, caching per class.
-      #
-      # @param klass [Class] The class to check
-      #
-      # @return [Boolean] true if the class is in the CMDx namespace
-      #
-      # @rbs (Class klass) -> bool
-      def cmdx_based_object?(klass)
-        @cmdx_classes ||= {}
-        return @cmdx_classes[klass] if @cmdx_classes.key?(klass)
-
-        @cmdx_classes[klass] = klass.ancestors.any? { |a| a.name&.start_with?("CMDx::") }
-      end
-
-    end
-  end
-end

data/lib/cmdx/utils/normalize.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  module Utils
-    # Provides normalization utilities for a variety of objects
-    # into consistent formats.
-    module Normalize
-
-      extend self
-
-      # Normalizes an exception into a string representation.
-      #
-      # @param exception [Exception] The exception to normalize
-      #
-      # @return [String] The normalized exception string
-      #
-      # @example From exception
-      #   Normalize.exception(StandardError.new("test"))
-      #   # => "[StandardError] test"
-      #
-      # @rbs (Exception exception) -> String
-      def exception(exception)
-        "[#{exception.class}] #{exception.message}"
-      end
-
-      # Normalizes an object into an array of unique status strings.
-      #
-      # @param object [Object] The object to normalize into status strings
-      #
-      # @return [Array<String>] Unique status strings
-      #
-      # @example From array of symbols
-      #   Normalize.statuses([:success, :pending, :success])
-      #   # => ["success", "pending"]
-      # @example From single value
-      #   Normalize.statuses(:success)
-      #   # => ["success"]
-      # @example From nil
-      #   Normalize.statuses(nil)
-      #   # => []
-      #
-      # @rbs (untyped object) -> Array[String]
-      def statuses(object)
-        ary = Wrap.array(object)
-        return EMPTY_ARRAY if ary.empty?
-
-        ary.map(&:to_s).uniq
-      end
-
-    end
-  end
-end

data/lib/cmdx/utils/wrap.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  module Utils
-    # Provides array wrapping utilities for normalizing input values
-    # into consistent array structures.
-    module Wrap
-
-      extend self
-
-      # Wraps an object in an array if it is not already an array.
-      #
-      # @param object [Object] The object to wrap in an array
-      #
-      # @return [Array] The wrapped array
-      #
-      # @example Already an array
-      #   Wrap.array([1, 2, 3])
-      #   # => [1, 2, 3]
-      # @example Single value
-      #   Wrap.array(1)
-      #   # => [1]
-      # @example Nil value
-      #   Wrap.array(nil)
-      #   # => []
-      #
-      # @rbs (untyped object) -> Array[untyped]
-      def array(object)
-        case object
-        when Array then object
-        when NilClass then EMPTY_ARRAY
-        else Array(object)
-        end
-      end
-
-    end
-  end
-end

data/lib/cmdx/validator_registry.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module CMDx
-  # Registry for managing validation rules and their corresponding validator classes.
-  # Provides methods to register, deregister, and execute validators against task values.
-  #
-  # Supports copy-on-write semantics: a duped registry shares the parent's
-  # data until a write operation triggers materialization.
-  class ValidatorRegistry
-
-    extend Forwardable
-
-    def_delegators :registry, :keys
-
-    # Initialize a new validator registry with default validators.
-    #
-    # @param registry [Hash, nil] Optional hash mapping validator names to validator classes
-    #
-    # @return [ValidatorRegistry] A new validator registry instance
-    #
-    # @rbs (?Hash[Symbol, Class]? registry) -> void
-    def initialize(registry = nil)
-      @registry = registry || {
-        absence: Validators::Absence,
-        exclusion: Validators::Exclusion,
-        format: Validators::Format,
-        inclusion: Validators::Inclusion,
-        length: Validators::Length,
-        numeric: Validators::Numeric,
-        presence: Validators::Presence
-      }
-    end
-
-    # Sets up copy-on-write state when duplicated via dup.
-    #
-    # @param source [ValidatorRegistry] The registry being duplicated
-    #
-    # @rbs (ValidatorRegistry source) -> void
-    def initialize_dup(source)
-      @parent = source
-      @registry = nil
-      super
-    end
-
-    # Returns the internal registry mapping validator types to classes.
-    # Delegates to the parent registry when not yet materialized.
-    #
-    # @return [Hash{Symbol => Class}] Hash of validator type names to validator classes
-    #
-    # @example
-    #   registry.registry # => { presence: Validators::Presence, format: Validators::Format }
-    #
-    # @rbs () -> Hash[Symbol, Class]
-    def registry
-      @registry || @parent.registry
-    end
-    alias to_h registry
-
-    # Register a new validator class with the given name.
-    #
-    # @param name [String, Symbol] The name to register the validator under
-    # @param validator [Class] The validator class to register
-    #
-    # @return [ValidatorRegistry] Returns self for method chaining
-    #
-    # @example
-    #   registry.register(:custom, CustomValidator)
-    #   registry.register("email", EmailValidator)
-    #
-    # @rbs ((String | Symbol) name, Class validator) -> self
-    def register(name, validator)
-      materialize!
-
-      @registry[name.to_sym] = validator
-      self
-    end
-
-    # Remove a validator from the registry by name.
-    #
-    # @param name [String, Symbol] The name of the validator to remove
-    #
-    # @return [ValidatorRegistry] Returns self for method chaining
-    #
-    # @example
-    #   registry.deregister(:format)
-    #   registry.deregister("presence")
-    #
-    # @rbs ((String | Symbol) name) -> self
-    def deregister(name)
-      materialize!
-
-      @registry.delete(name.to_sym)
-      self
-    end
-
-    # Validate a value using the specified validator type and options.
-    #
-    # @param type [Symbol] The type of validator to use
-    # @param task [Task] The task context for validation
-    # @param value [Object] The value to validate
-    # @param options [Hash, Object] Validation options or condition
-    # @option options [Boolean] :allow_nil Whether to allow nil values
-    #
-    # @raise [TypeError] When the validator type is not registered
-    #
-    # @example
-    #   registry.validate(:presence, task, user.name, presence: true)
-    #   registry.validate(:length, task, password, { min: 8, allow_nil: false })
-    #
-    # @rbs (Symbol type, Task task, untyped value, untyped options) -> untyped
-    def validate(type, task, value, options = EMPTY_HASH)
-      raise TypeError, "unknown validator type #{type.inspect}" unless registry.key?(type)
-
-      match =
-        if options.is_a?(Hash)
-          case options
-          in allow_nil: then !(allow_nil && value.nil?)
-          else Utils::Condition.evaluate(task, options, value)
-          end
-        else
-          options
-        end
-
-      return unless match
-
-      Utils::Call.invoke(task, registry[type], value, options)
-    end
-
-    private
-
-    # Copies the parent's registry data into this instance,
-    # severing the copy-on-write link.
-    #
-    # @rbs () -> void
-    def materialize!
-      return if @registry
-
-      @registry = @parent.registry.dup
-      @parent = nil
-    end
-
-  end
-end

data/lib/generators/cmdx/locale_generator.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Cmdx
-  # Generates CMDx locale files for Rails applications
-  #
-  # Rails generator that copies CMDx locale files into the application's
-  # config/locales directory. This allows applications to customize and extend
-  # the default CMDx locale files.
-  class LocaleGenerator < Rails::Generators::Base
-
-    source_root File.expand_path("../../locales", __dir__)
-
-    desc "Copies the locale with the given ISO 639 code"
-
-    argument :locale, type: :string, default: "en", banner: "locale: en, es, fr, etc"
-
-    # Copies the locale template to the Rails application
-    #
-    # Copies the specified locale file from the gem's locales directory to the
-    # application's config/locales directory. If the locale file doesn't exist
-    # in the gem, the generator will fail gracefully.
-    #
-    # @return [void]
-    #
-    # @example Copy default (English) locale file
-    #   generator = Cmdx::LocaleGenerator.new(["en"])
-    #   generator.copy_locale_files
-    #   # => Creates config/locales/en.yml
-    #
-    # @example Copy Spanish locale file
-    #   generator = Cmdx::LocaleGenerator.new(["es"])
-    #   generator.copy_locale_files
-    #   # => Creates config/locales/es.yml
-    def copy_locale_files
-      copy_file("#{locale}.yml", "config/locales/#{locale}.yml")
-    end
-
-  end
-end

data/lib/locales/af.yml

@@ -1,53 +0,0 @@
-af:
-  cmdx:
-    attributes:
-      required: "moet toeganklik wees via die %{method} bronmetode"
-      undefined: "delegeer na ongedefinieerde metode %{method}"
-    coercions:
-      into_a: "kon nie na %{type} omskep word nie"
-      into_an: "kon nie na %{type} omskep word nie"
-      into_any: "kon nie na een van: %{types} omskep word nie"
-      unknown: "onbekende %{type} omskep tipe"
-    returns:
-      missing: "moet in die konteks gestel word"
-    faults:
-      invalid: "Ongeldig"
-      unspecified: "Ongespesifiseer"
-    types:
-      array: "skikking"
-      big_decimal: "groot desimale"
-      boolean: "booleaanse"
-      complex: "kompleks"
-      date_time: "datum en tyd"
-      date: "datum"
-      float: "drywende punt"
-      hash: "hash"
-      integer: "heelgetal"
-      rational: "rasionaal"
-      string: "string"
-      symbol: "simbool"
-      time: "tyd"
-    validators:
-      absence: "moet leeg wees"
-      exclusion:
-        of: "moet nie een van wees nie: %{values}"
-        within: "moet nie binne %{min} en %{max} wees nie"
-      format: "is 'n ongeldige formaat"
-      inclusion:
-        of: "moet een van wees: %{values}"
-        within: "moet binne %{min} en %{max} wees"
-      length:
-        is: "lengte moet %{is} wees"
-        is_not: "lengte moet nie %{is_not} wees nie"
-        min: "lengte moet ten minste %{min} wees"
-        max: "lengte kan maksimum %{max} wees"
-        not_within: "lengte moet nie binne %{min} en %{max} wees nie"
-        within: "lengte moet binne %{min} en %{max} wees"
-      numeric:
-        is: "moet %{is} wees"
-        is_not: "moet nie %{is_not} wees nie"
-        min: "moet ten minste %{min} wees"
-        max: "kan maksimum %{max} wees"
-        not_within: "moet nie binne %{min} en %{max} wees nie"
-        within: "moet binne %{min} en %{max} wees"
-      presence: "kan nie leeg wees nie"

data/lib/locales/ar.yml

@@ -1,53 +0,0 @@
-ar:
-  cmdx:
-    attributes:
-      required: "يجب أن يكون قابلاً للوصول عبر طريقة المصدر %{method}"
-      undefined: "يفوض إلى طريقة غير معرفة %{method}"
-    coercions:
-      into_a: "لا يمكن تحويله إلى %{type}"
-      into_an: "لا يمكن تحويله إلى %{type}"
-      into_any: "لا يمكن تحويله إلى واحد من: %{types}"
-      unknown: "نوع تحويل %{type} غير معروف"
-    returns:
-      missing: "يجب تعيينه في السياق"
-    faults:
-      invalid: "غير صالح"
-      unspecified: "غير محدد"
-    types:
-      array: "مصفوفة"
-      big_decimal: "عدد عشري كبير"
-      boolean: "منطقي"
-      complex: "مركب"
-      date_time: "التاريخ والوقت"
-      date: "التاريخ"
-      float: "رقم عشري"
-      hash: "جدول تجزئة"
-      integer: "عدد صحيح"
-      rational: "عدد نسبي"
-      string: "سلسلة نصية"
-      symbol: "رمز"
-      time: "الوقت"
-    validators:
-      absence: "يجب أن يكون فارغاً"
-      exclusion:
-        of: "يجب ألا يكون واحداً من: %{values}"
-        within: "يجب ألا يكون بين %{min} و %{max}"
-      format: "تنسيق غير صالح"
-      inclusion:
-        of: "يجب أن يكون واحداً من: %{values}"
-        within: "يجب أن يكون بين %{min} و %{max}"
-      length:
-        is: "يجب أن يكون الطول %{is}"
-        is_not: "يجب ألا يكون الطول %{is_not}"
-        min: "يجب أن يكون الطول على الأقل %{min}"
-        max: "يجب أن يكون الطول على الأكثر %{max}"
-        not_within: "يجب ألا يكون الطول بين %{min} و %{max}"
-        within: "يجب أن يكون الطول بين %{min} و %{max}"
-      numeric:
-        is: "يجب أن يكون %{is}"
-        is_not: "يجب ألا يكون %{is_not}"
-        min: "يجب أن يكون على الأقل %{min}"
-        max: "يجب أن يكون على الأكثر %{max}"
-        not_within: "يجب ألا يكون بين %{min} و %{max}"
-        within: "يجب أن يكون بين %{min} و %{max}"
-      presence: "لا يمكن أن يكون فارغاً"

data/lib/locales/az.yml

@@ -1,53 +0,0 @@
-az:
-  cmdx:
-    attributes:
-      required: "%{method} mənbə metodu vasitəsilə əlçatan olmalıdır"
-      undefined: "müəyyən edilməmiş metoda %{method} təyin edir"
-    coercions:
-      into_a: "%{type} tipinə çevrilə bilmədi"
-      into_an: "%{type} tipinə çevrilə bilmədi"
-      into_any: "aşağıdakılardan birinə çevrilə bilmədi: %{types}"
-      unknown: "naməlum %{type} çevrilmə tipi"
-    returns:
-      missing: "kontekstdə təyin edilməlidir"
-    faults:
-      invalid: "Etibarsız"
-      unspecified: "Göstərilməyib"
-    types:
-      array: "massiv"
-      big_decimal: "böyük onluq"
-      boolean: "məntiqi"
-      complex: "mürəkkəb"
-      date_time: "tarix və vaxt"
-      date: "tarix"
-      float: "üzən nöqtə"
-      hash: "haş"
-      integer: "tam ədəd"
-      rational: "rasional"
-      string: "sətir"
-      symbol: "simvol"
-      time: "vaxt"
-    validators:
-      absence: "boş olmalıdır"
-      exclusion:
-        of: "aşağıdakılardan biri ola bilməz: %{values}"
-        within: "%{min} və %{max} arasında ola bilməz"
-      format: "etibarsız formatdır"
-      inclusion:
-        of: "aşağıdakılardan biri olmalıdır: %{values}"
-        within: "%{min} və %{max} arasında olmalıdır"
-      length:
-        is: "uzunluq %{is} olmalıdır"
-        is_not: "uzunluq %{is_not} ola bilməz"
-        min: "uzunluq ən azı %{min} olmalıdır"
-        max: "uzunluq ən çoxu %{max} ola bilər"
-        not_within: "uzunluq %{min} və %{max} arasında ola bilməz"
-        within: "uzunluq %{min} və %{max} arasında olmalıdır"
-      numeric:
-        is: "%{is} olmalıdır"
-        is_not: "%{is_not} ola bilməz"
-        min: "ən azı %{min} olmalıdır"
-        max: "ən çoxu %{max} ola bilər"
-        not_within: "%{min} və %{max} arasında ola bilməz"
-        within: "%{min} və %{max} arasında olmalıdır"
-      presence: "boş ola bilməz"

data/lib/locales/be.yml

@@ -1,53 +0,0 @@
-be:
-  cmdx:
-    attributes:
-      required: "павінен быць даступны праз зыходны метад %{method}"
-      undefined: "дэлегуе невызначанаму метаду %{method}"
-    coercions:
-      into_a: "не ўдалося пераўтварыць у %{type}"
-      into_an: "не ўдалося пераўтварыць у %{type}"
-      into_any: "не ўдалося пераўтварыць у адзін з: %{types}"
-      unknown: "невядомы тып пераўтварэння %{type}"
-    returns:
-      missing: "павінна быць усталявана ў кантэксце"
-    faults:
-      invalid: "Няправільныя"
-      unspecified: "Не паказана"
-    types:
-      array: "масіў"
-      big_decimal: "вялікае дзесятковае лік"
-      boolean: "лагічны"
-      complex: "камплексны"
-      date_time: "дата і час"
-      date: "дата"
-      float: "лік з плаваючай коскай"
-      hash: "хэш"
-      integer: "цэлы лік"
-      rational: "рацыянальны"
-      string: "радок"
-      symbol: "сімвал"
-      time: "час"
-    validators:
-      absence: "павінна быць пустым"
-      exclusion:
-        of: "не можа быць адным з: %{values}"
-        within: "не можа быць паміж %{min} і %{max}"
-      format: "з'яўляецца несапраўдным фарматам"
-      inclusion:
-        of: "павінна быць адным з: %{values}"
-        within: "павінна быць паміж %{min} і %{max}"
-      length:
-        is: "даўжыня павінна быць %{is}"
-        is_not: "даўжыня не можа быць %{is_not}"
-        min: "даўжыня павінна быць не менш %{min}"
-        max: "даўжыня можа быць не больш %{max}"
-        not_within: "даўжыня не можа быць паміж %{min} і %{max}"
-        within: "даўжыня павінна быць паміж %{min} і %{max}"
-      numeric:
-        is: "павінна быць %{is}"
-        is_not: "не можа быць %{is_not}"
-        min: "павінна быць не менш %{min}"
-        max: "можа быць не больш %{max}"
-        not_within: "не можа быць паміж %{min} і %{max}"
-        within: "павінна быць паміж %{min} і %{max}"
-      presence: "не можа быць пустым"