typed_params 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c59b3bb4616ea961712403ef227a38d003dcc3f1ee9a6d84f310b853c67ebd0
-  data.tar.gz: '092c41c550392b86b7a54355d061c2a6580181a3e9c7cd159035628edcf42459'
+  metadata.gz: 532f36036d10c99438c7764f96edee2a81609957e91549be1d39c09eeac3b986
+  data.tar.gz: 2780ca74ef0c99371dc87486134e37b25c8de93a4814f297d7d1955fab18ba32
 SHA512:
-  metadata.gz: a8861eadab77356645756dbac358566ad33e872132ac9c68b29a8769c653806a0aa7487d81cf65a4a8046720a9389a20c75d4db0009418d785d844a0a908efff
-  data.tar.gz: ac7f14c76deb864aad8d11a3cf3cb5e2a72567ab7bf781780b8822aacb68820a8965374f439dee63568bf0a01a197c0189951cbc898e1ef15bbf4bc8840f4eb6
+  metadata.gz: 52d65870463fa00390b94bb2b469f3c12dda164518d4a32ed3151c5f09303ceb546ab4fcc76388eb0c42902a19a64ba249eb44119492ab771175c876821e0d7e
+  data.tar.gz: cd70318ed475aa00a8cbdafc89656957a93abe17c1108b0d39bca744102a1e91546d483168b8e5a9e8ac1ae9b58bb17870594d8611b8a05d46d46862f744d7ae

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.0.3
+
+- Revert 0b0aaa6b66edd3e4c3336e51fa340592e7ef9e86.
+
 ## 1.0.2
 
 - Fix parameterization of nil children.

data/README.md

@@ -14,7 +14,7 @@ to serve millions of API requests per day.
 class UsersController < ApplicationController
   include TypedParams::Controller
 
-  rescue_from TypedParams::InvalidParameterError, -> err {
+  rescue_from TypedParams::InvalidParameterError, with: -> err {
     render_bad_request err.message, source: err.path.to_s
   }
 
@@ -38,10 +38,16 @@ end
 
 Sponsored by:
 
-[![Keygen logo](https://github.com/keygen-sh/typed_params/assets/6979737/f2947915-2956-4415-a9c0-5411c388ea96)](https://keygen.sh)
+<a href="https://keygen.sh?ref=typed_params">
+  <div>
+    <img src="https://keygen.sh/images/logo-pill.png" width="200" alt="Keygen">
+  </div>
+</a>
 
 _An open, source-available software licensing and distribution API._
 
+__
+
 Links:
 
 - [Installing `typed_params`](#installation)
@@ -52,6 +58,7 @@ Links:
   - [Query schemas](#query-schemas)
   - [Defining schemas](#defining-schemas)
   - [Shared schemas](#shared-schemas)
+  - [Namespaced schemas](#namespaced-schemas)
   - [Configuration](#configuration)
   - [Invalid parameters](#invalid-parameters)
   - [Unpermitted parameters](#unpermitted-parameters)
@@ -115,7 +122,7 @@ To start, include the controller module:
 class ApplicationController < ActionController::API
   include TypedParams::Controller
 
-  rescue_from TypedParams::InvalidParameterError, -> err {
+  rescue_from TypedParams::InvalidParameterError, with: -> err {
     render_bad_request err.message, source: err.path.to_s
   }
 end
@@ -266,13 +273,28 @@ class PostsController < ApplicationController
 end
 ```
 
-Named schemas can have an optional `:namespace` as well.
+### Namespaced schemas
+
+Schemas can have an optional `:namespace`. This can be especially useful when
+defining and sharing schemas across multiple versions of an API.
 
 ```ruby
-typed_schema :post, namespace: :v1 do
-  param :title, type: :string, length: { within: 10..80 }
-  param :content, type: :string, length: { minimum: 100 }
-  param :author_id, type: :integer
+class PostsController < ApplicationController
+  typed_schema :post, namespace: :v1 do
+    param :title, type: :string, length: { within: 10..80 }
+    param :content, type: :string, length: { minimum: 100 }
+    param :author_id, type: :integer
+  end
+
+  typed_params schema: %i[v1 post]
+  def create
+    # ...
+  end
+
+  typed_params schema: %i[v1 post]
+  def update
+    # ...
+  end
 end
 ```
 
@@ -345,7 +367,7 @@ TypedParams.configure do |config|
   #
   # With an invalid `child_key`, the path would be:
   #
-  #   rescue_from TypedParams::UnpermittedParameterError, -> err {
+  #   rescue_from TypedParams::UnpermittedParameterError, with: -> err {
   #     puts err.path.to_s # => parentKey.childKey
   #   }
   #
@@ -362,7 +384,7 @@ You can rescue this error at the controller-level like so:
 
 ```ruby
 class ApplicationController < ActionController::API
-  rescue_from TypedParams::InvalidParameterError, -> err {
+  rescue_from TypedParams::InvalidParameterError, with: -> err {
     render_bad_request "invalid parameter: #{err.message}", parameter: err.path.to_dot_notation
   }
 end
@@ -388,7 +410,7 @@ You can rescue this error at the controller-level like so:
 ```ruby
 class ApplicationController < ActionController::API
   # NOTE: Should be rescued before TypedParams::InvalidParameterError
-  rescue_from TypedParams::UnpermittedParameterError, -> err {
+  rescue_from TypedParams::UnpermittedParameterError, with: -> err {
     render_bad_request "unpermitted parameter: #{err.path.to_jsonapi_pointer}"
   }
 end
@@ -621,9 +643,18 @@ The lambda must return a tuple with the new key and value.
 #### Validate parameter
 
 Define a custom validation for the parameter, outside of the default
-validations.
+validations. The can be useful for defining mutually exclusive params,
+or even validating that an ID exists before proceeding.
 
 ```ruby
+# Mutually exclusive params (i.e. either-or, not both)
+param :login, type: :hash, validate: -> v { v.key?(:username) ^ v.key?(:email) } do
+  param :username, type: :string, optional: true
+  param :email, type: :string, optional: true
+  param :password, type: :string
+end
+
+# Assert user exists
 param :user, type: :integer, validate: -> id {
   User.exists?(id)
 }
@@ -633,6 +664,15 @@ The lambda should accept a value and return a boolean. When the boolean
 evaluates to `false`, a `TypedParams::InvalidParameterError` will
 be raised.
 
+To customize the error message, the lambda can raise a `TypedParams::ValidationError`
+error:
+
+```ruby
+param :invalid, type: :string, validate: -> v {
+  raise TypedParams::ValidationError, 'is always invalid'
+}
+```
+
 ### Shared options
 
 You can define a set of options that will be applied to immediate
@@ -708,7 +748,7 @@ which may be a nested schema.
 ```ruby
 # array of hashes
 param :boundless_array, type: :array do
-  item type: :hash do
+  items type: :hash do
     # ...
   end
 end

data/lib/typed_params/controller.rb

@@ -3,15 +3,19 @@
 require 'typed_params/handler'
 require 'typed_params/handler_set'
 require 'typed_params/schema_set'
+require 'typed_params/memoize'
 
 module TypedParams
   module Controller
     extend ActiveSupport::Concern
 
     included do
+      include Memoize
+
       cattr_accessor :typed_handlers, default: HandlerSet.new
       cattr_accessor :typed_schemas,  default: SchemaSet.new
 
+      memoize
       def typed_params(format: AUTO)
         handler = typed_handlers.params[self.class, action_name.to_sym]
 
@@ -42,6 +46,7 @@ module TypedParams
         )
       end
 
+      memoize
       def typed_query(format: AUTO)
         handler = typed_handlers.query[self.class, action_name.to_sym]
 

data/lib/typed_params/memoize.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Memoize
+    def self.included(klass) = klass.extend ClassMethods
+
+    module ClassMethods
+      cattr_accessor :memoize_queue, default: []
+
+      def memoize
+        if memoize_queue.include?(self)
+          memoize_queue.clear
+
+          raise RuntimeError, 'memoize cannot be called more than once in succession'
+        end
+
+        memoize_queue << self
+      end
+
+      private
+
+      def singleton_method_added(method_name)
+        while klass = memoize_queue.shift
+          raise RuntimeError, "memoize cannot be instrumented more than once for class method #{method_name}" if
+            klass.respond_to?(:"unmemoized_#{method_name}")
+
+          method_visibility = case
+                              when klass.singleton_class.private_method_defined?(method_name)
+                                :private
+                              when klass.singleton_class.protected_method_defined?(method_name)
+                                :protected
+                              when klass.singleton_class.public_method_defined?(method_name)
+                                :public
+                              end
+
+          klass.singleton_class.send(:alias_method, :"unmemoized_#{method_name}", method_name)
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{method_name}(*args, **kwargs, &block)
+              key = args.hash ^ kwargs.hash ^ block.hash
+
+              return @_memoized_#{method_name}_values[key] if
+                defined?(@_memoized_#{method_name}_values) && @_memoized_#{method_name}_values.key?(key)
+
+              value     = unmemoized_#{method_name}(*args, **kwargs, &block)
+              memo      = @_memoized_#{method_name}_values ||= {}
+              memo[key] = value
+
+              value
+            end
+          RUBY
+
+          klass.singleton_class.send(method_visibility, method_name)
+        end
+
+        super
+      ensure
+        memoize_queue.clear
+      end
+
+      def method_added(method_name)
+        while klass = memoize_queue.shift
+          raise RuntimeError, "memoize cannot be instrumented more than once for instance method #{method_name}" if
+            klass.method_defined?(:"unmemoized_#{method_name}")
+
+          method_visibility = case
+                              when klass.private_method_defined?(method_name)
+                                :private
+                              when klass.protected_method_defined?(method_name)
+                                :protected
+                              when klass.public_method_defined?(method_name)
+                                :public
+                              end
+
+          klass.alias_method :"unmemoized_#{method_name}", method_name
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method_name}(*args, **kwargs, &block)
+              key = args.hash ^ kwargs.hash ^ block.hash
+
+              return @_memoized_#{method_name}_values[key] if
+                defined?(@_memoized_#{method_name}_values) && @_memoized_#{method_name}_values.key?(key)
+
+              value     = unmemoized_#{method_name}(*args, **kwargs, &block)
+              memo      = @_memoized_#{method_name}_values ||= {}
+              memo[key] = value
+
+              value
+            end
+          RUBY
+
+          klass.send(method_visibility, method_name)
+        end
+
+        super
+      ensure
+        memoize_queue.clear
+      end
+    end
+  end
+end

data/lib/typed_params/parameterizer.rb

@@ -31,8 +31,8 @@ module TypedParams
                 :parent
 
     def parameterize_array_schema(key:, value:)
-      return parameterize_value(key:, value:) if
-        value.nil?
+      return parameterize_value(key:, value:) unless
+        value.is_a?(Array)
 
       param = Parameter.new(key:, value: [], schema:, parent:)
 
@@ -56,8 +56,8 @@ module TypedParams
     end
 
     def parameterize_hash_schema(key:, value:)
-      return parameterize_value(key:, value:) if
-        value.nil?
+      return parameterize_value(key:, value:) unless
+        value.is_a?(Hash)
 
       param = Parameter.new(key:, value: {}, schema:, parent:)
 

data/lib/typed_params/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypedParams
-  VERSION = '1.0.2'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed_params
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Zeke Gabrielse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-08 00:00:00.000000000 Z
+date: 2023-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -63,6 +63,7 @@ files:
 - lib/typed_params/handler.rb
 - lib/typed_params/handler_set.rb
 - lib/typed_params/mapper.rb
+- lib/typed_params/memoize.rb
 - lib/typed_params/namespaced_set.rb
 - lib/typed_params/parameter.rb
 - lib/typed_params/parameterizer.rb