parametric 0.0.5 → 0.1.0

data/spec/schema_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+
+describe Parametric::Schema do
+  before do
+    Parametric.policy :flexible_bool do
+      coerce do |v, k, c|
+        case v
+        when '1', 'true', 'TRUE', true
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+
+  subject do
+    described_class.new do
+      field(:title).policy(:string).present
+      field(:price).policy(:integer).meta(label: "A price")
+      field(:status).policy(:string).options(['visible', 'hidden'])
+      field(:tags).policy(:split).policy(:array)
+      field(:description).policy(:string)
+      field(:variants).policy(:array).schema do
+        field(:name).policy(:string).present
+        field(:sku)
+        field(:stock).policy(:integer).default(1)
+        field(:available_if_no_stock).policy(:boolean).policy(:flexible_bool).default(false)
+      end
+    end
+  end
+
+  describe "#structure" do
+    it "represents data structure and meta data" do
+      sc = subject.structure
+      expect(sc[:title][:present]).to be true
+      expect(sc[:title][:type]).to eq :string
+      expect(sc[:price][:type]).to eq :integer
+      expect(sc[:price][:label]).to eq "A price"
+      expect(sc[:variants][:type]).to eq :array
+      sc[:variants][:structure].tap do |sc|
+        expect(sc[:name][:type]).to eq :string
+        expect(sc[:name][:present]).to be true
+        expect(sc[:stock][:default]).to eq 1
+      end
+    end
+  end
+
+  def resolve(schema, payload, &block)
+    yield schema.resolve(payload)
+  end
+
+  def test_schema(schema, payload, result)
+    resolve(schema, payload) do |results|
+      expect(results.output).to eq result
+    end
+  end
+
+  it 'works' do
+    test_schema(subject, {
+      title: 'iPhone 6 Plus',
+      price: '100.0',
+      status: 'visible',
+      tags: 'tag1, tag2',
+      description: 'A description',
+      variants: [{name: 'v1', sku: 'ABC', stock: '10', available_if_no_stock: true}]
+    },
+    {
+      title: 'iPhone 6 Plus',
+      price: 100,
+      status: 'visible',
+      tags: ['tag1', 'tag2'],
+      description: 'A description',
+      variants: [{name: 'v1', sku: 'ABC', stock: 10, available_if_no_stock: true}]
+    })
+
+    test_schema(subject, {
+      title: 'iPhone 6 Plus',
+      variants: [{name: 'v1', available_if_no_stock: '1'}]
+    },
+    {
+      title: 'iPhone 6 Plus',
+      variants: [{name: 'v1', stock: 1, available_if_no_stock: true}]
+    })
+
+    resolve(subject, {}) do |results|
+      expect(results.valid?).to be false
+      expect(results.errors['$.title']).not_to be_nil
+      expect(results.errors['$.variants']).to be_nil
+      expect(results.errors['$.status']).to be_nil
+    end
+
+    resolve(subject, {title: 'Foobar', variants: [{name: 'v1'}, {sku: '345'}]}) do |results|
+      expect(results.valid?).to be false
+      expect(results.errors['$.variants[1].name']).not_to be_nil
+    end
+  end
+
+  describe "#policy" do
+    it "applies policy to all fields" do
+      subject.policy(:declared)
+
+      resolve(subject, {}) do |results|
+        expect(results.valid?).to be true
+        expect(results.errors.keys).to be_empty
+      end
+    end
+
+    it "replaces previous policies" do
+      subject.policy(:declared)
+      subject.policy(:present)
+
+      resolve(subject, {title: "hello"}) do |results|
+        expect(results.valid?).to be false
+        expect(results.errors.keys).to match_array(%w(
+          $.price
+          $.status
+          $.tags
+          $.description
+          $.variants
+        ))
+      end
+    end
+
+    it "applies :noop policy to all fields" do
+      subject.policy(:noop)
+
+      resolve(subject, {}) do |results|
+        expect(results.valid?).to be false
+        expect(results.errors['$.title']).not_to be_nil
+      end
+    end
+  end
+
+  describe "#merge" do
+    context "no options" do
+      let!(:schema1) {
+        described_class.new do
+          field(:title).policy(:string).present
+          field(:price).policy(:integer)
+        end
+      }
+
+      let!(:schema2) {
+        described_class.new do
+          field(:price).policy(:string)
+          field(:description).policy(:string)
+        end
+      }
+
+      it "returns a new schema adding new fields and updating existing ones" do
+        new_schema = schema1.merge(schema2)
+        expect(new_schema.fields.keys).to match_array([:title, :price, :description])
+
+        # did not mutate original
+        expect(schema1.fields[:price].meta_data[:type]).to eq :integer
+
+        expect(new_schema.fields[:title].meta_data[:type]).to eq :string
+        expect(new_schema.fields[:price].meta_data[:type]).to eq :string
+      end
+    end
+
+    context "with options" do
+      let!(:schema1) {
+        described_class.new(price_type: :integer, label: "Foo") do |opts|
+          field(:title).policy(:string).present
+          field(:price).policy(opts[:price_type]).meta(label: opts[:label])
+        end
+      }
+
+      let!(:schema2) {
+        described_class.new(price_type: :string) do
+          field(:description).policy(:string)
+        end
+      }
+
+      it "inherits options" do
+        new_schema = schema1.merge(schema2)
+        expect(new_schema.fields[:price].meta_data[:type]).to eq :string
+        expect(new_schema.fields[:price].meta_data[:label]).to eq "Foo"
+      end
+
+      it "re-applies blocks with new options" do
+        new_schema = schema1.merge(schema2)
+        expect(new_schema.fields.keys).to match_array([:title, :price, :description])
+
+        # did not mutate original
+        expect(schema1.fields[:price].meta_data[:type]).to eq :integer
+
+        expect(new_schema.fields[:title].meta_data[:type]).to eq :string
+        expect(new_schema.fields[:price].meta_data[:type]).to eq :string
+      end
+    end
+  end
+
+  describe "#clone" do
+    let!(:schema1) {
+      described_class.new do |opts|
+        field(:id).present
+        field(:title).policy(:string).present
+        field(:price)
+      end
+    }
+
+    it "returns a copy that can be further manipulated" do
+      schema2 = schema1.clone.policy(:declared).ignore(:id)
+      expect(schema1.fields.keys).to match_array([:id, :title, :price])
+      expect(schema2.fields.keys).to match_array([:title, :price])
+
+      results1 = schema1.resolve(id: "abc", price: 100)
+      expect(results1.errors.keys).to eq ["$.title"]
+
+      results2 = schema2.resolve(id: "abc", price: 100)
+      expect(results2.errors.keys).to eq []
+    end
+  end
+
+  describe "#ignore" do
+    it "ignores fields" do
+      s1 = described_class.new.ignore(:title, :status) do
+        field(:status)
+        field(:title).policy(:string).present
+        field(:price).policy(:integer)
+      end
+
+      output = s1.resolve(status: "draft", title: "foo", price: "100").output
+      expect(output).to eq({price: 100})
+    end
+
+    it "ignores when merging" do
+      s1 = described_class.new do
+        field(:status)
+        field(:title).policy(:string).present
+      end
+
+      s1 = described_class.new.ignore(:title, :status) do
+        field(:price).policy(:integer)
+      end
+
+      output = s1.resolve(title: "foo", status: "draft", price: "100").output
+      expect(output).to eq({price: 100})
+    end
+
+    it "returns self so it can be chained" do
+      s1 = described_class.new do
+        field(:status)
+        field(:title).policy(:string).present
+      end
+
+      expect(s1.ignore(:status)).to eq s1
+    end
+  end
+end

data/spec/schema_walk_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Schema#walk' do
+  let(:schema) do
+    Parametric::Schema.new do
+      field(:title).meta(example: 'a title', label: 'custom title')
+      field(:tags).policy(:array).meta(example: ['tag1', 'tag2'], label: 'comma-separated tags')
+      field(:friends).policy(:array).schema do
+        field(:name).meta(example: 'a friend', label: 'friend full name')
+        field(:age).meta(example: 34, label: 'age')
+      end
+    end
+  end
+
+  it "recursively walks the schema and collects meta data" do
+    results = schema.walk(:label)
+    expect(results.output).to eq({
+      title: 'custom title',
+      tags: 'comma-separated tags',
+      friends: [
+        {
+          name: 'friend full name',
+          age: 'age'
+        }
+      ]
+    })
+  end
+
+  it "works with blocks" do
+    results = schema.walk{|field| field.meta_data[:example]}
+    expect(results.output).to eq({
+      title: 'a title',
+      tags: ['tag1', 'tag2'],
+      friends: [
+        {
+          name: 'a friend',
+          age: 34
+        }
+      ]
+    })
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,3 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'byebug'
 require 'parametric'

data/spec/validators_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe 'default validators' do
+
+  def test_validator(payload, key, name, eligible, valid, *args)
+    validator = Parametric.registry.policies[name]
+    validator = validator.new(*args) if validator.respond_to?(:new)
+    expect(validator.eligible?(payload[key], key, payload)).to eq eligible
+    expect(validator.valid?(payload[key], key, payload)).to eq valid
+  end
+
+  describe ':format' do
+    it {
+      test_validator({key: 'Foobar'}, :key, :format, true, true, /^Foo/)
+      test_validator({key: 'Foobar'}, :key, :format, true, false, /^Bar/)
+      test_validator({foo: 'Foobar'}, :key, :format, false, true, /^Foo/)
+    }
+  end
+
+  describe ':email' do
+    it {
+      test_validator({key: 'foo@bar.com'}, :key, :email, true, true)
+      test_validator({key: 'foo@'}, :key, :email, true, false)
+      test_validator({foo: 'foo@bar.com'}, :key, :email, false, true)
+    }
+  end
+
+  describe ':required' do
+    it {
+      test_validator({key: 'foo'}, :key, :required, true, true)
+      test_validator({key: ''}, :key, :required, true, true)
+      test_validator({key: nil}, :key, :required, true, true)
+      test_validator({foo: 'foo'}, :key, :required, true, false)
+    }
+  end
+
+  describe ':present' do
+    it {
+      test_validator({key: 'foo'}, :key, :present, true, true)
+      test_validator({key: ''}, :key, :present, true, false)
+      test_validator({key: nil}, :key, :present, true, false)
+      test_validator({foo: 'foo'}, :key, :present, true, false)
+    }
+  end
+
+  describe ':gt' do
+    it {
+      test_validator({key: 10}, :key, :gt, true, true, 9)
+      test_validator({key: '10'}, :key, :gt, true, true, 9)
+      test_validator({key: 10}, :key, :gt, true, false, 11)
+      test_validator({key: '10'}, :key, :gt, true, false, 11)
+      test_validator({foo: '10'}, :key, :gt, true, true, 11)
+    }
+  end
+
+  describe ':lt' do
+    it {
+      test_validator({key: 10}, :key, :lt, true, true, 11)
+      test_validator({key: '10'}, :key, :lt, true, true, 11)
+      test_validator({key: 10}, :key, :lt, true, false, 9)
+      test_validator({key: '10'}, :key, :lt, true, false, 9)
+      test_validator({foo: '10'}, :key, :lt, true, true, 9)
+    }
+  end
+
+  describe ':options' do
+    it {
+      test_validator({key: 'b'}, :key, :options, true, true, %w(a b c))
+      test_validator({key: 'd'}, :key, :options, true, false, %w(a b c))
+      test_validator({key: ['c', 'b']}, :key, :options, true, true, %w(a b c))
+      test_validator({key: ['c', 'b', 'd']}, :key, :options, true, false, %w(a b c))
+      test_validator({foo: 'b'}, :key, :options, false, true, %w(a b c))
+    }
+  end
+
+  describe ':array' do
+    it {
+      test_validator({key: ['a', 'b']}, :key, :array, true, true)
+      test_validator({key: []}, :key, :array, true, true)
+      test_validator({key: nil}, :key, :array, true, false)
+      test_validator({key: 'hello'}, :key, :array, true, false)
+      test_validator({key: 123}, :key, :array, true, false)
+      test_validator({foo: []}, :key, :array, true, true)
+    }
+  end
+
+  describe ':object' do
+    it {
+      test_validator({key: {'a' =>'b'}}, :key, :object, true, true)
+      test_validator({key: {}}, :key, :object, true, true)
+      test_validator({key: ['a', 'b']}, :key, :object, true, false)
+      test_validator({key: nil}, :key, :object, true, false)
+      test_validator({key: 123}, :key, :object, true, false)
+      test_validator({foo: {}}, :key, :object, true, true)
+    }
+  end
+end

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: parametric
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Ismael Celis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-27 00:00:00.000000000 Z
+date: 2016-12-16 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
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -44,41 +44,67 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Useful for modelling search or form objects, white-listed query parameters
   and safe parameter defaults.
 email:
 - ismaelct@gmail.com
-executables: []
+executables:
+- console
+- setup
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/setup
 - lib/parametric.rb
-- lib/parametric/hash.rb
-- lib/parametric/params.rb
+- lib/parametric/block_validator.rb
+- lib/parametric/context.rb
+- lib/parametric/default_types.rb
+- lib/parametric/dsl.rb
+- lib/parametric/field.rb
+- lib/parametric/field_dsl.rb
 - lib/parametric/policies.rb
-- lib/parametric/typed_params.rb
-- lib/parametric/utils.rb
+- lib/parametric/registry.rb
+- lib/parametric/results.rb
+- lib/parametric/schema.rb
 - lib/parametric/version.rb
-- lib/support/class_attribute.rb
 - parametric.gemspec
-- spec/nested_params_spec.rb
-- spec/parametric_spec.rb
+- spec/dsl_spec.rb
+- spec/field_spec.rb
+- spec/policies_spec.rb
+- spec/schema_spec.rb
+- spec/schema_walk_spec.rb
 - spec/spec_helper.rb
+- spec/validators_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -89,22 +115,26 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: DSL for declaring allowed parameters with options, regexp patern and default
   values.
 test_files:
-- spec/nested_params_spec.rb
-- spec/parametric_spec.rb
+- spec/dsl_spec.rb
+- spec/field_spec.rb
+- spec/policies_spec.rb
+- spec/schema_spec.rb
+- spec/schema_walk_spec.rb
 - spec/spec_helper.rb
+- spec/validators_spec.rb

data/lib/parametric/hash.rb

@@ -1,38 +0,0 @@
-require 'forwardable'
-module Parametric
-  class Hash
-    include TypedParams
-    include Enumerable
-    extend ::Forwardable
-    def_delegators(:params,
-      :[],
-      :[]=,
-      :each,
-      :each_value,
-      :each_key,
-      :each_pair,
-      :keys,
-      :values,
-      :values_at,
-      :fetch,
-      :size,
-      :to_hash,
-      :merge,
-      :merge!,
-      :replace,
-      :update,
-      :has_key?,
-      :key?,
-      :key,
-      :select,
-      :select!,
-      :delete,
-      :store,
-      :inspect,
-      :stringify_keys,
-      :symbolize_keys
-    )
-
-  end
-
-end

data/lib/parametric/params.rb

@@ -1,86 +0,0 @@
-require 'ostruct'
-require 'support/class_attribute'
-module Parametric
-
-  class ParamsHash < Hash
-    def flat(separator = ',')
-      self.each_with_object({}) do |(k,v),memo|
-        memo[k] = Utils.value(v, separator)
-      end
-    end
-  end
-
-  module Params
-
-    def self.included(base)
-      base.send(:attr_reader, :params)
-      base.class_attribute :_allowed_params
-      base._allowed_params = {}
-      base.extend DSL
-    end
-
-    def initialize(raw_params = {})
-      @params = _reduce(raw_params)
-    end
-
-    def available_params
-      @available_params ||= params.each_with_object(ParamsHash.new) do |(k,v),memo|
-        if Utils.present?(v)
-          memo[k] = v.respond_to?(:available_params) ? v.available_params : v
-        end
-      end
-    end
-
-    def schema
-      @schema ||= params.each_with_object({}) do |(k,v),memo|
-        is_nested = v.kind_of?(Parametric::Hash)
-        attrs = self.class._allowed_params[k].dup
-        attrs[:value] = is_nested ? v : Utils.value(v)
-        attrs[:schema] = v.schema if is_nested
-        memo[k] = OpenStruct.new(attrs)
-      end
-    end
-
-    protected
-
-    def _reduce(raw_params)
-      self.class._allowed_params.each_with_object(ParamsHash.new) do |(key,options),memo|
-        has_key = raw_params.respond_to?(:has_key?) && raw_params.has_key?(key)
-        value = has_key ? raw_params[key] : []
-        policy = Policies::Policy.new(value, options)
-        policy = policy.wrap(Policies::CoercePolicy)   if options[:coerce]
-        policy = policy.wrap(Policies::NestedPolicy)   if options[:nested]
-        policy = policy.wrap(Policies::MultiplePolicy) if options[:multiple]
-        policy = policy.wrap(Policies::OptionsPolicy)  if options[:options]
-        policy = policy.wrap(Policies::MatchPolicy)    if options[:match]
-        policy = policy.wrap(Policies::DefaultPolicy)  if options.has_key?(:default)
-        policy = policy.wrap(Policies::SinglePolicy)   unless options[:multiple]
-        memo[key] = policy.value unless options[:nullable] && !has_key
-      end
-    end
-
-    module DSL
-
-      # When subclasses params definitions
-      # we want to copy parent class definitions
-      # so changes in the child class
-      # don't mutate the parent definitions
-      #
-      def inherited(subclass)
-        subclass._allowed_params = self._allowed_params.dup
-      end
-
-      def param(field_name, label = '', opts = {}, &block)
-        opts[:label] = label
-        if block_given?
-          nested = Class.new(Parametric::Hash)
-          nested.instance_eval &block
-          opts[:nested] = nested
-        end
-        _allowed_params[field_name] = opts
-      end
-    end
-
-  end
-
-end