respect 0.1.0

data/lib/respect/global_def.rb

@@ -0,0 +1,79 @@
+require 'set'
+
+module Respect
+  # Global context of the schema definition DSL.
+  #
+  # This is the base class of all DSL evaluation context. It provides
+  # minimal evaluation support. Any methods added to this class will
+  # be available in every context of DSL.
+  #
+  # You can evaluate a block using the {#eval} method. Sub-classes must
+  # implement the +evalulation_result+ methods (which must returns the
+  # result of the evaluation) or provides their own +eval+ methods.
+  #
+  # End-users are not supposed to sub-class this class yet. Its API is
+  # *experimental*.
+  class GlobalDef
+
+    # Remove methods inherited from Object and conflicting with the
+    # dynamic methods in CoreStatement.
+    %w{hash}.each do |name|
+      undef_method name
+    end
+
+    class << self
+
+      # Instantiate this evaluation context using the given +args+
+      # and evaluate the given +block+ within it.
+      def eval(*args, &block)
+        new(*args).eval(&block)
+      end
+
+      # Return whether the statements declared in this context accept a name
+      # as first argument. All classes not including {DefWithoutName}
+      # accept names.
+      def accept_name?
+        !(self < DefWithoutName)
+      end
+
+      @@core_contexts = Set.new
+
+      # Call this method in "def" class willing to offer core statements.
+      # Do not include {CoreStatements} directly.
+      def include_core_statements
+        @@core_contexts << self
+        include CoreStatements
+      end
+
+      # Return the list of all classes including {CoreStatements}.
+      def core_contexts
+        @@core_contexts
+      end
+
+    end
+
+    # Shortcut to {GlobalDef.accept_name?}.
+    def accept_name?
+      self.class.accept_name?
+    end
+
+    # Evaluate the given +block+ in the context of this class through
+    # a {FakeNameProxy} with this class as target.
+    # {#evaluation_result} is called at the end to return the
+    # result of this evaluation.
+    def eval(&block)
+      @def_evaluator ||= FakeNameProxy.new(self)
+      @def_evaluator.eval(&block)
+      evaluation_result
+    end
+
+    private
+
+    # Overwrite this method in sub-classes to return the result value
+    # of this evaluation context.
+    def evaluation_result
+      raise NoMethodError, "overwrite me in sub-classes"
+    end
+  end
+
+end

data/lib/respect/greater_than_or_equal_to_validator.rb

@@ -0,0 +1,19 @@
+module Respect
+  class GreaterThanOrEqualToValidator < Validator
+    def initialize(min)
+      @min = min
+    end
+
+    def validate(value)
+      unless value >= @min
+        raise ValidationError, "#{value} is not greater than or equal to #@min"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { "minimum" => @min }
+    end
+  end
+end

data/lib/respect/greater_than_validator.rb

@@ -0,0 +1,19 @@
+module Respect
+  class GreaterThanValidator < Validator
+    def initialize(min)
+      @min = min
+    end
+
+    def validate(value)
+      unless value > @min
+        raise ValidationError, "#{value} is not greater than #@min"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { "minimum" => @min, "exclusiveMinimum" => true }
+    end
+  end
+end

data/lib/respect/has_constraints.rb

@@ -0,0 +1,34 @@
+module Respect
+  # Module supporting execution of validators referred in options.
+  #
+  # Classes including this module must fulfill the following requirements:
+  # * Respond to +options+ and returned a hash of options where keys
+  #   refers to validator name (i.e. +greater_than+ for {GreaterThanValidator}).
+  # * Respond to +validate_type(object)+ which must returns the sanitized object.
+  module HasConstraints
+
+    # Validate all the constraints listed in +options+ to the
+    # given +value+.
+    def validate_constraints(value)
+      options.each do |option, arg|
+        if validator_class = Respect.validator_for(option)
+          validator_class.new(arg).validate(value)
+        end
+      end
+    end
+
+    # Call +validate_type+ with the given +object+, apply the constraints
+    # and assign the sanitized object.
+    def validate(object)
+      sanitized_object = validate_type(object)
+      validate_constraints(sanitized_object) unless sanitized_object.nil? && allow_nil?
+      self.sanitized_object = sanitized_object
+      true
+    rescue ValidationError => e
+      # Reset sanitized object.
+      self.sanitized_object = nil
+      raise e
+    end
+
+  end
+end

data/lib/respect/hash_def.rb

@@ -0,0 +1,40 @@
+module Respect
+  class HashDef < GlobalDef
+    include_core_statements
+
+    def initialize(options = {})
+      @hash_schema = HashSchema.new(options)
+    end
+
+    def extra(&block)
+      with_options(required: false, &block)
+    end
+
+    # Shortcut to say a schema +key+ must be equal to a given +value+. When it
+    # does not recognize the value type it creates a "any" schema.
+    #
+    # Example:
+    #   HashSchema.define do |s|
+    #     s["a_string"] = "value"       # equivalent to: s.string("a_string", equal_to: "value")
+    #     s["a_key"] = 0..5             # equivalent to: s.any("a_key", equal_to: "0..5")
+    #   end
+    def []=(key, value)
+      case value
+      when String
+        string(key, equal_to: value.to_s)
+      else
+        any(key, equal_to: value.to_s)
+      end
+    end
+
+    private
+
+    def evaluation_result
+      @hash_schema
+    end
+
+    def update_context(name, schema)
+      @hash_schema[name] = schema
+    end
+  end
+end

data/lib/respect/hash_schema.rb

@@ -0,0 +1,218 @@
+module Respect
+  # A schema to specify the structure of a hash.
+  #
+  # This schema defines the structure of a hash by listing
+  # the expected property name and they associated schema.
+  #
+  # Property can be define by using a symbol, a string or a regular
+  # expression.  In the later case, the associated schema will be used
+  # to validate the value of all the properties matching the regular
+  # expression. You can get the list of all pattern properties
+  # using the {#pattern_properties} method.
+  #
+  # You can specify optional property by either setting the "required"
+  # option to false or y setting a non nil default value.
+  # You can get the list of all optional properties using the
+  # {#optional_properties} method.
+  #
+  # Access to the object's value being validated is done using either
+  # string key or symbol key. In other word +{ i: "42" }+ and
+  # +{ "i" => "42" }+ are the same object for the {#validate} method.
+  # The object passed is left untouched. The sanitized object
+  # is a hash with indifferent access. Note that when an object
+  # is sanitized in-place, its original keys are kept
+  # (see {Respect.sanitize_object!}). Only validated keys are included
+  # in the sanitized object.
+  #
+  # You can pass several options when creating an {HashSchema}:
+  # strict:: if set to +true+ the hash must not have any extra
+  #          properties to be validated. (+false+ by default)
+  class HashSchema < Schema
+    include Enumerable
+
+    class << self
+      # Overwritten method. See Schema::default_options
+      def default_options
+        super().merge({
+            strict: false,
+          }).freeze
+      end
+    end
+
+    public_class_method :new
+
+    def initialize(options = {})
+      super(self.class.default_options.merge(options))
+      @properties = {}
+    end
+
+    def initialize_copy(other)
+      super
+      @properties = other.properties.dup
+    end
+
+    # Get the schema for the given property +name+.
+    def [](name)
+      @properties[name]
+    end
+
+    # Set the given +schema+ for the given property +name+. A name can be
+    # a Symbol, a String or a Regexp.
+    def []=(name, schema)
+      case name
+      when Symbol, String, Regexp
+        if @properties.has_key?(name)
+          raise InvalidSchemaError, "property '#{name}' already defined"
+        end
+        @properties[name] = schema
+      else
+        raise InvalidSchemaError, "unsupported property name type #{name}:#{name.class}"
+      end
+    end
+
+    # Returns the set of properties of this schema index by their name.
+    attr_reader :properties
+
+    # Overwritten method. See {Schema#validate}.
+    def validate(object)
+      # Handle nil case.
+      if object.nil?
+        if allow_nil?
+          self.sanitized_object = nil
+          return true
+        else
+          raise ValidationError, "object is nil but this #{self.class} does not allow nil"
+        end
+      end
+      # Validate object format.
+      unless object.is_a?(Hash)
+        raise ValidationError, "object is not a hash but a #{object.class}"
+      end
+      sanitized_object = {}.with_indifferent_access
+      # Validate expected properties.
+      @properties.each do |name, schema|
+        case name
+        when Symbol
+          validate_property_with_options(name.to_s, schema, object, sanitized_object)
+        when String
+          validate_property_with_options(name, schema, object, sanitized_object)
+        when Regexp
+          object.select{|prop, schema| prop =~ name }.each do |prop, value|
+            validate_property(prop, schema, object, sanitized_object)
+          end
+        end
+      end
+      if options[:strict]
+        # Check whether there are extra properties.
+        object.each do |name, schema|
+          unless sanitized_object.has_key? name
+            raise ValidationError, "unexpected key `#{name}'"
+          end
+        end
+      end
+      self.sanitized_object = sanitized_object
+      true
+    rescue ValidationError => e
+      # Reset sanitized object.
+      self.sanitized_object = nil
+      raise e
+    end
+
+    def validate_property_with_options(name, schema, object, sanitized_object)
+      if object_has_key?(object, name)
+        validate_property(name, schema, object, sanitized_object)
+      else
+        if schema.required?
+          raise ValidationError, "missing key `#{name}'"
+        else
+          if schema.has_default?
+            sanitized_object[name] = schema.default
+          end
+        end
+      end
+    end
+    private :validate_property_with_options
+
+    def object_has_key?(object, key)
+      if object.has_key?(key)
+        true
+      elsif object.has_key?(key.to_sym)
+        true
+      else
+        false
+      end
+    end
+    private :object_has_key?
+
+    def validate_property(name, schema, object, sanitized_object)
+      begin
+        schema.validate(object_get_key(object, name))
+        sanitized_object[name] = schema.sanitized_object
+      rescue ValidationError => e
+        e.context << "in hash property `#{name}'"
+        raise e
+      end
+    end
+    private :validate_property
+
+    def object_get_key(object, key)
+      if object.has_key?(key)
+        object[key]
+      elsif object.has_key?(key.to_sym)
+        object[key.to_sym]
+      else
+        object.default(key)
+      end
+    end
+    private :object_get_key
+
+    # Return the optional properties (e.g. those that are not required).
+    def optional_properties
+      @properties.select{|name, schema| schema.optional? }
+    end
+
+    # Return all the properties identified by a regular expression.
+    def pattern_properties
+      @properties.select{|name, schema| name.is_a?(Regexp) }
+    end
+
+    # In-place version of {#merge}. This schema is returned.
+    def merge!(hash_schema)
+      @options.merge!(hash_schema.options)
+      @properties.merge!(hash_schema.properties)
+      self
+    end
+
+    # Merge the given +hash_schema+ with this object schema. It works like
+    # +Hash.merge+.
+    def merge(hash_schema)
+      self.dup.merge!(hash_schema)
+    end
+
+    # Return whether +property_name+ is defined in this hash schema.
+    def has_property?(property_name)
+      @properties.has_key?(property_name)
+    end
+
+    # Evaluate the given block as a hash schema definition (i.e. in the context of
+    # {Respect::HashDef}) and merge the result with this hash schema.
+    # This is a way to "re-open" this hash schema definition to add some more.
+    def eval(&block)
+      self.merge!(HashSchema.define(&block))
+    end
+
+    # Return all the properties with a non-false documentation.
+    def documented_properties
+      @properties.select{|name, schema| schema.documented? }
+    end
+
+    def ==(other)
+      super && @properties == other.properties
+    end
+
+    # FIXME(Nicolas Despres): Add a test for me.
+    def each(&block)
+      @properties.each(&block)
+    end
+  end
+end

data/lib/respect/in_validator.rb

@@ -0,0 +1,19 @@
+module Respect
+  class InValidator < Validator
+    def initialize(set)
+      @set = set
+    end
+
+    def validate(value)
+      unless @set.include?(value)
+        raise ValidationError, "#{value.inspect} is not included in #@set"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { 'enum' => @set.dup }
+    end
+  end
+end

data/lib/respect/integer_schema.rb

@@ -0,0 +1,27 @@
+module Respect
+  class IntegerSchema < NumericSchema
+
+    def validate_type(object)
+      case object
+      when String
+        if object =~ /^[-+]?\d+$/
+          object.to_i
+        else
+          raise ValidationError,
+                "malformed integer value: `#{object}'"
+        end
+      when Integer
+        object
+      when NilClass
+        if allow_nil?
+          nil
+        else
+          raise ValidationError, "object is nil but this #{self.class} does not allow nil"
+        end
+      else
+        raise ValidationError, "object is not an integer but a '#{object.class}'"
+      end
+    end
+
+  end # class IntegerSchema
+end