paramore 1.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78a77466a7f6ac56ded5b60abc47444b7b922ac84f56641900800fbf6f4baeb7
-  data.tar.gz: b70caca4654067991e12eead85b235209b0690908a80b6afbb8eb2001d45c51f
+  metadata.gz: 7f6231e51cfe1acb4969ec05739c8386d6c772d5df241dee728fa2428e6bfc2a
+  data.tar.gz: 7bc786c9b1a163b1bcc6774c8a709d68e80b36cca3c69c6d501f98084d6538e9
 SHA512:
-  metadata.gz: 5e888539e7933c6b7d339e564e7d6ed6904b9c3aae715f7c533463b25c6ce93cc74753a031933ced70c50bf354f2830574b25ebbd56ba572915a6d1eeb0ab3e8
-  data.tar.gz: a54ccd70ffdcf5b76dfba4db4f51883c776e52915b3971dcafbdbb821b2000a90997780187fdb3832c3e27d83ef0bafcf5ac0b7ff3e044d330b7e4c94a808af0
+  metadata.gz: 1665184eba554c3216a5d8185535695dcfbb9e5ce5a38559acac184130ee4f7787065ac72445c258873a7479ac1c2ecaab34f6a68b65f607da6b96542a317a0c
+  data.tar.gz: 834d1432f9958709891ccd285280d4dd7f21caab56c1aa7d88d5178a4ef7745d0c5340553d346fbd32d4f17a6d525fd3e872c399640820940ef8830fca34ec99

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,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,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

@@ -4,33 +4,42 @@ require_relative 'permitted_parameter_argument'
 
 module Paramore
   module Extension
-    def paramorize(accessor_name, parameter_configuration)
+    OPTIONS = %i[
+      default
+    ].freeze
+
+    def param_schema(accessor_name, parameter_configuration)
       unless parameter_configuration.keys.size == 1
         raise ArgumentError,
-          "Paramore: exactly one required attribute allowed! Given: #{param_definition.keys}"
+          "Paramore: exactly one required attribute allowed! Given: #{parameter_configuration.keys}"
       end
 
       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?(Paramore::Field)
+          Paramore::PermittedParameterArgument.parse(types_definition)
+        else
+          types_definition
+        end
 
       define_method(accessor_name) do |rails_parameters = params|
         return instance_variable_get("@#{accessor_name}") if instance_variable_defined?("@#{accessor_name}")
 
-        permitted_parameter_argument =
-          if types_definition.is_a?(Hash)
-            Paramore::PermittedParameterArgument.parse(types_definition)
-          else
-            types_definition
-          end
+        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
 
         permitted_params = rails_parameters
           .require(required_parameter_name)
           .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,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, 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.0.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Lukas Kairevičius
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-01 00:00:00.000000000 Z
+date: 2021-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -56,16 +56,22 @@ dependencies:
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !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.
@@ -85,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.0.2 !
+  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

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