compel 0.1.1

data/lib/compel/validation.rb

@@ -0,0 +1,72 @@
+module Compel
+
+  module Validation
+
+    def valid?(value, options)
+      validate(value, options).length == 0
+    end
+
+    def validate!(value, options)
+      errors = validate(value, options)
+
+      if errors.length > 0
+        raise ParamValidationError, errors[0]
+      end
+    end
+
+    def validate(value, options)
+      errors = []
+
+      options.each do |option, option_value|
+        # most of this code snippet is from sinatra-param gem
+        # https://github.com/mattt/sinatra-param
+        # by Mattt Thompson (@mattt)
+        begin
+          case option.to_sym
+          when :required
+            raise ParamValidationError, 'is required' if option_value && value.nil?
+          when :blank
+            raise ParamValidationError, 'cannot be blank' if !option_value && case value
+            when String
+              !(/\S/ === value)
+            when Array, Hash
+              value.empty?
+            else
+              value.nil?
+            end
+          when :format
+            raise ParamValidationError, 'must be a string if using the format validation' unless value.kind_of?(String)
+            raise ParamValidationError, "must match format #{option_value}" unless value =~ option_value
+          when :is
+            raise ParamValidationError, "must be #{option_value}" unless value === option_value
+          when :in, :within, :range
+            raise ParamValidationError, "must be within #{option_value}" unless value.nil? || case option_value
+            when Range
+              option_value.include?(value)
+            else
+              Array(option_value).include?(value)
+            end
+          when :min
+            raise ParamValidationError, "cannot be less than #{option_value}" unless value.nil? || option_value <= value
+          when :max
+            raise ParamValidationError, "cannot be greater than #{option_value}" unless value.nil? || option_value >= value
+          when :length
+            raise ParamValidationError, "cannot have length different than #{option_value}" unless value.nil? || option_value == "#{value}".length
+          when :min_length
+            raise ParamValidationError, "cannot have length less than #{option_value}" unless value.nil? || option_value <= value.length
+          when :max_length
+            raise ParamValidationError, "cannot have length greater than #{option_value}" unless value.nil? || option_value >= value.length
+          end
+        rescue ParamValidationError => exception
+          errors << exception.message
+        end
+      end
+
+      errors
+    end
+
+    extend self
+
+  end
+
+end

data/lib/compel/version.rb

@@ -0,0 +1,3 @@
+module Compel
+  VERSION = '0.1.1'
+end

data/lib/compel.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'hashie'
+require 'hashie/extensions/symbolize_keys'
+
+require 'compel/coercion/type'
+require 'compel/coercion/integer'
+require 'compel/coercion/float'
+require 'compel/coercion/string'
+require 'compel/coercion/date'
+require 'compel/coercion/time'
+require 'compel/coercion/datetime'
+require 'compel/coercion/hash'
+require 'compel/coercion/json'
+require 'compel/coercion/boolean'
+
+require 'compel/invalid_params_error'
+require 'compel/param_validation_error'
+require 'compel/param_type_error'
+
+require 'compel/param'
+require 'compel/contract'
+require 'compel/coercion'
+require 'compel/validation'
+require 'compel/errors'
+
+module Compel
+
+  Boolean = Coercion::Boolean
+
+  def self.run!(params, &block)
+    Contract.new(params, &block).validate.raise?
+  end
+
+  def self.run?(params, &block)
+    Contract.new(params, &block).validate.valid?
+  end
+
+  def self.run(params, &block)
+    Contract.new(params, &block).validate.serialize
+  end
+
+end

data/spec/compel/coercion_spec.rb

@@ -0,0 +1,186 @@
+describe Compel::Coercion do
+
+  context 'Type coercion' do
+
+    context 'Integer' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!(123, Integer)
+        expect(value).to eq(123)
+      end
+
+      it 'should coerce 1' do
+        value = Compel::Coercion.coerce!('123', Integer)
+        expect(value).to eq(123)
+      end
+
+      it 'should coerce 2' do
+        value = Compel::Coercion.coerce!(123.3, Integer)
+        expect(value).to eq(123)
+      end
+
+      it 'should not coerce' do
+        expect(Compel::Coercion.valid?('123abc', Integer)).to eq(false)
+
+        expect { Compel::Coercion.coerce!('123abc', Integer) }.to \
+          raise_error Compel::ParamTypeError, "'123abc' is not a valid Integer"
+      end
+
+    end
+
+    context 'Float' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!('1.2', Float)
+
+        expect(value).to eq(1.2)
+      end
+
+      it 'should not coerce' do
+        expect(Compel::Coercion.valid?('1.a233', Float)).to eq(false)
+
+        expect { Compel::Coercion.coerce!('1.a233', Float) }.to \
+          raise_error Compel::ParamTypeError, "'1.a233' is not a valid Float"
+      end
+
+    end
+
+    context 'String' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!('abc', String)
+
+        expect(value).to eq('abc')
+      end
+
+      it 'should not coerce' do
+        value = 1.2
+
+        expect(Compel::Coercion.valid?(value, String)).to eq(false)
+
+        expect { Compel::Coercion.coerce!(value, String) }.to \
+          raise_error Compel::ParamTypeError, "'#{value}' is not a valid String"
+      end
+
+    end
+
+    context 'Date' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!('2015-12-22', Date)
+
+        expect(value).to eq(Date.parse('2015-12-22'))
+      end
+
+      it 'should not coerce' do
+        value = '2015-0'
+
+        expect(Compel::Coercion.valid?(value, Date)).to eq(false)
+
+        expect { Compel::Coercion.coerce!(value, Date) }.to \
+          raise_error Compel::ParamTypeError, "'#{value}' is not a valid Date"
+      end
+
+    end
+
+    context 'DateTime' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!('2015-12-22', DateTime)
+
+        expect(value).to be_a DateTime
+        expect(value.year).to eq(2015)
+        expect(value.month).to eq(12)
+        expect(value.day).to eq(22)
+      end
+
+    end
+
+    context 'Hash' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!({
+          first_name: 'Joaquim',
+          last_name: 'Adráz'
+        }, Hash)
+
+        expect(value).to eq({
+          'first_name' => 'Joaquim',
+          'last_name' => 'Adráz'
+        })
+      end
+
+      it 'should coerce 1' do
+        value = Compel::Coercion.coerce!({
+          'first_name' => 'Joaquim',
+          'last_name' => 'Adráz'
+        }, Hash)
+
+        expect(value).to eq({
+          'first_name' => 'Joaquim',
+          'last_name' => 'Adráz'
+        })
+      end
+
+      it 'should coerce 2' do
+        value = Compel::Coercion.coerce!(Hashie::Mash.new({
+          first_name: 'Joaquim',
+          last_name: 'Adráz'
+        }), Hash)
+
+        expect(value).to eq({
+          'first_name' => 'Joaquim',
+          'last_name' => 'Adráz'
+        })
+      end
+
+      it 'should not coerce' do
+        expect { Compel::Coercion.coerce!(123, Hash) }.to \
+          raise_error Compel::ParamTypeError, "'123' is not a valid Hash"
+      end
+
+      it 'should not coerce 1' do
+        expect { Compel::Coercion.coerce!('hash', Hash) }.to \
+          raise_error Compel::ParamTypeError, "'hash' is not a valid Hash"
+      end
+
+      it 'should not coerce 2' do
+        expect { Compel::Coercion.coerce!(['hash'], Hash) }.to \
+          raise_error Compel::ParamTypeError, "'[\"hash\"]' is not a valid Hash"
+      end
+
+    end
+
+    context 'JSON' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce! \
+          "{\"first_name\":\"Joaquim\",\"last_name\":\"Adráz\"}", JSON
+
+        expect(value).to eq({
+          'first_name' => 'Joaquim',
+          'last_name' => 'Adráz'
+        })
+      end
+
+    end
+
+    context 'Boolean' do
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!('f', Compel::Boolean)
+
+        expect(value).to eq(false)
+      end
+
+      it 'should coerce' do
+        value = Compel::Coercion.coerce!('0', Compel::Boolean)
+
+        expect(value).to eq(false)
+      end
+
+    end
+
+  end
+
+end

data/spec/compel/compel_spec.rb

@@ -0,0 +1,279 @@
+describe Compel do
+
+  def make_the_call(method, params)
+    Compel.send(method, params) do
+      param :first_name, String, required: true
+      param :last_name, String, required: true
+      param :birth_date, DateTime
+    end
+  end
+
+  context '#run!' do
+
+    it 'should raise InvalidParamsError exception' do
+      params = {
+        first_name: 'Joaquim'
+      }
+
+      expect{ make_the_call(:run!, params) }.to \
+        raise_error Compel::InvalidParamsError, 'params are invalid'
+    end
+
+    it 'shoudl raise InvalidParamsError exception with errors' do
+      params = {
+        first_name: 'Joaquim'
+      }
+
+      expect{ make_the_call(:run!, params) }.to raise_error do |exception|
+        expect(exception.params).to eq \
+          Hashie::Mash.new(first_name: 'Joaquim')
+
+        expect(exception.errors).to eq \
+          Hashie::Mash.new(last_name: ['is required'])
+      end
+    end
+
+  end
+
+  context '#run?' do
+
+    it 'should return true' do
+      params = {
+        first_name: 'Joaquim',
+        last_name: 'Adráz',
+        birth_date: '1989-08-06T09:00:00'
+      }
+
+      expect(make_the_call(:run?, params)).to eq(true)
+    end
+
+    it 'should return false' do
+      params = {
+        first_name: 'Joaquim'
+      }
+
+      expect(make_the_call(:run?, params)).to eq(false)
+    end
+
+  end
+
+  context '#run' do
+
+    def make_the_call(method, params)
+      Compel.send(method, params) do
+        param :first_name, String, required: true
+        param :last_name, String, required: true
+        param :birth_date, DateTime
+        param :age, Integer
+        param :admin, Compel::Boolean
+        param :blog_role, Hash do
+          param :admin, Compel::Boolean, required: true
+        end
+      end
+    end
+
+    it 'should compel returning coerced values' do
+      params = {
+        first_name: 'Joaquim',
+        last_name: 'Adráz',
+        birth_date: '1989-08-06T09:00:00',
+        age: '26',
+        admin: 'f',
+        blog_role: {
+          admin: '0'
+        }
+      }
+
+      expect(make_the_call(:run, params)).to eq \
+        Hashie::Mash.new({
+          first_name: 'Joaquim',
+          last_name: 'Adráz',
+          birth_date: DateTime.parse('1989-08-06T09:00:00'),
+          age: 26,
+          admin: false,
+          blog_role: {
+            admin: false
+          }
+        })
+    end
+
+    it 'should not compel for invalid params' do
+      expect{ make_the_call(:run, 1) }.to \
+        raise_error Compel::ParamTypeError, 'params must be an Hash'
+    end
+
+    it 'should not compel for invalid params 1' do
+      expect{ make_the_call(:run, nil) }.to \
+        raise_error Compel::ParamTypeError, 'params must be an Hash'
+    end
+
+    it 'should not compel'  do
+      params = {
+        first_name: 'Joaquim'
+      }
+
+      expect(make_the_call(:run, params)).to eq \
+        Hashie::Mash.new({
+          first_name: 'Joaquim',
+          errors: {
+            last_name: ['is required']
+          }
+        })
+    end
+
+    context 'nested Hash' do
+
+      def make_the_call(method, params)
+        Compel.send(method, params) do
+          param :address, Hash, required: true do
+            param :line_one, String, required: true
+            param :line_two, String
+            param :post_code, Hash, required: true do
+              param :prefix, Integer, length: 4, required: true
+              param :suffix, Integer, length: 3
+              param :county, Hash do
+                param :code, String, length: 2, required: true
+                param :name, String
+              end
+            end
+          end
+        end
+      end
+
+      it 'should run?' do
+        params = {
+          address: {
+            line_one: 'Lisbon',
+            line_two: 'Portugal',
+            post_code: {
+              prefix: 1100,
+              suffix: 100
+            }
+          }
+        }
+
+        expect(make_the_call(:run?, params)).to eq(true)
+      end
+
+      it 'should not compel' do
+        params = {
+          address: {
+            line_two: 'Portugal'
+          }
+        }
+
+        expect(make_the_call(:run, params)).to eq \
+          Hashie::Mash.new({
+            address: {
+              line_two: 'Portugal'
+            },
+            errors: {
+              address: {
+                line_one: ['is required'],
+                post_code: ['params must be an Hash']
+              }
+            }
+          })
+      end
+
+      it 'should not compel 1' do
+        params = {
+          address: {
+            line_two: 'Portugal',
+            post_code: {
+              prefix: '1',
+              county: {
+                code: 'LX'
+              }
+            }
+          }
+        }
+
+        expect(make_the_call(:run, params)).to eq \
+          Hashie::Mash.new({
+            address: {
+              line_two: 'Portugal',
+              post_code: {
+                prefix: 1,
+                county: {
+                  code: 'LX'
+                }
+              }
+            },
+            errors: {
+              address: {
+                line_one: ['is required'],
+                post_code: {
+                  prefix: ['cannot have length different than 4']
+                }
+              }
+            }
+          })
+      end
+
+      it 'should not compel 2' do
+        params = {
+          address: {
+            post_code: {
+              suffix: '1234'
+            }
+          }
+        }
+
+        expect(make_the_call(:run, params)).to eq \
+          Hashie::Mash.new({
+            address: {
+              post_code: {
+                suffix: 1234
+              }
+            },
+            errors: {
+              address: {
+                line_one: ['is required'],
+                post_code: {
+                  prefix: ['is required'],
+                  suffix: ['cannot have length different than 3']
+                }
+              }
+            }
+          })
+      end
+
+      it 'should not compel 3' do
+        params = {
+          address: {
+            post_code: {
+              prefix: '1100',
+              suffix: '100',
+              county: {}
+            },
+          }
+        }
+
+        expect(make_the_call(:run, params)).to eq \
+          Hashie::Mash.new({
+            address: {
+              post_code: {
+                prefix: 1100,
+                suffix: 100,
+                county: {}
+              }
+            },
+            errors: {
+              address: {
+                line_one: ['is required'],
+                post_code: {
+                  county: {
+                    code: ['is required']
+                  }
+                }
+              }
+            }
+          })
+      end
+
+    end
+
+  end
+
+end

data/spec/compel/contract_spec.rb

@@ -0,0 +1,36 @@
+describe Compel::Contract do
+
+  context '#conditions' do
+
+    it 'should build with conditions block option' do
+      contract = \
+        Compel::Contract.new({ first_name: 'Joaquim' }) do
+          param :address, Hash, required: true do
+            param :post_code, String
+          end
+        end
+
+      expect(contract.conditions[:address].type).to eq(Hash)
+      expect(contract.conditions[:address].required?).to eq(true)
+      expect(contract.conditions[:address].conditions?).to eq(true)
+    end
+
+  end
+
+  context 'params' do
+
+    it 'should return coerced params' do
+      contract = \
+        Compel::Contract.new(date: '2015-12-22') { param :date, DateTime }
+          .validate
+
+      expect(contract.coerced_params.date).to be_a DateTime
+      expect(contract.coerced_params.date.year).to eq(2015)
+      expect(contract.coerced_params.date.month).to eq(12)
+      expect(contract.coerced_params.date.day).to eq(22)
+    end
+
+  end
+
+
+end

data/spec/compel/errors_spec.rb

@@ -0,0 +1,48 @@
+describe Compel::Errors do
+
+  it 'should add error' do
+    errors = Compel::Errors.new
+    errors.add(:first_name, 'is required')
+
+    expect(errors.to_hash[:first_name]).to include('is required')
+  end
+
+  it 'should add multiple errors' do
+    errors = Compel::Errors.new
+    errors.add(:first_name, 'is required')
+    errors.add(:first_name, 'is invalid')
+
+    expect(errors.to_hash[:first_name]).to include('is required')
+    expect(errors.to_hash[:first_name]).to include('is invalid')
+  end
+
+  it 'should add Compel::Errors' do
+    address_errors = Compel::Errors.new
+    address_errors.add(:line_one, 'is required')
+    address_errors.add(:post_code, 'must be an Hash')
+
+    errors = Compel::Errors.new
+    errors.add(:address, address_errors)
+
+    expect(errors.to_hash[:address][:line_one]).to include('is required')
+    expect(errors.to_hash[:address][:post_code]).to include('must be an Hash')
+  end
+
+  it 'should add nested Compel::Errors' do
+    post_code_errors = Compel::Errors.new
+    post_code_errors.add(:prefix, 'is invalid')
+    post_code_errors.add(:suffix, 'is required')
+
+    address_errors = Compel::Errors.new
+    address_errors.add(:line_one, 'is required')
+    address_errors.add(:post_code, post_code_errors)
+
+    errors = Compel::Errors.new
+    errors.add(:address, address_errors)
+
+    expect(errors.to_hash[:address][:line_one]).to include('is required')
+    expect(errors.to_hash[:address][:post_code][:prefix]).to include('is invalid')
+    expect(errors.to_hash[:address][:post_code][:suffix]).to include('is required')
+  end
+
+end

data/spec/compel/param_spec.rb

@@ -0,0 +1,25 @@
+describe Compel::Param do
+
+  context 'default value' do
+
+    it 'should override default value when value is given' do
+      param = Compel::Param.new(:number, Integer, nil, { default: 123 })
+
+      expect(param.value).to eq(123)
+    end
+
+    it 'should use default value when not given a value' do
+      param = Compel::Param.new(:number, Integer, 123, { default: 456 })
+
+      expect(param.value).to eq(123)
+    end
+
+    it 'should allow proc as default value' do
+      param = Compel::Param.new(:year, Integer, nil, { default: Proc.new { Time.now.year } })
+
+      expect(param.value).to eq(Time.now.year)
+    end
+
+  end
+
+end