parametric 0.2.9 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e5e99f35e7a900299c8ca79bf1edecc57a73209c8fab7c292ef5fff11f1e467
-  data.tar.gz: a28ad622475c98957079ee5a000c02f91b1df05c6f3fd9492bcdfd10a6751edc
+  metadata.gz: 40164472fa5f68d604b2f20b6823b4b7c0ca81136c46826705d3a3a4b2e903f2
+  data.tar.gz: 1bce90d98794e1cc1a169bea9ff0b6d606486a9a2e33b95b0e461cfaae567c63
 SHA512:
-  metadata.gz: 86bcd5fcd359872f8eab2b23206bd359b13ab1363d5b7d29eb8ef9899ed421605d3be10cbf4841d2791eeecf46de8292e63d97180c799ae2febb0c955b054c92
-  data.tar.gz: b767db9489841a70489812bd51be1bb167de8a87b9c91a4f21cb82201d7023ed5e0a05747d853332f936bb0d05f2e3be44d6ed64c6bd24820fb19da1902c708f
+  metadata.gz: 0b93f931277e786ea4f6a39d2db2a8152be14a9887c4a31bfb54a38c5127c85bf43b6e35e442b4b9cc40531879d5638ed234b4e62102cffb23c5b2bf12552c6e
+  data.tar.gz: ca54de8f1cc1aaf4b0cb4805197e634ab07ecabf31cab56a54e3fca330312c3b247a984d5efabef9350729008e1f319730a74b1b068f6685eb6f9c74ddda71aa

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in parametric.gemspec
 gemspec
+
+group :development do
+  gem 'benchmark-ips'
+end

data/README.md

@@ -849,6 +849,130 @@ results.errors["$.Weight"] # => ["is required and value must be present"]
 
 NOTES: dynamically expanded field names are not included in `Schema#structure` metadata, and they are only processes if fields with the given expressions are present in the payload. This means that validations applied to those fields only run if keys are present in the first place.
 
+## Before and after resolve hooks
+
+`Schema#before_resolve` can be used to register blocks to modify the entire input payload _before_ individual fields are validated and coerced.
+This can be useful when you need to pre-populate fields relative to other fields' values, or fetch extra data from other sources.
+
+```ruby
+# This example computes the value of the :slug field based on :name
+schema = Parametric::Schema.new do
+  # Note1: These blocks run before field validations, so :name might be blank or invalid at this point.
+  # Note2: Before hooks _must_ return a payload hash.
+  before_resolve do |payload, context|
+    payload.merge(
+      slug: payload[:name].to_s.downcase.gsub(/\s+/, '-')
+    )
+  end
+
+  # You still need to define the fields you want
+  field(:name).type(:string).present
+  field(:slug).type(:string).present
+end
+
+result = schema.resolve( name: 'Joe Bloggs' )
+result.output # => { name: 'Joe Bloggs', slug: 'joe-bloggs' }
+```
+
+Before hooks can be added to nested schemas, too:
+
+```ruby
+schema = Parametric::Schema.new do
+  field(:friends).type(:array).schema do
+    before_resolve do |friend_payload, context|
+      friend_payload.merge(title: "Mr/Ms #{friend_payload[:name]}")
+    end
+
+    field(:name).type(:string)
+    field(:title).type(:string)
+  end
+end
+```
+
+You can use inline blocks, but anything that responds to `#call(payload, context)` will work, too:
+
+```ruby
+class SlugMaker
+  def initialize(slug_field, from:)
+    @slug_field, @from = slug_field, from
+  end
+
+  def call(payload, context)
+    payload.merge(
+      @slug_field => payload[@from].to_s.downcase.gsub(/\s+/, '-')
+    )
+  end
+end
+
+schema = Parametric::Schema.new do
+  before_resolve SlugMaker.new(:slug, from: :name)
+
+  field(:name).type(:string)
+  field(:slug).type(:slug)
+end
+```
+
+The `context` argument can be used to add custom validation errors in a before hook block.
+
+```ruby
+schema = Parametric::Schema.new do
+  before_resolve do |payload, context|
+    # validate that there's no duplicate friend names
+    friends = payload[:friends] || []
+    if friends.any? && friends.map{ |fr| fr[:name] }.uniq.size < friends.size
+      context.add_error 'friend names must be unique'
+    end
+
+    # don't forget to return the payload
+    payload
+  end
+
+  field(:friends).type(:array).schema do
+    field(:name).type(:string)
+  end
+end
+
+result = schema.resolve(
+  friends: [
+    {name: 'Joe Bloggs'},
+    {name: 'Joan Bloggs'},
+    {name: 'Joe Bloggs'}
+  ]
+)
+
+result.valid? # => false
+result.errors # => {'$' => ['friend names must be unique']}
+```
+
+In most cases you should be validating individual fields using field policies. Only validate in before hooks in cases you have dependencies between fields.
+
+`Schema#after_resolve` takes the sanitized input hash, and can be used to further validate fields that depend on eachother.
+
+```ruby
+schema = Parametric::Schema.new do
+  after_resolve do |payload, ctx|
+    # Add a top level error using an arbitrary key name
+    ctx.add_base_error('deposit', 'cannot be greater than house price') if payload[:deposit] > payload[:house_price]
+    # Or add an error keyed after the current position in the schema
+    # ctx.add_error('some error') if some_condition
+    # after_resolve hooks must also return the payload, or a modified copy of it
+    # note that any changes added here won't be validated.
+    payload.merge(desc: 'hello')
+  end
+
+  field(:deposit).policy(:integer).present
+  field(:house_price).policy(:integer).present
+  field(:desc).policy(:string)
+end
+
+result = schema.resolve({ deposit: 1100, house_price: 1000 })
+result.valid? # false
+result.errors[:deposit] # ['cannot be greater than house price']
+result.output[:deposit] # 1100
+result.output[:house_price] # 1000
+result.output[:desc] # 'hello'
+```
+
 ## Structs
 
 Structs turn schema definitions into objects graphs with attribute readers.

data/bench/struct_bench.rb

@@ -0,0 +1,53 @@
+require 'benchmark/ips'
+require 'parametric/struct'
+
+StructAccount = Struct.new(:id, :email, keyword_init: true)
+StructFriend = Struct.new(:name, keyword_init: true)
+StructUser = Struct.new(:name, :age, :friends, :account, keyword_init: true)
+
+class ParametricAccount
+  include Parametric::Struct
+  schema do
+    field(:id).type(:integer).present
+    field(:email).type(:string)
+  end
+end
+
+class ParametricUser
+  include Parametric::Struct
+  schema do
+    field(:name).type(:string).present
+    field(:age).type(:integer).default(42)
+    field(:friends).type(:array).schema do
+      field(:name).type(:string).present
+    end
+    field(:account).type(:object).schema ParametricAccount
+  end
+end
+
+Benchmark.ips do |x|
+  x.report("Struct") {
+    StructUser.new(
+      name: 'Ismael',
+      age: 42,
+      friends: [
+        StructFriend.new(name: 'Joe'),
+        StructFriend.new(name: 'Joan'),
+      ],
+      account: StructAccount.new(id: 123, email: 'my@account.com')
+    )
+  }
+  x.report("Parametric::Struct")  {
+    ParametricUser.new!(
+      name: 'Ismael',
+      age: 42,
+      friends: [
+        { name: 'Joe' },
+        { name: 'Joan' }
+      ],
+      account: { id: 123, email: 'my@account.com' }
+    )
+  }
+  x.compare!
+end
+

data/lib/parametric.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parametric/version"
 require "parametric/registry"
 require "parametric/field"

data/lib/parametric/block_validator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parametric
   class BlockValidator
     def self.build(meth, &block)
@@ -8,12 +10,12 @@ module Parametric
 
     def self.message(&block)
       @message_block = block if block_given?
-      @message_block
+      @message_block if instance_variable_defined?('@message_block')
     end
 
     def self.validate(&validate_block)
       @validate_block = validate_block if block_given?
-      @validate_block
+      @validate_block if instance_variable_defined?('@validate_block')
     end
 
     def self.coerce(&coerce_block)
@@ -23,12 +25,12 @@ module Parametric
 
     def self.eligible(&block)
       @eligible_block = block if block_given?
-      @eligible_block
+      @eligible_block if instance_variable_defined?('@eligible_block')
     end
 
     def self.meta_data(&block)
       @meta_data_block = block if block_given?
-      @meta_data_block
+      @meta_data_block if instance_variable_defined?('@meta_data_block')
     end
 
     attr_reader :message

data/lib/parametric/context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parametric
   class Top
     attr_reader :errors
@@ -26,6 +28,10 @@ module Parametric
       top.add_error(string_path, msg)
     end
 
+    def add_base_error(key, msg)
+      top.add_error(key, msg)
+    end
+
     def sub(key)
       self.class.new(path + [key], top)
     end
@@ -40,5 +46,4 @@ module Parametric
       end.join
     end
   end
-
 end

data/lib/parametric/default_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "date"
 
 module Parametric

data/lib/parametric/dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parametric"
 
 module Parametric

data/lib/parametric/field.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parametric/field_dsl"
 
 module Parametric
@@ -43,6 +45,15 @@ module Parametric
       policy sc.schema
     end
 
+    def from(another_field)
+      meta another_field.meta_data
+      another_field.policies.each do |plc|
+        policies << plc
+      end
+
+      self
+    end
+
     def visit(meta_key = nil, &visitor)
       if sc = meta_data[:schema]
         r = sc.visit(meta_key, &visitor)
@@ -83,8 +94,13 @@ module Parametric
       Result.new(eligible, value)
     end
 
+    protected
+
+    attr_reader :policies
+
     private
-    attr_reader :policies, :registry, :default_block
+
+    attr_reader :registry, :default_block
 
     def resolve_one(policy, value, context)
       begin

data/lib/parametric/field_dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parametric
   # Field DSL
   # host instance must implement:

data/lib/parametric/policies.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parametric
   module Policies
     class Format

data/lib/parametric/registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'parametric/block_validator'
 
 module Parametric

data/lib/parametric/results.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parametric
   class Results
     attr_reader :output, :errors

data/lib/parametric/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parametric/context"
 require "parametric/results"
 require "parametric/field"
@@ -12,6 +14,8 @@ module Parametric
       @default_field_policies = []
       @ignored_field_keys = []
       @expansions = {}
+      @before_hooks = []
+      @after_hooks = []
     end
 
     def schema
@@ -90,6 +94,20 @@ module Parametric
       end
     end
 
+    def before_resolve(klass = nil, &block)
+      raise ArgumentError, '#before_resolve expects a callable object, or a block' if !klass && !block_given?
+      callable = klass || block
+      before_hooks << callable
+      self
+    end
+
+    def after_resolve(klass = nil, &block)
+      raise ArgumentError, '#after_resolve expects a callable object, or a block' if !klass && !block_given?
+      callable = klass || block
+      after_hooks << callable
+      self
+    end
+
     def expand(exp, &block)
       expansions[exp] = block
       self
@@ -139,19 +157,35 @@ module Parametric
 
     protected
 
-    attr_reader :definitions, :options
+    attr_reader :definitions, :options, :before_hooks, :after_hooks
 
     private
 
     attr_reader :default_field_policies, :ignored_field_keys, :expansions
 
     def coerce_one(val, context, flds: fields)
-      flds.each_with_object({}) do |(_, field), m|
+      val = run_before_hooks(val, context)
+
+      out = flds.each_with_object({}) do |(_, field), m|
         r = field.resolve(val, context.sub(field.key))
         if r.eligible?
           m[field.key] = r.value
         end
       end
+
+      run_after_hooks(out, context)
+    end
+
+    def run_before_hooks(val, context)
+      before_hooks.reduce(val) do |value, callable|
+        callable.call(value, context)
+      end
+    end
+
+    def run_after_hooks(val, context)
+      after_hooks.reduce(val) do |value, callable|
+        callable.call(value, context)
+      end
     end
 
     class MatchContext

data/lib/parametric/struct.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'parametric/dsl'
 
 module Parametric
@@ -36,6 +38,10 @@ module Parametric
       _results.output.clone
     end
 
+    def [](key)
+      _results.output[key.to_sym]
+    end
+
     def ==(other)
       other.respond_to?(:to_h) && other.to_h.eql?(to_h)
     end
@@ -56,10 +62,24 @@ module Parametric
 
       # this hook is called after schema definition in DSL module
       def parametric_after_define_schema(schema)
-        schema.fields.keys.each do |key|
-          define_method key do
-            _graph[key]
+        schema.fields.values.each do |field|
+          if field.meta_data[:schema]
+            if field.meta_data[:schema].is_a?(Parametric::Schema)
+              klass = Class.new do
+                include Struct
+              end
+              klass.schema = field.meta_data[:schema]
+              self.const_set(__class_name(field.key), klass)
+              klass.parametric_after_define_schema(field.meta_data[:schema])
+            else
+              self.const_set(__class_name(field.key), field.meta_data[:schema])
+            end
           end
+          self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{field.key}
+              _graph[:#{field.key}]
+            end
+          RUBY
         end
       end
 
@@ -69,27 +89,11 @@ module Parametric
         end
       end
 
-      def parametric_build_class_for_child(key, child_schema)
-        klass = Class.new do
-          include Struct
-        end
-        klass.schema = child_schema
-        klass
-      end
-
       def wrap(key, value)
-        field = schema.fields[key]
-        return value unless field
-
         case value
         when Hash
           # find constructor for field
-          cons = field.meta_data[:schema]
-          if cons.kind_of?(Parametric::Schema)
-            klass = parametric_build_class_for_child(key, cons)
-            klass.parametric_after_define_schema(cons)
-            cons = klass
-          end
+          cons = self.const_get(__class_name(key))
           cons ? cons.new(value) : value.freeze
         when Array
           value.map{|v| wrap(key, v) }.freeze
@@ -97,6 +101,12 @@ module Parametric
           value.freeze
         end
       end
+
+      PLURAL_END = /s$/.freeze
+
+      def __class_name(key)
+        key.to_s.split('_').map(&:capitalize).join.sub(PLURAL_END, '')
+      end
     end
   end
 end

data/lib/parametric/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parametric
-  VERSION = "0.2.9"
+  VERSION = "0.2.14"
 end

data/parametric.gemspec

@@ -17,7 +17,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", '3.4.0'
   spec.add_development_dependency "byebug"

data/spec/field_spec.rb

@@ -112,6 +112,20 @@ describe Parametric::Field do
     end
   end
 
+  describe '#from' do
+    it 'copies policies and metadata from an existing field' do
+      subject.policy(:string).present.options(['a', 'b', 'c'])
+
+      field = described_class.new(:another_key, registry).from(subject)
+      resolve(field, another_key: "abc").tap do |r|
+        has_errors
+      end
+      expect(field.meta_data[:type]).to eq(:string)
+      expect(field.meta_data[:present]).to be(true)
+      expect(field.meta_data[:options]).to eq(['a', 'b', 'c'])
+    end
+  end
+
   describe "#present" do
     it "is valid if value is present" do
       resolve(subject.present, a_key: "abc").tap do |r|

data/spec/policies_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe 'default coercions' do
   def test_coercion(key, value, expected)
-    coercion = Parametric.registry.coercions[key]
+    coercion = Parametric.registry.policies[key]
     expect(coercion.new.coerce(value, nil, nil)).to eq expected
   end
 

data/spec/schema_lifecycle_hooks_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Parametric::Schema do
+  describe '#before_resolve' do
+    it 'passes payload through before_resolve block, if defined' do
+      schema = described_class.new do
+        before_resolve do |payload, _context|
+          payload[:slug] = payload[:name].to_s.downcase.gsub(/\s+/, '-') unless payload[:slug]
+          payload
+        end
+
+        field(:name).policy(:string).present
+        field(:slug).policy(:string).present
+        field(:variants).policy(:array).schema do
+          before_resolve do |payload, _context|
+            payload[:slug] = "v: #{payload[:name].to_s.downcase}"
+            payload
+          end
+          field(:name).policy(:string).present
+          field(:slug).type(:string).present
+        end
+      end
+
+      result = schema.resolve({ name: 'A name', variants: [{ name: 'A variant' }] })
+      expect(result.valid?).to be true
+      expect(result.output[:slug]).to eq 'a-name'
+      expect(result.output[:variants].first[:slug]).to eq 'v: a variant'
+    end
+
+    it 'collects errors added in before_resolve blocks' do
+      schema = described_class.new do
+        field(:variants).type(:array).schema do
+          before_resolve do |payload, context|
+            context.add_error 'nope!' if payload[:name] == 'with errors'
+            payload
+          end
+          field(:name).type(:string)
+        end
+      end
+
+      results = schema.resolve({ variants: [ {name: 'no errors'}, {name: 'with errors'}]})
+      expect(results.valid?).to be false
+      expect(results.errors['$.variants[1]']).to eq ['nope!']
+    end
+
+    it 'copies before_resolve hooks to merged schemas' do
+      schema1 = described_class.new do
+        before_resolve do |payload, _context|
+          payload[:slug] = payload[:name].to_s.downcase.gsub(/\s+/, '-') unless payload[:slug]
+          payload
+        end
+        field(:name).present.type(:string)
+        field(:slug).present.type(:string)
+      end
+
+      schema2 = described_class.new do
+        before_resolve do |payload, _context|
+          payload[:slug] = "slug-#{payload[:slug]}" if payload[:slug]
+          payload
+        end
+
+        field(:age).type(:integer)
+      end
+
+      schema3 = schema1.merge(schema2)
+
+      results = schema3.resolve({ name: 'Ismael Celis', age: 41 })
+      expect(results.output[:slug]).to eq 'slug-ismael-celis'
+    end
+
+    it 'works with any callable' do
+      slug_maker = Class.new do
+        def initialize(slug_field, from:)
+          @slug_field, @from = slug_field, from
+        end
+
+        def call(payload, _context)
+          payload.merge(
+            @slug_field => payload[@from].to_s.downcase.gsub(/\s+/, '-')
+          )
+        end
+      end
+
+      schema = described_class.new do |sc, _opts|
+        sc.before_resolve slug_maker.new(:slug, from: :name)
+
+        sc.field(:name).type(:string)
+        sc.field(:slug).type(:string)
+      end
+
+      results = schema.resolve(name: 'Ismael Celis')
+      expect(results.output[:slug]).to eq 'ismael-celis'
+    end
+  end
+
+  describe '#after_resolve' do
+    let!(:schema) do
+      described_class.new do
+        after_resolve do |payload, ctx|
+          ctx.add_base_error('deposit', 'cannot be greater than house price') if payload[:deposit] > payload[:house_price]
+          payload.merge(desc: 'hello')
+        end
+
+        field(:deposit).policy(:integer).present
+        field(:house_price).policy(:integer).present
+        field(:desc).policy(:string)
+      end
+    end
+
+    it 'passes payload through after_resolve block, if defined' do
+      result = schema.resolve({ deposit: 1100, house_price: 1000 })
+      expect(result.valid?).to be false
+      expect(result.output[:deposit]).to eq 1100
+      expect(result.output[:house_price]).to eq 1000
+      expect(result.output[:desc]).to eq 'hello'
+    end
+
+    it 'copies after hooks when merging schemas' do
+      child_schema = described_class.new do
+        field(:name).type(:string)
+      end
+
+      union = schema.merge(child_schema)
+
+      result = union.resolve({ name: 'Joe', deposit: 1100, house_price: 1000 })
+      expect(result.valid?).to be false
+      expect(result.output[:deposit]).to eq 1100
+      expect(result.output[:house_price]).to eq 1000
+      expect(result.output[:desc]).to eq 'hello'
+      expect(result.output[:name]).to eq 'Joe'
+    end
+  end
+end

data/spec/struct_spec.rb

@@ -40,6 +40,10 @@ describe Parametric::Struct do
     expect(instance.friends.first.name).to eq 'Ismael'
     expect(instance.friends.first).to be_a friend_class
 
+    # Hash access with #[]
+    expect(instance[:title]).to eq instance.title
+    expect(instance[:friends].first[:name]).to eq instance.friends.first.name
+
     invalid_instance = klass.new({
       friends: [
         {name: 'Ismael', age: 40},
@@ -99,32 +103,6 @@ describe Parametric::Struct do
     expect(instance.friends.first.age).to eq 10
   end
 
-  it 'wraps nested schemas in custom class' do
-    klass = Class.new do
-      include Parametric::Struct
-
-      def self.parametric_build_class_for_child(key, child_schema)
-        Class.new do
-          include Parametric::Struct
-          schema child_schema
-          def salutation
-            "my age is #{age}"
-          end
-        end
-      end
-
-      schema do
-        field(:name).type(:string).present
-        field(:friends).type(:array).schema do
-          field(:age).type(:integer)
-        end
-      end
-    end
-
-    user = klass.new(name: 'Ismael', friends: [{age: 43}])
-    expect(user.friends.first.salutation).to eq 'my age is 43'
-  end
-
   it "wraps regular schemas in structs" do
     friend_schema = Parametric::Schema.new do
       field(:name)

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: parametric
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.14
 platform: ruby
 authors:
 - Ismael Celis
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-08-07 00:00:00.000000000 Z
+date: 2021-03-11 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +67,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bench/struct_bench.rb
 - bin/console
 - lib/parametric.rb
 - lib/parametric/block_validator.rb
@@ -101,6 +88,7 @@ files:
 - spec/expand_spec.rb
 - spec/field_spec.rb
 - spec/policies_spec.rb
+- spec/schema_lifecycle_hooks_spec.rb
 - spec/schema_spec.rb
 - spec/schema_walk_spec.rb
 - spec/spec_helper.rb
@@ -110,7 +98,7 @@ homepage: ''
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -125,9 +113,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: DSL for declaring allowed parameters with options, regexp patern and default
   values.
@@ -137,6 +124,7 @@ test_files:
 - spec/expand_spec.rb
 - spec/field_spec.rb
 - spec/policies_spec.rb
+- spec/schema_lifecycle_hooks_spec.rb
 - spec/schema_spec.rb
 - spec/schema_walk_spec.rb
 - spec/spec_helper.rb