typed_params 1.0.3 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 440661d066c2dffa2f84361a952e7158ca7d56d16037ca2c937acb30f2f1cad6
-  data.tar.gz: ad9f0aad3b817b5fa5f99d6d9eaa9e8f73d556c037cd03207bdc10b51fb26e81
+  metadata.gz: ab9149f0354b3110bc3a5610b06785055ad0e3ec00cc5e352b2daef7be902178
+  data.tar.gz: a48c899da8bc5d9fa9ee1041a2e35ff8f2f942b9ff083f7bf42e18e34e7813a2
 SHA512:
-  metadata.gz: 5919d79cc5c6f4b8bc7c8b1f65520b04e7fb11632f3b20f50f1c99f9346602f2f471058d293da5e14709c6b5f95ae2f1b1ddf04fa3c235b1314ef701333b568d
-  data.tar.gz: dea4d641834d9ae1184cdcc5653f1d04bdca18650d787d3557991ab03219ebc2234b36e9edaa9bd7733466852538491e3ad42e93029d9a748c7cea5a4b735105
+  metadata.gz: 4dabec975049677e23ab38f91c121f8f83a2dab36b753c9ad58f0693ad31ce780122b503b4b7554f6afe36568e3a85ef8c4d559591a8205bbadc9740e5cfd4b9
+  data.tar.gz: a4c8be23f0472002c9e317924091b624ac7cd640f08bfc515f61db119b72d20d6312919a4f45b31b14560d8bde08dad55467be058422acd4f39e225b927fd539

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.1.1
+
+- Fix compatibility with Ruby 3.3.0 due to [#20091](https://bugs.ruby-lang.org/issues/20091).
+
+## 1.1.0
+
+- Add memoization to `#typed_params` and `#typed_query` methods.
+
 ## 1.0.3
 
 - Revert 0b0aaa6b66edd3e4c3336e51fa340592e7ef9e86.
@@ -18,4 +26,4 @@
 
 ## 0.2.0
 
-- Test release.
+- Test release.

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)
@@ -103,6 +110,7 @@ _We're working on improving the docs._
 - Reuse schemas across controllers by defining named schemas.
 - Run validations on params, similar to active model validations.
 - Run transforms on params before they hit your controller.
+- Support formatters such as JSON:API.
 
 ## Usage
 
@@ -115,7 +123,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 +274,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 +368,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 +385,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 +411,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 +644,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 +665,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 +749,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/mapper.rb

@@ -47,7 +47,7 @@ module TypedParams
     #   │ 1 ││ 2 │     │ 5 │
     #   └───┘└───┘     └───┘
     #
-    def depth_first_map(param, &)
+    def depth_first_map(param, &block)
       return if param.nil?
 
       # Postorder DFS, so we'll visit the children first.
@@ -55,12 +55,12 @@ module TypedParams
         case param.schema.children
         in Array if param.array?
           if param.schema.indexed?
-            param.schema.children.each_with_index { |v, i| self.class.call(param[i], schema: v, controller:, &) }
+            param.schema.children.each_with_index { |v, i| self.class.call(param[i], schema: v, controller:, &block) }
           else
-            param.value.each { |v| self.class.call(v, schema: param.schema.children.first, controller:, &) }
+            param.value.each { |v| self.class.call(v, schema: param.schema.children.first, controller:, &block) }
           end
         in Hash if param.hash?
-          param.schema.children.each { |k, v| self.class.call(param[k], schema: v, controller:, &) }
+          param.schema.children.each { |k, v| self.class.call(param[k], schema: v, controller:, &block) }
         else
         end
       end

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/schema.rb

@@ -211,7 +211,7 @@ module TypedParams
 
     ##
     # params defines multiple like-parameters for a hash schema.
-    def params(*keys, **kwargs, &) = keys.each { param(_1, **kwargs, &) }
+    def params(*keys, **kwargs, &block) = keys.each { param(_1, **kwargs, &block) }
 
     ##
     # item defines an indexed parameter for an array schema.

data/lib/typed_params/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed_params
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.1
 platform: ruby
 authors:
 - Zeke Gabrielse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-08 00:00:00.000000000 Z
+date: 2024-01-01 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