parametric 0.2.16 → 0.2.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f6f417ecf3ae9196ec9dc4757df98b21716c71ee43909e7f47a12d0885c983a
-  data.tar.gz: aae3258b0c564f98554a6de742aec9f25279c4352180c09b109add7587ab2977
+  metadata.gz: 403aac3495b3e90bc32cf01c0229b83497d37413fb43b6180c3dafd0a9ec36b9
+  data.tar.gz: a8396d8ab3831e7c93d1643f96562ff0d5fe1ddaa8794dfe7ed8993bd4732cd5
 SHA512:
-  metadata.gz: fffc57a0087500348370a0f4fe71744076eed77c9493e16638e21a457af66bc381865630bee84374c164b41909396e150e2e991480f97b2d8cac2017e512b84c
-  data.tar.gz: 8d24b5272d916ea58a1aa1f425d0261d948fe2c83957ec39a4156795de636f8c9a8e0e2fce1e166bb0a0f669c1ead5d864a65295b50ad7fb1f1d5077a450dc48
+  metadata.gz: dbd04349edf7e8f4777ef7c681ec8f16d2cf570d915088fae04942760415d9fd88123741b68957839b21d7145d97b83b6cf6911fce5f0e2db806d34a304e1a0d
+  data.tar.gz: 9851e0d8f4e5e48d38870027c8a987fbf65f264a8c9dfaafe74080ff463e3783267f605eae09ce65b1f43547a27935ae532fd75120d60823fd24e8bf09bd0c4d

data/README.md

@@ -127,6 +127,60 @@ person_schema = Parametric::Schema.new do |sc, options|
   sc.field(:friends).type(:array).schema(friends_schema)
 end
 ```
+
+## Tagged One Of (multiple nested schemas, discriminated by payload key).
+
+You can use `Field#tagged_one_of` to resolve a nested schema based on the value of a top-level field.
+
+```ruby
+user_schema = Parametric::Schema.new do |sc, _|
+  field(:name).type(:string).present
+  field(:age).type(:integer).present
+end
+
+company_schema = Parametric::Schema.new do
+  field(:name).type(:string).present
+  field(:company_code).type(:string).present
+end
+
+schema = Parametric::Schema.new do |sc, _|
+  # Use :type field to locate the sub-schema to use for :sub
+  sc.field(:type).type(:string)
+
+  # Use the :one_of policy to select the sub-schema based on the :type field above
+  sc.field(:sub).type(:object).tagged_one_of do |sub|
+    sub.index_by(:type)
+    sub.on('user', user_schema)
+    sub.on('company', company_schema)
+  end
+end
+
+# The schema will now select the correct sub-schema based on the value of :type
+result = schema.resolve(type: 'user', sub: { name: 'Joe', age: 30 })
+
+# Instances can also be created separately and used as a policy:
+
+UserOrCompany = Parametric::TaggedOneOf.new do |sc, _|
+  sc.on('user', user_schema)
+  sc.on('company', company_schema)
+end
+
+schema = Parametric::Schema.new do |sc, _|
+  sc.field(:type).type(:string)
+  sc.field(:sub).type(:object).policy(UserOrCompany.index_by(:type))
+end
+```
+
+`#index_by` can take a block to decide what value to resolve schemas by:
+
+```ruby
+sc.field(:sub).type(:object).tagged_one_of do |sub|
+  sub.index_by { |payload| payload[:entity_type] }
+  sub.on('user', user_schema)
+  sub.on('company', company_schema)
+end
+```
+
 ## Built-in policies
 
 Type coercions (the `type` method) and validations (the `validate` method) are all _policies_.
@@ -275,62 +329,106 @@ Useful for parsing comma-separated query-string parameters.
 field(:status).policy(:split) # turns "pending,confirmed" into ["pending", "confirmed"]
 ```
 
+### :value
+
+A policy to return a static value
+
+```ruby
+field(:currency).policy(:value, 'gbp') # this field always resolves to 'gbp'
+```
+
 ## Custom policies
 
-You can also register your own custom policy objects. A policy must implement the following methods:
+You can also register your own custom policy objects.
+A policy consist of the following:
+
+* A `PolicyFactory` interface:
 
 ```ruby
 class MyPolicy
-  # Validation error message, if invalid
-  def message
-    'is invalid'
+  # Initializer signature is up to you.
+  # These are the arguments passed to the policy when using in a Field,
+  # ex. field(:name).policy(:my_policy, 'arg1', 'arg2')
+  def initialize(arg1, arg2)
+    @arg1, @arg2 = arg1, arg2
   end
 
-  # Whether or not to validate and coerce this value
-  # if false, no other policies will be run on the field
-  def eligible?(value, key, payload)
-    true
+  # @return [Hash]
+  def meta_data
+   { type: :string }
+  end
+
+  # Buld a Policy Runner, which is instantiated
+  # for each field when resolving a schema
+  # @param key [Symbol]
+  # @param value [Any]
+  # @option payload [Hash]
+  # @option context [Parametric::Context]
+  # @return [PolicyRunner]
+  def build(key, value, payload:, context:)
+    MyPolicyRunner.new(key, value, payload, context)
+  end
+end
+```
+
+* A `PolicyRunner` interface.
+
+```ruby
+class MyPolicyRunner
+  # Initializer is up to you. See `MyPolicy#build`
+  def initialize(key, value, payload, context)
+
   end
 
-  # Transform the value
-  def coerce(value, key, context)
-    value
+  # Should this policy run at all?
+  # returning [false] halts the field policy chain.
+  # @return [Boolean]
+  def eligible?
+    true
   end
 
-  # Is the value valid?
-  def valid?(value, key, payload)
+  # If [false], add [#message] to result errors and halt processing field.
+  # @return [Boolean]
+  def valid?
     true
   end
 
-  # merge this object into the field's meta data
-  def meta_data
-    {type: :string}
+  # Coerce the value, or return as-is.
+  # @return [Any]
+  def value
+    @value
+  end
+
+  # Error message for this policy
+  # @return [String]
+  def message
+    "#{@value} is invalid"
   end
 end
 ```
 
-You can register your policy with:
+Then register your custom policy factory:
 
 ```ruby
-Parametric.policy :my_policy, MyPolicy
+Parametric.policy :my_polict, MyPolicy
 ```
 
 And then refer to it by name when declaring your schema fields
 
 ```ruby
-field(:title).policy(:my_policy)
+field(:title).policy(:my_policy, 'arg1', 'arg2')
 ```
 
 You can chain custom policies with other policies.
 
 ```ruby
-field(:title).required.policy(:my_policy)
+field(:title).required.policy(:my_policy, 'arg1', 'arg2')
 ```
 
 Note that you can also register instances.
 
 ```ruby
-Parametric.policy :my_policy, MyPolicy.new
+Parametric.policy :my_policy, MyPolicy.new('arg1', 'arg2')
 ```
 
 For example, a policy that can be configured on a field-by-field basis:
@@ -341,27 +439,34 @@ class AddJobTitle
     @job_title = job_title
   end
 
-  def message
-    'is invalid'
+  def build(key, value, payload:, context:)
+    Runner.new(@job_title, key, value, payload, context)
   end
 
-  # Noop
-  def eligible?(value, key, payload)
-    true
+  def meta_data
+    {}
   end
 
-  # Add job title to value
-  def coerce(value, key, context)
-    "#{value}, #{@job_title}"
-  end
+  class Runner
+    attr_reader :message
 
-  # Noop
-  def valid?(value, key, payload)
-    true
-  end
+    def initialize(job_title, key, value, payload, _context)
+      @job_title = job_title
+      @key, @value, @payload = key, value, payload
+      @message = 'is invalid'
+    end
 
-  def meta_data
-    {}
+    def eligible?
+      true
+    end
+
+    def valid?
+      true
+    end
+
+    def value
+      "#{@value}, #{@job_title}"
+    end
   end
 end
 

data/lib/parametric/field.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'delegate'
-require "parametric/field_dsl"
+require 'parametric/field_dsl'
+require 'parametric/policy_adapter'
+require 'parametric/tagged_one_of'
 
 module Parametric
   class ConfigurationError < StandardError; end
@@ -40,6 +42,10 @@ module Parametric
     end
     alias_method :type, :policy
 
+    def tagged_one_of(instance = nil, &block)
+      policy(instance || Parametric::TaggedOneOf.new(&block))
+    end
+
     def schema(sc = nil, &block)
       sc = (sc ? sc : Schema.new(&block))
       meta schema: sc
@@ -61,7 +67,7 @@ module Parametric
 
     def visit(meta_key = nil, &visitor)
       if sc = meta_data[:schema]
-        r = sc.visit(meta_key, &visitor)
+        r = sc.schema.visit(meta_key, &visitor)
         (meta_data[:type] == :array) ? [r] : r
       else
         meta_key ? meta_data[meta_key] : yield(self)
@@ -79,20 +85,26 @@ module Parametric
       end
 
       policies.each do |policy|
-        if !policy.eligible?(value, key, payload)
-          eligible = false
-          if has_default?
-            eligible = true
-            value = default_block.call(key, payload, context)
+        begin
+          pol = policy.build(key, value, payload:, context:)
+          if !pol.eligible?
+            eligible = false
+            if has_default?
+              eligible = true
+              value = default_block.call(key, payload, context)
+            end
+            break
+          else
+            value = pol.value
+            if !pol.valid?
+              eligible = true # eligible, but has errors
+              context.add_error pol.message
+              break # only one error at a time
+            end
           end
+        rescue StandardError => e
+          context.add_error e.message
           break
-        else
-          value = resolve_one(policy, value, context)
-          if !policy.valid?(value, key, payload)
-            eligible = true # eligible, but has errors
-            context.add_error policy.message
-            break # only one error at a time
-          end
         end
       end
 
@@ -107,15 +119,6 @@ module Parametric
 
     attr_reader :registry, :default_block
 
-    def resolve_one(policy, value, context)
-      begin
-        policy.coerce(value, key, context)
-      rescue StandardError => e
-        context.add_error e.message
-        value
-      end
-    end
-
     def has_default?
       !!default_block && !meta_data[:skip_default]
     end
@@ -127,6 +130,7 @@ module Parametric
 
       obj = obj.new(*args) if obj.respond_to?(:new)
       obj = PolicyWithKey.new(obj, key)
+      obj = PolicyAdapter.new(obj) unless obj.respond_to?(:build)
 
       obj
     end

data/lib/parametric/policies.rb

@@ -26,6 +26,31 @@ module Parametric
         {}
       end
     end
+
+    class Value
+      attr_reader :message
+
+      def initialize(val, msg = 'invalid value')
+        @message = msg
+        @val = val
+      end
+
+      def eligible?(value, key, payload)
+        payload.key?(key)
+      end
+
+      def coerce(_value, _key, _context)
+        @val
+      end
+
+      def valid?(value, key, payload)
+        !payload.key?(key) || !!(value == @val)
+      end
+
+      def meta_data
+        { value: @val }
+      end
+    end
   end
 
   # Default validators
@@ -33,6 +58,7 @@ module Parametric
 
   Parametric.policy :format, Policies::Format
   Parametric.policy :email, Policies::Format.new(EMAIL_REGEXP, 'invalid email')
+  Parametric.policy :value, Policies::Value
 
   Parametric.policy :noop do
     eligible do |value, key, payload|

data/lib/parametric/policy_adapter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Parametric
+  # Adapt legacy policies to the new policy interface
+  class PolicyAdapter
+    class PolicyRunner
+      def initialize(policy, key, value, payload, context)
+        @policy, @key, @raw_value, @payload, @context = policy, key, value, payload, context
+      end
+
+      # The PolicyRunner interface
+      # @return [Boolean]
+      def eligible?
+        @policy.eligible?(@raw_value, @key, @payload)
+      end
+
+      # @return [Boolean]
+      def valid?
+        @policy.valid?(value, @key, @payload)
+      end
+
+      # @return [Any]
+      def value
+        @value ||= @policy.coerce(@raw_value, @key, @context)
+      end
+
+      # @return [String]
+      def message
+        @policy.message
+      end
+    end
+
+    def initialize(policy)
+      @policy = policy
+    end
+
+    # The PolicyFactory interface
+    # Buld a Policy Runner, which is instantiated
+    # for each field when resolving a schema
+    # @param key [Symbol]
+    # @param value [Any]
+    # @option payload [Hash]
+    # @option context [Parametric::Context]
+    # @return [PolicyRunner]
+    def build(key, value, payload:, context:)
+      PolicyRunner.new(@policy, key, value, payload, context)
+    end
+
+    def meta_data
+      @policy.meta_data
+    end
+
+    def key
+      @policy.key
+    end
+  end
+end

data/lib/parametric/schema.rb

@@ -75,7 +75,7 @@ module Parametric
       fields.each_with_object({}) do |(_, field), obj|
         meta = field.meta_data.dup
         sc = meta.delete(:schema)
-        meta[:structure] = sc.structure if sc
+        meta[:structure] = sc.schema.structure if sc
         obj[field.key] = meta
       end
     end

data/lib/parametric/tagged_one_of.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Parametric
+  # A policy that allows you to select a sub-schema based on a value in the payload.
+  # @example
+  #
+  #   user_schema = Parametric::Schema.new do |sc, _|
+  #     field(:name).type(:string).present
+  #     field(:age).type(:integer).present
+  #   end
+  #
+  #   company_schema = Parametric::Schema.new do
+  #     field(:name).type(:string).present
+  #     field(:company_code).type(:string).present
+  #   end
+  #
+  #   schema = Parametric::Schema.new do |sc, _|
+  #      # Use :type field to locate the sub-schema to use for :sub
+  #      sc.field(:type).type(:string)
+  #
+  #      # Use the :one_of policy to select the sub-schema based on the :type field above
+  #      sc.field(:sub).type(:object).tagged_one_of do |sub|
+  #        sub.index_by(:type)
+  #        sub.on('user', user_schema)
+  #        sub.on('company', company_schema)
+  #      end
+  #    end
+  #
+  #    # The schema will now select the correct sub-schema based on the value of :type
+  #    result = schema.resolve(type: 'user', sub: { name: 'Joe', age: 30 })
+  #
+  # Instances can also be created separately and used as a policy:
+  # @example
+  #
+  #   UserOrCompany = Parametric::TaggedOneOf.new do |sc, _|
+  #     sc.on('user', user_schema)
+  #     sc.on('company', company_schema)
+  #   end
+  #
+  #   schema = Parametric::Schema.new do |sc, _|
+  #     sc.field(:type).type(:string)
+  #     sc.field(:sub).type(:object).policy(UserOrCompany.index_by(:type))
+  #   end
+  class TaggedOneOf
+    NOOP_INDEX = ->(payload) { payload }.freeze
+    def initialize(index: NOOP_INDEX, matchers: {}, &block)
+      @index = index
+      @matchers = matchers
+      @configuring = false
+      if block_given?
+        @configuring = true
+        block.call(self)
+        @configuring = false
+      end
+      freeze
+    end
+
+    def index_by(callable = nil, &block)
+      if callable.is_a?(Symbol)
+        key = callable
+        callable = ->(payload) { payload[key] }
+      end
+      index = callable || block
+      if configuring?
+        @index = index
+      else
+        self.class.new(index:, matchers: @matchers)
+      end
+    end
+
+    def on(key, schema)
+      @matchers[key] = schema
+    end
+
+    # The [PolicyFactory] interface
+    def build(key, value, payload:, context:)
+      Runner.new(@index, @matchers, key, value, payload, context)
+    end
+
+    def meta_data
+      { type: :object, one_of: @matchers }
+    end
+
+    private def configuring?
+      @configuring
+    end
+
+    class Runner
+      def initialize(index, matchers, key, value, payload, context)
+        @matchers = matchers
+        @key = key
+        @raw_value = value
+        @payload = payload
+        @context = context
+        @index_value = index.call(payload)
+      end
+
+      # Should this policy run at all?
+      # returning [false] halts the field policy chain.
+      # @return [Boolean]
+      def eligible?
+        true
+      end
+
+      # If [false], add [#message] to result errors and halt processing field.
+      # @return [Boolean]
+      def valid?
+        has_sub_schema?
+      end
+
+      # Coerce the value, or return as-is.
+      # @return [Any]
+      def value
+        @value ||= has_sub_schema? ? sub_schema.coerce(@raw_value, @key, @context) : @raw_value
+      end
+
+      # Error message for this policy
+      # @return [String]
+      def message
+        "#{@value} is invalid. No sub-schema found for '#{@index_value}'"
+      end
+
+      private
+
+      def has_sub_schema?
+        @matchers.key?(@index_value)
+      end
+
+      def sub_schema
+        @sub_schema ||= @matchers[@index_value]
+      end
+    end
+  end
+end

data/lib/parametric/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parametric
-  VERSION = '0.2.16'
+  VERSION = '0.2.18'
 end

data/parametric.gemspec

@@ -18,6 +18,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", '3.4.0'
+  spec.add_development_dependency "rspec", '3.12.0'
   spec.add_development_dependency "byebug"
 end

data/spec/field_spec.rb

@@ -264,6 +264,16 @@ describe Parametric::Field do
     end
   end
 
+  describe ":value policy" do
+    it 'always resolves to static value' do
+      resolve(subject.policy(:value, 'hello'), a_key: "tag1,tag2").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq 'hello'
+      end
+    end
+  end
+
   describe ":declared policy" do
     it "is eligible if key exists" do
       resolve(subject.policy(:declared).present, a_key: "").tap do |r|

data/spec/schema_spec.rb

@@ -251,6 +251,64 @@ describe Parametric::Schema do
     end
   end
 
+  describe '#tagged_one_of for multiple sub-schemas' do
+    let(:user_schema) do
+      described_class.new do
+        field(:name).type(:string).present
+        field(:age).type(:integer).present
+      end
+    end
+
+    let(:company_schema) do
+      described_class.new do
+        field(:name).type(:string).present
+        field(:company_code).type(:string).present
+      end
+    end
+
+    it 'picks the right sub-schema' do
+      schema = described_class.new do |sc, _|
+        sc.field(:type).type(:string)
+        sc.field(:sub).type(:object).tagged_one_of do |sub|
+          sub.index_by(:type)
+          sub.on('user', user_schema)
+          sub.on('company', company_schema)
+        end
+      end
+
+      result = schema.resolve(type: 'user', sub: { name: 'Joe', age: 30 })
+      expect(result.valid?).to be true
+      expect(result.output).to eq({ type: 'user', sub: { name: 'Joe', age: 30 } })
+
+      result = schema.resolve(type: 'company', sub: { name: 'ACME', company_code: 123 })
+      expect(result.valid?).to be true
+      expect(result.output).to eq({ type: 'company', sub: { name: 'ACME', company_code: '123' } })
+
+      result = schema.resolve(type: 'company', sub: { name: nil, company_code: 123 })
+      expect(result.valid?).to be false
+      expect(result.errors['$.sub.name']).not_to be_empty
+
+      result = schema.resolve(type: 'foo', sub: { name: 'ACME', company_code: 123 })
+      expect(result.valid?).to be false
+    end
+
+    it 'can be assigned to instance and reused' do
+      user_or_company = Parametric::TaggedOneOf.new do |sub|
+        sub.on('user', user_schema)
+        sub.on('company', company_schema)
+      end
+
+      schema = described_class.new do |sc, _|
+        sc.field(:type).type(:string)
+        sc.field(:sub).type(:object).tagged_one_of(user_or_company.index_by(:type))
+      end
+
+      result = schema.resolve(type: 'user', sub: { name: 'Joe', age: 30 })
+      expect(result.valid?).to be true
+      expect(result.output).to eq({ type: 'user', sub: { name: 'Joe', age: 30 } })
+    end
+  end
+
   describe "#ignore" do
     it "ignores fields" do
       s1 = described_class.new.ignore(:title, :status) do

data/spec/struct_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 require 'parametric/struct'
 
 describe Parametric::Struct do
-  it "works" do
-    friend_class = Class.new do
+  let(:friend_class) do
+    Class.new do
       include Parametric::Struct
 
       schema do
@@ -11,16 +11,19 @@ describe Parametric::Struct do
         field(:age).type(:integer)
       end
     end
+  end
+  let(:klass) do
+    Class.new.tap do |cl|
+      cl.send(:include, Parametric::Struct)
 
-    klass = Class.new do
-      include Parametric::Struct
-
-      schema do
-        field(:title).type(:string).present
-        field(:friends).type(:array).default([]).schema friend_class
+      cl.schema do |sc, _|
+        sc.field(:title).type(:string).present
+        sc.field(:friends).type(:array).default([]).schema friend_class
       end
     end
+  end
 
+  it "works" do
     new_instance = klass.new
     expect(new_instance.title).to eq ''
     expect(new_instance.friends).to eq []
@@ -57,6 +60,18 @@ describe Parametric::Struct do
     expect(invalid_instance.friends[1].errors['$.name']).not_to be_nil
   end
 
+  it 'supports #structure' do
+    st = klass.schema.structure
+    expect(st[:title][:type]).to eq(:string)
+    expect(st[:friends][:structure][:age][:type]).to eq(:integer)
+  end
+
+  it 'supports #walk' do
+    output = klass.schema.walk(:type).output
+    expect(output[:title]).to eq(:string)
+    expect(output[:friends][0][:name]).to eq(:string)
+  end
+
   it "is inmutable by default" do
     klass = Class.new do
       include Parametric::Struct
@@ -286,6 +301,9 @@ describe Parametric::Struct do
 
         schema do
           field(:title).type(:string).present
+          field(:consumption).type(:object).present.schema do
+            field(:type).present.options(%w[aaa bbb])
+          end
         end
       end
 
@@ -293,9 +311,10 @@ describe Parametric::Struct do
         klass.new!(title: '')
       rescue Parametric::InvalidStructError => e
         expect(e.errors['$.title']).not_to be nil
+        expect(e.errors['$.consumption']).not_to be nil
       end
 
-      valid = klass.new!(title: 'foo')
+      valid = klass.new!(title: 'foo', consumption: { type: 'aaa' })
       expect(valid.title).to eq 'foo'
     end
   end

data/spec/validators_spec.rb

@@ -9,6 +9,13 @@ describe 'default validators' do
     expect(validator.valid?(payload[key], key, payload)).to eq valid
   end
 
+  describe ':value' do
+    it {
+      test_validator({key: 'Foobar'}, :key, :value, true, true, 'Foobar')
+      test_validator({key: 'Nope'}, :key, :value, true, false, 'Foobar')
+    }
+  end
+
   describe ':format' do
     it {
       test_validator({key: 'Foobar'}, :key, :format, true, true, /^Foo/)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parametric
 version: !ruby/object:Gem::Version
-  version: 0.2.16
+  version: 0.2.18
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-09 00:00:00.000000000 Z
+date: 2023-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.4.0
+        version: 3.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.4.0
+        version: 3.12.0
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -77,10 +77,12 @@ files:
 - lib/parametric/field.rb
 - lib/parametric/field_dsl.rb
 - lib/parametric/policies.rb
+- lib/parametric/policy_adapter.rb
 - lib/parametric/registry.rb
 - lib/parametric/results.rb
 - lib/parametric/schema.rb
 - lib/parametric/struct.rb
+- lib/parametric/tagged_one_of.rb
 - lib/parametric/version.rb
 - parametric.gemspec
 - spec/custom_block_validator_spec.rb
@@ -113,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.18
 signing_key:
 specification_version: 4
 summary: DSL for declaring allowed parameters with options, regexp patern and default