compel 0.1.3 → 0.2.0

data/lib/compel/coercion/string.rb

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

data/lib/compel/coercion/time.rb

@@ -3,8 +3,25 @@ module Compel
 
     class Time < Type
 
-      def coerce
-        ::Time.parse(value)
+      def coerce!
+        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
+
+        fail
+
+        rescue
+          raise \
+            Compel::TypeError,
+            "'#{value}' is not a parsable time with format: #{format}"
       end
 
     end

data/lib/compel/coercion/type.rb

@@ -11,19 +11,6 @@ module Compel
         @options = options
       end
 
-      def parse
-        @value = value
-      end
-
-      def serialize
-        raise '#serialize? should be implemented'
-      end
-
-      def coerce!
-        parse
-        coerce
-      end
-
     end
 
   end

data/lib/compel/coercion.rb

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

data/lib/compel/contract.rb

@@ -3,78 +3,34 @@ module Compel
   class Contract
 
     attr_reader :errors,
-                :conditions,
                 :serialized_errors
 
-    def initialize(params, &block)
-      if params.nil? || !Coercion.valid?(params, Hash)
-        raise ParamTypeError, 'params must be an Hash'
+    def initialize(hash, schema)
+      if hash.nil? || !Coercion.valid?(hash, Hash)
+        raise Compel::TypeError, '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)
+      @hash = Hashie::Mash.new(hash)
+      @schema = schema
+      @coerced_hash = Hashie::Mash.new
     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, a value must be given to build the Compel::Contract
-            # otherwise, only build it if is given a value for the param
-            if (param.required? && !param.value.nil?) || !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 lose 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
+      validator = Validators::HashValidator.new(@hash, @schema).validate
 
-      self
-    end
+      @errors = validator.errors
+      @coerced_hash = validator.output
 
-    def param(name, type, options = {}, &block)
-      @conditions[name] = \
-        Param.new(name, type, @params.delete(name), options, &block)
+      self
     end
 
-    def coerced_params
-      # @params has all params that are not affected by the validation
-      @params.merge(@coerced_params)
+    def coerced_hash
+      # @hash has all params that are not affected by the validation
+      @hash.merge(@coerced_hash)
     end
 
     def serialize
-      coerced_params.tap do |hash|
+      coerced_hash.tap do |hash|
         if !valid?
           hash[:errors] = serialized_errors
         end
@@ -91,14 +47,14 @@ module Compel
 
     def raise?
       if !valid?
-        exception = InvalidParamsError.new
-        exception.params = coerced_params
+        exception = InvalidHashError.new
+        exception.object = coerced_hash
         exception.errors = serialized_errors
 
-        raise exception, 'params are invalid'
+        raise exception, 'hash has errors'
       end
 
-      coerced_params
+      coerced_hash
     end
 
   end

data/lib/compel/exceptions/invalid_hash_error.rb

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

data/lib/compel/exceptions/type_error.rb

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

data/lib/compel/exceptions/validation_error.rb

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

data/lib/compel/validation.rb

@@ -2,63 +2,49 @@ 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)
+    def validate(value, type, 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
+        case option.to_sym
+        when :required
+          errors << 'is required' if option_value && value.nil?
+        when :format
+          if type == Coercion::String && !value.nil?
+            errors << "must match format #{option_value.source}" unless value =~ option_value
+          else
+            errors << 'must be a string if using the format validation'
+          end
+        when :is
+          errors << "must be #{option_value}" unless value === option_value
+        when :in, :within, :range
+          errors << "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
+          errors << "cannot be less than #{option_value}" unless value.nil? || option_value <= value
+        when :max
+          errors << "cannot be greater than #{option_value}" unless value.nil? || option_value >= value
+        when :length
+          errors << "cannot have length different than #{option_value}" unless value.nil? || option_value == "#{value}".length
+        when :min_length
+          unless value.kind_of?(String)
+            errors << 'must be a string if using the min_length validation'
+          else
+            errors << "cannot have length less than #{option_value}" unless value.nil? || option_value <= value.length
+          end
+        when :max_length
+          unless value.kind_of?(String)
+            errors << 'must be a string if using the max_length validation'
+          else
+            errors << "cannot have length greater than #{option_value}" unless value.nil? || option_value >= value.length
           end
-        rescue ParamValidationError => exception
-          errors << exception.message
         end
       end
 

data/lib/compel/validators/base.rb

@@ -0,0 +1,19 @@
+module Compel
+  module Validators
+
+    class Base
+
+      attr_reader :input,
+                  :output,
+                  :errors,
+                  :schema
+
+      def initialize(input, schema)
+        @input = input
+        @schema = schema
+      end
+
+    end
+
+  end
+end

data/lib/compel/validators/hash_validator.rb

@@ -0,0 +1,51 @@
+# Validates values of an hash recursively
+# output is an hash with coerced values
+# errors is a Compel::Errors
+
+# This is not beauty,
+# but it's tested and working.
+module Compel
+  module Validators
+
+    class HashValidator < Base
+
+      def initialize(input, schema)
+        super
+        @output = Hashie::Mash.new
+        @errors = Errors.new
+
+        @keys_schemas = schema.options[:keys]
+      end
+
+      def validate
+        @keys_schemas.keys.each do |param_name|
+
+          if (@input[param_name].is_a?(Hash))
+            hash_validator = \
+              HashValidator.new(@input[param_name], @keys_schemas[param_name])
+                .validate
+
+            @errors.add(param_name, hash_validator.errors)
+            @output[param_name] = hash_validator.output
+          end
+
+          type_validator = \
+            TypeValidator.new(@output[param_name].nil? ? @input[param_name] : @output[param_name], @keys_schemas[param_name])
+              .validate
+
+          if !type_validator.output.nil?
+            @output[param_name] = type_validator.output
+          end
+
+          if type_validator.errors
+            @errors.add(param_name, type_validator.errors)
+          end
+        end
+
+        self
+      end
+
+    end
+
+  end
+end

data/lib/compel/validators/type_validator.rb

@@ -0,0 +1,30 @@
+# Validates a type, given an input, type and options
+# output is a coerced value
+# error is an array of strings
+module Compel
+  module Validators
+
+    class TypeValidator < Base
+
+      def initialize(input, schema)
+        super
+        @output = nil
+      end
+
+      def validate
+        value = input.nil? ? schema.default_value : input
+
+        begin
+          @output = Coercion.coerce!(value, schema.type, schema.options)
+          @errors = Validation.validate(value, schema.type, schema.options)
+        rescue Compel::TypeError => exception
+          @errors = [exception.message]
+        end
+
+        self
+      end
+
+    end
+
+  end
+end

data/lib/compel/version.rb

@@ -1,3 +1,3 @@
 module Compel
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end

data/lib/compel.rb

@@ -12,12 +12,17 @@ require 'compel/coercion/datetime'
 require 'compel/coercion/hash'
 require 'compel/coercion/json'
 require 'compel/coercion/boolean'
+require 'compel/coercion/regexp'
 
-require 'compel/invalid_params_error'
-require 'compel/param_validation_error'
-require 'compel/param_type_error'
+require 'compel/exceptions/invalid_hash_error'
+require 'compel/exceptions/validation_error'
+require 'compel/exceptions/type_error'
 
-require 'compel/param'
+require 'compel/validators/base'
+require 'compel/validators/type_validator'
+require 'compel/validators/hash_validator'
+
+require 'compel/builder/methods'
 require 'compel/contract'
 require 'compel/coercion'
 require 'compel/validation'
@@ -25,18 +30,18 @@ require 'compel/errors'
 
 module Compel
 
-  Boolean = Coercion::Boolean
+  extend Builder::Methods
 
-  def self.run!(params, &block)
-    Contract.new(params, &block).validate.raise?
+  def self.run!(params, schema)
+    Contract.new(params, schema).validate.raise?
   end
 
-  def self.run?(params, &block)
-    Contract.new(params, &block).validate.valid?
+  def self.run?(params, schema)
+    Contract.new(params, schema).validate.valid?
   end
 
-  def self.run(params, &block)
-    Contract.new(params, &block).validate.serialize
+  def self.run(params, schema)
+    Contract.new(params, schema).validate.serialize
   end
 
 end