parametric 0.0.5 → 0.1.0

data/lib/parametric/schema.rb

@@ -0,0 +1,151 @@
+require "parametric/context"
+require "parametric/results"
+require "parametric/field"
+
+module Parametric
+  class Schema
+    def initialize(options = {}, &block)
+      @options = options
+      @fields = {}
+      @definitions = []
+      @definitions << block if block_given?
+      @default_field_policies = []
+      @ignored_field_keys = []
+    end
+
+    def fields
+      apply!
+      @fields
+    end
+
+    def policy(*names, &block)
+      @default_field_policies = names
+      definitions << block if block_given?
+
+      self
+    end
+
+    def ignore(*field_keys, &block)
+      @ignored_field_keys += field_keys
+      @ignored_field_keys.uniq!
+
+      definitions << block if block_given?
+
+      self
+    end
+
+    def clone
+      instance = self.class.new(options)
+      copy_into instance
+    end
+
+    def merge(other_schema)
+      instance = self.class.new(options.merge(other_schema.options))
+
+      copy_into(instance)
+      other_schema.copy_into(instance)
+    end
+
+    def copy_into(instance)
+      instance.policy(*default_field_policies) if default_field_policies.any?
+
+      definitions.each do |d|
+        instance.definitions << d
+      end
+
+      instance.ignore *ignored_field_keys
+      instance
+    end
+
+    def structure
+      fields.each_with_object({}) do |(_, field), obj|
+        meta = field.meta_data.dup
+        sc = meta.delete(:schema)
+        meta[:structure] = sc.structure if sc
+        obj[field.key] = meta
+      end
+    end
+
+    def field(field_or_key)
+      f, key = if field_or_key.kind_of?(Field)
+        [field_or_key, field_or_key.key]
+      else
+        [Field.new(field_or_key), field_or_key.to_sym]
+      end
+
+      if ignored_field_keys.include?(f.key)
+        f
+      else
+        @fields[key] = apply_default_field_policies_to(f)
+      end
+    end
+
+    def resolve(payload)
+      context = Context.new
+      output = coerce(payload, nil, context)
+      Results.new(output, context.errors)
+    end
+
+    def walk(meta_key = nil, &visitor)
+      r = visit(meta_key, &visitor)
+      Results.new(r, {})
+    end
+
+    def eligible?(value, key, payload)
+      payload.key? key
+    end
+
+    def valid?(*_)
+      true
+    end
+
+    def meta_data
+      {}
+    end
+
+    def visit(meta_key = nil, &visitor)
+      fields.each_with_object({}) do |(_, field), m|
+        m[field.key] = field.visit(meta_key, &visitor)
+      end
+    end
+
+    def coerce(val, _, context)
+      if val.is_a?(Array)
+        val.map.with_index{|v, idx|
+          coerce_one(v, context.sub(idx))
+        }
+      else
+        coerce_one val, context
+      end
+    end
+
+    protected
+
+    attr_reader :definitions, :options
+
+    private
+
+    attr_reader :default_field_policies, :ignored_field_keys
+
+    def coerce_one(val, context)
+      fields.each_with_object({}) do |(_, field), m|
+        r = field.resolve(val, context.sub(field.key))
+        if r.eligible?
+          m[field.key] = r.value
+        end
+      end
+    end
+
+    def apply_default_field_policies_to(field)
+      default_field_policies.reduce(field) {|f, policy_name| f.policy(policy_name) }
+    end
+
+    def apply!
+      return if @applied
+      definitions.each do |d|
+        self.instance_exec(options, &d)
+      end
+      @applied = true
+    end
+  end
+end

data/lib/parametric/version.rb

@@ -1,3 +1,3 @@
 module Parametric
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/parametric.rb

@@ -1,10 +1,20 @@
+require "parametric/version"
+require "parametric/registry"
+require "parametric/field"
+require "parametric/results"
+require "parametric/schema"
+require "parametric/context"
+
 module Parametric
 
+  def self.registry
+    @registry ||= Registry.new
+  end
+
+  def self.policy(name, plcy = nil, &block)
+    registry.policy name, plcy, &block
+  end
 end
 
-require "parametric/utils"
-require "parametric/version"
-require "parametric/policies"
-require "parametric/params"
-require "parametric/typed_params"
-require "parametric/hash"
+require 'parametric/default_types'
+require 'parametric/policies'

data/parametric.gemspec

@@ -20,5 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", '2.14.1'
+  spec.add_development_dependency "rspec", '3.4.0'
+  spec.add_development_dependency "byebug"
 end

data/spec/dsl_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require "parametric/dsl"
+
+describe "classes including DSL module" do
+  class Parent
+    include Parametric::DSL
+
+    schema(age_type: :integer) do |opts|
+      field(:title).policy(:string)
+      field(:age).policy(opts[:age_type])
+    end
+  end
+
+  class Child < Parent
+    schema(age_type: :string) do
+      field(:description).policy(:string)
+    end
+  end
+
+  class GrandChild < Child
+    schema(age_type: :integer)
+  end
+
+  describe "#schema" do
+    let(:input) {
+      {
+        title: "A title",
+        age: 38,
+        description: "A description"
+      }
+    }
+
+    it "merges parent's schema into child's" do
+      parent_output = Parent.schema.resolve(input).output
+      child_output = Child.schema.resolve(input).output
+
+      expect(parent_output.keys).to match_array([:title, :age])
+      expect(parent_output[:title]).to eq "A title"
+      expect(parent_output[:age]).to eq 38
+
+      expect(child_output.keys).to match_array([:title, :age, :description])
+      expect(child_output[:title]).to eq "A title"
+      expect(child_output[:age]).to eq "38"
+      expect(child_output[:description]).to eq "A description"
+    end
+
+    it "inherits options" do
+      grand_child_output = GrandChild.schema.resolve(input).output
+
+      expect(grand_child_output.keys).to match_array([:title, :age, :description])
+      expect(grand_child_output[:title]).to eq "A title"
+      expect(grand_child_output[:age]).to eq 38
+      expect(grand_child_output[:description]).to eq "A description"
+    end
+  end
+
+  describe "inheriting schema policy" do
+    let!(:a) {
+      Class.new do
+        include Parametric::DSL
+
+        schema.policy(:present) do
+          field(:title).policy(:string)
+        end
+      end
+    }
+
+    let!(:b) {
+      Class.new(a)
+    }
+
+    it "inherits policy" do
+      results = a.schema.resolve({})
+      expect(results.errors["$.title"]).not_to be_empty
+
+      results = b.schema.resolve({})
+      expect(results.errors["$.title"]).not_to be_empty
+    end
+  end
+
+  describe "overriding schema policy" do
+    let!(:a) {
+      Class.new do
+        include Parametric::DSL
+
+        schema.policy(:present) do
+          field(:title).policy(:string)
+        end
+      end
+    }
+
+    let!(:b) {
+      Class.new(a) do
+        schema.policy(:declared)
+      end
+    }
+
+    it "does not mutate parent schema" do
+      results = a.schema.resolve({})
+      expect(results.errors).not_to be_empty
+
+      results = b.schema.resolve({})
+      expect(results.errors).to be_empty
+    end
+  end
+
+  describe "removes fields defined in the parent class" do
+    let!(:a) {
+      Class.new do
+        include Parametric::DSL
+
+        schema do
+          field(:title).policy(:string)
+        end
+      end
+    }
+
+    let!(:b) {
+      Class.new(a) do
+        schema.ignore(:title) do
+          field(:age)
+        end
+      end
+    }
+
+    it "removes inherited field from child class" do
+      results = a.schema.resolve({title: "Mr.", age: 20})
+      expect(results.output).to eq({title: "Mr."})
+
+      results = b.schema.resolve({title: "Mr.", age: 20})
+      expect(results.output).to eq({age: 20})
+    end
+  end
+end
+