parametric 0.0.1 → 0.2.12

data/lib/parametric/schema.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+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 = []
+      @expansions = {}
+      @before_hooks = []
+      @after_hooks = []
+    end
+
+    def schema
+      self
+    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 = nil, &block)
+      raise ArgumentError, '#merge takes either a schema instance or a block' if other_schema.nil? && !block_given?
+
+      if other_schema
+        instance = self.class.new(options.merge(other_schema.options))
+        copy_into(instance)
+        other_schema.copy_into(instance)
+      else
+        merge(self.class.new(&block))
+      end
+    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 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
+    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|
+          subcontext = context.sub(idx)
+          out = coerce_one(v, subcontext)
+          resolve_expansions(v, out, subcontext)
+        }
+      else
+        out = coerce_one(val, context)
+        resolve_expansions(val, out, context)
+      end
+    end
+
+    protected
+
+    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)
+      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
+      def field(key)
+        Field.new(key.to_sym)
+      end
+    end
+
+    def resolve_expansions(payload, into, context)
+      expansions.each do |exp, block|
+        payload.each do |key, value|
+          if match = exp.match(key.to_s)
+            fld = MatchContext.new.instance_exec(match, &block)
+            if fld
+              into.update(coerce_one({fld.key => value}, context, flds: {fld.key => apply_default_field_policies_to(fld)}))
+            end
+          end
+        end
+      end
+
+      into
+    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|
+        if d.arity == 2 # pass schema instance and options, preserve block context
+          d.call(self, options)
+        else # run block in context of current instance
+          self.instance_exec(options, &d)
+        end
+      end
+      @applied = true
+    end
+  end
+end

data/lib/parametric/struct.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'parametric/dsl'
+
+module Parametric
+  class InvalidStructError < ArgumentError
+    attr_reader :errors
+    def initialize(struct)
+      @errors = struct.errors
+      msg = @errors.map do |k, strings|
+        "#{k} #{strings.join(', ')}"
+      end.join('. ')
+      super "#{struct.class} is not a valid struct: #{msg}"
+    end
+  end
+
+  module Struct
+    def self.included(base)
+      base.send(:include, Parametric::DSL)
+      base.extend ClassMethods
+    end
+
+    def initialize(attrs = {})
+      @_results = self.class.schema.resolve(attrs)
+      @_graph = self.class.build(@_results.output)
+    end
+
+    def valid?
+      !_results.errors.any?
+    end
+
+    def errors
+      _results.errors
+    end
+
+    # returns a shallow copy.
+    def to_h
+      _results.output.clone
+    end
+
+    def ==(other)
+      other.respond_to?(:to_h) && other.to_h.eql?(to_h)
+    end
+
+    def merge(attrs = {})
+      self.class.new(to_h.merge(attrs))
+    end
+
+    private
+    attr_reader :_graph, :_results
+
+    module ClassMethods
+      def new!(attrs = {})
+        st = new(attrs)
+        raise InvalidStructError.new(st) unless st.valid?
+        st
+      end
+
+      # this hook is called after schema definition in DSL module
+      def parametric_after_define_schema(schema)
+        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
+
+      def build(attrs)
+        attrs.each_with_object({}) do |(k, v), obj|
+          obj[k] = wrap(k, v)
+        end
+      end
+
+      def wrap(key, value)
+        case value
+        when Hash
+          # find constructor for field
+          cons = self.const_get(__class_name(key))
+          cons ? cons.new(value) : value.freeze
+        when Array
+          value.map{|v| wrap(key, v) }.freeze
+        else
+          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.0.1"
+  VERSION = "0.2.12"
 end

data/lib/parametric.rb

@@ -1,9 +1,22 @@
+# frozen_string_literal: true
+
+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/hash"
+require 'parametric/default_types'
+require 'parametric/policies'

data/parametric.gemspec

@@ -14,11 +14,10 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   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"
+  spec.add_development_dependency "rspec", '3.4.0'
+  spec.add_development_dependency "byebug"
 end

data/spec/custom_block_validator_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe 'custom block validator' do
+  Parametric.policy :validate_if do
+    eligible do |options, value, key, payload|
+      options.all? do |key, value|
+        payload[key] == value
+      end
+    end
+  end
+
+  it 'works if I just define an :eligible block' do
+    schema = Parametric::Schema.new do
+      field(:name).policy(:validate_if, age: 40).present
+      field(:age).type(:integer)
+    end
+
+    expect(schema.resolve(age: 30).errors.any?).to be false
+    expect(schema.resolve(age: 40).errors.any?).to be true # name is missing
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+require "parametric/dsl"
+
+describe "classes including DSL module" do
+  class Parent
+    include Parametric::DSL
+
+    schema :extras, search_type: :string do |opts|
+      field(:search).policy(opts[:search_type])
+    end
+
+    schema(age_type: :integer) do |opts|
+      field(:title).policy(:string)
+      field(:age).policy(opts[:age_type])
+    end
+  end
+
+  class Child < Parent
+    schema :extras do
+      field(:query).type(:string)
+    end
+
+    schema(age_type: :string) do
+      field(:description).policy(:string)
+    end
+  end
+
+  class GrandChild < Child
+    schema :extras, search_type: :integer
+
+    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"
+
+      # named schema
+      parent_output = Parent.schema(:extras).resolve(search: 10, query: 'foo').output
+      child_output = Child.schema(:extras).resolve(search: 10, query: 'foo').output
+
+      expect(parent_output.keys).to match_array([:search])
+      expect(parent_output[:search]).to eq "10"
+      expect(child_output.keys).to match_array([:search, :query])
+      expect(child_output[:search]).to eq "10"
+      expect(child_output[:query]).to eq "foo"
+    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"
+
+      # named schema
+      grand_child_output = GrandChild.schema(:extras).resolve(search: "100", query: "bar").output
+      expect(grand_child_output.keys).to match_array([:search, :query])
+      expect(grand_child_output[:search]).to eq 100
+    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
+
+  describe "passing other schema or form in definition" do
+    it 'applies schema' do
+      a = Parametric::Schema.new do
+        field(:name).policy(:string)
+        field(:age).policy(:integer).default(40)
+      end
+      b = Class.new do
+        include Parametric::DSL
+        schema a
+      end
+
+      results = b.schema.resolve(name: 'Neil')
+      expect(results.output).to eq({name: 'Neil', age: 40})
+    end
+  end
+end
+

data/spec/expand_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Parametric::Schema do
+  it "expands fields dynamically" do
+    schema = described_class.new do
+      field(:title).type(:string).present
+      expand(/^attr_(.+)/) do |match|
+        field(match[1]).type(:string)
+      end
+      expand(/^validate_(.+)/) do |match|
+        field(match[1]).type(:string).present
+      end
+    end
+
+    out = schema.resolve({
+      title: "foo",
+      :"attr_Attribute 1" => "attr 1",
+      :"attr_Attribute 2" => "attr 2",
+      :"validate_valid_attr" => "valid",
+      :"validate_invalid_attr" => "",
+    })
+
+    expect(out.output[:title]).to eq 'foo'
+    expect(out.output[:"Attribute 1"]).to eq 'attr 1'
+    expect(out.output[:"Attribute 2"]).to eq 'attr 2'
+
+    expect(out.errors['$.invalid_attr']).to eq ['is required and value must be present']
+  end
+end