jschema 0.0.2

data/lib/jschema/validator/enum.rb

@@ -0,0 +1,23 @@
+module JSchema
+  module Validator
+    class Enum < SimpleValidator
+      private
+
+      self.keywords = ['enum']
+
+      def validate_args(enum)
+        unique_non_empty_array?(enum) || invalid_schema('enum', enum)
+      end
+
+      def post_initialize(enum)
+        @enum = enum
+      end
+
+      def validate_instance(instance)
+        unless @enum.include? instance
+          "#{instance} must be one of: #{@enum.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/format.rb

@@ -0,0 +1,75 @@
+require 'ipaddr'
+
+module JSchema
+  module Validator
+    class Format < SimpleValidator
+      private
+
+      self.keywords = ['format']
+
+      def validate_args(format)
+        allowed_formats =
+          ['date-time', 'email', 'hostname', 'ipv4', 'ipv6', 'uri']
+
+        if allowed_formats.include?(format)
+          true
+        else
+          invalid_schema 'format', format
+        end
+      end
+
+      def post_initialize(format)
+        @validator_method = format.gsub('-', '_')
+      end
+
+      def validate_instance(instance)
+        unless send(@validator_method, instance)
+          "#{instance} must be a #{@validator_method}"
+        end
+      end
+
+      def applicable_types
+        [String]
+      end
+
+      def date_time(instance)
+        true if DateTime.rfc3339(instance)
+      rescue ArgumentError
+        false
+      end
+
+      def email(instance)
+        instance.include? '@'
+      end
+
+      # Acc.to RFC 1034, 3.1
+      def hostname(instance)
+        if instance.length.between?(1, 255)
+          instance.split('.').all? do |label|
+            label =~ /^[\da-z\-]{1,63}$/i
+          end
+        else
+          false
+        end
+      end
+
+      def ipv4(instance)
+        IPAddr.new(instance).ipv4?
+      rescue ArgumentError
+        false
+      end
+
+      def ipv6(instance)
+        IPAddr.new(instance).ipv6?
+      rescue ArgumentError
+        false
+      end
+
+      def uri(instance)
+        URI.parse instance
+      rescue URI::InvalidURIError
+        false
+      end
+    end
+  end
+end

data/lib/jschema/validator/items.rb

@@ -0,0 +1,79 @@
+module JSchema
+  module Validator
+    class Items < SimpleValidator
+      private
+
+      self.keywords = ['items', 'additionalItems']
+
+      def validate_args(items, additional_items)
+        additional_items_valid? additional_items
+        items_valid? items
+      end
+
+      def additional_items_valid?(additional_items)
+        additional_items.nil? ||
+        boolean?(additional_items) ||
+        valid_schema?(additional_items, 'additionalItems') ||
+          invalid_schema('additionalItems', additional_items)
+      end
+
+      def items_valid?(items)
+        items.nil? ||
+        valid_schema?(items, 'items') ||
+        schema_array?(items, 'items') ||
+          invalid_schema('items', items)
+      end
+
+      def post_initialize(items, additional_items)
+        @items = items
+        @additional_items = additional_items
+      end
+
+      def validate_instance(instance)
+        validate_additional_items(instance) ||
+        validate_all_items(instance)
+      end
+
+      def validate_additional_items(instance)
+        if @additional_items == false &&
+           @items.is_a?(Array) &&
+           @items.size < instance.size
+
+          "#{instance} must not contain any additional items"
+        end
+      end
+
+      def validate_all_items(instance)
+        instance.to_enum.each_with_index do |item, index|
+          schema = schema_for_item(index)
+          validation_errors = schema.validate(item)
+          unless validation_errors.empty?
+            return validation_errors.first
+          end
+        end
+        nil
+      end
+
+      def schema_for_item(index)
+        case @items
+        when Array
+          if index < @items.size
+            Schema.build @items[index], parent, "items/#{index}"
+          elsif @additional_items.is_a?(Hash)
+            Schema.build @additional_items, parent, 'additionalItems'
+          else
+            Schema.build
+          end
+        when Hash
+          Schema.build @items, parent, 'items'
+        else
+          fail UnknownError
+        end
+      end
+
+      def applicable_types
+        [Array]
+      end
+    end
+  end
+end

data/lib/jschema/validator/max_items.rb

@@ -0,0 +1,28 @@
+module JSchema
+  module Validator
+    class MaxItems < SimpleValidator
+      private
+
+      self.keywords = ['maxItems']
+
+      def validate_args(max_items)
+        greater_or_equal_to?(max_items, 0) ||
+          invalid_schema('maxItems', max_items)
+      end
+
+      def post_initialize(max_items)
+        @max_items = max_items
+      end
+
+      def validate_instance(instance)
+        if instance.size > @max_items
+          "#{instance} has too many items"
+        end
+      end
+
+      def applicable_types
+        [Array]
+      end
+    end
+  end
+end

data/lib/jschema/validator/max_length.rb

@@ -0,0 +1,23 @@
+module JSchema
+  module Validator
+    class MaxLength < StringLengthValidator
+      private
+
+      self.keywords = ['maxLength']
+
+      def validate_args(max_length)
+        if valid_length_limit?(max_length, 1)
+          true
+        else
+          invalid_schema 'maxLength', max_length
+        end
+      end
+
+      def validate_instance(instance)
+        if instance.size > @length_limit
+          "#{instance} is too long"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/max_properties.rb

@@ -0,0 +1,31 @@
+module JSchema
+  module Validator
+    class MaxProperties < SimpleValidator
+      private
+
+      self.keywords = ['maxProperties']
+
+      def validate_args(max_properties)
+        if greater_or_equal_to?(max_properties, 0)
+          true
+        else
+          invalid_schema 'maxProperties', max_properties
+        end
+      end
+
+      def post_initialize(max_properties)
+        @max_properties = max_properties
+      end
+
+      def applicable_types
+        [Hash]
+      end
+
+      def validate_instance(instance)
+        if instance.keys.size > @max_properties
+          "#{instance} has too many properties"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/maximum.rb

@@ -0,0 +1,31 @@
+module JSchema
+  module Validator
+    class Maximum < SimpleValidator
+      private
+
+      self.keywords = ['maximum', 'exclusiveMaximum']
+
+      def validate_args(maximum, exclusive_maximum)
+        number?(maximum) || invalid_schema('maximum', maximum)
+        exclusive_maximum.nil? || boolean?(exclusive_maximum) ||
+          invalid_schema('exclusiveMaximum', exclusive_maximum)
+      end
+
+      def post_initialize(maximum, exclusive_maximum)
+        @maximum = maximum
+        @exclusive_maximum = exclusive_maximum
+      end
+
+      def validate_instance(instance)
+        method = @exclusive_maximum ? :< : :<=
+        unless instance.public_send(method, @maximum)
+          "#{instance} must be #{method} than #{@maximum}"
+        end
+      end
+
+      def applicable_types
+        [Fixnum, Bignum, Float, BigDecimal]
+      end
+    end
+  end
+end

data/lib/jschema/validator/min_items.rb

@@ -0,0 +1,28 @@
+module JSchema
+  module Validator
+    class MinItems < SimpleValidator
+      private
+
+      self.keywords = ['minItems']
+
+      def validate_args(min_items)
+        greater_or_equal_to?(min_items, 0) ||
+          invalid_schema('minItems', min_items)
+      end
+
+      def post_initialize(min_items)
+        @min_items = min_items
+      end
+
+      def validate_instance(instance)
+        if instance.size < @min_items
+          "#{instance} has too few items"
+        end
+      end
+
+      def applicable_types
+        [Array]
+      end
+    end
+  end
+end

data/lib/jschema/validator/min_length.rb

@@ -0,0 +1,23 @@
+module JSchema
+  module Validator
+    class MinLength < JSchema::StringLengthValidator
+      private
+
+      self.keywords = ['minLength']
+
+      def validate_args(min_length)
+        if valid_length_limit?(min_length, 0)
+          true
+        else
+          invalid_schema 'minLength', min_length
+        end
+      end
+
+      def validate_instance(instance)
+        if instance.size < @length_limit
+          "#{instance} is too short"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/min_properties.rb

@@ -0,0 +1,31 @@
+module JSchema
+  module Validator
+    class MinProperties < SimpleValidator
+      private
+
+      self.keywords = ['minProperties']
+
+      def validate_args(min_properties)
+        if greater_or_equal_to?(min_properties, 0)
+          true
+        else
+          invalid_schema 'minProperties', min_properties
+        end
+      end
+
+      def post_initialize(min_properties)
+        @min_properties = min_properties
+      end
+
+      def applicable_types
+        [Hash]
+      end
+
+      def validate_instance(instance)
+        if instance.keys.size < @min_properties
+          "#{instance} has too few properties"
+        end
+      end
+    end
+  end
+end

data/lib/jschema/validator/minimum.rb

@@ -0,0 +1,31 @@
+module JSchema
+  module Validator
+    class Minimum < SimpleValidator
+      private
+
+      self.keywords = ['minimum', 'exclusiveMinimum']
+
+      def validate_args(minimum, exclusive_minimum)
+        number?(minimum) || invalid_schema('minimum', minimum)
+        exclusive_minimum.nil? || boolean?(exclusive_minimum) ||
+          invalid_schema('exclusiveMinimum', exclusive_minimum)
+      end
+
+      def post_initialize(minimum, exclusive_minimum)
+        @minimum = minimum
+        @exclusive_minimum = exclusive_minimum
+      end
+
+      def validate_instance(instance)
+        method = @exclusive_minimum ? :> : :>=
+        unless instance.public_send(method, @minimum)
+          "#{instance} must be #{method} than #{@minimum}"
+        end
+      end
+
+      def applicable_types
+        [Fixnum, Bignum, Float, BigDecimal]
+      end
+    end
+  end
+end

data/lib/jschema/validator/multiple_of.rb

@@ -0,0 +1,32 @@
+module JSchema
+  module Validator
+    class MultipleOf < SimpleValidator
+      private
+
+      self.keywords = ['multipleOf']
+
+      def validate_args(multiple_of)
+        if number?(multiple_of) && multiple_of > 0
+          true
+        else
+          invalid_schema('multipleOf', multiple_of)
+        end
+      end
+
+      def post_initialize(multiple_of)
+        @multiple_of = multiple_of
+      end
+
+      def validate_instance(instance)
+        div_remainder = instance.abs % @multiple_of
+        unless div_remainder.abs < 1e-6
+          "#{instance} must be a multiple of #{@multiple_of}"
+        end
+      end
+
+      def applicable_types
+        [Fixnum, Bignum, Float, BigDecimal]
+      end
+    end
+  end
+end