compel 0.2.0 → 0.3.1

data/lib/compel/contract.rb

@@ -2,59 +2,31 @@ module Compel
 
   class Contract
 
-    attr_reader :errors,
-                :serialized_errors
+    attr_reader :object, :schema
 
-    def initialize(hash, schema)
-      if hash.nil? || !Coercion.valid?(hash, Hash)
-        raise Compel::TypeError, 'must be an Hash'
-      end
-
-      @hash = Hashie::Mash.new(hash)
+    def initialize(object, schema)
+      @object = object
       @schema = schema
-      @coerced_hash = Hashie::Mash.new
     end
 
     def validate
-      validator = Validators::HashValidator.new(@hash, @schema).validate
-
-      @errors = validator.errors
-      @coerced_hash = validator.output
-
-      self
-    end
-
-    def coerced_hash
-      # @hash has all params that are not affected by the validation
-      @hash.merge(@coerced_hash)
+      Result.new(setup!.validate)
     end
 
-    def serialize
-      coerced_hash.tap do |hash|
-        if !valid?
-          hash[:errors] = serialized_errors
-        end
-      end
-    end
-
-    def valid?
-      @errors.empty?
-    end
+    private
 
-    def serialized_errors
-      @errors.to_hash
+    def setup!
+      validator_klass.new(object, schema)
     end
 
-    def raise?
-      if !valid?
-        exception = InvalidHashError.new
-        exception.object = coerced_hash
-        exception.errors = serialized_errors
-
-        raise exception, 'hash has errors'
+    def validator_klass
+      if schema.type == Coercion::Hash
+        Validators::HashValidator
+      elsif schema.type == Coercion::Array
+        Validators::ArrayValidator
+      else
+        Validators::TypeValidator
       end
-
-      coerced_hash
     end
 
   end

data/lib/compel/errors.rb

@@ -7,33 +7,29 @@ module Compel
     end
 
     def add(key, error)
-      if error.is_a?(Compel::Errors)
-        if error.empty?
-          return
-        end
+      if error.empty?
+        return
+      end
 
+      if error.is_a?(Compel::Errors) || error.is_a?(Hash)
         if @errors[key].nil?
           @errors[key] = {}
         end
 
         @errors[key].merge!(error.to_hash)
+      else
+        if @errors[key].nil?
+          @errors[key] = []
+        end
 
-        return
-      end
-
-      if !error.is_a?(Array)
-        error = [error]
-      end
-
-      if error.empty?
-        return
-      end
+        if !error.is_a?(Array)
+          error = [error]
+        end
 
-      if @errors[key].nil?
-        @errors[key] = []
+        @errors[key].concat(error)
       end
 
-      @errors[key].concat(error)
+      @errors
     end
 
     def length

data/lib/compel/exceptions/invalid_object_error.rb

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

data/lib/compel/result.rb

@@ -0,0 +1,30 @@
+module Compel
+
+  class Result
+
+    attr_reader :value, :errors
+
+    def initialize(validator)
+      @valid = validator.valid?
+      @value = validator.serialize
+      @errors = validator.serialize_errors
+    end
+
+    def valid?
+      @valid
+    end
+
+    def raise?
+      if !valid?
+        exception = InvalidObjectError.new
+        exception.object = value
+
+        raise exception, 'object has errors'
+      end
+
+      value
+    end
+
+  end
+
+end

data/lib/compel/validation.rb

@@ -3,6 +3,12 @@ module Compel
   module Validation
 
     def validate(value, type, options)
+      # if a value is required and not given,
+      # don't do any other validation
+      if !!options[:required] && value.nil?
+        return ['is required']
+      end
+
       errors = []
 
       options.each do |option, option_value|
@@ -10,13 +16,9 @@ module Compel
         # https://github.com/mattt/sinatra-param
         # by Mattt Thompson (@mattt)
         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

data/lib/compel/validators/array_validator.rb

@@ -0,0 +1,107 @@
+module Compel
+  module Validators
+
+    class ArrayValidator < Base
+
+      attr_reader :items_schema
+
+      def initialize(input, schema)
+        super
+
+        @errors = Errors.new
+        @output = []
+        @items_schema = schema.options[:items]
+      end
+
+      def validate
+        unless array_valid?
+          return self
+        end
+
+        if items_schema.nil?
+          @output = input
+          return self
+        end
+
+        items_validator = \
+          ArrayItemsValidator.validate(input, items_schema)
+
+        @output = items_validator.output
+
+        unless items_validator.valid?
+          @errors = items_validator.errors
+        end
+
+        self
+      end
+
+      def serialize_errors
+        @errors.to_hash
+      end
+
+      alias_method :serialize, :output
+
+      private
+
+      def array_valid?
+        if !schema.required? && input.nil?
+          return false
+        end
+
+        array_errors = []
+
+        unless input.is_a?(Array)
+          array_errors << "'#{input}' is not a valid Array"
+        end
+
+        array_errors += \
+          Validation.validate(input, schema.type, schema.options)
+
+        unless array_errors.empty?
+          errors.add(:base, array_errors)
+          return false
+        end
+
+        true
+      end
+
+    end
+
+    class ArrayItemsValidator < Base
+
+      def initialize(input, schema)
+        super
+
+        @output = []
+        @errors = Errors.new
+      end
+
+      def validate
+        input.each_with_index do |item, index|
+
+          if !schema.required? && item.nil?
+            next
+          end
+
+          item_validator = \
+            if schema.type == Coercion::Hash
+              HashValidator.validate(item, schema)
+            else
+              TypeValidator.validate(item, schema)
+            end
+
+          output << item_validator.serialize
+
+          if !item_validator.valid?
+            # added errors for the index of that invalid array value
+            errors.add("#{index}", item_validator.serialize_errors)
+          end
+        end
+
+        self
+      end
+
+    end
+
+  end
+end

data/lib/compel/validators/base.rb

@@ -9,8 +9,18 @@ module Compel
                   :schema
 
       def initialize(input, schema)
-        @input = input
+        @input = input.nil? ? schema.default_value : input
         @schema = schema
+        @output = nil
+        @errors = []
+      end
+
+      def valid?
+        @errors.empty?
+      end
+
+      def self.validate(input, schema)
+        new(input, schema).validate
       end
 
     end

data/lib/compel/validators/hash_validator.rb

@@ -1,45 +1,103 @@
 # 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
 
+      attr_reader :keys_schemas
+
       def initialize(input, schema)
         super
-        @output = Hashie::Mash.new
-        @errors = Errors.new
 
+        @errors = Errors.new
         @keys_schemas = schema.options[:keys]
       end
 
       def validate
-        @keys_schemas.keys.each do |param_name|
+        unless root_hash_valid?
+          return self
+        end
 
-          if (@input[param_name].is_a?(Hash))
-            hash_validator = \
-              HashValidator.new(@input[param_name], @keys_schemas[param_name])
-                .validate
+        @input = Hashie::Mash.new(input)
+
+        keys_validator = \
+          HashKeysValidator.validate(input, keys_schemas)
+
+        @errors = keys_validator.errors
+        @output = keys_validator.output
+
+        self
+      end
 
-            @errors.add(param_name, hash_validator.errors)
-            @output[param_name] = hash_validator.output
+      def serialize
+        coerced = output.is_a?(Hash) ? input.merge(output) : Hashie::Mash.new
+
+        coerced.tap do |hash|
+          if !errors.empty?
+            hash[:errors] = serialize_errors
           end
+        end
+      end
+
+      def serialize_errors
+        errors.to_hash
+      end
+
+      private
+
+      def root_hash_valid?
+        if !schema.required? && input.nil?
+          return false
+        end
+
+        root_hash = TypeValidator.validate(input, schema)
 
-          type_validator = \
-            TypeValidator.new(@output[param_name].nil? ? @input[param_name] : @output[param_name], @keys_schemas[param_name])
-              .validate
+        unless root_hash.valid?
+          errors.add(:base, root_hash.errors)
+          return false
+        end
+
+        true
+      end
+
+    end
 
-          if !type_validator.output.nil?
-            @output[param_name] = type_validator.output
+    class HashKeysValidator < Base
+
+      attr_reader :schemas
+
+      def initialize(input, schemas)
+        super
+
+        @output = {}
+        @errors = Errors.new
+        @schemas = schemas
+      end
+
+      def validate
+        schemas.keys.each do |key|
+          value = output[key].nil? ? input[key] : output[key]
+
+          validator = TypeValidator.validate(value, schemas[key])
+
+          unless validator.output.nil?
+            output[key] = validator.output
           end
 
-          if type_validator.errors
-            @errors.add(param_name, type_validator.errors)
+          unless validator.valid?
+            errors.add(key, validator.errors)
+            next
           end
+
+          if input[key].is_a?(Hash)
+            hash_validator = HashValidator.validate(input[key], schemas[key])
+
+            errors.add(key, hash_validator.errors)
+            output[key] = hash_validator.output
+          end
+
         end
 
         self

data/lib/compel/validators/type_validator.rb

@@ -6,24 +6,55 @@ module Compel
 
     class TypeValidator < Base
 
-      def initialize(input, schema)
-        super
-        @output = nil
-      end
-
       def validate
-        value = input.nil? ? schema.default_value : input
+        if !schema.required? && input.nil?
+          return self
+        end
+
+        options = input, schema.type, schema.options
+
+        # coerce
+        coercion_result = Coercion.coerce(*options)
+
+        unless coercion_result.valid?
+          @errors = [coercion_result.error]
+          return self
+        end
+
+        @output = coercion_result.coerced
 
-        begin
-          @output = Coercion.coerce!(value, schema.type, schema.options)
-          @errors = Validation.validate(value, schema.type, schema.options)
-        rescue Compel::TypeError => exception
-          @errors = [exception.message]
+        # validate
+        @errors = Validation.validate(*options)
+
+        # validate array values
+        if schema.type == Coercion::Array && errors.empty?
+          validate_array_values(input)
         end
 
         self
       end
 
+      def validate_array_values(values)
+        result = Result.new \
+          ArrayValidator.validate(values, schema)
+
+        @output = result.value
+
+        if !result.valid?
+          # TODO: ArrayValidator should do this for me:
+          # remove invalid coerced index,
+          # and set the original value
+          result.errors.keys.each do |index|
+            @output[index.to_i] = values[index.to_i]
+          end
+
+          @errors = result.errors
+        end
+      end
+
+      alias_method :serialize, :output
+      alias_method :serialize_errors, :errors
+
     end
 
   end

data/lib/compel/version.rb

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

data/lib/compel.rb

@@ -2,29 +2,20 @@ 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/coercion/regexp'
-
-require 'compel/exceptions/invalid_hash_error'
+require 'compel/exceptions/invalid_object_error'
 require 'compel/exceptions/validation_error'
 require 'compel/exceptions/type_error'
 
+require 'compel/result'
+
 require 'compel/validators/base'
 require 'compel/validators/type_validator'
 require 'compel/validators/hash_validator'
+require 'compel/validators/array_validator'
 
 require 'compel/builder/methods'
+require 'compel/coercion/coercion'
 require 'compel/contract'
-require 'compel/coercion'
 require 'compel/validation'
 require 'compel/errors'
 
@@ -41,7 +32,7 @@ module Compel
   end
 
   def self.run(params, schema)
-    Contract.new(params, schema).validate.serialize
+    Contract.new(params, schema).validate
   end
 
 end