compel 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20943c4ee705f920a1d316a9028b0ddc7e26cfc7
+  data.tar.gz: e9071ee624b81b8efe30b1747eacc3d00426339b
+SHA512:
+  metadata.gz: 638f760fe8ea31a6545101cf48923ed2d835cf4f449d4f29bbf64610945eb78013d4aaedb5ea0724946846235b490741712b12d7dbd8cc09ac2c60127734aa0f
+  data.tar.gz: cf70bca72fc84dbc3e4c3434a16bb49569a659188e1be6049e20d058027ac33be2f0361b12f240a9d1b5e0a3b6572a7b5ae295735445cf29628f09f28558d1b9

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Joaquim Adráz
+
+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,131 @@
+Compel 
+==========================
+![](https://travis-ci.org/joaquimadraz/compel.svg)
+[![Code Climate](https://codeclimate.com/github/joaquimadraz/compel/badges/gpa.svg)](https://codeclimate.com/github/joaquimadraz/compel)
+
+Ruby Hash Coercion and Validation
+
+This is a straight forward way to validate a Ruby Hash: just give an object and the schema.
+
+The motivation was to create an integration for [RestMyCase](https://github.com/goncalvesjoao/rest_my_case) and have validations before any business logic execution.
+
+Based on the same principle from [Grape](https://github.com/ruby-grape/grape) framework and [sinatra-param](https://github.com/mattt/sinatra-param) gem to validate request params.
+
+###Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'compel'
+
+And then execute:
+
+    $ bundle
+
+### Example
+
+```ruby
+params= {
+  first_name: 'Joaquim',
+  birth_date: '1989-0',
+  address: {
+    line_one: 'Lisboa',
+    post_code: '1100',
+    country: 'PT'
+  }
+}
+
+Compel.run(params) do
+  param :first_name, String, required: true
+  param :last_name, String, required: true
+  param :birth_date, DateTime
+  param :address, Hash do
+    param :line_one, String, required: true
+    param :line_two, String, default: '-'
+    param :post_code, String, required: true, format: /^\d{4}-\d{3}$/
+    param :country_code, String, in: ['PT', 'GB'], default: 'PT'
+  end
+end
+```
+
+Will return an [Hashie::Mash](https://github.com/intridea/hashie) object:
+
+```ruby
+{
+  "first_name" => "Joaquim",
+  "address" => {
+    "line_one" => "Lisboa", 
+    "line_two" => "-", # default value
+    "post_code_pfx" => 1100, # Already an Integer
+    "country_code"=> "PT"
+  },
+  "errors" => {
+    "last_name" => ["is required"],
+    "birth_date" => ["'1989-0' is not a valid DateTime"],
+    "address" => {
+      "post_code_sfx" => ["is required"]
+    }
+  }
+}
+```
+
+There are 3 ways run validations:
+
+- `#run`  
+  - Validates and returns an Hash with coerced params plus a `:errors` key with a _Rails like_ Hash of errors if any.
+- `#run!`
+  - Validates and raises `Compel::InvalidParamsError` exception with the coerced params and errors.
+- `#run?`
+  - Validates and returns true or false.
+  
+
+### Types
+
+- `Integer`
+- `Float`
+- `String`
+- `JSON`
+  - ex: `"{\"a\":1,\"b\":2,\"c\":3}"`
+- `Hash`
+  - ex: `{ a: 1,  b: 2, c: 3 }`
+- `Date`
+- `Time`
+- `DateTime`
+- `Compel::Boolean`, 
+  - ex: `1`/`0`, `true`/`false`, `t`/`f`, `yes`/`no`, `y`/`n`
+
+### Sinatra Integration
+
+If you want to use with `Sinatra`, just add the following code to your Sinatra app:
+
+```ruby
+class App < Sinatra::Base
+  
+  ...
+  
+  def compel(&block)
+    Compel::run!(params, &block)
+  end
+
+  error Compel::InvalidParamsError do |exception|
+    status 400
+    json errors: exception.errors
+  end
+  
+  configure :development do
+    set :show_exceptions, false
+    set :raise_errors, true
+  end
+  
+end
+```
+
+### TODO
+
+- Write more Documentation (check specs for now ;)
+- Rails integration
+- [RestMyCase](https://github.com/goncalvesjoao/rest_my_case) integration
+
+
+### Get in touch
+If you have any questions, write an issue or get in touch [@joaquimadraz](https://twitter.com/joaquimadraz)
+

data/Rakefile

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

data/compel.gemspec

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'compel/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'compel'
+  gem.version       = Compel::VERSION
+  gem.authors       = ['Joaquim Adráz']
+  gem.email         = ['joaquim.adraz@gmail.com']
+  gem.description   = %q{Compel}
+  gem.summary       = %q{Ruby Hash Coercion and Validation}
+  gem.homepage      = 'https://github.com/joaquimadraz/compel'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'hashie', '~> 3.4'
+  gem.add_development_dependency 'rspec', '~> 3.2'
+  gem.add_development_dependency 'rake', '~> 0'
+  gem.add_development_dependency 'pry', '~> 0'
+end

data/lib/compel/coercion/boolean.rb

@@ -0,0 +1,21 @@
+module Compel
+  module Coercion
+
+    class Boolean < Type
+
+      def coerce
+        if /(false|f|no|n|0)$/i === "#{value}"
+          return false
+        end
+
+        if /(true|t|yes|y|1)$/i === "#{value}"
+          return true
+        end
+
+        fail
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/date.rb

@@ -0,0 +1,13 @@
+module Compel
+  module Coercion
+
+    class Date < Type
+
+      def coerce
+        ::Date.parse(value)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/datetime.rb

@@ -0,0 +1,13 @@
+module Compel
+  module Coercion
+
+    class DateTime < Type
+
+      def coerce
+        ::DateTime.parse(value)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/float.rb

@@ -0,0 +1,13 @@
+module Compel
+  module Coercion
+
+    class Float < Type
+
+      def coerce
+        Float(value)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/hash.rb

@@ -0,0 +1,13 @@
+module Compel
+  module Coercion
+
+    class Hash < Type
+
+      def coerce
+        Hashie::Mash.new(value).to_hash
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/integer.rb

@@ -0,0 +1,13 @@
+module Compel
+  module Coercion
+
+    class Integer < Type
+
+      def coerce
+        Integer(value)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/json.rb

@@ -0,0 +1,13 @@
+module Compel
+  module Coercion
+
+    class JSON < Type
+
+      def coerce
+        ::JSON.parse(value)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/string.rb

@@ -0,0 +1,17 @@
+module Compel
+  module Coercion
+
+    class String < Type
+
+      def coerce
+        if !value.is_a?(::String)
+          fail
+        end
+
+        value
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/time.rb

@@ -0,0 +1,13 @@
+module Compel
+  module Coercion
+
+    class Time < Type
+
+      def coerce
+        ::Time.parse(value)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/type.rb

@@ -0,0 +1,30 @@
+module Compel
+  module Coercion
+
+    class Type
+
+      attr_accessor :value,
+                    :options
+
+      def initialize(value, options = {})
+        @value = value
+        @options = options
+      end
+
+      def parse
+        @value = value
+      end
+
+      def serialize
+        raise '#serialize? should be implemented'
+      end
+
+      def coerce!
+        parse
+        coerce
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion.rb

@@ -0,0 +1,33 @@
+module Compel
+
+  module Coercion
+
+    def valid?(value, type, options = {})
+      !!coerce!(value, type, options) rescue false
+    end
+
+    def coerce!(value, type, options = {})
+      return nil if value.nil?
+
+      begin
+        klass = compel_type?(type) ? type : get_compel_type_klass(type)
+
+        return klass.new(value, options).coerce!
+      rescue
+        raise ParamTypeError, "'#{value}' is not a valid #{type}"
+      end
+    end
+
+    def compel_type?(type)
+      type.to_s.split('::')[0..1].join('::') == 'Compel::Coercion'
+    end
+
+    def get_compel_type_klass(type)
+      const_get("Compel::Coercion::#{type}")
+    end
+
+    extend self
+
+  end
+
+end

data/lib/compel/contract.rb

@@ -0,0 +1,101 @@
+module Compel
+
+  class Contract
+
+    attr_reader :errors,
+                :conditions,
+                :coerced_params,
+                :serialized_errors
+
+    def initialize(params, &block)
+      if params.nil? || !Coercion.valid?(params, Hash)
+        raise ParamTypeError, 'params must be an Hash'
+      end
+
+      @errors = Errors.new
+      @params = Hashie::Mash.new(params)
+      @conditions = Hashie::Mash.new
+      @coerced_params = Hashie::Mash.new
+
+      instance_eval(&block)
+    end
+
+    def validate
+      @conditions.values.each do |param|
+        begin
+          # If it is an Hash and it was given conditions for that Hash,
+          # build a new Compel::Contract form inner conditions
+          if (param.hash? && param.conditions?)
+
+            # If this param is required, build the Compel::Contract,
+            # otherwise, only build it if is given a value for the param
+            if param.required? || !param.value.nil?
+              contract = Contract.new(param.value, &param.conditions).validate
+
+              @errors.add(param.name, contract.errors)
+
+              # Update the param value with coerced values to use later
+              # when coercing param parent
+              @coerced_params[param.name] = contract.coerced_params
+            end
+          end
+
+          # All values must coerce before going through validation,
+          # raise exception to avoid validation
+
+          # If the param value has already been coerced from digging into child Hash
+          # use that value instead, so we don't loose the previous coerced values
+
+          coerced_value = Coercion.coerce! \
+            (@coerced_params[param.name].nil? ? param.value : @coerced_params[param.name]), param.type, param.options
+
+          # Only add to coerced values if not nil
+          if !coerced_value.nil?
+            @coerced_params[param.name] = coerced_value
+          end
+
+          @errors.add \
+            param.name, Validation.validate(param.value, param.options)
+
+        rescue Compel::ParamTypeError => exception
+          @errors.add(param.name, exception.message)
+        end
+      end
+
+      self
+    end
+
+    def param(name, type, options = {}, &block)
+      @conditions[name] = \
+        Param.new(name, type, @params[name], options, &block)
+    end
+
+    def serialize
+      coerced_params.tap do |hash|
+        if !valid?
+          hash[:errors] = serialized_errors
+        end
+      end
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def serialized_errors
+      @errors.to_hash
+    end
+
+    def raise?
+      if !valid?
+        exception = InvalidParamsError.new
+        exception.params = coerced_params
+        exception.errors = serialized_errors
+
+        raise exception, 'params are invalid'
+      end
+    end
+
+  end
+
+end

data/lib/compel/errors.rb

@@ -0,0 +1,53 @@
+module Compel
+
+  class Errors
+
+    def initialize
+      @errors = Hashie::Mash.new
+    end
+
+    def add(key, error)
+      if error.is_a?(Compel::Errors)
+        if error.empty?
+          return
+        end
+
+        if @errors[key].nil?
+          @errors[key] = {}
+        end
+
+        @errors[key].merge!(error.to_hash)
+
+        return
+      end
+
+      if !error.is_a?(Array)
+        error = [error]
+      end
+
+      if error.empty?
+        return
+      end
+
+      if @errors[key].nil?
+        @errors[key] = []
+      end
+
+      @errors[key].concat(error)
+    end
+
+    def length
+      @errors.keys.length
+    end
+
+    def empty?
+      length == 0
+    end
+
+    def to_hash
+      @errors
+    end
+
+  end
+
+end

data/lib/compel/invalid_params_error.rb

@@ -0,0 +1,9 @@
+module Compel
+
+  class InvalidParamsError < StandardError
+
+    attr_accessor :params, :errors
+
+  end
+
+end

data/lib/compel/param.rb

@@ -0,0 +1,46 @@
+module Compel
+
+  class Param
+
+    attr_reader :name,
+                :type,
+                :options,
+                :conditions
+
+    def initialize(name, type, value, options = {}, &conditions)
+      @name = name
+      @type = type
+      @value = value
+      @options = options
+      @conditions = conditions
+    end
+
+    def value
+      default_value = if options[:default].is_a?(Proc)
+        options[:default].call
+      else
+        options[:default]
+      end
+
+      @value || default_value
+    end
+
+    def value=(value)
+      @value = value
+    end
+
+    def required?
+      !!@options[:required]
+    end
+
+    def hash?
+      @type == Hash
+    end
+
+    def conditions?
+      !!@conditions
+    end
+
+  end
+
+end

data/lib/compel/param_type_error.rb

@@ -0,0 +1,7 @@
+module Compel
+
+  class ParamTypeError < StandardError
+
+  end
+
+end

data/lib/compel/param_validation_error.rb

@@ -0,0 +1,7 @@
+module Compel
+
+  class ParamValidationError < StandardError
+
+  end
+
+end