paramore 3.9.1 → 3.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 443c4fd7a430d181af1f221f8e2f8d162cde504112ccafa80e7d672445add93d
-  data.tar.gz: 8557e290f05dcc0654a5bcbb55b2832d41ea0d98ac171bd3e29939a1d9312e4f
+  metadata.gz: dc2e88fe6b6a88a0447d4625d2d6111a1741a6fb73d0e1564defb60ab59a7ceb
+  data.tar.gz: b6698578f905466beede01ff25d16d7e22455e61755de121cf07c869f643f371
 SHA512:
-  metadata.gz: d86cf6d7f77328271d2bc82beebf700ccb70c7303b77654342a20e7087a4d22da5779bdfcae8e64624b1f04316f0f15472385234a4668bcfdbf7f5ba88760379
-  data.tar.gz: b8f97f9e0dde2c4f646876fb4ac8fea06301fcbe882e4244a088439091464161d873791923dd2415f67a1169c2c1c2851dd5be21323d97f8aab3700bd6e460c8
+  metadata.gz: 4e54fdb3b3082165128001c95a58c49d9a862d82486448e9cb5d163a853ba92ea62b284d01dd349f4f24a3da843c456944a38a155072e2f7cdc8592a8c90c5b2
+  data.tar.gz: 4df4f72270c8556e3d24d6b41d63244a91b6409fe1c232d562eb63970037e85f58ea83c16ba86458aacf77f303580bfba52b4eedf3311b0caed947ba9e3e2942

data/lib/paramore/cast_parameters.rb

@@ -15,81 +15,92 @@ module Paramore
     end
 
     def run
-      cast(root_field, data, 'data')
+      cast(root_field, data, nil)
     end
 
-    def cast(field, value, name = nil)
+    def cast(field, value, key, namespace = nil)
+      full_name = [namespace, key].select(&:present?).join('.')
+
       if value.nil?
-        if field.nullable? || field.default?
-          return field.default
-        else
-          raise Paramore::NilParameter, name
-        end
+        return field.default if field.nullable? || field.default?
+
+        raise Paramore::NilParameter, full_name
       elsif value == ''
-        if field.allow_empty?
-          return typecast_value(field.type, '', name)
-        elsif field.default?
-          return field.default
-        elsif field.nullable?
-          return
-        else
-          raise Paramore::NilParameter, name
-        end
+        return typecast_value(field.type, '', full_name) if field.allow_empty?
+        return field.default if field.default?
+        return if field.nullable?
+
+        raise Paramore::NilParameter, full_name
       end
 
       case field.type
       when Hash
-        typecast_hash(field, value || {}, name)
+        typecast_hash(field, value || {}, full_name)
       when Array
-        typecast_array(field, value, name)
+        typecast_array(field, value, full_name)
       else
-        typecast_value(field.type, value, name)
+        typecast_value(field.type, value, full_name)
       end
     end
 
-    def typecast_hash(field, hash, name)
-      raise Paramore::HashExpected.new(name, hash) unless hash.is_a?(Hash)
+    def typecast_hash(field, hash, full_name)
+      raise Paramore::HashExpected.new(full_name, hash) unless hash.is_a?(Hash)
 
       result =
         if field.wildly_keyed_hash?
-          value_field = field.type.values.first
-          key_type = field.type.keys.first
-          hash.to_h do |name, value|
-            [typecast_value(key_type, name, nil), cast(value_field, value, name)]
-          end
+          cast_wild_hash(field, hash, full_name)
         else
-          if options[:no_extra_keys]
-            extra = hash.keys - field.type.keys
-            raise "Found extra keys in `name`: #{extra}!"
-          end
-
-          field
-            .type
-            .reject { |name, value_field| missing_and_optional?(hash, name, value_field) }
-            .to_h { |name, value_field| [name, cast(value_field, hash[name], name)] }
+          cast_regular_hash(field, hash, full_name)
         end
 
       field.compact? ? result.compact : result
     end
 
-    def typecast_array(field, array, name)
-      raise Paramore::ArrayExpected.new(name, array) unless array.is_a?(Array)
+    def typecast_array(field, array, full_name)
+      raise Paramore::ArrayExpected.new(full_name, array) unless array.is_a?(Array)
 
-      result = array
+      result =
+        array
         .reject { |unit| unit.to_s == '' && field.compact? }
-        .map { |unit| cast(Paramore.field(field.type.first, null: true), unit) }
+        .map { |unit| cast(Paramore.field(field.type.first, null: true), unit, nil, full_name) }
 
       field.compact? ? result.compact : result
     end
 
-    def typecast_value(type, value, name)
+    def typecast_value(type, value, full_name)
       type.send(Paramore.configuration.type_method_name, value)
     rescue StandardError => e
-      raise "The field `#{name}` raised \"#{e}\"!"
+      raise "Tried casting #{Paramore::ErrorFieldName(full_name)}, but \"#{e}\" was raised!"
+    end
+
+    def cast_wild_hash(field, hash, full_name)
+      value_field = field.type.values.first
+      key_type = field.type.keys.first
+
+      hash.to_h do |inner_key, value|
+        [
+          typecast_value(key_type, inner_key, nil),
+          cast(value_field, value, inner_key, full_name)
+        ]
+      end
+    end
+
+    def cast_regular_hash(field, hash, full_name)
+      if options[:no_extra_keys]
+        extra = hash.keys - field.type.keys
+        raise "Found extra keys in #{Paramore::ErrorFieldName(full_name)}: #{extra}!" if extra.any?
+      end
+
+      field
+        .type
+        .reject { |inner_key, value_field| missing_and_optional?(hash, inner_key, value_field) }
+        .to_h do |inner_key, value_field|
+          [inner_key, cast(value_field, hash[inner_key], inner_key, full_name)]
+        end
     end
 
-    def missing_and_optional?(hash, name, field)
-      !hash.key?(name) && !field.required?
+    def missing_and_optional?(hash, key, field)
+      !hash.key?(key) && !field.required?
     end
   end
 end

data/lib/paramore/errors.rb

@@ -1,24 +1,24 @@
 class Paramore::NilParameter < StandardError
   def initialize(param_name)
-    super("Received a nil `#{param_name}`, but it's type is non nullable!")
+    super("Received a nil #{Paramore::ErrorFieldName(param_name)}, but its type is non nullable!")
   end
 end
 
 class Paramore::NonField < StandardError
   def initialize(param_name, type)
-    super("`#{param_name}` defined as a `#{type.class}`, expected a call of `Paramore.field()`! Perhaps you declared a plain hash instead of Paramore.field({})?")
+    super("#{Paramore::ErrorFieldName(param_name)} defined as a `#{type.class}`, expected a call of `Paramore.field()`! Perhaps you declared a plain hash instead of Paramore.field({})?")
   end
 end
 
 class Paramore::HashExpected < StandardError
   def initialize(param_name, param)
-    super("Expected `#{param_name}` to be a hash, received #{param.class} instead!")
+    super("Expected #{Paramore::ErrorFieldName(param_name)} to be a hash, received #{param.class} instead!")
   end
 end
 
 class Paramore::ArrayExpected < StandardError
   def initialize(param_name, param)
-    super("Expected `#{param_name}` to be an array, received #{param.class} instead!")
+    super("Expected #{Paramore::ErrorFieldName(param_name)} to be an array, received #{param.class} instead!")
   end
 end
 
@@ -27,3 +27,7 @@ class Paramore::HashTooWild < StandardError
     super("A hash field with a type as key may not contain any more entries! (so, eg.: { String => field } is ok, but { String => field, user_id: field } is not)")
   end
 end
+
+def Paramore::ErrorFieldName(name)
+  name.present? ? "`#{name}`" : 'root field'
+end

data/lib/paramore/types.rb

@@ -1,7 +1,14 @@
 module Paramore
+  module TypeRegexes
+    INTEGER_REGEX = /^-{0,1}\d+$/
+    FLOAT_REGEX = /^-{0,1}\d+(\.\d*){0,1}$/
+  end
+
   module BigDecimal
     module_function
     def [](input)
+      raise ArgumentError "#{input} is not a BigDecimal!" unless input.to_s.match?(TypeRegexes::FLOAT_REGEX)
+
       BigDecimal(input)
     end
   end
@@ -18,7 +25,7 @@ module Paramore
   module Float
     module_function
     def [](input)
-      raise ArgumentError "#{input} is not a float!" unless input.to_s.match?(/-{0,1}\d*(\.\d*){0,1}/)
+      raise ArgumentError "#{input} is not a Float!" unless input.to_s.match?(TypeRegexes::FLOAT_REGEX)
 
       input.to_f
     end
@@ -27,7 +34,7 @@ module Paramore
   module Int
     module_function
     def [](input)
-      raise ArgumentError, "#{input} is not an integer!" unless input.to_s.match?(/^-{0,1}\d*$/)
+      raise ArgumentError, "#{input} is not an Integer!" unless input.to_s.match?(TypeRegexes::INTEGER_REGEX)
 
       input.to_i
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paramore
 version: !ruby/object:Gem::Version
-  version: 3.9.1
+  version: 3.9.5
 platform: ruby
 authors:
 - Lukas Kairevičius
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-07 00:00:00.000000000 Z
+date: 2022-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -73,9 +73,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -83,9 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '7'
 description: |
   Paramore lets you declare which parameters are permitted and what object is responsible
   for typing/sanitizing/type-casting them before they are passed along to your models/domain.
@@ -115,7 +109,7 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: |
-  Thank you for installing Paramore 3.9.1 !
+  Thank you for installing Paramore 3.9.5 !
   From the command line you can run `paramore` to generate a configuration file
 
   More details here         : https://github.com/lumzdas/paramore/blob/master/README.md