parametric 0.0.1 → 0.2.10

data/spec/validators_spec.rb

@@ -0,0 +1,106 @@
+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 ':declared' do
+    it {
+      test_validator({key: 'foo'}, :key, :declared, true, true)
+      test_validator({key: ''}, :key, :declared, true, true)
+      test_validator({key: nil}, :key, :declared, true, true)
+      test_validator({foo: 'foo'}, :key, :declared, false, true)
+    }
+  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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parametric
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.10
 platform: ruby
 authors:
 - Ismael Celis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-13 00:00:00.000000000 Z
+date: 2019-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -40,6 +40,20 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,15 +81,31 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
 - 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/utils.rb
+- lib/parametric/registry.rb
+- lib/parametric/results.rb
+- lib/parametric/schema.rb
+- lib/parametric/struct.rb
 - lib/parametric/version.rb
 - parametric.gemspec
-- spec/parametric_spec.rb
+- spec/custom_block_validator_spec.rb
+- spec/dsl_spec.rb
+- spec/expand_spec.rb
+- spec/field_spec.rb
+- spec/policies_spec.rb
+- spec/schema_spec.rb
+- spec/schema_walk_spec.rb
 - spec/spec_helper.rb
+- spec/struct_spec.rb
+- spec/validators_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -96,11 +126,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: DSL for declaring allowed parameters with options, regexp patern and default
   values.
 test_files:
-- spec/parametric_spec.rb
+- spec/custom_block_validator_spec.rb
+- spec/dsl_spec.rb
+- spec/expand_spec.rb
+- spec/field_spec.rb
+- spec/policies_spec.rb
+- spec/schema_spec.rb
+- spec/schema_walk_spec.rb
 - spec/spec_helper.rb
+- spec/struct_spec.rb
+- spec/validators_spec.rb

data/lib/parametric/hash.rb

@@ -1,36 +0,0 @@
-module Parametric
-  module Hash
-
-    def self.included(base)
-      base.send(:include, Params)
-      base.send(:include, Enumerable)
-      base.extend Forwardable
-      base.send(: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
-      )
-    end
-
-  end
-end

data/lib/parametric/params.rb

@@ -1,60 +0,0 @@
-module Parametric
-
-  module Params
-
-    def self.included(base)
-      base.send(:attr_reader, :params)
-      base.extend DSL
-    end
-
-    def initialize(raw_params = {})
-      @params = _reduce(raw_params)
-    end
-
-    def available_params
-      @available_params ||= params.each_with_object({}) do |(k,v),memo|
-        memo[k] = v if Utils.present?(v)
-      end
-    end
-
-    def schema
-      @schema ||= params.each_with_object({}) do |(k,v),memo|
-        memo[k] = {
-          value: Utils.value(v),
-          label: self.class._allowed_params[k][:label],
-          multiple: !!self.class._allowed_params[k][:multiple]
-        }
-        memo[k][:match] = self.class._allowed_params[k][:match].to_s if self.class._allowed_params[k].has_key?(:match)
-        memo[k][:options] = self.class._allowed_params[k][:options] if self.class._allowed_params[k].has_key?(:options)
-      end
-    end
-
-    protected
-
-    def _reduce(raw_params)
-      self.class._allowed_params.each_with_object({}) do |(key,options),memo|
-        policy = Policies::Policy.new(raw_params[key], options)
-        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
-      end
-    end
-
-    module DSL
-      def _allowed_params
-        @allowed_params ||= {}
-      end
-
-      def param(field_name, label = '', opts = {})
-        opts[:label] = label
-        _allowed_params[field_name] = opts
-      end
-    end
-
-  end
-
-end

data/lib/parametric/utils.rb

@@ -1,24 +0,0 @@
-module Parametric
-  module Utils
-    def self.value(val)
-      if val.nil?
-        ''
-      elsif val.is_a?(Array)
-        val.join(',')
-      else
-        val
-      end
-    end
-
-    def self.present?(value)
-      case value
-      when String
-        value.strip != ''
-      when Array, Hash
-        value.any?
-      else
-        !value.nil?
-      end
-    end
-  end
-end

data/spec/parametric_spec.rb

@@ -1,182 +0,0 @@
-require 'spec_helper'
-
-describe Parametric do
-  it 'should have a version number' do
-    Parametric::VERSION.should_not be_nil
-  end
-
-  describe Parametric do
-
-    let(:klass) do
-      Class.new do
-        include Parametric::Params
-        param :name, 'User name'
-        param :page, 'page number', default: 1
-        param :per_page, 'items per page', default: 50
-        param :status, 'status', options: ['one', 'two', 'three'], multiple: true
-        param :piped_status, 'status with pipes', multiple: true, separator: '|'
-        param :country, 'country', options: ['UK', 'CL', 'JPN']
-        param :email, 'email', match: /\w+@\w+\.\w+/
-        param :emails, 'emails', match: /\w+@\w+\.\w+/, multiple: true, default: 'default@email.com'
-      end
-    end
-
-    describe '#params' do
-      let(:subject) { klass.new(foo: 'bar', per_page: 20, status: 'four') }
-
-      it 'ignores undeclared fields' do
-        subject.params.has_key?(:foo).should be_false
-      end
-
-      it 'sets passed values' do
-        subject.params[:per_page].should == 20
-      end
-
-      it 'uses defaults if no value passed' do
-        subject.params[:page].should == 1
-      end
-
-      it 'does not set value if outside of declared options' do
-        subject.params[:status].should == []
-      end
-
-      it 'does not set value if it does not :match' do
-        klass.new(email: 'my@email').params[:email].should be_nil
-      end
-
-      it 'does set value if it does :match' do
-        klass.new(email: 'my@email.com').params[:email].should == 'my@email.com'
-      end
-
-      it 'only sets value for :multiple values that :match' do
-        klass.new(emails: 'my@email,your,her@email.com').params[:emails].should == ['her@email.com']
-      end
-
-      it 'returns :default wrapped in array if :multiple' do
-        klass.new().params[:emails].should == ['default@email.com']
-      end
-
-      it 'turns :multiple comma-separated values into arrays' do
-        klass.new(status: 'one,three').params[:status].should == ['one', 'three']
-      end
-
-      it 'turns :multiple separated values with custom separator into arrays' do
-        klass.new(piped_status: 'one|three').params[:piped_status].should == ['one', 'three']
-      end
-
-      it 'does not turn non-multiple comma-separated values into arrays' do
-        klass.new(name: 'foo,bar').params[:name].should == 'foo,bar'
-      end
-
-      it 'filters out undeclared options' do
-        klass.new(status: 'one,three,fourteen').params[:status].should == ['one', 'three']
-      end
-
-      it 'defaults empty multiple options to empty array' do
-        klass.new().params[:status].should == []
-      end
-
-      it 'wraps single multiple options in array' do
-        klass.new(status: 'one').params[:status].should == ['one']
-      end
-
-      it 'does not accept comma-separated values outside of options unless :multiple == true' do
-        klass.new(country: 'UK,CL').params[:country].should be_nil
-      end
-
-      it 'does accept single option' do
-        klass.new(country: 'UK').params[:country].should == 'UK'
-      end
-
-      it 'does not accept single option if not in declared options' do
-        klass.new(country: 'USA').params[:country].should be_nil
-      end
-    end
-
-    describe '#available_params' do
-      let(:subject) { klass.new(foo: 'bar', name: 'lala', per_page: 20, status: 'four') }
-
-      it 'only includes declared params with values or defaults' do
-        subject.available_params.keys.sort.should == [:emails, :name, :page, :per_page]
-        subject.available_params[:emails].should == ["default@email.com"]
-        subject.available_params[:name].should == 'lala'
-        subject.available_params[:per_page].should == 20
-        subject.available_params[:page].should == 1
-      end
-    end
-
-    describe '#schema' do
-      let(:subject) { klass.new(foo: 'bar', name: 'lala', per_page: 20, status: 'four') }
-
-      it 'returns full param definitions with populated value' do
-        regexp = /\w+@\w+\.\w+/.to_s
-
-        subject.schema[:name][:label].should == 'User name'
-        subject.schema[:name][:value].should == 'lala'
-
-        subject.schema[:page][:label].should == 'page number'
-        subject.schema[:page][:value].should == 1
-
-        subject.schema[:per_page][:label].should == 'items per page'
-        subject.schema[:per_page][:value].should == 20
-
-        subject.schema[:status][:label].should == 'status'
-        subject.schema[:status][:value].should == ''
-        subject.schema[:status][:options].should == ['one', 'two', 'three']
-        subject.schema[:status][:multiple].should be_true
-
-        subject.schema[:piped_status][:label].should == 'status with pipes'
-        subject.schema[:piped_status][:value].should == ''
-        subject.schema[:piped_status][:multiple].should be_true
-
-        subject.schema[:country][:label].should == 'country'
-        subject.schema[:country][:value].should == ''
-        subject.schema[:country][:options].should == ['UK', 'CL', 'JPN']
-
-        subject.schema[:email][:label].should == 'email'
-        subject.schema[:email][:value].should == ''
-        subject.schema[:email][:match].should == regexp
-
-        subject.schema[:emails][:label].should == 'emails'
-        subject.schema[:emails][:value].should == 'default@email.com'
-        subject.schema[:emails][:multiple].should be_true
-        subject.schema[:emails][:match].should == regexp
-      end
-    end
-  end
-
-  describe Parametric::Hash do
-    let(:klass) do
-      Class.new do
-        include Parametric::Hash
-        param :name, 'User name'
-        param :page, 'page number', default: 1
-        param :per_page, 'items per page', default: 50
-      end
-    end
-
-    let(:subject) { klass.new(name: 'Ismael', page: 2) }
-
-    it 'quacks like a hash' do
-      subject[:name].should == 'Ismael'
-      subject[:page].should == 2
-      subject[:per_page].should == 50
-      subject.map{|k,v| k}.sort.should == [:name, :page, :per_page]
-      subject.keys.sort.should == [:name, :page, :per_page]
-      subject.values.map(&:to_s).sort.should == ['2', '50', 'Ismael']
-      subject.fetch(:page, 0).should == 2
-      subject.fetch(:foo, 0).should == 0
-      subject.merge(foo: 22).should == {name: 'Ismael', page: 2, per_page: 50, foo: 22}
-      subject.select{|k,v| k == :name}.should == {name: 'Ismael'}
-    end
-
-    it 'has #available_params' do
-      subject.available_params[:name].should == 'Ismael'
-    end
-
-    it 'has #schema' do
-      subject.schema[:name][:label].should == 'User name'
-      subject.schema[:name][:value].should == 'Ismael'
-    end
-  end
-end