duck-hunt 0.0.3

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

@@ -0,0 +1,135 @@
+module DuckHunt
+  module Schemas
+    class HashSchema
+      # Valditation is performed in the following steps:
+      # 1. Check that the object being validated is of the correct type
+      # 2. Iterate through each defined property and check that the object's property value is `valid?`
+      # 3. If the schema validation has been set to "strict mode", check that the object doesn't have any properties that are not defined in the schema
+      include Schemas::SchemaDefinition
+      include Schemas::PropertyLookup
+
+      require 'set'
+
+      def initialize(var={})
+        DuckHunt::HashHelpers.stringify_keys!(var)
+        options = {"strict_mode" => true, "allow_nil" => false}.merge(var)
+        @strict_mode = options["strict_mode"]
+        @allow_nil = options["allow_nil"]
+        @properties = {}
+        #a key-value pair of all the required properties in the schema, references objects in `@properties`
+        @required_properties = {}
+        @errors = {}
+      end
+
+      def properties
+        return @properties.dup
+      end
+
+      def strict_mode
+        return @strict_mode
+      end
+
+      def strict_mode?
+        return strict_mode
+      end
+
+      def allow_nil
+        return @allow_nil
+      end
+
+      def allow_nil?
+        return @allow_nil
+      end
+
+      def validate?(object_being_validated)
+        @errors.clear #reset since we are revalidating
+        if object_being_validated.nil?
+          return true if allow_nil?
+          add_base_error_message(NIL_OBJECT_NOT_ALLOWED_MESSAGE)
+          return false
+        end
+        return false unless matches_type?(object_being_validated)
+        #now that we know the type matches, we can stringify the hash's keys
+        DuckHunt::HashHelpers.stringify_keys!(object_being_validated)
+        return false unless conforms_to_strict_mode_setting?(object_being_validated)
+        return false unless objects_properties_are_valid_and_has_all_required_properties?(object_being_validated)
+        return true
+      end
+
+      def errors
+        @properties.each{|name, property| @errors[name] = property.errors unless property.errors.empty?  }
+        return DuckHunt::HashHelpers.stringify_keys(@errors)
+      end
+
+      protected
+
+      def add_property(property_constant, *args, &block)
+        name = args.shift.to_s
+        raise ArgumentError, "Property name cannot be blank" if name.nil? or name.empty?
+        raise PropertyAlreadyDefined, "`#{name}` has already been defined in this schema" if @properties.has_key?(name)
+        @properties[name] = property_constant.new(*args, &block)
+        if @properties[name].required?
+          @required_properties[name] = @properties[name]
+        end
+      end
+
+      def add_base_error_message(message)
+        @errors[:base] = [] if @errors[:base].nil?
+        @errors[:base] << message
+      end
+
+      def conforms_to_strict_mode_setting?(object_being_validated)
+        object_properties_set = object_being_validated.keys.to_set
+        schema_properties_set = properties.keys.to_set
+        # if we are in strict mode, we have to check that the object's properties are a subset
+        # of the schema (do not contain any extra properties).
+        if strict_mode?
+          if !(object_properties_set.subset? schema_properties_set)
+            add_base_error_message("has properties not defined in schema")
+            return false
+          end
+        end
+        #passes test, or is not in strict mode
+        return true
+      end
+
+      def objects_properties_are_valid_and_has_all_required_properties?(object_being_validated)
+        object_valid = missing_required_properties?(object_being_validated)
+        object_being_validated.each do |name, value|
+          next unless properties.has_key?(name.to_s)
+
+          # we want to validate every property, even if the object is invalid. That way, the
+          # errors are correctly populated for each property
+          property_is_valid = properties[name.to_s].valid?(value)
+
+          # switch the object's validity to false if a property is invalid. This will not
+          # revert back if a propety is true and the `object_valid == true` check prevents
+          # unnecessary re-assignments to false
+          if object_valid == true and property_is_valid == false
+            object_valid = false
+          end
+        end
+
+        return object_valid
+      end
+
+      def missing_required_properties?(object_being_validated)
+        missing_required_properties = @required_properties.keys - object_being_validated.keys
+        unless missing_required_properties.empty?
+          missing_required_properties.each{|name| properties[name.to_s].add_required_error }
+          return false
+        end
+        return true
+      end
+
+      #implemented by the class to do a top-level check that the object is even of the right type
+      def matches_type?(object_being_validated)
+        unless object_being_validated.is_a? Hash
+          add_base_error_message(DuckHunt::TYPE_MISMATCH_MESSAGE)
+          return false
+        end
+        return true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module DuckHunt
+  module Schemas
+    module PropertyLookup
+      def method_missing(method_name, *args, &block)
+        #convert the method name into camel case and turn it into a symbol.
+        camelized_string = DuckHunt::StringHelpers.camelize(method_name.to_s)
+        property_symbol = camelized_string.to_sym
+        #check if this property has been defined.
+        if property_definition_exists?(property_symbol)
+          property_constant = get_property_constant(property_symbol)
+          add_property(property_constant, *args, &block)
+        else
+          super
+        end
+      end
+
+      protected
+
+      def property_definition_exists?(property)
+        DuckHunt::Properties.const_defined?(property)
+      end
+
+      def get_property_constant(property)
+        DuckHunt::Properties.const_get(property)
+      end
+
+      def add_property(property_constant, *args, &block)
+        raise NotImplementedError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module DuckHunt
+	module Schemas
+		module SchemaDefinition
+			# This module encompasses all of the logic required to define a schema, along with the necessary instance variables.
+			# Schema Definition requires the following:
+			# * using the block passed through the `define` method to define the Schema for this instance
+			# * Finding the correct Property subclass based on the method name in the `define` class (e.g: `schema.string "name"`)
+			# * Accepting the `strict!` method, which sets Schema validation to strict mode
+			# * Storing/Retrieving the Property instances defined as part of the schema
+
+			# Include class-level methods
+			def self.included(base)
+		    base.extend(ClassMethods)
+		  end
+
+		  module ClassMethods
+		    def define(*args, &block)
+		    	instance = self.new(*args)
+		    	instance.instance_eval(&block)
+		    	return instance
+		    end
+		  end
+		end
+	end
+end

data/lib/duck-hunt/string_helpers.rb

@@ -0,0 +1,25 @@
+# add support for camelization (to make property/validation lookup easier)
+# 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 StringHelpers
+    def self.camelize(string, first_letter = :upper)
+      case first_letter
+      when :upper
+        self.camelize_string(string, true)
+      when :lower
+        self.camelize_string(string, false)
+      end
+    end
+
+    protected
+
+    def self.camelize_string(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators.rb

@@ -0,0 +1,16 @@
+module DuckHunt
+  module Validators
+    autoload :Validator, File.dirname(__FILE__) + "/validators/validator.rb"
+    autoload :Matches, File.dirname(__FILE__) + "/validators/matches.rb"
+    autoload :GreaterThan, File.dirname(__FILE__) + "/validators/greater_than.rb"
+    autoload :GreaterThanOrEqualTo, File.dirname(__FILE__) + "/validators/greater_than_or_equal_to.rb"
+    autoload :LessThan, File.dirname(__FILE__) + "/validators/less_than.rb"
+    autoload :LessThanOrEqualTo, File.dirname(__FILE__) + "/validators/less_than_or_equal_to.rb"
+    autoload :EqualTo, File.dirname(__FILE__) + "/validators/equal_to.rb"
+    autoload :NotEqualTo, File.dirname(__FILE__) + "/validators/not_equal_to.rb"
+    autoload :DivisibleBy, File.dirname(__FILE__) + "/validators/divisible_by.rb"
+    autoload :NotDivisibleBy, File.dirname(__FILE__) + "/validators/not_divisible_by.rb"
+    autoload :AcceptedValues, File.dirname(__FILE__) + "/validators/accepted_values.rb"
+    autoload :RejectedValues, File.dirname(__FILE__) + "/validators/rejected_values.rb"
+  end
+end

data/lib/duck-hunt/validators/accepted_values.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class AcceptedValues < Validator
+      attr_reader :values
+      def initialize(*args)
+        @values = args[0]
+        raise ArgumentError, "an array must be provided" unless @values.is_a? Array
+      end
+
+      def valid?(value)
+        return @values.include? value
+      end
+
+      def error_message
+        return "not an accepted value"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/divisible_by.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class DivisibleBy < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return (value % @value).zero?
+      end
+
+      def error_message
+        return "not divisible by `#{@value}`"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/equal_to.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class EqualTo < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return value == @value
+      end
+
+      def error_message
+        return "not equal to `#{@value}`"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/greater_than.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class GreaterThan < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return value > @value
+      end
+
+      def error_message
+        return "less than `#{@value}`"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/greater_than_or_equal_to.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class GreaterThanOrEqualTo < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return value >= @value
+      end
+
+      def error_message
+        return "less than `#{@value}`"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/less_than.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class LessThan < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return value < @value
+      end
+
+      def error_message
+        return "greater than `#{@value}`"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/less_than_or_equal_to.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class LessThanOrEqualTo < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return value <= @value
+      end
+
+      def error_message
+        return "greater than `#{@value}`"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/matches.rb

@@ -0,0 +1,18 @@
+module DuckHunt
+  module Validators
+    class Matches < Validator
+      attr_reader :regex
+      def initialize(*args)
+        @regex = Regexp.new(args[0])
+      end
+
+      def valid?(value)
+        return @regex.match(value) != nil
+      end
+
+      def error_message
+        return "No matches for Regexp"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/not_divisible_by.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class NotDivisibleBy < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return !(value % @value).zero?
+      end
+
+      def error_message
+        return "divisible by `#{@value}`"
+      end
+    end
+  end
+end

data/lib/duck-hunt/validators/not_equal_to.rb

@@ -0,0 +1,19 @@
+module DuckHunt
+  module Validators
+    class NotEqualTo < Validator
+      attr_reader :value
+      def initialize(*args)
+        @value = args[0]
+        raise ArgumentError, "a value must be provided" if @value.nil?
+      end
+
+      def valid?(value)
+        return value != @value
+      end
+
+      def error_message
+        return "equal to `#{@value}`"
+      end
+    end
+  end
+end