paramore 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bc18680611ecf9983143593443a9d04e3a7b57ac77111f183960287600a9592
-  data.tar.gz: 613b869bddc6de6a585e8de9f0448373a40da62d4daecf736e19e0955fa477ed
+  metadata.gz: 7f6231e51cfe1acb4969ec05739c8386d6c772d5df241dee728fa2428e6bfc2a
+  data.tar.gz: 7bc786c9b1a163b1bcc6774c8a709d68e80b36cca3c69c6d501f98084d6538e9
 SHA512:
-  metadata.gz: efb59cc8e0ee2d9bb324f8d543ff7e5e22a652d4bc23b5ea067b5fdadb3d47cd85ea228d5d855e47a43980f2723b8dc7983d11f592c44404607c00967b522788
-  data.tar.gz: aba0613b0838fd1b1d523bfe62913e33f1b4be678891c0794db7af2aa3138cd9755ff3c8c9b501e13203ccb49c94cd6d04e303d43bb7df4951279cdc22ff7c44
+  metadata.gz: 1665184eba554c3216a5d8185535695dcfbb9e5ce5a38559acac184130ee4f7787065ac72445c258873a7479ac1c2ecaab34f6a68b65f607da6b96542a317a0c
+  data.tar.gz: 834d1432f9958709891ccd285280d4dd7f21caab56c1aa7d88d5178a4ef7745d0c5340553d346fbd32d4f17a6d525fd3e872c399640820940ef8830fca34ec99

data/README.md

@@ -75,15 +75,15 @@ class ItemsController < ApplicationController
   end
 
   param_schema :item_params,
-    item: {
+    item: Paramore.field({
       name: Paramore.field(Paramore::SanitizedString),
       description: Paramore.field(Paramore::StrippedString, null: true),
-      for_sale: Paramore.field(Paramore::Boolean),
+      for_sale: Paramore.field(Paramore::Boolean, default: false),
       price: Paramore.field(Paramore::Decimal),
       metadata: Paramore.field({
         tags: Paramore.field([Types::ItemTag], compact: true)
       })
-    }
+    })
 end
 ```
 
@@ -133,8 +133,7 @@ This can be disabled for any type by declaring `Paramore.field(Paramore::Int, nu
 
 nils will usually not reach any of the type classes - if some parameter is nullable, the class will not be called.
 If a parameter is non-nullable, then a `Paramore::NilParameter` error will be raised before calling the class.
-If a, say, `item_ids` array is non-nullable, but the received parameter is `['1', '', '3']`, only the `'1'` and `'2'` will get passed to type classes, and the resulting array will contain a nil, eg.: `['1', nil, '3']`.
-nils inside arrays can still be passed to type classes by declaring `Paramore.field([Paramore::Int], empty: true)`.
+If an incoming array contains nils, they will get passed to type classes.
 If you wish to get rid of empty array elements, declare `Paramore.field(Paramore::Int, compact: true)`.
 
 <h3>Configuration</h3>

data/lib/paramore/cast_parameters.rb

@@ -3,59 +3,49 @@ require_relative 'errors'
 module Paramore
   module CastParameters
     module_function
-    def run(types_definition, permitted_params)
-      recursive_merge(
-        recursive_typecast(
-          types_definition, permitted_params
-        )
-      )
+    def run(field, data)
+      recursive_merge(cast(field, data, 'data'))
     end
 
     def recursive_merge(nested_hash_array)
-      nested_hash_array.reduce(:merge).map do |param_name, value|
+      nested_hash_array.reduce(:merge).map do |name, value|
         if value.is_a?(Array) && value.all? { |_value| _value.is_a?(Hash) }
-          { param_name => recursive_merge(value) }
+          { name => recursive_merge(value) }
         else
-          { param_name => value }
+          { name => value }
         end
       end.reduce(:merge)
     end
 
-    def recursive_typecast(types_definition, permitted_params)
-      types_definition.map do |param_name, definition|
-        value = permitted_params[param_name]
-
-        if value.nil?
-          if definition.nullable?
-            next { param_name => nil }
-          else
-            raise Paramore::NilParameter, param_name
-          end
+    def cast(field, value, name = nil)
+      if value.nil?
+        if field.nullable? || field.default
+          return field.default
+        else
+          raise Paramore::NilParameter, name
         end
-
-        { param_name => cast(definition, value) }
       end
-    end
 
-    def cast(definition, value)
-      case definition.type
+      case field.type
       when Hash
-        recursive_typecast(definition.type, value || {})
+        typecast_hash(field.type, value || {})
       when Array
-        typecast_array(definition, value)
+        typecast_array(field, value)
       else
-        typecast_value(definition.type, value)
+        typecast_value(field.type, value)
       end
     end
 
-    def typecast_array(definition, array)
+    def typecast_hash(field, hash)
+      field.map do |name, field|
+        { name => cast(field, hash[name], name) }
+      end
+    end
+
+    def typecast_array(field, array)
       array
-        .reject { |unit| unit.to_s == '' && definition.compact? }
-        .map do |unit|
-          if unit.to_s != '' || definition.use_empty_strings?
-            typecast_value(definition.type.first, unit)
-          end
-        end
+        .reject { |unit| unit.to_s == '' && field.compact? }
+        .map { |unit| typecast_value(field.type.first, unit) }
     end
 
     def typecast_value(type, value)

data/lib/paramore/errors.rb

@@ -4,7 +4,7 @@ class Paramore::NilParameter < StandardError
   end
 end
 
-class Paramore::NonFieldSchema < StandardError
+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({})?")
   end

data/lib/paramore/extension.rb

@@ -8,9 +8,7 @@ module Paramore
       default
     ].freeze
 
-    def param_schema(accessor_name, configuration)
-      parameter_configuration = configuration.except(*OPTIONS)
-
+    def param_schema(accessor_name, parameter_configuration)
       unless parameter_configuration.keys.size == 1
         raise ArgumentError,
           "Paramore: exactly one required attribute allowed! Given: #{parameter_configuration.keys}"
@@ -19,10 +17,10 @@ module Paramore
       required_parameter_name = parameter_configuration.keys.first
       types_definition = parameter_configuration.values.first
 
-      Paramore::Validate.run(types_definition) if types_definition.is_a?(Hash)
+      Paramore::Validate.run(types_definition) if types_definition.is_a?(Paramore::Field)
 
       permitted_parameter_argument =
-        if types_definition.is_a?(Hash)
+        if types_definition.is_a?(Paramore::Field)
           Paramore::PermittedParameterArgument.parse(types_definition)
         else
           types_definition
@@ -31,8 +29,8 @@ module Paramore
       define_method(accessor_name) do |rails_parameters = params|
         return instance_variable_get("@#{accessor_name}") if instance_variable_defined?("@#{accessor_name}")
 
-        if rails_parameters[required_parameter_name].nil? && configuration[:default]
-          instance_variable_set("@#{accessor_name}", configuration[:default])
+        if rails_parameters[required_parameter_name].nil? && types_definition.default
+          instance_variable_set("@#{accessor_name}", types_definition.default)
           return instance_variable_get("@#{accessor_name}")
         end
 
@@ -41,7 +39,7 @@ module Paramore
           .permit(permitted_parameter_argument)
 
         parameter_values =
-          if types_definition.is_a?(Hash)
+          if types_definition.is_a?(Paramore::Field)
             permitted_params.merge(
               Paramore::CastParameters.run(types_definition, permitted_params)
             ).permit!

data/lib/paramore/{field_schema.rb → field.rb}

@@ -1,36 +1,32 @@
 module Paramore
-  class FieldSchema
+  class Field
     DEFAULT_OPTIONS = {
       null: false,
-      empty: false,
       compact: false,
+      default: nil,
     }.freeze
 
-    def initialize(given_type, null:, empty:, compact:)
+    def initialize(given_type, null:, compact:, default:)
       @given_type = given_type
       @nullable = null
-      @empty = empty
       @compact = compact
+      @default = default
     end
 
-    def compact?
-      compact
+    def default
+      @default
     end
 
-    def nullable?
-      nullable
+    def compact?
+      @compact
     end
 
-    def use_empty_strings?
-      empty
+    def nullable?
+      @nullable
     end
 
     def type
-      given_type
+      @given_type
     end
-
-    private
-
-    attr_reader :given_type, :nullable, :empty, :compact
   end
 end

data/lib/paramore/permitted_parameter_argument.rb

@@ -2,22 +2,26 @@ module Paramore
   module PermittedParameterArgument
     module_function
 
-    def parse(types_definition)
+    def parse(field)
+      parse_type(field.type)
+    end
+
+    def parse_type(type)
       merge_hashes(
-        types_definition.map do |key, definition|
-          case definition
-          when Hash
-            { key => merge_hashes(parse(definition)) }
-          when Paramore::FieldSchema
-            case definition.type
-            when Array
-              { key => [] }
-            when Hash
-              { key => merge_hashes(parse(definition.type)) }
+        case type
+        when Array
+          parse_type(type.first)
+        when Hash
+          type.map do |name, field|
+            case field.type
+            when Array, Hash
+              { name => parse_type(field.type) }
             else
-              key
+              name
             end
           end
+        else
+          []
         end
       )
     end

data/lib/paramore/validate.rb

@@ -2,8 +2,8 @@ module Paramore
   module Validate
     module_function
 
-    def run(types_definition)
-      types(types_definition).each do |type|
+    def run(root_field)
+      types(root_field.type).uniq.each do |type|
         unless type.respond_to?(Paramore.configuration.type_method_name)
           raise NoMethodError,
             "Paramore: type `#{type}` does not respond to " +
@@ -12,13 +12,22 @@ module Paramore
       end
     end
 
-    def types(types_definition)
-      types_definition.flat_map do |param_name, field_schema|
-        unless field_schema.is_a?(Paramore::FieldSchema)
-          raise Paramore::NonFieldSchema.new(param_name, field_schema)
-        end
+    def types(type)
+      case type
+      when Hash
+        hash_types(type)
+      when Array
+        type.flat_map { |subtype| types(subtype) }
+      else
+        [type]
+      end
+    end
+
+    def hash_types(hash)
+      hash.flat_map do |param_name, field|
+        raise Paramore::NonField.new(param_name, field) unless field.is_a?(Paramore::Field)
 
-        field_schema.type.is_a?(Hash) ? types(field_schema.type) : field_schema.type
+        field.type.is_a?(Hash) ? types(field.type) : field.type
       end.uniq
     end
   end

data/lib/paramore.rb

@@ -1,7 +1,7 @@
 require_relative 'paramore/configuration'
 require_relative 'paramore/railtie'
 require_relative 'paramore/types'
-require_relative 'paramore/field_schema'
+require_relative 'paramore/field'
 
 module Paramore
   class << self
@@ -17,9 +17,9 @@ module Paramore
   end
 
   def self.field(given_type, options = {})
-    Paramore::FieldSchema.new(
+    Paramore::Field.new(
       given_type,
-      **Paramore::FieldSchema::DEFAULT_OPTIONS.merge(options)
+      **Paramore::Field::DEFAULT_OPTIONS.merge(options)
     )
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paramore
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Lukas Kairevičius
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-30 00:00:00.000000000 Z
+date: 2021-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -91,7 +91,7 @@ files:
 - lib/paramore/configuration.rb
 - lib/paramore/errors.rb
 - lib/paramore/extension.rb
-- lib/paramore/field_schema.rb
+- lib/paramore/field.rb
 - lib/paramore/permitted_parameter_argument.rb
 - lib/paramore/railtie.rb
 - lib/paramore/types.rb
@@ -101,7 +101,7 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: |
-  Thank you for installing Paramore 2.0.0 !
+  Thank you for installing Paramore 3.0.0 !
   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