compel 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ca24b865ca3552e7fb66b3b5fa3cb54522c69f6
-  data.tar.gz: 06342b5d60518ad7f05fc4fcd380ad6dce9b1017
+  metadata.gz: 258250ae836758b145cc384b581c628a696260b8
+  data.tar.gz: 1298e32dee4358430f051fcb378785e487b4123a
 SHA512:
-  metadata.gz: eadd3a9cf227017eb8ed57431ba6b6b687ef2e76cee95de5dc89c9691201ff8cb2ce6afb96e7061314f07b2bc3fda5d0660bb3345e2784086f9e28d31ad90ad8
-  data.tar.gz: d2adaa09f03406c98f87bdc0b816b30a3983a65bf306bab7ef8fc7cd6873302d024173d3cf3ca3122c0595d903962fa154a763e66e31c8f5e7c434927e214b08
+  metadata.gz: 69e0028f7dc235d8a8cf5e8a2bd3af74c59c11c7c37cf933a041447360444774e0590d38bad735ee8cf8463f602f48d38981394c7f109519ef604effc0da9d60
+  data.tar.gz: a580c0ff252daecc215142f323ca35f4d874cd62893da793ff5175f7f4c1d1491ba1272608043681dbed2ee87c9db17077407718c78b7556ba076ef5223404c9

data/README.md

@@ -2,7 +2,7 @@ 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)
-[![Test Coverage](https://codeclimate.com/github/joaquimadraz/compel/badges/coverage.svg)](https://codeclimate.com/github/joaquimadraz/compel)
+[![Test Coverage](https://codeclimate.com/github/joaquimadraz/compel/badges/coverage.svg)](https://codeclimate.com/github/joaquimadraz/compel/coverage)
 
 Ruby Hash Coercion and Validation
 
@@ -12,7 +12,7 @@ The motivation was to create an integration for [RestMyCase](https://github.com/
 
 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. The schema builder is based on [Joi](https://github.com/hapijs/joi).
 
-### Example
+### Usage
 
 ```ruby
 object = {
@@ -67,23 +67,91 @@ There are 3 ways to run validations:
 Method  | Behaviour
 ------------- | -------------
 `#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::InvalidHashError` exception with the coerced params and errors.
+`#run!` | Validates and raises `Compel::InvalidObjectError` exception with the coerced params and errors.
 `#run?` | Validates and returns true or false.
+`schema#validate` | Chech below
 
-### Types
-
-- `#integer`
-- `#float`
-- `#string`
-- `#json`
-  - ex: `"{\"a\":1,\"b\":2,\"c\":3}"`
-- `#hash`
-  - ex: `{ a: 1,  b: 2, c: 3 }`
-- `#date`
-- `#time`
-- `#datetime`
-- `#boolean`,
-  - ex: `1`/`0`, `true`/`false`, `t`/`f`, `yes`/`no`, `y`/`n`
+==========================
+
+### Schema Builder API
+- `Compel#array` *
+  - `is(``array``)`
+  - `#items(``schema``)`
+  ```ruby
+  * ex: [1, 2, 3], [{ a: 1, b: 2}, { a: 3, b: 4 }]
+  ```
+
+- `Compel#hash` *
+  - `#keys(``schema_hash``)`
+  ```ruby
+  * ex: { a: 1,  b: 2, c: 3 }
+  ```
+
+- `Compel.date` *
+  - `#format(``ruby_date_format``)`
+  - `iso8601`, set format to: `%Y-%m-%d`
+
+- `Compel.datetime & Compel.time` *
+  - `#format(``ruby_date_format``)`
+  - `#iso8601`, set format to: `%FT%T`
+
+- `Compel#string` **
+  - `#format(``regexp``)` 
+  - `#min_length(``integer``)`
+  - `#max_length(``integer``)`
+
+- `Compel#json` *
+  ```ruby
+  * ex: "{\"a\":1,\"b\":2,\"c\":3}"
+  ```
+
+- `Compel#boolean` *
+  ```ruby
+  * ex: 1/0, true/false, 't'/'f', 'yes'/'no', 'y'/'n'
+  ```
+  
+- `Compel#integer` **
+
+- `Compel#float` **
+
+(\*) **Common methods**
+  - `required`
+  - `default(``value``)`
+
+(\*\*) **Common value methods**
+  - `is(``value``)`
+  - `in(``array``)`
+  - `length(``integer``)`
+  - `min(``value``)`
+  - `max(``value``)`
+
+
+### Schema Validate
+
+For straight forward validations, you can call `#validate` on schema and it will return a `Compel::Result` object.
+
+```ruby
+result = Compel.string
+               .format(/^\d{4}-\d{3}$/)
+               .required
+               .validate('1234')
+
+puts result.errors
+# => ["must match format ^\\d{4}-\\d{3}$"]
+```
+
+#### Compel Result
+
+Simple object that encapsulates a validation result.
+
+Method  | Behaviour
+------------- | -------------
+`#value`  | the coerced value or the input value is invalid
+`#errors` | array of errors is any.
+`#valid?` | `true` or `false`
+`#raise?` | raises a `Compel::InvalidObjectError` if invalid, otherwise returns `#value`
+
+==========================
 
 ### Sinatra Integration
 
@@ -107,9 +175,9 @@ class App < Sinatra::Base
 
   end
 
-  error Compel::InvalidHashError do |exception|
+  error Compel::InvalidObjectError do |exception|
     status 400
-    { errors: exception.errors }.to_json
+    { errors: exception.object[:errors] }.to_json
   end
 
   configure :development do
@@ -143,7 +211,7 @@ And then execute:
 
 ### TODO
 
-- Write more Documentation (check specs for now ;)
+- Write Advanced Documentation (check specs for now ;)
 - Rails integration
 - [RestMyCase](https://github.com/goncalvesjoao/rest_my_case) integration
 

data/lib/compel/builder/array.rb

@@ -0,0 +1,31 @@
+module Compel
+  module Builder
+
+    class Array < Schema
+
+      def initialize
+        super(Coercion::Array)
+      end
+
+      def items(schema)
+        if !schema.is_a?(Schema)
+          raise Compel::TypeError, '#items must be a valid Schema'
+        end
+
+        options[:items] = schema
+        self
+      end
+
+      def is(value)
+        options[:is] = Coercion.coerce!(value, ::Array)
+        self
+      end
+
+      def validate(object)
+        Contract.new(object, self).validate
+      end
+
+    end
+
+  end
+end

data/lib/compel/builder/boolean.rb

@@ -7,6 +7,13 @@ module Compel
         super(Coercion::Boolean)
       end
 
+      def is(value)
+        Coercion.coerce!(value, Coercion::Boolean)
+        options[:is] = value
+
+        self
+      end
+
     end
 
   end

data/lib/compel/builder/common.rb

@@ -3,8 +3,8 @@ module Compel
 
     module Common
 
-      def is(value)
-        options[:is] = value
+      def length(value)
+        options[:length] = Coercion.coerce!(value, ::Integer)
         self
       end
 

data/lib/compel/builder/common_value.rb

@@ -3,13 +3,13 @@ module Compel
 
     module CommonValue
 
-      def in(value)
-        options[:in] = value
+      def is(value)
+        options[:is] = value
         self
       end
 
-      def length(value)
-        options[:length] = Coercion.coerce!(value, ::Integer)
+      def in(value)
+        options[:in] = value
         self
       end
 

data/lib/compel/builder/hash.rb

@@ -5,6 +5,8 @@ module Compel
 
       def initialize
         super(Coercion::Hash)
+
+        options[:keys] = {}
       end
 
       def keys(hash)
@@ -13,7 +15,7 @@ module Compel
       end
 
       def validate(object)
-        Contract.new(object, self).validate.serialize
+        Contract.new(object, self).validate
       end
 
     end

data/lib/compel/builder/methods.rb

@@ -10,6 +10,7 @@ require 'compel/builder/datetime'
 require 'compel/builder/time'
 require 'compel/builder/date'
 require 'compel/builder/boolean'
+require 'compel/builder/array'
 
 module Compel
   module Builder
@@ -52,6 +53,10 @@ module Compel
         Builder::Boolean.new
       end
 
+      def array
+        Builder::Array.new
+      end
+
       extend self
 
     end

data/lib/compel/builder/schema.rb

@@ -21,6 +21,10 @@ module Compel
         options[:default]
       end
 
+      def validate(object)
+        Contract.new(object, self).validate
+      end
+
     end
 
   end

data/lib/compel/coercion/coercion.rb

@@ -0,0 +1,47 @@
+require 'compel/coercion/types/type'
+require 'compel/coercion/types/integer'
+require 'compel/coercion/types/float'
+require 'compel/coercion/types/string'
+require 'compel/coercion/types/date'
+require 'compel/coercion/types/time'
+require 'compel/coercion/types/datetime'
+require 'compel/coercion/types/hash'
+require 'compel/coercion/types/json'
+require 'compel/coercion/types/boolean'
+require 'compel/coercion/types/regexp'
+require 'compel/coercion/types/array'
+
+require 'compel/coercion/result'
+require 'compel/coercion/nil_result'
+
+module Compel
+
+  module Coercion
+
+    def valid?(value, type, options = {})
+      coerce(value, type, options).valid?
+    end
+
+    def coerce!(value, type, options = {})
+      result = coerce(value, type, options)
+
+      unless result.valid?
+        raise Compel::TypeError, result.error
+      end
+
+      result.coerced
+    end
+
+    def coerce(value, type, options = {})
+      return NilResult.new if value.nil?
+
+      coercion_klass = Compel::Coercion.const_get("#{type}")
+
+      coercion_klass.new(value, options).coerce
+    end
+
+    extend self
+
+  end
+
+end

data/lib/compel/coercion/nil_result.rb

@@ -0,0 +1,13 @@
+ module Compel
+  module Coercion
+
+    class NilResult < Result
+
+      def initialize
+        super(nil, nil, nil)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/result.rb

@@ -0,0 +1,37 @@
+ module Compel
+  module Coercion
+
+    class Result
+
+      attr_reader :coerced,
+                  :value,
+                  :klass,
+                  :error
+
+      def initialize(coerced, value, klass, coercion_error = nil)
+        @coerced = coerced
+        @value = value
+        @klass = klass
+        @error = coercion_error.nil? ? standard_error : coercion_error
+      end
+
+      def valid?
+        @error.nil?
+      end
+
+      private
+
+      def standard_error
+        if !klass.nil? && coerced.nil?
+          "'#{value}' is not a valid #{klass_final_type}"
+        end
+      end
+
+      def klass_final_type
+        "#{klass}".split('::')[-1]
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/types/array.rb

@@ -0,0 +1,15 @@
+module Compel
+  module Coercion
+
+    class Array < Type
+
+      def coerce_value
+        if value.is_a?(::Array)
+          value
+        end
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/{boolean.rb → types/boolean.rb}

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

data/lib/compel/coercion/types/date.rb

@@ -0,0 +1,36 @@
+module Compel
+  module Coercion
+
+    class Date < Type
+
+      attr_reader :format
+
+      def coerce_value
+        @format = options[:format] || '%Y-%m-%d'
+
+        if value.is_a?(::Date)
+          @value = value.strftime(format)
+        end
+
+        coerced = ::Date.strptime(value, format)
+
+        if coerced.strftime(format) == value
+          return coerced
+        end
+
+        build_error_result
+
+        rescue
+          build_error_result
+      end
+
+      def build_error_result
+        custom_error = "'#{value}' is not a parsable date with format: #{format}"
+
+        Result.new(nil, value, self.class, custom_error)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/types/datetime.rb

@@ -0,0 +1,36 @@
+module Compel
+  module Coercion
+
+    class DateTime < Type
+
+      attr_reader :format
+
+      def coerce_value
+        @format = options[:format] || '%FT%T'
+
+        if value.is_a?(::DateTime)
+          @value = value.strftime(format)
+        end
+
+        coerced = ::DateTime.strptime(value, format)
+
+        if coerced.strftime(format) == value
+          return coerced
+        end
+
+        build_error_result
+
+        rescue
+          build_error_result
+      end
+
+      def build_error_result
+        custom_error = "'#{value}' is not a parsable datetime with format: #{format}"
+
+        Result.new(nil, value, self.class, custom_error)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/{float.rb → types/float.rb}

@@ -3,8 +3,8 @@ module Compel
 
     class Float < Type
 
-      def coerce!
-        Float(value)
+      def coerce_value
+        Float(value) rescue nil
       end
 
     end

data/lib/compel/coercion/{hash.rb → types/hash.rb}

@@ -3,8 +3,8 @@ module Compel
 
     class Hash < Type
 
-      def coerce!
-        Hashie::Mash.new(value).to_hash
+      def coerce_value
+        Hashie::Mash.new(value).to_hash rescue nil
       end
 
     end

data/lib/compel/coercion/{integer.rb → types/integer.rb}

@@ -3,8 +3,8 @@ module Compel
 
     class Integer < Type
 
-      def coerce!
-        Integer(value)
+      def coerce_value
+        Integer(value) rescue nil
       end
 
     end

data/lib/compel/coercion/{json.rb → types/json.rb}

@@ -3,8 +3,8 @@ module Compel
 
     class JSON < Type
 
-      def coerce!
-        ::JSON.parse(value)
+      def coerce_value
+        ::JSON.parse(value) rescue nil
       end
 
     end

data/lib/compel/coercion/{regexp.rb → types/regexp.rb}

@@ -3,12 +3,10 @@ module Compel
 
     class Regexp < Type
 
-      def coerce!
+      def coerce_value
         if value.is_a?(::Regexp)
-          return value
+          value
         end
-
-        fail
       end
 
     end

data/lib/compel/coercion/{string.rb → types/string.rb}

@@ -3,12 +3,10 @@ module Compel
 
     class String < Type
 
-      def coerce!
-        if !value.is_a?(::String)
-          fail
+      def coerce_value
+        if value.is_a?(::String)
+          value
         end
-
-        value
       end
 
     end

data/lib/compel/coercion/types/time.rb

@@ -0,0 +1,36 @@
+module Compel
+  module Coercion
+
+    class Time < Type
+
+      attr_reader :format
+
+      def coerce_value
+        @format = options[:format] || '%FT%T'
+
+        if value.is_a?(::Time)
+          @value = value.strftime(format)
+        end
+
+        coerced = ::Time.strptime(value, format)
+
+        if coerced.strftime(format) == value
+          return coerced
+        end
+
+        build_error_result
+
+        rescue
+          build_error_result
+      end
+
+      def build_error_result
+        custom_error = "'#{value}' is not a parsable time with format: #{format}"
+
+        Result.new(nil, value, self.class, custom_error)
+      end
+
+    end
+
+  end
+end

data/lib/compel/coercion/types/type.rb

@@ -0,0 +1,29 @@
+module Compel
+  module Coercion
+
+    class Type
+
+      attr_accessor :value,
+                    :options
+
+      def initialize(value, options = {})
+        @value = value
+        @options = options
+      end
+
+      def coerce
+        result = coerce_value
+
+        # There are some special cases that
+        # we need to build a custom error
+        if result.is_a?(Result)
+          return result
+        end
+
+        Result.new(result, value, self.class)
+      end
+
+    end
+
+  end
+end