parametric 0.2.10 → 0.2.19

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/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
@@ -71,7 +75,9 @@ 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
+        one_of = meta.delete(:one_of)
+        meta[:one_of] = one_of.values.map(&:structure) if one_of
         obj[field.key] = meta
       end
     end
@@ -90,6 +96,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 +159,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/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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Parametric
-  VERSION = "0.2.10"
+  VERSION = '0.2.19'
 end

data/lib/parametric.rb

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

data/parametric.gemspec

@@ -17,8 +17,7 @@ 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 "rspec", '3.12.0'
   spec.add_development_dependency "byebug"
 end

data/spec/field_spec.rb

@@ -88,6 +88,14 @@ describe Parametric::Field do
     end
   end
 
+  describe '#has_policy?' do
+    it 'is a boolean' do
+      subject.policy(:integer)
+      expect(subject.has_policy?(:integer)).to be(true)
+      expect(subject.has_policy?(:string)).to be(false)
+    end
+  end
+
   describe "#default" do
     it "is default if missing key" do
       resolve(subject.default("AA"), foobar: 1).tap do |r|
@@ -112,6 +120,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|
@@ -242,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/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/schema_spec.rb

@@ -251,6 +251,87 @@ 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
+
+    specify '#structure' 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
+
+      structure = schema.structure
+      structure.dig(:sub).tap do |sub|
+        expect(sub[:type]).to eq :object
+        expect(sub[:one_of][0][:name][:type]).to eq :string
+        expect(sub[:one_of][0][:name][:required]).to be true
+        expect(sub[:one_of][0][:name][:present]).to be true
+        expect(sub[:one_of][0][:age][:type]).to eq :integer
+
+        expect(sub[:one_of][1][:company_code][:type]).to eq :string
+      end
+    end
+  end
+
   describe "#ignore" do
     it "ignores fields" do
       s1 = described_class.new.ignore(:title, :status) do