parametric 0.0.5 → 0.1.0

data/lib/parametric/typed_params.rb

@@ -1,23 +0,0 @@
-require 'parametric/params'
-module Parametric
-  module TypedParams
-    def self.included(base)
-      base.send(:include, Params)
-      base.extend DSL
-    end
-
-    module DSL
-      def integer(field_name, label = '', opts = {}, &block)
-        param(field_name, label, opts.merge(coerce: :to_i), &block)
-      end
-
-      def string(field_name, label = '', opts = {}, &block)
-        param(field_name, label, opts.merge(coerce: :to_s), &block)
-      end
-
-      def array(field_name, label = '', opts = {}, &block)
-        param(field_name, label, opts.merge(multiple: true), &block)
-      end
-    end
-  end
-end

data/lib/parametric/utils.rb

@@ -1,24 +0,0 @@
-module Parametric
-  module Utils
-    def self.value(val, separator = ',')
-      if val.nil?
-        ''
-      elsif val.is_a?(Array)
-        val.join(separator)
-      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/support/class_attribute.rb

@@ -1,68 +0,0 @@
-begin
-  require 'active_support/core_ext/class/attribute'
-rescue LoadError
-  module Kernel
-    # Returns the object's singleton class.
-    def singleton_class
-      class << self
-        self
-      end
-    end unless respond_to?(:singleton_class) # exists in 1.9.2
-
-    # class_eval on an object acts like singleton_class.class_eval.
-    def class_eval(*args, &block)
-      singleton_class.class_eval(*args, &block)
-    end
-  end
-
-  class Module
-    def remove_possible_method(method)
-      if method_defined?(method) || private_method_defined?(method)
-        remove_method(method)
-      end
-    rescue NameError
-      # If the requested method is defined on a superclass or included module,
-      # method_defined? returns true but remove_method throws a NameError.
-      # Ignore this.
-    end
-
-    def redefine_method(method, &block)
-      remove_possible_method(method)
-      define_method(method, &block)
-    end
-  end
-
-  class Class
-    def class_attribute(*attrs)
-      attrs.each do |name|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def self.#{name}() nil end
-          def self.#{name}?() !!#{name} end
-
-          def self.#{name}=(val)
-            singleton_class.class_eval do
-              remove_possible_method(:#{name})
-              define_method(:#{name}) { val }
-            end
-
-            if singleton_class?
-              class_eval do
-                remove_possible_method(:#{name})
-                def #{name}
-                  defined?(@#{name}) ? @#{name} : singleton_class.#{name}
-                end
-              end
-            end
-            val
-          end
-        RUBY
-
-      end
-    end
-
-    private
-    def singleton_class?
-      ancestors.first != self
-    end
-  end
-end

data/spec/nested_params_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-describe Parametric do
-
-  describe Parametric::Params do
-
-    let(:klass) do
-      Class.new do
-        include Parametric::Params
-        param :name, 'User name'
-        param :tags, 'Tags', multiple: true, default: 'defaulttag'
-        param :lala, 'Lala' do
-          param :foo, 'foo'
-        end
-        param :account, 'Account' do
-          param :name, 'Account name'
-          param :admin, 'Admin user' do
-            param :name, 'User name'
-          end
-          param :shop, 'Shop' do
-            param :url, 'Shop url', default: 'http://google.com'
-          end
-        end
-        param :variants, 'Product variants', multiple: true do
-          param :name, 'variant name', default: 'default'
-          param :price
-          param :tags, 'Variant tags', multiple: true
-        end
-      end
-    end
-
-    let(:subject) do
-      klass.new({
-        foo: 'bar',
-        name: 'user1',
-        account: {
-          name: 'account1',
-          lala: 1,
-          admin: {
-            name: 'Joe Bloggs'
-          }
-        },
-        variants: [
-          {name: 'red', price: 10},
-          {price: 11, tags: 'foo,bar'}
-        ]
-      })
-    end
-
-    describe '#params' do
-      it 'filters nested objects' do
-        expect(subject.params.has_key?(:foo)).to be_false
-        expect(subject.params[:name]).to eql('user1')
-        expect(subject.params[:account][:name]).to eql('account1')
-        expect(subject.params[:account].has_key?(:lala)).to be_false
-        expect(subject.params[:account][:admin][:name]).to eql('Joe Bloggs')
-      end
-
-      it 'nullifies nested objects that were not passed' do
-        expect(subject.params[:account].has_key?(:shop)).to be_true
-        expect(subject.params[:account][:shop]).to be_nil
-      end
-      
-      it 'filters nested :multiple into arrays of objects' do
-        expect(subject.params[:variants].size).to eql(2)
-        expect(subject.params[:variants][0][:name]).to eql('red')
-        expect(subject.params[:variants][0][:price]).to eql(10)
-        expect(subject.params[:variants][0][:tags]).to match_array([])
-        expect(subject.params[:variants][1][:name]).to eql('default')
-        expect(subject.params[:variants][1][:price]).to eql(11)
-        expect(subject.params[:variants][1][:tags]).to match_array(['foo', 'bar'])
-      end
-    end
-
-    describe '#available_params' do
-      it 'does not include key for nested objects that were not passed' do
-        expect(subject.available_params.has_key?(:lala)).to be_false
-        expect(subject.available_params[:account].has_key?(:shop)).to be_false
-      end
-    end
-
-    describe '#schema' do
-      it 'includes nested param schemas' do
-        expect(subject.schema[:account].schema[:name].value).to eql('account1')
-        expect(subject.schema[:account].schema[:name].label).to eql('Account name')
-        expect(subject.schema[:account].schema[:admin].schema[:name].value).to eql('Joe Bloggs')
-      end
-    end
-  end
-end

data/spec/parametric_spec.rb

@@ -1,261 +0,0 @@
-require 'spec_helper'
-
-describe Parametric do
-  it 'should have a version number' do
-    Parametric::VERSION.should_not be_nil
-  end
-
-  shared_examples 'a configurable params object' do
-    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 'does set value if it does :match' do
-      klass.new(email: 'my@email.com').params[:email].should == 'my@email.com'
-    end
-
-    it ':multiple values can be arrays' do
-      klass.new(status: ['one','three']).params[:status].should == ['one', 'three']
-    end
-
-    it 'defaults work for false values' do
-      klass.new(email: 'my@email').params[:email].should be_nil
-    end
-
-    it 'does set value if it does :match' do
-      klass.new(available: false).params[:available].should be_false
-    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
-
-    it 'does not include parameters marked as :nullable' do
-      klass.new.params.has_key?(:nullable).should be_false
-    end
-  end
-
-  describe 'TypedParams' do
-    let(:klass) do
-      Class.new do
-        include Parametric::TypedParams
-        string :name, 'User name'
-        integer :page, 'page number', default: 1
-        integer :per_page, 'items per page', default: 50
-        array :status, 'status', options: ['one', 'two', 'three']
-        array :piped_status, 'status with pipes', separator: '|'
-        string :country, 'country', options: ['UK', 'CL', 'JPN']
-        string :email, 'email', match: /\w+@\w+\.\w+/
-        array :emails, 'emails', match: /\w+@\w+\.\w+/, default: 'default@email.com'
-        param :nullable, 'nullable param', nullable: true
-      end
-    end
-
-    let(:subject) { klass.new(foo: 'bar', per_page: '20', status: 'four') }
-    it_should_behave_like 'a configurable params object'
-
-    it 'does not break when value is nil' do
-      klass = Class.new do
-        include Parametric::TypedParams
-        array :friends, 'friends', nullable: true do
-          string :name, 'Name'
-        end
-      end
-      klass.new(friends: nil).params[:friends].should == []
-      klass.new(friends: []).params[:friends].should == []
-      klass.new(friends: [{name: 'foo'}]).params[:friends].first[:name].should == 'foo'
-      klass.new.params.has_key?(:friends).should be_false
-    end
-  end
-
-  describe Parametric::Params do
-
-    let(:klass) do
-      Class.new do
-        include Parametric::Params
-        param :name, 'User name'
-        param :page, 'page number', default: 1, coerce: :to_i
-        param :per_page, 'items per page', default: 50, coerce: lambda{|value| value.to_i}
-        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'
-        param :available, 'available', default: true
-        param :nullable, 'nullable param', nullable: true
-      end
-    end
-
-    describe '#params' do
-      let(:subject) { klass.new(foo: 'bar', per_page: 20, status: 'four') }
-      it_should_behave_like 'a configurable params object'
-    end
-
-    describe 'subclassing' do
-      let(:subclass){ Class.new(klass) }
-      let(:subject){ subclass.new(foo: 'bar', per_page: 20, status: 'four') }
-      it_should_behave_like 'a configurable params object'
-    end
-
-    describe '#available_params' do
-      let(:subject) { klass.new(foo: 'bar', name: 'lala', per_page: 20, status: 'four', emails: 'one@email.com,two@email.com') }
-
-      it 'only includes declared params with values or defaults' do
-        subject.available_params.keys.sort.should == [:available, :emails, :name, :page, :per_page]
-        subject.available_params[:emails].should == ['one@email.com', 'two@email.com']
-        subject.available_params[:name].should == 'lala'
-        subject.available_params[:per_page].should == 20
-        subject.available_params[:page].should == 1
-      end
-
-      describe ':coerce option' do
-        it 'accepts method_name as a symbol' do
-          klass.new(page: '10').available_params[:page].should == 10
-        end
-
-        it 'accepts a proc' do
-          klass.new(per_page: '10').available_params[:per_page].should == 10
-        end
-      end
-
-      describe '#flat' do
-        it 'joins values back' do
-          subject.available_params.flat[:emails].should == 'one@email.com,two@email.com'
-        end
-      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+/
-
-        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(Parametric::Hash) do
-        string :name, 'User name'
-        integer :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