duck-hunt 0.0.3

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+desc "Run tests"
+task :default => :test
+
+
+task :console do
+  exec "irb -r duck-hunt -I ./lib"
+end

data/lib/duck-hunt.rb

@@ -0,0 +1,17 @@
+module DuckHunt
+	class MethodNotDefined < StandardError; end
+	class AbstractClass < StandardError; end
+	class PropertyAlreadyDefined < StandardError; end
+  class ValidatorAlreadyDefined < StandardError; end
+  class InvalidSchema < StandardError; end
+
+  TYPE_MISMATCH_MESSAGE = "wrong type"
+  REQUIRED_MESSAGE = "required"
+  NIL_OBJECT_NOT_ALLOWED_MESSAGE = "nil object not allowed"
+
+  autoload :StringHelpers, File.dirname(__FILE__) + '/duck-hunt/string_helpers.rb'
+  autoload :HashHelpers, File.dirname(__FILE__) + '/duck-hunt/hash_helpers.rb'
+	autoload :Schemas, File.dirname(__FILE__) + '/duck-hunt/schemas.rb'
+	autoload :Properties, File.dirname(__FILE__) + '/duck-hunt/properties.rb'
+  autoload :Validators, File.dirname(__FILE__) + '/duck-hunt/validators.rb'
+end

data/lib/duck-hunt/hash_helpers.rb

@@ -0,0 +1,28 @@
+# Support `stringify_keys` and `symbolize_keys`
+# keep these methods in their own modules so they don't conflict with other libraries that might
+# be loaded (e.g: activesupport)
+module DuckHunt
+  module HashHelpers
+    def self.stringify_keys!(hash)
+      hash.keys.each do |key|
+        hash[key.to_s] = hash.delete(key)
+      end
+      return hash
+    end
+
+    def self.stringify_keys(hash)
+      return stringify_keys!(hash.dup)
+    end
+
+    def self.symbolize_keys!(hash)
+      hash.keys.each do |key|
+        hash[(key.to_sym rescue key) || key] = hash.delete(key)
+      end
+      return hash
+    end
+
+    def self.symbolize_keys(hash)
+      return symbolize_keys!(hash.dup)
+    end
+  end
+end

data/lib/duck-hunt/properties.rb

@@ -0,0 +1,13 @@
+module DuckHunt
+	module Properties
+    autoload :ValidatorLookup, File.dirname(__FILE__) + "/properties/validator_lookup.rb"
+		autoload :Property, File.dirname(__FILE__) + "/properties/property.rb"
+    autoload :Integer, File.dirname(__FILE__) + "/properties/integer.rb"
+    autoload :Float, File.dirname(__FILE__) + "/properties/float.rb"
+    autoload :NestedHash, File.dirname(__FILE__) + "/properties/nested_hash.rb"
+    autoload :Array, File.dirname(__FILE__) + "/properties/array.rb"
+    autoload :String, File.dirname(__FILE__) + "/properties/string.rb"
+    autoload :Boolean, File.dirname(__FILE__) + "/properties/boolean.rb"
+    autoload :Nil, File.dirname(__FILE__) + "/properties/nil.rb"
+	end
+end

data/lib/duck-hunt/properties/array.rb

@@ -0,0 +1,81 @@
+module DuckHunt
+  module Properties
+    class Array
+      # Used when an array is a property of a schema.
+      # Allows us to "nest" schemas (eg: an array in a array, an array of arrays)
+      attr_reader :required
+
+      def initialize(options= {}, &block)
+        raise ArgumentError, "a block must be given to define the array" unless block_given?
+        DuckHunt::HashHelpers.stringify_keys!(options)
+        options = {"required" => true}.merge(options)
+        @required = options["required"]
+        @required_but_not_present = false
+        @schema = DuckHunt::Schemas::ArraySchema.define options, &block
+      end
+
+      def required?
+        return self.required
+      end
+
+      def single_type_property
+        return @schema.single_type_property
+      end
+
+      def tuple_properties
+        return @schema.tuple_properties
+      end
+
+      def optional_tuple_properties
+        return @schema.optional_tuple_properties
+      end
+
+      def validates_uniqueness
+        return @schema.validates_uniqueness
+      end
+
+      def validates_uniqueness?
+        return @schema.validates_uniqueness?
+      end
+
+      def allow_nil
+        return @schema.allow_nil
+      end
+
+      def allow_nil?
+        return @schema.allow_nil?
+      end
+
+      def min_size
+        return @schema.min_size
+      end
+
+      def max_size
+        return @schema.max_size
+      end
+
+      def errors
+        return @schema.errors
+      end
+
+      def valid?(value)
+        @required_but_not_present = false
+        return @schema.validate?(value)
+      end
+
+      def add_required_error
+        @required_but_not_present = true
+      end
+
+      def errors
+        errors = @schema.errors
+        if @required_but_not_present
+          errors[:base] = [] if errors[:base].nil?
+          errors[:base] << DuckHunt::REQUIRED_MESSAGE
+        end
+
+        return errors
+      end
+    end
+  end
+end

data/lib/duck-hunt/properties/boolean.rb

@@ -0,0 +1,10 @@
+module DuckHunt
+  module Properties
+    class Boolean < Property
+      def matches_type?(value)
+        return true if value.is_a? ::TrueClass or value.is_a? ::FalseClass
+        return false
+      end
+    end
+  end
+end

data/lib/duck-hunt/properties/float.rb

@@ -0,0 +1,10 @@
+module DuckHunt
+  module Properties
+    class Float < Property
+      def matches_type?(value)
+        return true if value.is_a? ::Float or value.is_a? ::BigDecimal
+        return false
+      end
+    end
+  end
+end

data/lib/duck-hunt/properties/integer.rb

@@ -0,0 +1,9 @@
+module DuckHunt
+  module Properties
+    class Integer < Property
+      def matches_type?(value)
+        return value.integer? rescue return false
+      end
+    end
+  end
+end

data/lib/duck-hunt/properties/nested_hash.rb

@@ -0,0 +1,61 @@
+module DuckHunt
+  module Properties
+    class NestedHash
+      # Used when a hash is a property of a schema.
+      # Allows us to "nest" schemas (eg: an array in a hash, an array of hashes)
+      attr_reader :required
+
+      def initialize(options= {}, &block)
+        raise ArgumentError, "a block must be given to define the hash" unless block_given?
+        DuckHunt::HashHelpers.stringify_keys!(options)
+        options = {"required" => true}.merge(options)
+        @required = options["required"]
+        @required_but_not_present = false
+        @schema = DuckHunt::Schemas::HashSchema.define options, &block
+      end
+
+      def required?
+        return self.required
+      end
+
+      def properties
+        return @schema.properties
+      end
+
+      def strict_mode
+        return @schema.strict_mode
+      end
+
+      def strict_mode?
+        return strict_mode
+      end
+
+      def allow_nil
+        return @schema.allow_nil
+      end
+
+      def allow_nil?
+        return @schema.allow_nil
+      end
+
+      def valid?(value)
+        @required_but_not_present = false
+        return @schema.validate?(value)
+      end
+
+      def add_required_error
+        @required_but_not_present = true
+      end
+
+      def errors
+        errors = @schema.errors
+        if @required_but_not_present
+          errors[:base] = [] if errors[:base].nil?
+          errors[:base] << DuckHunt::REQUIRED_MESSAGE
+        end
+
+        return errors
+      end
+    end
+  end
+end

data/lib/duck-hunt/properties/nil.rb

@@ -0,0 +1,15 @@
+module DuckHunt
+  module Properties
+    class Nil < Property
+      def initialize(options= {})
+        super(options)
+        @allow_nil = true
+      end
+
+      def matches_type?(value)
+        return true if value.nil?
+        return false
+      end
+    end
+  end
+end

data/lib/duck-hunt/properties/property.rb

@@ -0,0 +1,85 @@
+module DuckHunt
+	module Properties
+		class Property
+			# the base class for the individual properties that make up a schema
+			# a property is valid if:
+			# 1. The value is required and has not been provided
+			# 2. The value provided `matches_type?`
+			# 3. Each of the attached validators returns `true` when `valid?` is called
+			include DuckHunt::Properties::ValidatorLookup
+			attr_reader :required, :allow_nil
+
+			def initialize(options= {})
+				DuckHunt::HashHelpers.stringify_keys!(options)
+				options = {"required" => true, "allow_nil" => false}.merge(options)
+				@required 	= options["required"]
+				@allow_nil = options["allow_nil"]
+				@validators = {}
+				@errors = []
+
+				options.delete("required")
+				options.delete("allow_nil")
+				options.each{ |key, value| find_and_create_validator(key, value) }
+			end
+
+			def required?
+				return self.required
+			end
+
+			def allow_nil?
+				return @allow_nil
+			end
+
+			def valid?(value)
+				@errors.clear
+				if value.nil?
+          return true if allow_nil?
+          add_error(NIL_OBJECT_NOT_ALLOWED_MESSAGE)
+          return false
+        end
+
+        if matches_type?(value)
+					check_validators(value)
+				else
+					add_type_mismatch_error(value)
+				end
+				return @errors.size == 0
+			end
+
+			def add_required_error
+				add_error(DuckHunt::REQUIRED_MESSAGE)
+			end
+
+			def errors
+				@errors.dup
+			end
+
+			protected
+
+			def add_type_mismatch_error(value)
+				add_error(DuckHunt::TYPE_MISMATCH_MESSAGE)
+			end
+
+			def check_validators(value)
+				@validators.values.each do |validator|
+					unless validator.valid?(value)
+						add_error(validator.error_message)
+					end
+				end
+			end
+
+			def add_error(error_message)
+				@errors << error_message unless @errors.include?(error_message)
+			end
+
+			def add_validator(validator_symbol, validator_constant, *args)
+        raise ValidatorAlreadyDefined, "`#{validator_symbol}` has already been defined in this schema" if @validators.has_key?(validator_symbol)
+        @validators[validator_symbol] = validator_constant.new(*args)
+      end
+
+      def matches_type?(value)
+      	raise NotImplementedError
+      end
+		end
+	end
+end

data/lib/duck-hunt/properties/string.rb

@@ -0,0 +1,10 @@
+module DuckHunt
+  module Properties
+    class String < Property
+      def matches_type?(value)
+        return true if value.is_a? ::String
+        return false
+      end
+    end
+  end
+end

data/lib/duck-hunt/properties/validator_lookup.rb

@@ -0,0 +1,27 @@
+module DuckHunt
+  module Properties
+    module ValidatorLookup
+      protected
+      def find_and_create_validator(validator_name, *args)
+        #convert the validator name into camel case and turn it into a symbol.
+        camelized_string = DuckHunt::StringHelpers.camelize(validator_name.to_s)
+        validator_symbol = camelized_string.to_sym
+
+        validator_constant = get_validator_constant(validator_symbol)
+        add_validator(validator_symbol, validator_constant, *args)
+      end
+
+      def validator_definition_exists?(validator)
+        DuckHunt::Validators.const_defined?(validator)
+      end
+
+      def get_validator_constant(validator)
+        DuckHunt::Validators.const_get(validator)
+      end
+
+      def add_validator(validator_symbol, validator_constant, *args)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/duck-hunt/schemas.rb

@@ -0,0 +1,8 @@
+module DuckHunt
+  module Schemas
+    autoload :SchemaDefinition, File.dirname(__FILE__) + "/schemas/schema_definition.rb"
+    autoload :PropertyLookup, File.dirname(__FILE__) + "/schemas/property_lookup.rb"
+    autoload :HashSchema, File.dirname(__FILE__) + "/schemas/hash_schema.rb"
+    autoload :ArraySchema, File.dirname(__FILE__) + "/schemas/array_schema.rb"
+  end
+end

data/lib/duck-hunt/schemas/array_schema.rb

@@ -0,0 +1,254 @@
+module DuckHunt
+  module Schemas
+    class ArraySchema
+      # There are two ways to define the schema of an array:
+      # * All items in the array have the same definition (integer, specific hash, etc.)
+      # * The order of the items in the array matters
+      #   * each item in the array can have a different definition (e.g.: [1,"hello", { :hash=>"here" }])
+      #   * The array definition can also include an optional set of items.
+      #
+      # These two types cannot be mixed
+      #
+      # The Array Schema also accepts some options during definition:
+      # * validates_uniqueness: if true, the array is invalid if it has duplicates (false by default)
+      # * min_size: the array must be at least this large (nil by default)
+      # * max_size: the array cannot be any larger (nil by default)
+      #
+      # Validation is performed in the following steps:
+      # 1. If the object is nil and nil objects are allowed, then return true
+      # 2. Check that the object is an array
+      # 3. If the `validates_uniqueness` flag is set, check that the array's entries are unique.
+      # 4. If the schema is a single-type:
+      #   1. Check that it falls within the specified min/max range
+      #   2. Check that every entry is valid according to the defined single type property
+      # 5. If the Schema is a tuple:
+      #   1. Check that the total number of entries is within the following range:
+      #      (tuple_properties) <= (number of enties) <= (tuple_properties + optional_tuple_properties)
+      #   2. Check that each entry is valid according to the defined type in the tuple properties
+      include Schemas::SchemaDefinition
+      include Schemas::PropertyLookup
+
+      DUPLICATE_ITEMS_NOT_ALLOWED_MESSAGE = "duplicate items are not allowed"
+
+      def initialize(var={})
+        DuckHunt::HashHelpers.stringify_keys!(var)
+        options = {"validates_uniqueness" => false, "min_size" => nil, "max_size" => nil, "allow_nil" => false}.merge(var)
+        @single_type_property  = nil
+        @tuple_properties = nil
+        @optional_tuple_properties = nil
+        @validates_uniqueness = options["validates_uniqueness"]
+        @min_size = options["min_size"]
+        @max_size = options["max_size"]
+        @allow_nil = options["allow_nil"]
+        @errors = {}
+      end
+
+      def single_type_property
+        @single_type_property
+      end
+
+      def tuple_properties
+        return nil if @tuple_properties.nil?
+        @tuple_properties.properties
+      end
+
+      def optional_tuple_properties
+        return nil if @optional_tuple_properties.nil?
+        @optional_tuple_properties.properties
+      end
+
+      def validates_uniqueness
+        return @validates_uniqueness
+      end
+
+      def validates_uniqueness?
+        return @validates_uniqueness
+      end
+
+      def allow_nil
+        return @allow_nil
+      end
+
+      def allow_nil?
+        return @allow_nil
+      end
+
+      def min_size
+        return @min_size
+      end
+
+      def max_size
+        return @max_size
+      end
+
+      def errors
+        return DuckHunt::HashHelpers.stringify_keys(@errors)
+      end
+
+      def items(&block)
+        raise InvalidSchema, "cannot mix single-type and tuple definitions" unless @single_type_property.nil?
+        @tuple_properties = TupleProperties.new(&block)
+      end
+
+      def optional_items(&block)
+        raise InvalidSchema, "cannot mix single-type and tuple definitions" unless @single_type_property.nil?
+        @optional_tuple_properties = TupleProperties.new(&block)
+      end
+
+      def validate?(object)
+        @errors.clear
+        if object.nil?
+          return true if allow_nil?
+          add_base_error_message(NIL_OBJECT_NOT_ALLOWED_MESSAGE)
+          return false
+        end
+
+        return false unless matches_type?(object)
+
+        if validates_uniqueness? and not has_unique_entries?(object)
+          add_base_error_message(DUPLICATE_ITEMS_NOT_ALLOWED_MESSAGE)
+          return false
+        end
+
+        return validate_single_type?(object) if single_type_schema?
+        return validate_tuple?(object) if tuple_schema?
+      end
+
+      protected
+
+      def add_property(property_constant, *args, &block)
+        raise InvalidSchema, "cannot mix single-type and tuple definitions" unless @tuple_properties.nil? and @optional_tuple_properties.nil?
+        raise InvalidSchema, "single type property has already been defined for this schema" unless @single_type_property.nil?
+        @single_type_property = property_constant.new(*args, &block)
+      end
+
+
+      def matches_type?(object_being_validated)
+        unless object_being_validated.is_a? Array
+          add_base_error_message(DuckHunt::TYPE_MISMATCH_MESSAGE)
+          return false
+        end
+        return true
+      end
+
+      def add_base_error_message(message)
+        @errors[:base] = [] if @errors[:base].nil?
+        @errors[:base] << message
+      end
+
+      def single_type_schema?
+        return !@single_type_property.nil?
+      end
+
+      def tuple_schema?
+        @tuple_properties.nil? == false or @optional_tuple_properties.nil? == false
+      end
+
+      def has_unique_entries?(object)
+        return object.uniq.size == object.size
+      end
+
+      def validate_single_type?(object)
+        object_size = object.size
+        object_valid = true
+
+        if !min_size.nil? and object_size < min_size
+          add_base_error_message(generate_under_minimum_message(min_size, object_size))
+          return false
+        end
+
+        if !max_size.nil? and object_size > max_size
+          add_base_error_message(generate_over_maximum_message(max_size, object_size))
+          return false
+        end
+
+        object.each_with_index{ |item, index|
+          unless single_type_property.valid?(item)
+            @errors[index.to_s] = single_type_property.errors
+            object_valid = false
+          end
+        }
+
+        return object_valid
+      end
+
+      def validate_tuple?(object)
+        object_size = object.size
+        object_valid = true
+
+        if object_size < minimum_tuple_size
+          add_base_error_message(generate_under_minimum_message(minimum_tuple_size, object_size))
+          return false
+        end
+
+        if object_size > maximum_tuple_size
+          add_base_error_message(generate_over_maximum_message(maximum_tuple_size, object_size))
+          return false
+        end
+
+        unless tuple_properties.nil?
+          # check that each required entry has the correct type in the tuple
+          tuple_properties.each_with_index{ |property, index|
+            unless property.valid?(object[index])
+              @errors[index.to_s] = property.errors
+              object_valid = false
+            end
+          }
+        end
+
+        if !optional_tuple_properties.nil? and object.size > 0
+          # check that each optional entry has the correct type in the tuple
+          optional_tuple_properties.each_with_index{ |property, index|
+            object_index = minimum_tuple_size + index
+            if object_index > (object.size - 1)
+              break #stop looking at optional properties if we've reached the end of the array
+            end
+            unless property.valid?(object[object_index])
+              @errors[object_index.to_s] = property.errors
+              object_valid = false
+            end
+          }
+        end
+
+        return object_valid
+      end
+
+      def minimum_tuple_size
+        return tuple_properties.nil? ? 0 : tuple_properties.size
+      end
+
+      def maximum_tuple_size
+        optional_tuple_size = optional_tuple_properties.nil? ? 0 : optional_tuple_properties.size
+        return minimum_tuple_size + optional_tuple_size
+      end
+
+      def generate_under_minimum_message(minimum_size, object_size)
+        return "expected at least #{minimum_size} item(s) but got #{object_size} item(s)"
+      end
+
+      def generate_over_maximum_message(maximum_size, object_size)
+        return "expected at most #{maximum_size} item(s) but got #{object_size} item(s)"
+      end
+
+      class TupleProperties
+        include Schemas::PropertyLookup
+
+        def initialize(*var)
+          raise ArgumentError, "a block of properties must be given to define the tuple items" unless block_given?
+          @properties = []
+          yield self
+        end
+
+        def properties
+          @properties.dup
+        end
+
+        protected
+
+        def add_property(property_constant, *args, &block)
+          @properties << property_constant.new(*args, &block)
+        end
+      end
+    end
+  end
+end