paramore 1.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a45a04ffeaabb270fd7b57a2e27e195205a26ad281c46d69561040d71fb6961
-  data.tar.gz: 0df60483be44946c6e1fedb711039d5a915787c54e46c5f841c73172393e35f9
+  metadata.gz: fb73686fb48a297c559c211476f565f8aba18a2e93a10936b75cacd4eab2bcb2
+  data.tar.gz: df12fd5715e1c4e3851a1ed2f9748f24cccec9d9ccc817c7b6ba74960370f426
 SHA512:
-  metadata.gz: f0f3ed2da9f139467f5d4f6db3d7cbc7f0b29c3c1385a4eb8835d0cbffced915d0c77700d69722d11807984624e611856b2acd36462fe6ea4cb577736f8c6255
-  data.tar.gz: decf8bc3cbaa99c75ce7070b59f58f4e84d5cd0b3d22681836ae56f61596a600f3777e58c929d9db31a698689ea07a7b00330d45f54a9706262b512734b07393
+  metadata.gz: 5d7f2e6f52065f18ebb5b7d51577950ceb234db5f5a21fd3a20fdb987066c451da22beda1bc86a4101ad9bfaf4ccf195a38b1281b02c92c4d8cc2d1fa6602958
+  data.tar.gz: b5dd8ae054488a628c580924cfdfb0355ef063a43eb7e46fe249ae9ecad62a4a80d5603b4eed182d1b69c1d691926c97165c605b11d05eec4b5ed66efbc3cac3

data/README.md

@@ -1,7 +1,7 @@
 # Paramore
 
-Paramore is a small gem intended to make strong parameter definitions declarative
-and provide a unified way to typecast and sanitize their values outside of controllers.
+Paramore allows you to declare a typed schema for your params,
+so that any downstream code can work with the data it expects.
 
 # Installation
 
@@ -20,7 +20,7 @@ $ bundle
 <h3>Without typing</h3>
 
 ```ruby
-paramorize :item_params,
+param_schema :item_params,
   item: [:name, :description, :for_sale, :price, metadata: [tags: []]]
 ```
 
@@ -74,16 +74,16 @@ class ItemsController < ApplicationController
     Item.create(item_params)
   end
 
-  paramorize :item_params,
-    item: {
-      name: Paratype[Paramore::SanitizedString],
-      description: Paratype[Paramore::StrippedString, null: true],
-      for_sale: Paratype[Paramore::Boolean],
-      price: Paratype[Paramore::Decimal],
-      metadata: Paratype[{
-        tags: Paratype[[Types::ItemTag], compact: true]
-      }]
-    }
+  param_schema :item_params,
+    item: Paramore.field({
+      name: Paramore.field(Paramore::SanitizedString),
+      description: Paramore.field(Paramore::StrippedString, null: true),
+      for_sale: Paramore.field(Paramore::Boolean, default: false),
+      price: Paramore.field(Paramore::Decimal),
+      metadata: Paramore.field({
+        tags: Paramore.field([Types::ItemTag], compact: true)
+      })
+    })
 end
 ```
 
@@ -129,13 +129,12 @@ Notice that the `Paramore::StrippedString` does not perform `.squeeze(' ')`, onl
 <h3>nil</h3>
 
 Types are non-nullable by default and raise exceptions if the param hash misses any.
-This can be disabled for any type by declaring `Paratype[Paramore::Int, null: true]`.
+This can be disabled for any type by declaring `Paramore.field(Paramore::Int, null: true)`.
 
 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 `Paratype[[Paramore::Int], empty: true]`.
-If you wish to get rid of empty array elements, declare `Paratype[Paramore::Int, compact: 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,58 +3,38 @@ 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)
+      cast(field, data, 'data')
     end
 
-    def recursive_merge(nested_hash_array)
-      nested_hash_array.reduce(:merge).map do |param_name, value|
-        if value.is_a?(Array) && value.all? { |_value| _value.is_a?(Hash) }
-          { param_name => recursive_merge(value) }
+    def cast(field, value, name = nil)
+      if value.nil?
+        if field.nullable? || field.default
+          return field.default
         else
-          { param_name => value }
+          raise Paramore::NilParameter, name
         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
-        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.to_h { |name, field| [name, cast(field, hash[name], name)] }
+    end
+
+    def typecast_array(field, array)
       array
-        .reject { |unit| unit.to_s == '' && definition.compact? }
+        .reject { |unit| unit.to_s == '' && field.compact? }
         .map do |unit|
-          if unit.to_s != '' || definition.use_empty_strings?
-            typecast_value(definition.type.first, unit)
-          end
+          cast(Paramore.field(field.type.first, null: true), unit)
         end
     end
 

data/lib/paramore/errors.rb

@@ -4,8 +4,8 @@ class Paramore::NilParameter < StandardError
   end
 end
 
-class Paramore::NonParatype < StandardError
+class Paramore::NonField < StandardError
   def initialize(param_name, type)
-    super("`#{param_name}` defined as a `#{type.class}`, expected `Paratype`! Perhaps you declared a plain hash instead of Paratype[{}]?")
+    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
 end

data/lib/paramore/extension.rb

@@ -8,9 +8,7 @@ module Paramore
       default
     ].freeze
 
-    def paramorize(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.rb

@@ -0,0 +1,32 @@
+module Paramore
+  class Field
+    DEFAULT_OPTIONS = {
+      null: false,
+      compact: false,
+      default: nil,
+    }.freeze
+
+    def initialize(given_type, null:, compact:, default:)
+      @given_type = given_type
+      @nullable = null
+      @compact = compact
+      @default = default
+    end
+
+    def default
+      @default
+    end
+
+    def compact?
+      @compact
+    end
+
+    def nullable?
+      @nullable
+    end
+
+    def type
+      @given_type
+    end
+  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 Paratype
-            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,23 +2,34 @@ 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 " +
             "`#{Paramore.configuration.type_method_name}`!"
         end
       end
+
+      root_field
     end
 
-    def types(types_definition)
-      types_definition.flat_map do |param_name, paratype|
-        unless paratype.is_a?(Paratype)
-          raise Paramore::NonParatype.new(param_name, paratype)
-        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)
 
-        paratype.type.is_a?(Hash) ? types(paratype.type) : paratype.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 'paratype'
+require_relative 'paramore/field'
 
 module Paramore
   class << self
@@ -15,4 +15,11 @@ module Paramore
   def self.configure
     yield(configuration)
   end
+
+  def self.field(given_type, options = {})
+    Paramore::Field.new(
+      given_type,
+      **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: 1.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Lukas Kairevičius
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-27 00:00:00.000000000 Z
+date: 2021-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -91,17 +91,17 @@ files:
 - lib/paramore/configuration.rb
 - lib/paramore/errors.rb
 - lib/paramore/extension.rb
+- lib/paramore/field.rb
 - lib/paramore/permitted_parameter_argument.rb
 - lib/paramore/railtie.rb
 - lib/paramore/types.rb
 - lib/paramore/validate.rb
-- lib/paratype.rb
 homepage: https://github.com/lumzdas/paramore
 licenses:
 - MIT
 metadata: {}
 post_install_message: |
-  Thank you for installing Paramore 1.1.0 !
+  Thank you for installing Paramore 3.1.1 !
   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

data/lib/paratype.rb

@@ -1,32 +0,0 @@
-class Paratype
-  def self.[](given_type, null: false, empty: false, compact: false)
-    self.new(given_type, null: null, empty: empty, compact: compact)
-  end
-
-  def initialize(given_type, null:, empty:, compact:)
-    @given_type = given_type
-    @nullable = null
-    @empty = empty
-    @compact = compact
-  end
-
-  def compact?
-    compact
-  end
-
-  def nullable?
-    nullable
-  end
-
-  def use_empty_strings?
-    empty
-  end
-
-  def type
-    given_type
-  end
-
-  private
-
-  attr_reader :given_type, :nullable, :empty, :compact
-end