zero_ruby 0.1.0.alpha2 → 0.1.0.alpha4

data/lib/zero_ruby/types/float.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_type"
-
-module ZeroRuby
-  module Types
-    class Float < BaseType
-      class << self
-        def name
-          "Float"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          return nil if value.nil?
-          return value if value.is_a?(::Float)
-
-          if value.is_a?(::Integer)
-            value.to_f
-          elsif value.is_a?(::String)
-            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
-            result = Kernel.Float(value, exception: false)
-            coercion_error!(value) if result.nil?
-            result
-          else
-            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/zero_ruby/types/id.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_type"
-
-module ZeroRuby
-  module Types
-    # ID type for unique identifiers (database PKs, FKs, etc.)
-    # Accepts strings and integers, always coerces to String.
-    class ID < BaseType
-      class << self
-        def name
-          "ID"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          return nil if value.nil?
-
-          case value
-          when ::String
-            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
-            value
-          when ::Integer
-            value.to_s
-          when ::Symbol
-            value.to_s
-          else
-            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/zero_ruby/types/integer.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_type"
-
-module ZeroRuby
-  module Types
-    class Integer < BaseType
-      class << self
-        def name
-          "Integer"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          return nil if value.nil?
-          return value if value.is_a?(::Integer)
-
-          if value.is_a?(::String)
-            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
-            result = Kernel.Integer(value, exception: false)
-            coercion_error!(value) if result.nil?
-            result
-          elsif value.is_a?(::Float)
-            value.to_i
-          else
-            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/zero_ruby/types/iso8601_date.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "date"
-require_relative "base_type"
-
-module ZeroRuby
-  module Types
-    # ISO8601Date type for date values.
-    # Accepts ISO8601 formatted date strings, Date, Time, and DateTime objects.
-    # Coerces to Date.
-    class ISO8601Date < BaseType
-      class << self
-        def name
-          "ISO8601Date"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          return nil if value.nil?
-
-          case value
-          when ::Date
-            value
-          when ::Time, ::DateTime
-            value.to_date
-          when ::String
-            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
-            parse_iso8601_date(value)
-          else
-            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
-          end
-        end
-
-        private
-
-        def parse_iso8601_date(value)
-          Date.iso8601(value)
-        rescue ArgumentError
-          coercion_error!(value, "#{format_value_for_error(value)} is not a valid ISO8601 date")
-        end
-      end
-    end
-  end
-end

data/lib/zero_ruby/types/iso8601_date_time.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-require_relative "base_type"
-
-module ZeroRuby
-  module Types
-    # ISO8601DateTime type for datetime values.
-    # Accepts ISO8601 formatted strings, Time, and DateTime objects.
-    # Coerces to Time.
-    class ISO8601DateTime < BaseType
-      class << self
-        def name
-          "ISO8601DateTime"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          return nil if value.nil?
-
-          case value
-          when ::Time
-            value
-          when ::DateTime
-            value.to_time
-          when ::String
-            coercion_error!(value, "empty string is not a valid #{name}") if value.empty?
-            parse_iso8601(value)
-          else
-            coercion_error!(value, "#{format_value_for_error(value)} (#{value.class}) cannot be coerced to #{name}")
-          end
-        end
-
-        private
-
-        def parse_iso8601(value)
-          Time.iso8601(value)
-        rescue ArgumentError
-          coercion_error!(value, "#{format_value_for_error(value)} is not a valid ISO8601 datetime")
-        end
-      end
-    end
-  end
-end

data/lib/zero_ruby/types/string.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_type"
-
-module ZeroRuby
-  module Types
-    class String < BaseType
-      class << self
-        def name
-          "String"
-        end
-
-        def coerce_input(value, _ctx = nil)
-          return nil if value.nil?
-          value.to_s
-        end
-      end
-    end
-  end
-end

data/lib/zero_ruby/validator.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module ZeroRuby
-  # Base class for argument validators.
-  # Inspired by graphql-ruby's validation system.
-  class Validator
-    class << self
-      # Registry of validator classes by name
-      def validators
-        @validators ||= {}
-      end
-
-      # Register a validator class
-      def register(name, klass)
-        validators[name.to_sym] = klass
-      end
-
-      # Get a validator class by name
-      def get(name)
-        validators[name.to_sym]
-      end
-
-      # Run all validations on a value
-      # @param validators_config [Hash] Configuration hash for validators
-      # @param mutation [ZeroRuby::Mutation] The mutation instance
-      # @param ctx [Hash] The context hash
-      # @param value [Object] The value to validate
-      # @return [Array<String>] Array of error messages
-      def validate!(validators_config, mutation, ctx, value)
-        return [] if validators_config.nil? || validators_config.empty?
-
-        errors = []
-
-        validators_config.each do |validator_name, config|
-          validator_class = get(validator_name)
-          next unless validator_class
-
-          validator = validator_class.new(config)
-          result = validator.validate(mutation, ctx, value)
-          errors.concat(Array(result)) if result
-        end
-
-        errors
-      end
-    end
-
-    attr_reader :config
-
-    def initialize(config)
-      @config = config
-    end
-
-    # Validate a value
-    # @param mutation [ZeroRuby::Mutation] The mutation instance
-    # @param ctx [Hash] The context hash
-    # @param value [Object] The value to validate
-    # @return [String, Array<String>, nil] Error message(s) or nil if valid
-    def validate(mutation, ctx, value)
-      raise NotImplementedError, "Subclasses must implement #validate"
-    end
-
-    protected
-
-    # Helper to format error messages
-    def error_message(message)
-      message
-    end
-  end
-end

data/lib/zero_ruby/validators/allow_blank_validator.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../validator"
-
-module ZeroRuby
-  module Validators
-    # Validates that a value is not blank when allow_blank is false.
-    #
-    # @example
-    #   validates: { allow_blank: false }
-    class AllowBlankValidator < Validator
-      def validate(mutation, ctx, value)
-        # If allow_blank is true (or truthy), blank values are allowed
-        return nil if config == true || config
-
-        # Check if value is blank (nil, empty string, or whitespace-only string)
-        is_blank = value.nil? ||
-          (value.respond_to?(:empty?) && value.empty?) ||
-          (value.is_a?(::String) && value.strip.empty?)
-
-        if is_blank
-          return "can't be blank"
-        end
-
-        nil
-      end
-    end
-
-    Validator.register(:allow_blank, AllowBlankValidator)
-  end
-end

data/lib/zero_ruby/validators/allow_null_validator.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../validator"
-
-module ZeroRuby
-  module Validators
-    # Validates that a value is not null when allow_null is false.
-    #
-    # @example
-    #   validates: { allow_null: false }
-    class AllowNullValidator < Validator
-      def validate(mutation, ctx, value)
-        # If allow_null is true (or truthy), null values are allowed
-        return nil if config == true || config
-
-        if value.nil?
-          return "can't be null"
-        end
-
-        nil
-      end
-    end
-
-    Validator.register(:allow_null, AllowNullValidator)
-  end
-end

data/lib/zero_ruby/validators/exclusion_validator.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../validator"
-
-module ZeroRuby
-  module Validators
-    # Validates that a value is NOT included in a given set.
-    #
-    # @example
-    #   validates: { exclusion: { in: ["admin", "root", "system"] } }
-    class ExclusionValidator < Validator
-      def validate(mutation, ctx, value)
-        return nil if value.nil?
-
-        excluded = config[:in] || config[:within]
-        return nil unless excluded
-
-        if excluded.respond_to?(:include?) ? excluded.include?(value) : excluded.cover?(value)
-          message = config[:message] || "is reserved"
-          return message
-        end
-
-        nil
-      end
-    end
-
-    Validator.register(:exclusion, ExclusionValidator)
-  end
-end

data/lib/zero_ruby/validators/format_validator.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../validator"
-
-module ZeroRuby
-  module Validators
-    # Validates that a value matches a regular expression.
-    #
-    # @example
-    #   validates: { format: { with: /\A[a-z0-9_]+\z/ } }
-    #   validates: { format: { without: /[<>]/ } }
-    class FormatValidator < Validator
-      def validate(mutation, ctx, value)
-        return nil if value.nil?
-
-        str_value = value.to_s
-        errors = []
-
-        if config[:with] && !str_value.match?(config[:with])
-          message = config[:message] || "is invalid"
-          errors << message
-        end
-
-        if config[:without] && str_value.match?(config[:without])
-          message = config[:message] || "is invalid"
-          errors << message
-        end
-
-        errors.empty? ? nil : errors
-      end
-    end
-
-    Validator.register(:format, FormatValidator)
-  end
-end

data/lib/zero_ruby/validators/inclusion_validator.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../validator"
-
-module ZeroRuby
-  module Validators
-    # Validates that a value is included in a given set.
-    #
-    # @example
-    #   validates: { inclusion: { in: ["draft", "published", "archived"] } }
-    #   validates: { inclusion: { in: 1..10 } }
-    class InclusionValidator < Validator
-      def validate(mutation, ctx, value)
-        return nil if value.nil?
-
-        allowed = config[:in] || config[:within]
-        return nil unless allowed
-
-        unless allowed.respond_to?(:include?) ? allowed.include?(value) : allowed.cover?(value)
-          message = config[:message] || "is not included in the list"
-          return message
-        end
-
-        nil
-      end
-    end
-
-    Validator.register(:inclusion, InclusionValidator)
-  end
-end

data/lib/zero_ruby/validators/length_validator.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../validator"
-
-module ZeroRuby
-  module Validators
-    # Validates the length of a string or array value.
-    #
-    # @example
-    #   validates: { length: { minimum: 1, maximum: 200 } }
-    #   validates: { length: { is: 10 } }
-    #   validates: { length: { in: 5..10 } }
-    class LengthValidator < Validator
-      def validate(mutation, ctx, value)
-        return nil if value.nil?
-
-        length = value.respond_to?(:length) ? value.length : value.to_s.length
-        errors = []
-
-        if config[:minimum] && length < config[:minimum]
-          errors << "is too short (minimum is #{config[:minimum]})"
-        end
-
-        if config[:maximum] && length > config[:maximum]
-          errors << "is too long (maximum is #{config[:maximum]})"
-        end
-
-        if config[:is] && length != config[:is]
-          errors << "is the wrong length (should be #{config[:is]})"
-        end
-
-        if config[:in] && !config[:in].cover?(length)
-          errors << "length is not in #{config[:in]}"
-        end
-
-        errors.empty? ? nil : errors
-      end
-    end
-
-    Validator.register(:length, LengthValidator)
-  end
-end

data/lib/zero_ruby/validators/numericality_validator.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../validator"
-
-module ZeroRuby
-  module Validators
-    # Validates numeric constraints on a value.
-    #
-    # @example
-    #   validates: { numericality: { greater_than: 0 } }
-    #   validates: { numericality: { less_than_or_equal_to: 100 } }
-    #   validates: { numericality: { equal_to: 42 } }
-    #   validates: { numericality: { odd: true } }
-    #   validates: { numericality: { even: true } }
-    class NumericalityValidator < Validator
-      def validate(mutation, ctx, value)
-        return nil if value.nil?
-
-        unless value.is_a?(Numeric)
-          return "is not a number"
-        end
-
-        errors = []
-
-        if config[:greater_than] && value <= config[:greater_than]
-          errors << "must be greater than #{config[:greater_than]}"
-        end
-
-        if config[:greater_than_or_equal_to] && value < config[:greater_than_or_equal_to]
-          errors << "must be greater than or equal to #{config[:greater_than_or_equal_to]}"
-        end
-
-        if config[:less_than] && value >= config[:less_than]
-          errors << "must be less than #{config[:less_than]}"
-        end
-
-        if config[:less_than_or_equal_to] && value > config[:less_than_or_equal_to]
-          errors << "must be less than or equal to #{config[:less_than_or_equal_to]}"
-        end
-
-        if config[:equal_to] && value != config[:equal_to]
-          errors << "must be equal to #{config[:equal_to]}"
-        end
-
-        if config[:other_than] && value == config[:other_than]
-          errors << "must be other than #{config[:other_than]}"
-        end
-
-        if config[:odd] && value.to_i.even?
-          errors << "must be odd"
-        end
-
-        if config[:even] && value.to_i.odd?
-          errors << "must be even"
-        end
-
-        errors.empty? ? nil : errors
-      end
-    end
-
-    Validator.register(:numericality, NumericalityValidator)
-  end
-end