respect 0.1.0

data/lib/respect/ip_addr_schema.rb

@@ -0,0 +1,23 @@
+require 'ipaddr'
+
+module Respect
+  # Validate a string containing an IPv4 or IPv6 address but also accept IPAddr object.
+  class IPAddrSchema < StringSchema
+
+    def validate_type(object)
+      case object
+      when NilClass
+        if allow_nil?
+          nil
+        else
+          raise ValidationError, "object is nil but this #{self.class} does not allow nil"
+        end
+      when IPAddr
+        object
+      else
+        FormatValidator.new(:ip_addr).validate(object)
+      end
+    end
+
+  end # class IPAddrSchema
+end # module Respect

data/lib/respect/ipv4_addr_schema.rb

@@ -0,0 +1,27 @@
+require 'ipaddr'
+
+module Respect
+  # Validate a string containing an IPv4 address but also accept IPAddr object.
+  class Ipv4AddrSchema < StringSchema
+
+    def validate_type(object)
+      case object
+      when NilClass
+        if allow_nil?
+          nil
+        else
+          raise ValidationError, "object is nil but this #{self.class} does not allow nil"
+        end
+      when IPAddr
+        if object.ipv4?
+          object
+        else
+          raise ValidationError, "IPAddr object '#{object}' is not IPv4"
+        end
+      else
+        FormatValidator.new(:ipv4_addr).validate(object)
+      end
+    end
+
+  end # class Ipv4AddrSchema
+end # module Respect

data/lib/respect/ipv6_addr_schema.rb

@@ -0,0 +1,27 @@
+require 'ipaddr'
+
+module Respect
+  # Validate a string containing an IPv6 address but also accept IPAddr object.
+  class Ipv6AddrSchema < StringSchema
+
+    def validate_type(object)
+      case object
+      when NilClass
+        if allow_nil?
+          nil
+        else
+          raise ValidationError, "object is nil but this #{self.class} does not allow nil"
+        end
+      when IPAddr
+        if object.ipv6?
+          object
+        else
+          raise ValidationError, "IPAddr object '#{object}' is not IPv6"
+        end
+      else
+        FormatValidator.new(:ipv6_addr).validate(object)
+      end
+    end
+
+  end # class Ipv6AddrSchema
+end # module Respect

data/lib/respect/items_def.rb

@@ -0,0 +1,21 @@
+module Respect
+  class ItemsDef < GlobalDef
+    include_core_statements
+    include DefWithoutName
+
+    def initialize
+      @items = []
+    end
+
+    private
+
+    def evaluation_result
+      @items
+    end
+
+    def update_context(name, schema)
+      @items << schema
+      schema
+    end
+  end
+end

data/lib/respect/json_schema_html_formatter.rb

@@ -0,0 +1,143 @@
+module Respect
+  # Format a JSON schema in HTML with CSS class to allow highlighting.
+  class JSONSchemaHTMLFormatter
+    def initialize(json_schema)
+      @indent_level = 0
+      @indent_size = 2
+      @json_schema = json_schema
+      @css_class ||= {
+        json_highlight: "json_highlight",
+        plain: "plain",
+        key: "key",
+        keyword: "keyword",
+        string: "string",
+        numeric: "numeric",
+        comment: "comment",
+      }
+    end
+
+    attr_accessor :css_class
+
+    def dump(output = "")
+      @output = output
+      @output ||= String.new
+      @output << "<div class=\"#{css_class[:json_highlight]}\"><pre>"
+      @output << dump_json(@json_schema)
+      @output << "</pre></div>\n"
+      @output
+    end
+
+    private
+
+    def indent(&block)
+      @indent_level += 1
+      block.call
+      @indent_level -= 1
+    end
+
+    def newline
+      "\n#{indentation}"
+    end
+
+    def indentation
+      " " * @indent_level * @indent_size
+    end
+
+    def dump_json(json)
+      case json
+      when Hash
+        dump_hash(json)
+      when Array
+        dump_array(json)
+      else
+        dump_terminal(json)
+      end
+    end
+
+    def dump_hash(json)
+      result = plain_text("{")
+      indent do
+        result << newline
+        keys = json.keys
+        keys.each_with_index do |key, i|
+          if json[key].is_a? Hash
+            doc = ""
+            if json[key].key? "title"
+              doc << json[key]["title"]
+              json[key].delete("title")
+            end
+            if json[key].key? "description"
+              doc << "\n\n"
+              doc << json[key]["description"]
+              json[key].delete("description")
+            end
+            unless doc.empty?
+              result << comment(doc)
+              result << newline
+            end
+          end
+          result << span(css_class[:key], key.to_s.inspect) << plain_text(":") << " "
+          result << dump_json(json[key])
+          if i < keys.size - 1
+            result << plain_text(",")
+            result << newline
+          end
+        end
+      end
+      result << newline
+      result << plain_text("}")
+      result
+    end
+
+    def dump_array(json)
+      result = plain_text("[")
+      indent do
+        result << newline
+        json.each_with_index do |item, i|
+          result << dump_json(item)
+          if i < json.size - 1
+            result << plain_text(",")
+            result << newline
+          end
+        end
+      end
+      result << newline
+      result << plain_text("]")
+      result
+    end
+
+    def dump_terminal(json)
+      css = (case json
+             when TrueClass, FalseClass
+               css_class[:keyword]
+             when String
+               css_class[:string]
+             when Numeric
+               css_class[:numeric]
+             else
+               css_class[:plain]
+             end)
+      span(css, json.inspect)
+    end
+
+    def plain_text(text)
+      span(css_class[:plain], text)
+    end
+
+    def tag(tag, klass, value)
+      "<#{tag} class=\"#{klass}\">#{value}</#{tag}>"
+    end
+
+    def span(klass, value)
+      tag("span", klass, value)
+    end
+
+    def comment(text)
+      s = text.dup
+      s.sub!(/\n*\Z/m, '')
+      s.gsub!(/\n/m, "\n#{indentation}// ")
+      s.gsub!(/\s*\n/m, "\n")
+      span(css_class[:comment], "// #{s}")
+    end
+  end
+end # module Respect

data/lib/respect/less_than_or_equal_to_validator.rb

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

data/lib/respect/less_than_validator.rb

@@ -0,0 +1,19 @@
+module Respect
+  class LessThanValidator < Validator
+    def initialize(max)
+      @max = max
+    end
+
+    def validate(value)
+      unless value < @max
+        raise ValidationError, "#{value} is not less than #@max"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { "maximum" => @max, "exclusiveMaximum" => true }
+    end
+  end
+end

data/lib/respect/match_validator.rb

@@ -0,0 +1,19 @@
+module Respect
+  class MatchValidator < Validator
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def validate(value)
+      unless value =~ @pattern
+        raise ValidationError, "#{value.inspect} does not match #{@pattern.inspect}"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { "pattern" => @pattern.source }
+    end
+  end
+end

data/lib/respect/max_length_validator.rb

@@ -0,0 +1,20 @@
+module Respect
+  class MaxLengthValidator < Validator
+    def initialize(max_length)
+      @max_length = max_length
+    end
+
+    def validate(value)
+      unless value.length <= @max_length
+        raise ValidationError,
+              "#{value.inspect} must be at most #@max_length long but is #{value.length}"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { 'maxLength' => @max_length }
+    end
+  end
+end

data/lib/respect/min_length_validator.rb

@@ -0,0 +1,20 @@
+module Respect
+  class MinLengthValidator < Validator
+    def initialize(min_length)
+      @min_length = min_length
+    end
+
+    def validate(value)
+      unless value.length >= @min_length
+        raise ValidationError,
+              "#{value.inspect} must be at least #@min_length long but is #{value.length}"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { 'minLength' => @min_length }
+    end
+  end
+end

data/lib/respect/multiple_of_validator.rb

@@ -0,0 +1,10 @@
+module Respect
+  class MultipleOfValidator < DivisibleByValidator
+    def validate(value)
+      super
+    rescue ValidationError => e
+      raise ValidationError,
+            e.message.sub(/\bdivisible by\b/, "a multiple of")
+    end
+  end
+end # module Respect

data/lib/respect/null_schema.rb

@@ -0,0 +1,26 @@
+module Respect
+  class NullSchema < Schema
+
+    public_class_method :new
+
+    def validate(object)
+      case object
+      when String
+        if object == "null"
+          self.sanitized_object = nil
+          true
+        else
+          raise ValidationError,
+                "expected 'null' value but got '#{object}:#{object.class}'"
+        end
+      when NilClass
+        self.sanitized_object = nil
+        true
+      else
+        raise ValidationError,
+              "object is not of null type but a #{object.class}"
+      end
+    end
+
+  end # class NullSchema
+end # module Respect

data/lib/respect/numeric_schema.rb

@@ -0,0 +1,33 @@
+module Respect
+  class NumericSchema < Schema
+    include HasConstraints
+
+    public_class_method :new
+
+    def validate_type(object)
+      case object
+      when String
+        if match_data = /^[-+]?\d+(\.\d+)?$/.match(object)
+          if match_data[1]
+            object.to_f
+          else
+            object.to_i
+          end
+        else
+          raise ValidationError, "malformed numeric value: `#{object}'"
+        end
+      when Integer, Float
+        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 a numeric but a '#{object.class}'"
+      end
+    end
+
+  end # class NumericSchema
+end # module Respect

data/lib/respect/org3_dumper.rb

@@ -0,0 +1,213 @@
+module Respect
+  # Dump a schema to a hash representation following the format specified
+  # on {json-schema.org standard draft v3}[http://tools.ietf.org/id/draft-zyp-json-schema-03.html].
+  #
+  # The current implementation covers all the _Schema_ and _Validator_ classes
+  # defined in this package. User-defined {Schema} and {Validator} are not guarantee
+  # to work and may never work in the future. The _JSON-Schema_ standard is
+  # a general purpose standard and include only primitive type so it is
+  # very unlikely that it will include your custom schema and validator
+  # out of the box. However, if you can translate your schema/validator
+  # as a composition of primitive type mentioned in the standard it will work.
+  # That's why it is recommended to sub-class {CompositeSchema} when creating
+  # your own schema. User-defined are not properly supported yet as the
+  # API of this dumper is *experimental*. However, an easy way to extend
+  # both the schema and validator class hierarchies will be added in
+  # future releases.
+  class Org3Dumper
+
+    # Translation table mapping DSL options with json-schema.org v3
+    # options. The associated hash is injected in the output. Values
+    # are interpreted as follow:
+    # - :option_value represent the option value passed to the DSL option parameter.
+    # - a proc is called with the option value as argument and the result is used
+    #   as the value for the output key if it is not nil.
+    # - other value are inserted verbatim.
+    OPTION_MAP = {
+      min_size: { 'minItems' => :option_value },
+      max_size: { 'maxItems' => :option_value },
+      uniq: { "uniqueItems" => Proc.new{|v| v if v } },
+      default: { "default" => Proc.new{|v| v unless v.nil? } },
+      required: { "required" => Proc.new{|v| true if required? } },
+    }.freeze
+
+    def initialize(schema)
+      @schema = schema
+    end
+
+    def dump(output = nil)
+      @output = output
+      @output ||= Hash.new
+      @output = dump_schema(@schema, ignore: [:required])
+      @output
+    end
+
+    attr_reader :output
+
+    def dump_schema(schema, *args)
+      dispatch("dump_schema", schema.class, schema, *args)
+    end
+
+    def dump_schema_for_schema(schema, params = {})
+      return nil if !schema.documented?
+      h = {}
+      h['type'] = dump_statement_name(schema)
+      # Dump generic options.
+      schema.options.each do |opt, opt_value|
+        next if params[:ignore] && params[:ignore].include?(opt)
+        if validator_class = Respect.validator_for(opt)
+          h.merge!(validator_class.new(opt_value).to_h(:org3))
+        elsif Org3Dumper::OPTION_MAP.has_key?(opt)
+          Org3Dumper::OPTION_MAP[opt].each do |k, v|
+            if v == :option_value
+              h[k] = (opt_value.is_a?(Numeric) ? opt_value : opt_value.dup)
+            elsif v.is_a?(Proc)
+              result = schema.instance_exec(opt_value, &v)
+              h[k] = result unless result.nil?
+            else
+              h[k] = v
+            end
+          end
+        end
+      end
+      h.merge!(dump_options(schema))
+      # Dump documentation
+      h["title"] = schema.title if schema.title
+      h["description"] = schema.description if schema.description
+      h
+    end
+
+    def dump_schema_for_hash_schema(schema, params = {})
+      h = dump_schema_for_schema(schema, params)
+      return nil if h.nil?
+      props = {}
+      pattern_props = {}
+      additional_props = {}
+      schema.properties.each do |prop, schema|
+        if prop.is_a?(Regexp)
+          if schema.optional?
+            # FIXME(Nicolas Despres): Find a better warning reporting system.
+            warn "pattern properties cannot be optional in json-schema.org draft v3"
+          else
+            # FIXME(Nicolas Despres): What do we do with regexp options such as 'i'?
+            schema_dump = dump_schema(schema)
+            pattern_props[prop.source] = schema_dump if schema_dump
+          end
+        else
+          if schema.optional?
+            schema_dump = dump_schema(schema)
+            additional_props[prop.to_s] = schema_dump if schema_dump
+          else
+            schema_dump = dump_schema(schema)
+            props[prop.to_s] = schema_dump if schema_dump
+          end
+        end
+      end
+      h['properties'] = props unless props.empty?
+      h['patternProperties'] = pattern_props unless pattern_props.empty?
+      if additional_props.empty?
+        if schema.options[:strict]
+          h['additionalProperties'] = false
+        end
+      else
+        h['additionalProperties'] = additional_props
+      end
+      h
+    end
+
+    def dump_schema_for_array_schema(schema, params = {})
+      h = dump_schema_for_schema(schema, params)
+      return nil if h.nil?
+      if schema.item
+        h['items'] = dump_schema(schema.item, ignore: [:required])
+      else
+        if schema.items && !schema.items.empty?
+          h['items'] = schema.items.map do |x|
+            dump_schema(x, ignore: [:required])
+          end
+        end
+        if schema.extra_items && !schema.extra_items.empty?
+          h['additionalItems'] = schema.extra_items.map do |x|
+            dump_schema(x, ignore: [:required])
+          end
+        end
+      end
+      h
+    end
+
+    def dump_schema_for_composite_schema(schema, params = {})
+      dump_schema(schema.schema, params)
+    end
+
+    def dump_statement_name(schema, *args)
+      dispatch("dump_statement_name", schema.class, schema, *args)
+    end
+
+    def dump_statement_name_for_schema(schema)
+      schema.class.statement_name
+    end
+
+    def dump_statement_name_for_hash_schema(schema)
+      "object"
+    end
+
+    def dump_statement_name_for_numeric_schema(schema)
+      "number"
+    end
+
+    def dump_statement_name_for_integer_schema(schema)
+      "integer"
+    end
+
+    def dump_statement_name_for_string_schema(schema)
+      "string"
+    end
+
+    def dump_options(schema, *args)
+      dispatch("dump_options", schema.class, schema, *args)
+    end
+
+    def dump_options_for_schema(schema)
+      {}
+    end
+
+    def dump_options_for_uri_schema(schema)
+      { "format" => "uri" }
+    end
+
+    def dump_options_for_regexp_schema(schema)
+      { "format" => "regex" }
+    end
+
+    def dump_options_for_datetime_schema(schema)
+      { "format" => "date-time" }
+    end
+
+    def dump_options_for_ipv4_addr_schema(schema)
+      { "format" => "ip-address" }
+    end
+
+    def dump_options_for_ipv6_addr_schema(schema)
+      { "format" => "ipv6" }
+    end
+
+    private
+
+    # Perform a virtual dispatch on a single object.
+    # FIXME(Nicolas Despres): Get me out of here and test me.
+    def dispatch(prefix, klass, object, *args, &block)
+      symbol = "#{prefix}_for_#{klass.name.demodulize.underscore}"
+      if respond_to? symbol
+        send(symbol, object, *args, &block)
+      else
+        if klass == BasicObject
+          raise NoMethodError, "undefined method '#{symbol}' for schema class #{object.class}"
+        else
+          dispatch(prefix, klass.superclass, object, *args, &block)
+        end
+      end
+    end
+
+  end
+
+end