hash_cast 0.5.2 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 899228916d29fc1b30a38151b850f6734ea57cb7390561b6a3aaecd0e3e1a7e6
-  data.tar.gz: b055bcb17b4863fea30a1f5b3a6e739514aaff9ca853fcefb3ee702bed3ece5d
+  metadata.gz: b1ff1d676f80eaba8132c7027e6b70f59047a31df70a19f55183ecaff1d915cf
+  data.tar.gz: c1d44f71ee442b52abd55703e96dd4eca331e2ef63329e7fc17188d9bc053200
 SHA512:
-  metadata.gz: 1ebd62549257464c42f8d9550b5a3a592e9b84fc430619821818497d74bc1c95946effc1c21188a619834f6420b3c78fef2aac6f9859289da0ec7719188e9726
-  data.tar.gz: 0134f1c7695a0c205e0b9f57fa6ed995fc568e55e1e999b37d80973ac102c0450d2bde94eaf20c7c72f74f534d9da6d9432a017224d1bac4eb4b05e8b04e9f2c
+  metadata.gz: 9e7a988fa4dffefccb42d33249c923fb475b3f1e4605aa959d20ab1e92e44dc6ada092df1afd720eb4f5d5d0484b6182fb3b90822f00d50363f36a38e55b622e
+  data.tar.gz: df5c9a15f7c1ba2c25a7830d1426fb218202f16ce02cecab6e1234e0b8839e8ae31bd8150c15c6a58733b99e7b5d79bc61787d7133f7b12ab9360d7b36fb3a5e

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+**Version 0.5.4**
+- Integer caster should only allow integer range by default (-2^31, 2^31)
+
+**Version 0.5.3**
+- Added optional support for array and string size validation
+
 **Version 0.5.2**
 - Rename AttributesCaster to HashCast::RecursiveCasterApplicator, to highlight that it's not a regular Caster
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hash_cast (0.5.2)
+    hash_cast (0.5.4)
 
 GEM
   remote: https://rubygems.org/

data/lib/hash_cast/casters/array_caster.rb

@@ -1,14 +1,20 @@
 class HashCast::Casters::ArrayCaster
 
   def self.cast(value, attr_name, options = {})
-    if value.is_a?(Array)
-      if options[:each]
-        cast_array_items(value, attr_name, options)
-      else
-        value
+    unless value.is_a?(Array)
+      raise HashCast::Errors::CastingError, "should be an array"
+    end
+
+    if HashCast.config.array_size_validator_enabled
+      if value.size > HashCast.config.array_size_validator_limit
+        HashCast.config.array_size_validator_callback.call(value, attr_name, options)
       end
+    end
+
+    if options[:each]
+      cast_array_items(value, attr_name, options)
     else
-      raise HashCast::Errors::CastingError, "should be an array"
+      value
     end
   end
 

data/lib/hash_cast/casters/integer_caster.rb

@@ -1,17 +1,36 @@
 class HashCast::Casters::IntegerCaster
 
+  DEFAULT_MIN_VALUE = 2**31 * -1
+  DEFAULT_MAX_VALUE = 2**31
+
   def self.cast(value, attr_name, options = {})
-    if value.is_a?(Integer)
-      value
-    elsif value.is_a?(String)
-      begin
-        Integer(value)
-      rescue ArgumentError => e
-        raise HashCast::Errors::CastingError, "is invalid integer"
-      end
-    else
-      raise HashCast::Errors::CastingError, "should be a integer"
+    integer_value = get_integer_value(value)
+
+    if integer_value < options.fetch(:min_value, DEFAULT_MIN_VALUE)
+      raise HashCast::Errors::CastingError, "should be within allowed range"
     end
+
+    if integer_value > options.fetch(:max_value, DEFAULT_MAX_VALUE)
+      raise HashCast::Errors::CastingError, "should be within allowed range"
+    end
+
+    integer_value
   end
 
+  private
+    def self.get_integer_value(value)
+      if value.is_a?(Integer)
+        return value
+      end
+
+      if value.is_a?(String)
+        begin
+          return Integer(value)
+        rescue ArgumentError => e
+          raise HashCast::Errors::CastingError, "is invalid integer"
+        end
+      end
+
+      raise HashCast::Errors::CastingError, "should be a integer"
+    end
 end

data/lib/hash_cast/casters/string_caster.rb

@@ -8,6 +8,12 @@ class HashCast::Casters::StringCaster
       raise HashCast::Errors::CastingError, 'contains invalid characters'
     end
 
+    if HashCast.config.string_size_validator_enabled
+      if value.size > HashCast.config.string_size_validator_limit
+        HashCast.config.string_size_validator_callback.call(value, attr_name, options)
+      end
+    end
+
     casted_value
   end
 

data/lib/hash_cast/config.rb

@@ -1,5 +1,14 @@
 class HashCast::Config
-  attr_accessor :input_keys, :output_keys, :validate_string_null_byte
+  attr_writer :input_keys, :output_keys, :validate_string_null_byte, 
+    :array_size_validator_enabled, 
+    :array_size_validator_limit, 
+    :array_size_validator_callback,
+    :string_size_validator_enabled, 
+    :string_size_validator_limit, 
+    :string_size_validator_callback
+
+  DEFAULT_ARRAY_SIZE_VALIDATOR_LIMIT = 1000_000
+  DEFAULT_STRING_SIZE_VALIDATOR_LIMIT = 1000_000
 
   def input_keys
     @input_keys || :symbol
@@ -14,4 +23,48 @@ class HashCast::Config
     
     @validate_string_null_byte
   end
+
+  def array_size_validator_enabled
+    return false if @array_size_validator_enabled.nil?
+    
+    @array_size_validator_enabled
+  end
+
+  def array_size_validator_limit
+    return DEFAULT_ARRAY_SIZE_VALIDATOR_LIMIT if @array_size_validator_limit.nil?
+    
+    @array_size_validator_limit
+  end
+
+  def array_size_validator_callback
+    if @array_size_validator_callback.nil?
+      return lambda{ |value, name, options|
+        raise HashCast::Errors::CastingError, "array is too large" 
+      }
+    end
+    
+    @array_size_validator_callback
+  end
+
+  def string_size_validator_enabled
+    return false if @string_size_validator_enabled.nil?
+    
+    @string_size_validator_enabled
+  end
+
+  def string_size_validator_limit
+    return DEFAULT_STRING_SIZE_VALIDATOR_LIMIT if @string_size_validator_limit.nil?
+    
+    @string_size_validator_limit
+  end
+
+  def string_size_validator_callback
+    if @string_size_validator_callback.nil?
+      return lambda{ |value, name, options|
+        raise HashCast::Errors::CastingError, "string is too large" 
+      }
+    end
+    
+    @string_size_validator_callback
+  end
 end

data/lib/hash_cast/version.rb

@@ -1,3 +1,3 @@
 module HashCast
-  VERSION = "0.5.2"
+  VERSION = "0.5.4"
 end

data/spec/hash_cast/casters/array_caster_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe HashCast::Casters::ArrayCaster do
+  subject { HashCast::Casters::ArrayCaster }
+
+  it "should cast an array" do
+    result = subject.cast([1,2,3], :ids)
+    expect(result).to eq([1,2,3])
+  end
+
+  it "should raise an error for non-array" do
+    expect {
+      subject.cast(1, :ids)
+    }.to raise_error(HashCast::Errors::CastingError, "should be an array")
+  end
+
+  context "array size validation" do
+    after{ 
+      HashCast.config.array_size_validator_enabled = nil
+      HashCast.config.array_size_validator_limit = nil
+    }
+
+    it "should not raise an error for large array by default" do
+      result = subject.cast([1] * 10_000, :ids)
+      expect(result).to eq([1] * 10_000)
+    end
+
+    it "should raise an error for large array when validation is enabled" do
+      HashCast.config.array_size_validator_enabled = true
+      HashCast.config.array_size_validator_limit = 1000
+
+      expect {
+        subject.cast([1] * 10_000, :ids)
+      }.to raise_error(HashCast::Errors::CastingError, "array is too large")
+    end
+
+    it "should allow overriding the callback" do
+      HashCast.config.array_size_validator_enabled = true
+      HashCast.config.array_size_validator_limit = 1000
+      HashCast.config.array_size_validator_callback = lambda { |value, name, options|
+        raise HashCast::Errors::UnexpectedAttributeError, 'test'
+      }
+
+      expect {
+        subject.cast([1] * 10_000, :ids)
+      }.to raise_error(HashCast::Errors::UnexpectedAttributeError, "test")
+    end
+  end
+end

data/spec/hash_cast/casters/integer_caster_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe HashCast::Casters::IntegerCaster do
+  subject { HashCast::Casters::IntegerCaster }
+
+  it "should cast from a numeric string" do
+    result = subject.cast("123", :number)
+    expect(result).to eq(123)
+  end
+
+  it "should cast from an positive integer" do
+    result = subject.cast(10_000, :number)
+    expect(result).to eq(10_000)
+  end
+
+  it "should cast from a negative integer" do
+    result = subject.cast(-10_000, :number)
+    expect(result).to eq(-10_000)
+  end
+
+  it "should cast from a zero" do
+    result = subject.cast(0, :number)
+    expect(result).to eq(0)
+  end
+
+  it "should not cast from a random string" do
+    expect {
+      subject.cast("test", :number)
+    }.to raise_error(HashCast::Errors::CastingError, "is invalid integer")
+  end
+
+  it "should not cast from an array" do
+    expect {
+      subject.cast([1], :number)
+    }.to raise_error(HashCast::Errors::CastingError, "should be a integer")
+  end
+
+  it "only allow values larger than max integer range" do
+    expect {
+      subject.cast(2**40, :number)
+    }.to raise_error(HashCast::Errors::CastingError, "should be within allowed range")
+  end
+
+  it "only allow values smaller than min integer range" do
+    expect {
+      subject.cast(2**40 * -1, :number)
+    }.to raise_error(HashCast::Errors::CastingError, "should be within allowed range")
+  end
+end

data/spec/hash_cast/casters/string_caster_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe HashCast::Casters::StringCaster do
+  subject { HashCast::Casters::StringCaster }
+
+  it "should cast a string" do
+    result = subject.cast("foobar", :name)
+    expect(result).to eq("foobar")
+  end
+
+  context "string size validation" do
+    after{ 
+      HashCast.config.string_size_validator_enabled = nil
+      HashCast.config.string_size_validator_limit = nil
+    }
+
+    it "should not raise an error for large string by default" do
+      result = subject.cast("a" * 10_000, :name)
+      expect(result).to eq("a" * 10_000)
+    end
+
+    it "should raise an error for large string when validation is enabled" do
+      HashCast.config.string_size_validator_enabled = true
+      HashCast.config.string_size_validator_limit = 1000
+
+      expect {
+        subject.cast("a" * 10_000, :ids)
+      }.to raise_error(HashCast::Errors::CastingError, "string is too large")
+    end
+
+    it "should allow overriding the callback" do
+      HashCast.config.string_size_validator_enabled = true
+      HashCast.config.string_size_validator_limit = 1000
+      HashCast.config.string_size_validator_callback = lambda { |value, name, options|
+        raise HashCast::Errors::UnexpectedAttributeError, 'test'
+      }
+
+      expect {
+        subject.cast("a" * 10_000, :ids)
+      }.to raise_error(HashCast::Errors::UnexpectedAttributeError, "test")
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_cast
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.4
 platform: ruby
 authors:
 - Albert Gazizov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-13 00:00:00.000000000 Z
+date: 2025-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,6 +78,9 @@ files:
 - lib/hash_cast/recursive_caster_applicator.rb
 - lib/hash_cast/version.rb
 - spec/hash_cast/caster_spec.rb
+- spec/hash_cast/casters/array_caster_spec.rb
+- spec/hash_cast/casters/integer_caster_spec.rb
+- spec/hash_cast/casters/string_caster_spec.rb
 - spec/hash_cast/hash_cast_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/droidlabs/hash_cast
@@ -105,5 +108,8 @@ specification_version: 4
 summary: Declarative Hash Caster
 test_files:
 - spec/hash_cast/caster_spec.rb
+- spec/hash_cast/casters/array_caster_spec.rb
+- spec/hash_cast/casters/integer_caster_spec.rb
+- spec/hash_cast/casters/string_caster_spec.rb
 - spec/hash_cast/hash_cast_spec.rb
 - spec/spec_helper.rb