respect 0.1.0

data/lib/respect/dsl_dumper.rb

@@ -0,0 +1,181 @@
+module Respect
+  # Dump a schema to a string representation using the DSL syntax so you
+  # can evaluate it and get the same schema back.
+  #
+  # Theoretically, this must always be true:
+  #   eval(DslDumper.new(schema).dump) == schema
+  #
+  # The current implementation covers all the _Schema_ and _Validator_
+  # classes defined in this package. User-defined sub-class of {Schema}
+  # are not guarantee to work. Specially those using a custom "Def" class
+  # or with special attributes. The API of this dumper is *experimental*,
+  # so relying on it to teach the dumper how to dump a user-defined schema
+  # class may break in future releases.
+  #
+  # However, sub-classes of {CompositeSchema} are handled
+  # properly as well as all {Validator} sub-classes.
+  class DslDumper
+
+    def initialize(schema)
+      @schema = schema
+      @indent_level = 0
+      @indent_size = 2
+      @context_data = {}
+    end
+
+    attr_reader :schema, :output
+
+    def dump(output = nil)
+      @output = output
+      @output ||= String.new
+      self << "Respect::Schema.define do |s|"
+      self.indent do
+        self.dump_schema(@schema)
+      end
+      self << "\nend\n"
+      @output
+    end
+
+    def <<(str)
+      @output << str.gsub(/(\n+)/, "\\1#{indentation}")
+      self
+    end
+
+    def indent(count = 1, &block)
+      @indent_level += count
+      if block
+        block.call
+        unindent(count)
+      end
+    end
+
+    def unindent(count = 1)
+      @indent_level -= count
+    end
+
+    def indentation
+      " " * @indent_size * @indent_level
+    end
+
+    attr_accessor :context_data
+
+    def dump_block(args = [ "s" ], &block)
+      self << " do |#{args.join(', ')}|"
+      self.indent(&block)
+      self << "\nend"
+    end
+
+    def dump_schema(schema)
+      self.dump_doc(schema)
+      self << "\ns."
+      self.dump_name(schema)
+      self.dump_arguments(schema)
+      self.dump_body(schema)
+      self
+    end
+
+    def dump_doc(schema, prefix = false)
+      if schema.doc
+        if schema.description
+          self << "\n"
+          self << %q{s.doc <<-EOS.strip_heredoc}
+          self.indent do
+            self << "\n"
+            self << schema.doc
+            self << "EOS"
+          end
+        else
+          self << "\ns.doc \"#{schema.title}\""
+        end
+      end
+    end
+
+    def dump_name(schema)
+      self << schema.class.statement_name
+    end
+
+    def dump_arguments(schema)
+      # Fetch name if there is one?
+      if self.context_data.has_key?(:name)
+        name = self.context_data[:name]
+      else
+        name = nil
+      end
+      # Compute options to dump.
+      options = schema.non_default_options.reject do |opt|
+        opt == :doc
+      end
+      # Dump name and options
+      if name || !options.empty?
+        if name
+          self << " "
+          self << name.inspect
+        end
+        if !options.empty?
+          if name
+            self << ","
+          end
+          self << " "
+          self.dump_options(schema)
+        end
+      end
+      self
+    end
+
+    def dump_options(schema)
+      options = schema.non_default_options
+      option_keys = options.keys
+      option_keys.each do |opt|
+        self << opt.inspect
+        self << " => "
+        self << options[opt].inspect
+        self << ", " unless opt == option_keys.last
+      end
+      self
+    end
+
+    def dump_body(schema)
+      symbol = "dump_body_for_#{schema.class.statement_name}"
+      if respond_to? symbol
+        send(symbol, schema)
+      end
+    end
+
+    def dump_body_for_hash(schema)
+      dump_block do
+        schema.properties.each do |name, schema|
+          context_data[:name] = name
+          dump_schema(schema)
+        end
+      end
+    end
+
+    def dump_body_for_array(schema)
+      dump_block do
+        context_data.delete(:name)
+        if schema.item
+          dump_schema(schema.item)
+        end
+        if schema.items && !schema.items.empty?
+          self << "\ns.items do |s|"
+          indent do
+            schema.items.each do |schema|
+              dump_schema(schema)
+            end
+          end
+          self << "\nend"
+        end
+        if schema.extra_items && !schema.extra_items.empty?
+          self << "\ns.extra_items do |s|"
+          indent do
+            schema.extra_items.each do |schema|
+              dump_schema(schema)
+            end
+          end
+          self << "\nend"
+        end
+      end
+    end
+  end
+
+end # module Respect

data/lib/respect/equal_to_validator.rb

@@ -0,0 +1,20 @@
+module Respect
+  class EqualToValidator < Validator
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def validate(value)
+      unless value == @expected
+        raise ValidationError,
+              "wrong value: `#{value}':#{value.class} instead of `#@expected':#{@expected.class}"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { 'enum' => [ @expected ] }
+    end
+  end
+end

data/lib/respect/fake_name_proxy.rb

@@ -0,0 +1,116 @@
+module Respect
+  # The evaluation proxy used for the DSL.
+  #
+  # This class sends all methods it receives to the target object it has
+  # received when initialized.
+  #
+  # If the target's response to +accept_name?+ is +false+, this proxy
+  # passes a +nil+ value as first argument to target's dynamic methods
+  # and target's methods expecting a name as first argument.
+  #
+  # This is useful to factor method code that should work in two different
+  # contexts. For instance, in the context of a hash schema definition,
+  # core statements expect a name as first argument whereas in the context
+  # of an array schema definition they do not.
+  #
+  #   HashSchema.define do |s|
+  #     s.integer "age", greater_than: 0
+  #   end
+  #   ArraySchema.define do |s|
+  #     # FakeNameProxy passes +nil+ here as value for the +name+ argument.
+  #     s.integer greater_than: 0
+  #   end
+  #
+  # To factor this code, we define the +integer+ method in a module included
+  # in both context classes.
+  #
+  #   module CoreStatements
+  #     def integer(name, options = {})
+  #       update_context name, IntegerSchema.define(options)
+  #     end
+  #   end
+  #   class HashDef
+  #     include CoreStatements
+  #     def accept_name?; true; end
+  #     def update_context(name, schema)
+  #       @hash_schema[name] = schema
+  #     end
+  #   end
+  #   class ArrayDef
+  #     include CoreStatements
+  #     def accept_name?; false; end
+  #     def update_context(name, schema)
+  #       @array_schema.item = schema
+  #     end
+  #   end
+  #
+  # The +update_context+ method simply ignored the name argument in ArrayDef
+  # because it does not make any sens in this context.
+  class FakeNameProxy < BasicObject
+
+    def initialize(target)
+      @target = target
+    end
+
+    # Return the DSL context object where the evaluation takes place.
+    attr_reader :target
+
+    def method_missing(symbol, *args, &block)
+      if respond_to_missing?(symbol, false)
+        # If the target's default behavior for its methods is to not accept a name as
+        # first argument (this is the case for ArrayDef), we introspect the method
+        # to decide whether we have to send a nil name as first argument.
+        if should_fake_name?
+          method = @target.method(symbol)
+        else
+          method = nil
+        end
+        # If we have a method and this method is either dynamic or expects a name as its first parameter.
+        if method && (dynamic_method?(symbol) || has_name_param?(method))
+          args.insert(0, nil)
+          begin
+            method.call(*args, &block)
+          rescue ::ArgumentError => e
+            # Decrements argument number mentioned in the message by one.
+            message = e.message.sub(/ \((\d+) for (\d+)\)$/) do |match|
+              # FIXME(Nicolas Despres): Not sure if this class is still
+              # re-entrant since we use $1 and $2. I could not find a way to access
+              # to the data matched by sub.
+              " (#{$1.to_i - 1} for #{$2.to_i - 1})"
+            end
+            ::Kernel.raise(::ArgumentError, message)
+          end
+        else
+          @target.public_send(symbol, *args, &block)
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(symbol, include_all)
+      # We ignore include_all since we are only interested in non-private methods.
+      @target.respond_to?(symbol)
+    end
+
+    # Evaluate the given +block+ in the context of this class and pass it this
+    # instance as argument and returns the value returned by the block.
+    def eval(&block)
+      block.call(self)
+    end
+
+    private
+
+    def dynamic_method?(symbol)
+      !@target.methods.include?(symbol)
+    end
+
+    def has_name_param?(method)
+      !method.parameters.empty? && method.parameters.first.last == :name
+    end
+
+    def should_fake_name?
+      @target.respond_to?(:accept_name?) && !@target.accept_name?
+    end
+  end
+end

data/lib/respect/float_schema.rb

@@ -0,0 +1,27 @@
+module Respect
+  class FloatSchema < NumericSchema
+
+    def validate_type(object)
+      case object
+      when String
+        if object =~ /^[-+]?\d+(\.\d+)?$/
+          object.to_f
+        else
+          raise ValidationError,
+                "malformed float value: `#{object}'"
+        end
+      when 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 float but a '#{object.class}'"
+      end
+    end
+
+  end # class FloatSchema
+end # module Respect

data/lib/respect/format_validator.rb

@@ -0,0 +1,136 @@
+require 'ipaddr'
+require 'uri'
+
+module Respect
+  class FormatValidator < Validator
+
+    PHONE_NUMBER_REGEXP = /^((\+|00)\d{1,2})?\d+$/
+
+    # FIXME(Nicolas Despres): RFC 1034 mentions that a valid domain can be " "
+    # in section 3.5. (see http://www.rfc-editor.org/rfc/rfc1034.txt) but we don't
+    # since I don't understand when it is useful.
+    HOSTNAME_REGEXP = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/i
+
+    def initialize(format)
+      @format = format
+    end
+
+    def validate(value)
+      send("validate_#@format", value)
+    end
+
+    # Validate the given string _value_ describes a well-formed email
+    # address following this specification
+    # http://www.w3.org/TR/2012/CR-html5-20121217/forms.html#valid-e-mail-address
+    def validate_email(value)
+      unless value =~ /^[a-zA-Z0-9.!#$\%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/
+        raise ValidationError, "invalid email address format '#{value}'"
+      end
+    end
+
+    # Validate URI string format following RFC 2396
+    # (see http://tools.ietf.org/html/rfc2396)
+    def validate_uri(value)
+      URI.parse(value)
+    rescue URI::InvalidURIError => e
+      raise ValidationError, "invalid URI: #{e.message}"
+    end
+
+    # Validate the given string _value_ describes a regular expression
+    # following the Ruby regular expression syntax.
+    def validate_regexp(value)
+      Regexp.new(value)
+    rescue RegexpError => e
+      raise ValidationError, "invalid regexp: #{e.message}"
+    end
+
+    # Validate date and time string format following RFC 3399
+    # (see https://tools.ietf.org/html/rfc3339)
+    def validate_datetime(value)
+      DateTime.rfc3339(value)
+    rescue ArgumentError => e
+      raise ValidationError, e.message
+    end
+
+    # Validate IPV4 using the standard "ipaddr" ruby module.
+    def validate_ipv4_addr(value)
+      ipaddr = IPAddr.new(value)
+      unless ipaddr.ipv4?
+        raise ValidationError, "IP address '#{value}' is not IPv4"
+      end
+      ipaddr
+    rescue ArgumentError => e
+      raise ValidationError, "invalid IPv4 address '#{value}' - #{e.message}"
+    end
+
+    # Validate phone number following E.123
+    # (see http://en.wikipedia.org/wiki/E.123)
+    def validate_phone_number(value)
+      unless value =~ PHONE_NUMBER_REGEXP
+        raise ValidationError, "invalid phone number '#{value}'"
+      end
+    end
+
+    # Validate that the given string _value_ describes a well-formed
+    # IPV6 network address using the standard "ipaddr" ruby module.
+    def validate_ipv6_addr(value)
+      ipaddr = IPAddr.new(value)
+      unless ipaddr.ipv6?
+        raise ValidationError, "IP address '#{value}' is not IPv6"
+      end
+      ipaddr
+    rescue ArgumentError => e
+      raise ValidationError, "invalid IPv6 address '#{value}' - #{e.message}"
+    end
+
+    # Validate that the given string _value_ describes a well-formed
+    # IP (IPv6 or IPv4) network address using the standard "ipaddr" ruby module.
+    def validate_ip_addr(value)
+      IPAddr.new(value)
+    rescue ArgumentError => e
+      raise ValidationError, "invalid IP address '#{value}' - #{e.message}"
+    end
+
+    # Validate that the given string _value_ describes a well-formed
+    # host name as specified by RFC 1034.
+    # (see http://www.rfc-editor.org/rfc/rfc1034.txt)
+    def validate_hostname(value)
+      match_data = HOSTNAME_REGEXP.match(value)
+      if match_data
+        value.split('.').each_with_index do |label, i|
+          unless label.length <= 63
+            raise ValidationError,
+                  "hostname's #{i.ordinalize} label '#{label}' is not less than 63 characters in '#{value}'"
+          end
+        end
+      else
+        raise ValidationError, "invalid hostname '#{value}'"
+      end
+    end
+
+    private
+
+    def to_h_org3
+      { 'format' => convert_to_org3_format(@format) }
+    end
+
+    def convert_to_org3_format(format)
+      format_type_map = {
+        regexp: 'regex',
+        datetime: 'date-time',
+        ipv4_addr: 'ip-address',
+        phone_number: 'phone',
+        ipv6_addr: 'ipv6',
+        ip_addr: nil,
+        hostname: 'host-name',
+      }.freeze
+      if format_type_map.has_key?(format)
+        translation_value = format_type_map[format]
+        translation_value unless translation_value.nil?
+      else
+        format.to_s
+      end
+    end
+
+  end # class FormatValidator
+end # module Respect