respect 0.1.0

data/test/support/circle.rb

@@ -0,0 +1,11 @@
+class Circle
+  def initialize(center, radius)
+    @center, @radius = center, radius
+  end
+
+  attr_reader :center, :radius
+
+  def ==(other)
+    @center == other.center && @radius == radius
+  end
+end

data/test/support/color.rb

@@ -0,0 +1,24 @@
+class Color
+  class FormatError < StandardError
+  end
+
+  class << self
+    def from_string(str)
+      if str.to_s =~ /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/
+        Color.new($1.to_i(16), $2.to_i(16), $3.to_i(16), $4.to_i(16))
+      else
+        raise FormatError, "'#{str}' does not match color regexp"
+      end
+    end
+  end
+
+  def initialize(red, green, blue, alpha)
+    @red, @green, @blue, @alpha = red, green, blue, alpha
+  end
+
+  attr_reader :red, :green, :blue, :alpha
+
+  def ==(other)
+    @red == other.red && @green == other.green && @blue == other.blue && @alpha == other.alpha
+  end
+end

data/test/support/point.rb

@@ -0,0 +1,11 @@
+class Point
+  def initialize(x, y)
+    @x, @y = x, y
+  end
+
+  attr_reader :x, :y
+
+  def ==(other)
+    @x == other.x && @y == other.y
+  end
+end

data/test/support/respect/circle_schema.rb

@@ -0,0 +1,16 @@
+module Respect
+  # Test class proving that users can easily extend the schema hierarchy
+  # with a custom type based on another custom type.
+  class CircleSchema < CompositeSchema
+    def schema_definition
+      HashSchema.define do |s|
+        s.point "center"
+        s.float "radius", greater_than: 0.0
+      end
+    end
+
+    def sanitize(doc)
+      Circle.new(doc[:center], doc[:radius])
+    end
+  end
+end

data/test/support/respect/color_def.rb

@@ -0,0 +1,19 @@
+module Respect
+  class ColorDef < GlobalDef
+    def initialize(options = {})
+      @color_schema = ColorSchema.new(options)
+    end
+
+    [ :red, :green, :blue, :alpha ].each do |name|
+      define_method(name) do |value|
+        @color_schema.send("#{name}=", value)
+      end
+    end
+
+    private
+
+    def evaluation_result
+      @color_schema
+    end
+  end
+end

data/test/support/respect/color_schema.rb

@@ -0,0 +1,33 @@
+module Respect
+  class ColorSchema < Schema
+
+    public_class_method :new
+
+    def initialize(options = {})
+      super
+      @red, @green, @blue, @alpha = 0, 0, 0, 0
+    end
+
+    attr_accessor :red, :green, :blue, :alpha
+
+    def validate(doc)
+      color = nil
+      begin
+         color = Color.from_string(doc.to_s)
+      rescue Color::FormatError => e
+        raise ValidationError, "invalid color: #{e.message}"
+      end
+      [ :red, :green, :blue, :alpha ].each do |part|
+        if expected = send(part)
+          value = color.send(part)
+          unless value == expected
+            raise ValidationError, "color part #{part} is #{value} but should be #{expected}"
+          end
+        end
+      end
+      self.sanitized_object = color
+    end
+
+  end # class ColorSchema
+
+end # module Respect

data/test/support/respect/point_schema.rb

@@ -0,0 +1,19 @@
+module Respect
+  # Test class proving that users can easily extend the schema hierarchy
+  # with a custom type providing both a composition macro and a
+  # sanitizer block.
+  class PointSchema < CompositeSchema
+
+    def schema_definition
+      HashSchema.define do |s|
+        s.float "x"
+        s.float "y"
+      end
+    end
+
+    def sanitize(doc)
+      Point.new(doc["x"], doc["y"])
+    end
+
+  end
+end

data/test/support/respect/rgba_schema.rb

@@ -0,0 +1,20 @@
+module Respect
+  # Test class proving that users can easily extend the schema hierarchy
+  # with a composite schema based on an array schema.
+  class RgbaSchema < CompositeSchema
+    def schema_definition
+      ArraySchema.define do |s|
+        s.items do |s|
+          s.color_channel # red
+          s.color_channel # green
+          s.color_channel # blue
+          s.color_channel # alpha
+        end
+      end
+    end
+
+    def sanitize(doc)
+      Rgba.new(doc[0], doc[1], doc[2], doc[3])
+    end
+  end
+end

data/test/support/respect/universal_validator.rb

@@ -0,0 +1,25 @@
+module Respect
+  # Test class proving that users can easily extend the validator hierarchy
+  # with their own ones.
+  class UniversalValidator < Validator
+
+    def initialize(enabled)
+      @enabled = enabled
+    end
+
+    def validate(value)
+      if @enabled
+        unless value == 42
+          raise ValidationError, "#{value} is not a universal value"
+        end
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { "minimum" => 42, "maximum" => 42 }
+    end
+
+  end # class UniversalValidator
+end # module Respect

data/test/support/respect/user_macros.rb

@@ -0,0 +1,12 @@
+module Respect
+  # Test module proving that users can easily extend the definition DSL
+  # with their own macros bundled in their own modules organized as they
+  # want.
+  module UserMacros
+    def color_channel(name)
+      float name, in: 0.0..1.0
+    end
+  end
+
+  extend_dsl_with(UserMacros)
+end

data/test/support/rgba.rb

@@ -0,0 +1,11 @@
+class Rgba
+  def initialize(red, green, blue, alpha)
+    @red, @green, @blue, @alpha = red, green, blue, alpha
+  end
+
+  attr_reader :red, :green, :blue, :alpha
+
+  def ==(other)
+    @red == other.red && @green == other.green && @blue == other.blue && @alpha == other.alpha
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+require 'debugger'
+
+require 'respect'
+
+# Test that "hash" methods has been removed from GlabelDef as soon as we load "respect".
+# We cannot do it in HashSchema since the "hash" method maybe call before hand.
+if Respect::GlobalDef.new.respond_to? :hash
+  raise "'hash' method should have been removed before Respect::HashSchema class is loaded."
+end
+
+require 'respect/unit_test_helper'
+
+class Test::Unit::TestCase
+  # Similar to assert_raises but return the exception object caught.
+  def assert_exception(exception_class, message = nil, &block)
+    begin
+      block.call
+      assert false, message
+    rescue exception_class => e
+      e
+    end
+  end
+end
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# It *MUST* be defined before EndUserDSLStatement.
+module Respect
+  # A class to test DSL extension.
+  class CoreDef < GlobalDef
+    include_core_statements
+    include DefWithoutName
+  end
+end
+
+# A module to test statement extension helper.
+module EndUserDSLStatement
+
+  def id(name = "id")
+    integer name, greater_than: 0
+  end
+
+  def call_to_kernel
+    # The point is to call an instance method of the Kernel module.
+    integer "kernel", equal_to: Integer(0)
+  end
+
+  def call_to_object
+    # The point is to call an instance method of the Object class.
+    string "object", equal_to: self.class.to_s
+  end
+
+end
+
+Respect.extend_dsl_with(EndUserDSLStatement)
+
+FORMAT_HELPER_STATEMENTS_LIST = [
+  :phone_number,
+  :hostname,
+  :email,
+]
+
+PRIMITIVE_STATEMENTS_LIST = [
+  :integer,
+  :string,
+  :any,
+  :boolean,
+  :null,
+  :float,
+  :numeric,
+  :uri,
+  :regexp,
+  :datetime,
+  :ipv4_addr,
+  :ipv6_addr,
+  :ip_addr,
+]
+
+TERMINAL_STATEMENTS_LIST = FORMAT_HELPER_STATEMENTS_LIST + PRIMITIVE_STATEMENTS_LIST
+
+COMPOSITE_STATEMENTS_LIST = [
+  :hash,
+  :array,
+]
+
+BASIC_STATEMENTS_LIST = TERMINAL_STATEMENTS_LIST + COMPOSITE_STATEMENTS_LIST
+
+require "mocha/setup"

data/test/uri_schema_test.rb

@@ -0,0 +1,54 @@
+require "test_helper"
+
+class URISchemaTest < Test::Unit::TestCase
+
+  def test_uri_schema_creates_uri_object
+    s = Respect::URISchema.new
+    assert_nil s.sanitized_object
+    assert_schema_validate s, "http://foo.com"
+    assert s.sanitized_object.is_a?(URI::Generic)
+    assert_equal "http://foo.com", s.sanitized_object.to_s
+  end
+
+  def test_uri_schema_relies_on_format_validator
+    doc = "http://foo.com"
+    Respect::FormatValidator.any_instance.stubs(:validate_uri).with(doc).at_least_once
+    Respect::URISchema.new.validate(doc)
+  end
+
+  def test_failed_validation_reset_sanitized_object
+    s = Respect::URISchema.new
+    assert_schema_validate(s, "http://foo.com")
+    assert_not_nil(s.sanitized_object)
+    assert_schema_invalidate(s, "<")
+    assert_nil(s.sanitized_object)
+  end
+
+  def test_allow_nil
+    s = Respect::URISchema.new(allow_nil: true)
+    assert s.allow_nil?
+    assert_schema_validate s, nil
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, "http://foo.com"
+    assert_not_nil(s.sanitized_object)
+    assert_schema_invalidate(s, "<")
+    assert_nil(s.sanitized_object)
+  end
+
+  def test_disallow_nil
+    s = Respect::URISchema.new
+    assert !s.allow_nil?
+    exception = assert_exception(Respect::ValidationError) { s.validate(nil) }
+    assert_match exception.message, /\bURISchema\b/
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, "http://foo.com"
+    assert_not_nil(s.sanitized_object)
+    assert_schema_invalidate(s, "<")
+    assert_nil(s.sanitized_object)
+  end
+
+  def test_validate_uri_object
+    s = Respect::URISchema.new
+    assert_schema_validate(s, URI.parse("http://foo.com"))
+  end
+end

data/test/utc_time_schema_test.rb

@@ -0,0 +1,63 @@
+require "test_helper"
+
+class UTCTimeSchemaTest < Test::Unit::TestCase
+
+  def test_utc_time_schema_creates_time_object
+    s = Respect::UTCTimeSchema.new
+    assert_nil s.sanitized_object
+    t = Time.now.to_i
+    assert_schema_validate s, t.to_s
+    assert_equal Time, s.sanitized_object.class
+    assert_equal(t, s.sanitized_object.to_i)
+  end
+
+  def test_utc_time_schema_accept_float
+    s = Respect::UTCTimeSchema.new
+    assert_nil s.sanitized_object
+    t = Time.now.to_f
+    assert_schema_validate s, t.to_s
+    assert_equal Time, s.sanitized_object.class
+    assert_equal(t, s.sanitized_object.to_f)
+  end
+
+  def test_utc_time_schema_do_not_accept_negative
+    s = Respect::UTCTimeSchema.new
+    begin
+      s.validate(-1)
+      assert false
+    rescue Respect::ValidationError => e
+      assert_match(/-1/, e.message)
+    end
+  end
+
+  def test_failed_validation_reset_sanitized_object
+    s = Respect::UTCTimeSchema.new
+    assert_schema_validate(s, 42)
+    assert_not_nil(s.sanitized_object)
+    assert_schema_invalidate(s, "*")
+    assert_nil(s.sanitized_object)
+  end
+
+  def test_allow_nil
+    s = Respect::UTCTimeSchema.new(allow_nil: true)
+    assert s.allow_nil?
+    assert_schema_validate s, nil
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, 42
+    assert_not_nil(s.sanitized_object)
+    assert_schema_invalidate(s, "wrong")
+    assert_nil(s.sanitized_object)
+  end
+
+  def test_disallow_nil
+    s = Respect::UTCTimeSchema.new
+    assert !s.allow_nil?
+    exception = assert_exception(Respect::ValidationError) { s.validate(nil) }
+    assert_match exception.message, /\bUTCTimeSchema\b/
+    assert_equal(nil, s.sanitized_object)
+    assert_schema_validate s, 42
+    assert_not_nil(s.sanitized_object)
+    assert_schema_invalidate(s, "wrong")
+    assert_nil(s.sanitized_object)
+  end
+end

data/test/validator_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class ValidatorTest < Test::Unit::TestCase
+  def test_constraint_name
+    assert_equal "equal_to", Respect::EqualToValidator.constraint_name
+  end
+
+  def test_end_user_validator
+    s = Respect::IntegerSchema.new(universal: true)
+    assert_schema_invalidate s, 52
+    assert_schema_validate s, 42
+  end
+
+  def test_end_user_validate_get_called
+    value = 1664
+    v = Respect::UniversalValidator.new(true)
+    Respect::UniversalValidator.expects(:new).with(true).returns(v)
+    v.stubs(:validate).with(value).at_least_once
+    Respect::IntegerSchema.new(universal: true).validate(value)
+  end
+
+end