hash_validator 1.1.0 → 1.2.0

data/lib/hash_validator/validators/array_validator.rb

@@ -46,7 +46,21 @@ class HashValidator::Validator::ArrayValidator < HashValidator::Validator::Base
     return if array_spec.empty?
 
     size_spec = array_spec[:size]
-    if size_spec.present?
+
+    size_spec_present = case size_spec
+      when String
+        !object.strip.empty?
+      when NilClass
+        false
+      when Numeric
+        true
+      when Array, Hash
+        !object.empty?
+      else
+        !!object
+      end
+
+    if size_spec_present
       unless value.size == size_spec
         errors[key] = "The required size of array is #{size_spec} but is #{value.size}."
         return

data/lib/hash_validator/validators/digits_validator.rb

@@ -0,0 +1,23 @@
+class HashValidator::Validator::DigitsValidator < HashValidator::Validator::Base
+  def initialize
+    super('digits')  # The name of the validator
+  end
+
+  def presence_error_message
+    'must contain only digits'
+  end
+
+  def validate(key, value, _validations, errors)
+    unless value.is_a?(String) && valid_digits?(value)
+      errors[key] = presence_error_message
+    end
+  end
+
+  private
+
+  def valid_digits?(value)
+    /\A\d+\z/.match?(value)
+  end
+end
+
+HashValidator.append_validator(HashValidator::Validator::DigitsValidator.new)

data/lib/hash_validator/validators/hash_validator.rb

@@ -4,10 +4,15 @@ class HashValidator::Validator::HashValidator < HashValidator::Validator::Base
   end
 
   def should_validate?(rhs)
-    rhs.is_a?(Hash)
+    rhs.is_a?(Hash) || (defined?(ActionController::Parameters) && rhs.is_a?(ActionController::Parameters))
   end
 
   def validate(key, value, validations, errors)
+    # Convert ActionController::Parameters to Hash if needed
+    if !value.is_a?(Hash) && defined?(ActionController::Parameters) && value.is_a?(ActionController::Parameters)
+      value = value.to_unsafe_h
+    end
+
     # Validate hash
     unless value.is_a?(Hash)
       errors[key] = presence_error_message

data/lib/hash_validator/validators/hex_color_validator.rb

@@ -0,0 +1,23 @@
+class HashValidator::Validator::HexColorValidator < HashValidator::Validator::Base
+  def initialize
+    super('hex_color')  # The name of the validator
+  end
+
+  def presence_error_message
+    'is not a valid hex color'
+  end
+
+  def validate(key, value, _validations, errors)
+    unless value.is_a?(String) && valid_hex_color?(value)
+      errors[key] = presence_error_message
+    end
+  end
+
+  private
+
+  def valid_hex_color?(value)
+    /\A#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})\z/.match?(value)
+  end
+end
+
+HashValidator.append_validator(HashValidator::Validator::HexColorValidator.new)

data/lib/hash_validator/validators/json_validator.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+class HashValidator::Validator::JsonValidator < HashValidator::Validator::Base
+  def initialize
+    super('json')  # The name of the validator
+  end
+
+  def presence_error_message
+    'is not valid JSON'
+  end
+
+  def validate(key, value, _validations, errors)
+    unless value.is_a?(String) && valid_json?(value)
+      errors[key] = presence_error_message
+    end
+  end
+
+  private
+
+  def valid_json?(value)
+    JSON.parse(value)
+    true
+  rescue JSON::ParserError
+    false
+  end
+end
+
+HashValidator.append_validator(HashValidator::Validator::JsonValidator.new)

data/lib/hash_validator/validators/url_validator.rb

@@ -0,0 +1,28 @@
+require 'uri'
+
+class HashValidator::Validator::UrlValidator < HashValidator::Validator::Base
+  def initialize
+    super('url')  # The name of the validator
+  end
+
+  def presence_error_message
+    'is not a valid URL'
+  end
+
+  def validate(key, value, _validations, errors)
+    unless value.is_a?(String) && valid_url?(value)
+      errors[key] = presence_error_message
+    end
+  end
+
+  private
+
+  def valid_url?(value)
+    uri = URI.parse(value)
+    %w[http https ftp].include?(uri.scheme)
+  rescue URI::InvalidURIError
+    false
+  end
+end
+
+HashValidator.append_validator(HashValidator::Validator::UrlValidator.new)

data/lib/hash_validator/validators.rb

@@ -37,4 +37,10 @@ require 'hash_validator/validators/lambda_validator'
 require 'hash_validator/validators/optional_validator'
 require 'hash_validator/validators/many_validator'
 require 'hash_validator/validators/multiple_validator'
-require 'hash_validator/validators/array_validator'
+require 'hash_validator/validators/array_validator'
+require 'hash_validator/validators/url_validator'
+require 'hash_validator/validators/json_validator'
+require 'hash_validator/validators/hex_color_validator'
+require 'hash_validator/validators/alphanumeric_validator'
+require 'hash_validator/validators/alpha_validator'
+require 'hash_validator/validators/digits_validator'

data/lib/hash_validator/version.rb

@@ -1,3 +1,3 @@
 module HashValidator
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/spec/spec_helper.rb

@@ -1,6 +1,3 @@
-require 'coveralls'
-Coveralls.wear!
-
 require 'rubygems'
 require 'hash_validator'
 require 'hash_validator_spec_helper'
@@ -9,6 +6,6 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
   config.order = 'random'
-  
+
   config.include HashValidatorSpecHelper
 end

data/spec/validators/alpha_validator_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::AlphaValidator do
+  let(:validator) { HashValidator::Validator::AlphaValidator.new }
+
+  context 'valid alpha strings' do
+    it 'validates lowercase letters' do
+      errors = {}
+      validator.validate('key', 'abc', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates uppercase letters' do
+      errors = {}
+      validator.validate('key', 'ABC', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates mixed case letters' do
+      errors = {}
+      validator.validate('key', 'AbC', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates single letter' do
+      errors = {}
+      validator.validate('key', 'a', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates long strings' do
+      errors = {}
+      validator.validate('key', 'HelloWorld', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid alpha strings' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects strings with numbers' do
+      errors = {}
+      validator.validate('key', 'abc123', {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects strings with spaces' do
+      errors = {}
+      validator.validate('key', 'abc def', {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects strings with special characters' do
+      errors = {}
+      validator.validate('key', 'abc!', {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects strings with hyphens' do
+      errors = {}
+      validator.validate('key', 'abc-def', {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects strings with underscores' do
+      errors = {}
+      validator.validate('key', 'abc_def', {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+
+    it 'rejects strings with periods' do
+      errors = {}
+      validator.validate('key', 'abc.def', {}, errors)
+      expect(errors['key']).to eq('must contain only letters')
+    end
+  end
+end

data/spec/validators/alphanumeric_validator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::AlphanumericValidator do
+  let(:validator) { HashValidator::Validator::AlphanumericValidator.new }
+
+  context 'valid alphanumeric strings' do
+    it 'validates letters only' do
+      errors = {}
+      validator.validate('key', 'abc', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates numbers only' do
+      errors = {}
+      validator.validate('key', '123', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates mixed letters and numbers' do
+      errors = {}
+      validator.validate('key', 'abc123', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates uppercase letters' do
+      errors = {}
+      validator.validate('key', 'ABC', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates mixed case letters' do
+      errors = {}
+      validator.validate('key', 'AbC123', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates single character' do
+      errors = {}
+      validator.validate('key', 'a', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates single digit' do
+      errors = {}
+      validator.validate('key', '1', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid alphanumeric strings' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+
+    it 'rejects strings with spaces' do
+      errors = {}
+      validator.validate('key', 'abc 123', {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+
+    it 'rejects strings with special characters' do
+      errors = {}
+      validator.validate('key', 'abc!123', {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+
+    it 'rejects strings with hyphens' do
+      errors = {}
+      validator.validate('key', 'abc-123', {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+
+    it 'rejects strings with underscores' do
+      errors = {}
+      validator.validate('key', 'abc_123', {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+
+    it 'rejects strings with periods' do
+      errors = {}
+      validator.validate('key', 'abc.123', {}, errors)
+      expect(errors['key']).to eq('must contain only letters and numbers')
+    end
+  end
+end

data/spec/validators/digits_validator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::DigitsValidator do
+  let(:validator) { HashValidator::Validator::DigitsValidator.new }
+
+  context 'valid digit strings' do
+    it 'validates single digit' do
+      errors = {}
+      validator.validate('key', '1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates multiple digits' do
+      errors = {}
+      validator.validate('key', '123', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates zero' do
+      errors = {}
+      validator.validate('key', '0', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates long number strings' do
+      errors = {}
+      validator.validate('key', '1234567890', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates leading zeros' do
+      errors = {}
+      validator.validate('key', '0123', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid digit strings' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects strings with letters' do
+      errors = {}
+      validator.validate('key', '123abc', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects strings with spaces' do
+      errors = {}
+      validator.validate('key', '123 456', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects strings with special characters' do
+      errors = {}
+      validator.validate('key', '123!', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects strings with hyphens' do
+      errors = {}
+      validator.validate('key', '123-456', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects strings with periods' do
+      errors = {}
+      validator.validate('key', '123.456', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects negative signs' do
+      errors = {}
+      validator.validate('key', '-123', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+
+    it 'rejects positive signs' do
+      errors = {}
+      validator.validate('key', '+123', {}, errors)
+      expect(errors['key']).to eq('must contain only digits')
+    end
+  end
+end

data/spec/validators/hash_validator_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe 'ActionController::Parameters support' do
+  # Mock ActionController::Parameters for testing
+  let(:mock_params_class) do
+    Class.new do
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def keys
+        @data.keys
+      end
+
+      def to_unsafe_h
+        @data
+      end
+
+      def is_a?(klass)
+        return true if klass.name == 'ActionController::Parameters'
+        super
+      end
+
+      def class
+        OpenStruct.new(name: 'ActionController::Parameters')
+      end
+    end
+  end
+
+  before do
+    # Define ActionController::Parameters constant for testing
+    unless defined?(ActionController::Parameters)
+      ActionController = Module.new unless defined?(ActionController)
+      ActionController.const_set(:Parameters, mock_params_class)
+    end
+  end
+
+  it 'should validate ActionController::Parameters objects' do
+    params = ActionController::Parameters.new({ name: 'John', age: 30 })
+    validations = { name: 'string', age: 'integer' }
+    
+    validator = HashValidator.validate(params, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+
+  it 'should handle nested ActionController::Parameters' do
+    nested_params = ActionController::Parameters.new({ theme: 'dark' })
+    params = ActionController::Parameters.new({ 
+      name: 'John', 
+      preferences: nested_params
+    })
+    
+    validations = { 
+      name: 'string',
+      preferences: { theme: 'string' }
+    }
+    
+    validator = HashValidator.validate(params, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+
+  it 'should validate ActionController::Parameters with our new validators' do
+    params = ActionController::Parameters.new({
+      name: 'John',
+      email: 'john@example.com',
+      website: 'https://john.com',
+      zip_code: '12345'
+    })
+    
+    validations = {
+      name: 'alpha',
+      email: 'email',
+      website: 'url',
+      zip_code: 'digits'
+    }
+    
+    validator = HashValidator.validate(params, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+
+  it 'should still work with regular hashes' do
+    hash = { name: 'John', age: 30 }
+    validations = { name: 'string', age: 'integer' }
+    
+    validator = HashValidator.validate(hash, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+end

data/spec/validators/hex_color_validator_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::HexColorValidator do
+  let(:validator) { HashValidator::Validator::HexColorValidator.new }
+
+  context 'valid hex colors' do
+    it 'validates 6-digit hex colors (lowercase)' do
+      errors = {}
+      validator.validate('key', '#ff0000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 6-digit hex colors (uppercase)' do
+      errors = {}
+      validator.validate('key', '#FF0000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 6-digit hex colors (mixed case)' do
+      errors = {}
+      validator.validate('key', '#Ff0000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 3-digit hex colors (lowercase)' do
+      errors = {}
+      validator.validate('key', '#f00', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 3-digit hex colors (uppercase)' do
+      errors = {}
+      validator.validate('key', '#F00', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates black color' do
+      errors = {}
+      validator.validate('key', '#000000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates white color' do
+      errors = {}
+      validator.validate('key', '#ffffff', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates complex hex colors' do
+      errors = {}
+      validator.validate('key', '#3a7bd4', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid hex colors' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects hex colors without hash' do
+      errors = {}
+      validator.validate('key', 'ff0000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid length (4 digits)' do
+      errors = {}
+      validator.validate('key', '#ff00', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid length (5 digits)' do
+      errors = {}
+      validator.validate('key', '#ff000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid length (7 digits)' do
+      errors = {}
+      validator.validate('key', '#ff00000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid characters' do
+      errors = {}
+      validator.validate('key', '#gg0000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects just hash symbol' do
+      errors = {}
+      validator.validate('key', '#', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+  end
+end