parametric 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f8f3fe8f214b883a606c2418b1aaabc5b70e5b3
+  data.tar.gz: 736039abdbf281c7121ff770f41fe718ff9a3e64
+SHA512:
+  metadata.gz: 1349a426eceace4895e23d2be890d82c5748b20d9628087f29d163c0aef1dc13d79796b240cb5ece5336dc325af853b6f81940d272749fcd2370b0419b45e742
+  data.tar.gz: f0b3cb7792f497cdf8283afc2acb3b8b67fbf8acd17be94d81034e123eb55a2b7960b5062c5156bfc1de701ca3ad53c3cef074f87af616d06ea61b8c5ff1a341

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in parametric.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ismael Celis
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,211 @@
+# Parametric
+
+DSL for declaring allowed parameters with options, regexp patern and default values.
+
+Useful for building self-documeting APIs, search or form objects.
+
+## Usage
+
+Declare your parameters
+
+```ruby
+class OrdersSearch
+  include Parametric::Params
+  param :q, 'Full text search query'
+  param :page, 'Page number', default: 1
+  param :per_page, 'Items per page', default: 30
+  param :status, 'Order status', options: ['checkout', 'pending', 'closed', 'shipped'], multiple: true
+end
+```
+
+Populate and use. Missing keys return defaults, if provided.
+
+```ruby
+order_search = OrdersSearch.new(page: 2, q: 'foobar')
+order_search.params[:page] # => 2
+order_search.params[:per_page] # => 30
+order_search.params[:q] # => 'foobar'
+order_search.params[:status] # => nil
+```
+
+Undeclared keys are ignored.
+
+```ruby
+order_search = OrdersSearch.new(page: 2, foo: 'bar')
+order_params.params.has_key?(:foo) # => false
+```
+
+```ruby
+order_search = OrderParams.new(status: 'checkout,closed')
+order_search.params[:status] #=> ['checkout', 'closed']
+```
+
+### Search object pattern
+
+A class that declares allowed params and defaults, and builds a query.
+
+```ruby
+class OrdersSearch
+  include Parametric::Params
+  param :q, 'Full text search query'
+  param :page, 'Page number', default: 1
+  param :per_page, 'Items per page', default: 30
+  param :status, 'Order status', options: ['checkout', 'pending', 'closed', 'shipped'], multiple: true
+  param :sort, 'Sort', options: ['updated_on-desc', 'updated_on-asc'], default: 'updated_on-desc'
+
+  def results
+    query = Order.sort(params[:sort])
+    query = query.where(["code LIKE ? OR user_name ?", params[:q]]) if params[:q]
+    query = query.where(status: params[:status]) if params[:status].any?
+    query = query.paginate(page: params[:page], per_page: params[:per_page])
+  end
+end
+```
+
+### :match
+
+Pass a regular expression to match parameter value. Non-matching values will be ignored or use default value, if available.
+
+```ruby
+class OrdersSearch
+  include Parametric::Params
+  param :email, 'Valid email address', match: /\w+@\w+\.\w+/
+end
+```
+
+### :options array
+
+Declare allowed values in an array. Values not in the options will be ignored or use default value.
+
+```ruby
+class OrdersSearch
+  include Parametric::Params
+  param :sort, 'Sort', options: ['updated_on-desc', 'updated_on-asc'], default: 'updated_on-desc'
+end
+```
+
+### :multiple values
+
+`:multiple` values are separated on "," and treated as arrays.
+
+```ruby
+class OrdersSearch
+  include Parametric::Params
+  param :status, 'Order status', multiple: true
+end
+
+search = OrdersSearch.new(status: 'closed,shipped,abandoned')
+search.params[:status] # => ['closed', 'shipped', 'abandoned']
+```
+
+If `:options` array is declared, values outside of the options will be filtered out.
+
+```ruby
+class OrdersSearch
+  include Parametric::Params
+  param :status, 'Order status', options: ['checkout', 'pending', 'closed', 'shipped'], multiple: true
+end
+
+search = OrdersSearch.new(status: 'closed,shipped,abandoned')
+search.params[:status] # => ['closed', 'shipped']
+```
+
+When using `:multiple`, results and defaults are always returned as an array, for consistency.
+
+```ruby
+class OrdersSearch
+  include Parametric::Params
+  param :status, 'Order status', multiple: true, default: 'closed'
+end
+
+search = OrdersSearch.new
+search.params[:status] # => ['closed']
+```
+
+## `available_params`
+
+`#available_params` returns the subset of keys that were populated (including defaults). Useful to build query strings.
+
+```ruby
+order_search = OrdersSearch.new(page: 2, foo: 'bar')
+order_search.available_params # => {page: 2, per_page: 50}
+```
+
+## `schema`
+
+`#schema` returns a data structure including meta-data on each parameter, such as "label" and "options". Useful for building forms or self-documented Hypermedia APIs (or maybe [json-schema](http://json-schema.org/example2.html) endpoints).
+
+```ruby
+order_search.schema # =>
+
+{
+  q: {label: 'Full text search query', value: ''},
+  page: {label: 'Page number', value: 1},
+  per_page: {label: 'Items per page', value: 30},
+  status: {label: 'Order status', value: '', options: ['checkout', 'pending', 'closed', 'shipped'], multiple: true},
+  sort: {label: 'Sort', value: 'updated_on-desc', options: ['updated_on-desc', 'updated_on-asc']}
+}
+```
+
+## Parametric::Hash
+
+The alternative `Parametric::Hash` module makes your objects quack like a hash, instead of exposing the `#params` object directly.
+
+```ruby
+class OrdersParams
+  include Parametric::Hash
+  param :q, 'Full text search query'
+  param :page, 'Page number', default: 1
+  param :per_page, 'Items per page', default: 30
+  param :status, 'Order status', options: ['checkout', 'pending', 'closed', 'shipped'], multiple: true
+end
+```
+
+```ruby
+order_params = OrdersParams.new(page: 2, q: 'foobar')
+order_params[:page] # => 2
+order_params[:per_page] # => 30
+order_params.each{|key, value| ... }
+```
+
+## Use cases
+
+### In Rails
+
+```ruby
+def index
+  @search = OrdersSearch.new(params)
+  @results = @search.results
+end
+```
+
+I use this along with [Oat](https://github.com/ismasan/oat) in API projects:
+
+```ruby
+def index
+  search = OrdersSearch.new(params)
+  render json: OrdersSerializer.new(search)
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'parametric'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parametric
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/parametric/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/parametric/hash.rb

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,60 @@
+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/policies.rb

@@ -0,0 +1,62 @@
+module Parametric
+  module Policies
+
+    class Policy
+      def initialize(value, options, decorated = nil)
+        @value, @options = value, options
+        @decorated = decorated
+      end
+
+      def wrap(decoratedClass)
+        decoratedClass.new(@value, @options, self)
+      end
+
+      def value
+        Array(@value)
+      end
+
+      protected
+      attr_reader :decorated, :options
+    end
+
+    class DefaultPolicy < Policy
+      def value
+        v = decorated.value
+        v.any? ? v : Array(options[:default])
+      end
+    end
+
+    class MultiplePolicy < Policy
+      OPTION_SEPARATOR = /\s*,\s*/.freeze
+
+      def value
+        v = decorated.value.first
+        v = v.split(options.fetch(:separator, OPTION_SEPARATOR)) if v.is_a?(String)
+        Array(v)
+      end
+    end
+
+    class SinglePolicy < Policy
+      def value
+        decorated.value.first
+      end
+    end
+
+    class OptionsPolicy < Policy
+      def value
+        decorated.value.each_with_object([]){|a,arr| 
+          arr << a if options[:options].include?(a)
+        }
+      end
+    end
+
+    class MatchPolicy < Policy
+      def value
+        decorated.value.each_with_object([]){|a,arr| 
+          arr << a if a.to_s =~ options[:match]
+        }
+      end
+    end
+
+  end
+end

data/lib/parametric/utils.rb

@@ -0,0 +1,24 @@
+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/lib/parametric/version.rb

@@ -0,0 +1,3 @@
+module Parametric
+  VERSION = "0.0.1"
+end

data/lib/parametric.rb

@@ -0,0 +1,9 @@
+module Parametric
+
+end
+
+require "parametric/utils"
+require "parametric/version"
+require "parametric/policies"
+require "parametric/params"
+require "parametric/hash"

data/parametric.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parametric/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "parametric"
+  spec.version       = Parametric::VERSION
+  spec.authors       = ["Ismael Celis"]
+  spec.email         = ["ismaelct@gmail.com"]
+  spec.summary       = %q{DSL for declaring allowed parameters with options, regexp patern and default values.}
+  spec.description   = %q{Useful for modelling search or form objects, white-listed query parameters and safe parameter defaults.}
+  spec.homepage      = ""
+  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"
+end

data/spec/parametric_spec.rb

@@ -0,0 +1,182 @@
+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

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: parametric
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ismael Celis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-13 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
+  name: rspec
+  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: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/parametric.rb
+- lib/parametric/hash.rb
+- lib/parametric/params.rb
+- lib/parametric/policies.rb
+- lib/parametric/utils.rb
+- lib/parametric/version.rb
+- parametric.gemspec
+- spec/parametric_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.1.11
+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/spec_helper.rb