schemacop 2.4.6 → 3.0.0.rc3

data/lib/schemacop/{node_resolver.rb → v2/node_resolver.rb}

@@ -1,4 +1,4 @@
-module Schemacop
+module Schemacop::V2
   class NodeResolver
     class_attribute :node_classes
     self.node_classes = [].freeze

data/lib/schemacop/v2/node_supporting_field.rb

@@ -0,0 +1,70 @@
+module Schemacop::V2
+  class NodeSupportingField < NodeWithBlock
+    block_method :req?
+    block_method :req!
+    block_method :req
+    block_method :opt?
+    block_method :opt!
+    block_method :opt
+
+    attr_reader :fields
+
+    def initialize(options = {}, &block)
+      @fields = {}
+      super
+      exec_block(&block)
+    end
+
+    def req?(*args, **kwargs, &block)
+      kwargs ||= {}
+      kwargs[:required] = true
+      kwargs[:allow_nil] = true
+      field(*args, **kwargs, &block)
+    end
+
+    def req!(*args, **kwargs, &block)
+      kwargs ||= {}
+      kwargs[:required] = true
+      kwargs[:allow_nil] = false
+      field(*args, **kwargs, &block)
+    end
+
+    alias req req!
+
+    def opt?(*args, **kwargs, &block)
+      kwargs ||= {}
+      kwargs[:required] = false
+      kwargs[:allow_nil] = true
+      field(*args, **kwargs, &block)
+    end
+
+    def opt!(*args, **kwargs, &block)
+      kwargs ||= {}
+      kwargs[:required] = false
+      kwargs[:allow_nil] = false
+      field(*args, **kwargs, &block)
+    end
+
+    alias opt opt?
+
+    protected
+
+    def field(*args, **kwargs, &block)
+      name = args.shift
+      required = kwargs.delete(:required)
+      allow_nil = kwargs.delete(:allow_nil)
+
+      if @fields[name]
+        @fields[name].type(*args, **kwargs, &block)
+      elsif args.any?
+        @fields[name] = FieldNode.new(name, required) do
+          type(*args, **kwargs, &block)
+        end
+      else
+        @fields[name] = FieldNode.new(name, required, &block)
+      end
+
+      @fields[name].type(:nil) if allow_nil
+    end
+  end
+end

data/lib/schemacop/{node_supporting_type.rb → v2/node_supporting_type.rb}

@@ -1,4 +1,4 @@
-module Schemacop
+module Schemacop::V2
   class NodeSupportingType < NodeWithBlock
     block_method :type
 
@@ -14,6 +14,7 @@ module Schemacop
 
       if @types.none?
         fail Exceptions::InvalidSchemaError, 'Block must contain a type definition or not be given at all.' if block_given?
+
         type :object
       end
 
@@ -32,7 +33,7 @@ module Schemacop
       super
     rescue NoMethodError
       @types = []
-      type :hash, {}, &block
+      type :hash, &block
     end
 
     # required signature:
@@ -46,8 +47,8 @@ module Schemacop
     # happens in here directly and not in the constructor. This way we can
     # always call 'type', even if we don't have one and the type is auto-guessed
     # as it formerly was the case in the constructor.
-    def type(*args, &block)
-      options = args.last.is_a?(Hash) ? args.pop : {}
+    def type(*args, **kwargs, &block)
+      options = kwargs
       types = [*args.shift]
       subtypes = args
 
@@ -72,7 +73,7 @@ module Schemacop
           end
 
           child = klass.new do
-            self.type(*subtypes, options, &block)
+            self.type(*subtypes, **options, &block)
           end
 
           # child = klass.build(options)
@@ -101,9 +102,11 @@ module Schemacop
     def cast!(data, collector)
       @types.each do |type|
         next unless type.option?(:cast) && !type.type_matches?(data) && type.type_filter_matches?(data)
+
         caster = Caster.new(type.option(:cast), data, type.class.klasses.first)
 
         next unless caster.castable?
+
         begin
           data = caster.cast
           collector.override_value(data)

data/lib/schemacop/{node_with_block.rb → v2/node_with_block.rb}

@@ -1,4 +1,4 @@
-module Schemacop
+module Schemacop::V2
   class NodeWithBlock < Node
     class_attribute :block_methods
     self.block_methods = [].freeze
@@ -9,7 +9,8 @@ module Schemacop
 
     def exec_block(&block)
       return unless block_given?
-      se = ScopedEnv.new(self, self.class.block_methods)
+
+      se = Schemacop::ScopedEnv.new(self, self.class.block_methods)
       se.instance_exec(&block)
     end
   end

data/lib/schemacop/v2/validator/array_validator.rb

@@ -0,0 +1,32 @@
+module Schemacop
+  module V2
+    class ArrayValidator < NodeSupportingType
+      register symbols: :array, klasses: Array
+
+      option :min # Minimal number of elements
+      option :max # Maximal number of elements
+      option :nil # Whether to allow nil values
+
+      def initialize(*args)
+        super
+        type(:nil) if option(:nil)
+      end
+
+      def validate(data, collector)
+        validate_custom_check(data, collector)
+
+        if option?(:min) && data.size < option(:min)
+          collector.error "Array must have more (>=) than #{option(:min)} elements."
+        end
+        if option?(:max) && data.size > option(:max)
+          collector.error "Array must have less (<=) than #{option(:max)} elements."
+        end
+        data.each_with_index do |entry, index|
+          collector.path("[#{index}]", index, :array) do
+            validate_types(entry, collector)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/{validator → v2/validator}/boolean_validator.rb

@@ -1,4 +1,4 @@
-module Schemacop
+module Schemacop::V2
   class BooleanValidator < Node
     register symbols: :boolean, klasses: [TrueClass, FalseClass]
   end

data/lib/schemacop/v2/validator/float_validator.rb

@@ -0,0 +1,7 @@
+module Schemacop
+  module V2
+    class FloatValidator < NumberValidator
+      register symbols: :float, klasses: Float, before: NumberValidator
+    end
+  end
+end

data/lib/schemacop/v2/validator/hash_validator.rb

@@ -0,0 +1,37 @@
+module Schemacop
+  module V2
+    class HashValidator < NodeSupportingField
+      register symbols: :hash, klasses: Hash
+
+      option :allow_obsolete_keys
+
+      def validate(data, collector)
+        super
+
+        if data.is_a? ActiveSupport::HashWithIndifferentAccess
+          allowed_fields = @fields.keys.map { |k| k.is_a?(String) ? k.to_sym : k }
+          data_keys = data.keys.map { |k| k.is_a?(String) ? k.to_sym : k }
+
+          # If the same key is specified in the schema as string and symbol, we
+          # definitely expect a Ruby hash and not one with indifferent access
+          if @fields.keys.length != Set.new(allowed_fields).length
+            fail Exceptions::ValidationError, 'Hash expected, but got ActiveSupport::HashWithIndifferentAccess.'
+          end
+        else
+          allowed_fields = @fields.keys
+          data_keys = data.keys
+        end
+
+        obsolete_keys = data_keys - allowed_fields
+
+        if !option?(:allow_obsolete_keys) && obsolete_keys.any?
+          collector.error "Obsolete keys: #{obsolete_keys.inspect}."
+        end
+
+        @fields.each_value do |field|
+          field.validate(data, collector)
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/v2/validator/integer_validator.rb

@@ -0,0 +1,7 @@
+module Schemacop
+  module V2
+    class IntegerValidator < NumberValidator
+      register symbols: :integer, klasses: Integer, before: NumberValidator
+    end
+  end
+end

data/lib/schemacop/{validator → v2/validator}/nil_validator.rb

@@ -1,4 +1,4 @@
-module Schemacop
+module Schemacop::V2
   class NilValidator < Node
     register symbols: :nil, klasses: NilClass
   end

data/lib/schemacop/v2/validator/number_validator.rb

@@ -0,0 +1,21 @@
+module Schemacop
+  module V2
+    class NumberValidator < Node
+      register symbols: :number, klasses: [Integer, Float]
+
+      option :min
+      option :max
+
+      def validate(data, collector)
+        super
+
+        if option?(:min) && data < option(:min)
+          collector.error "Value must be >= #{option(:min)}."
+        end
+        if option?(:max) && data > option(:max)
+          collector.error "Value must be <= #{option(:max)}."
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/v2/validator/object_validator.rb

@@ -0,0 +1,29 @@
+module Schemacop
+  module V2
+    class ObjectValidator < Node
+      register symbols: :object, klasses: BasicObject
+
+      option :classes
+      option :strict
+
+      def type_label
+        "#{super} (#{classes.join(', ')})"
+      end
+
+      def type_matches?(data)
+        if option(:strict).is_a?(FalseClass)
+          sub_or_class = classes.map { |klass| data.class <= klass }.include?(true)
+          super && (classes.empty? || sub_or_class) && !data.nil?
+        else
+          super && (classes.empty? || classes.include?(data.class)) && !data.nil?
+        end
+      end
+
+      private
+
+      def classes
+        [*option(:classes)]
+      end
+    end
+  end
+end

data/lib/schemacop/v2/validator/string_validator.rb

@@ -0,0 +1,39 @@
+module Schemacop
+  module V2
+    class StringValidator < Node
+      register symbols: :string, klasses: String
+
+      option :min
+      option :max
+
+      def initialize(options = {})
+        super(options)
+
+        validate_options!
+      end
+
+      def validate(data, collector)
+        super
+
+        if option?(:min) && data.size < option(:min)
+          collector.error "String must be longer (>=) than #{option(:min)} characters."
+        end
+        if option?(:max) && data.size > option(:max)
+          collector.error "String must be shorter (<=) than #{option(:max)} characters."
+        end
+      end
+
+      protected
+
+      def validate_options!
+        option_schema = Schema.new :integer, min: 0
+
+        if option?(:min) && option_schema.invalid?(option(:min))
+          fail Exceptions::InvalidSchemaError, 'String option :min must be an integer >= 0.'
+        elsif option?(:max) && option_schema.invalid?(option(:max))
+          fail Exceptions::InvalidSchemaError, 'String option :max must be an integer >= 0.'
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/{validator → v2/validator}/symbol_validator.rb

@@ -1,4 +1,4 @@
-module Schemacop
+module Schemacop::V2
   class SymbolValidator < Node
     register symbols: :symbol, klasses: Symbol
   end

data/lib/schemacop/v3.rb

@@ -0,0 +1,45 @@
+module Schemacop
+  module V3
+    def self.register(*args)
+      NodeRegistry.register(*args)
+    end
+  end
+end
+
+# Require V3 files
+require 'schemacop/v3/node_registry'
+require 'schemacop/v3/dsl_scope'
+require 'schemacop/v3/context'
+require 'schemacop/v3/global_context'
+require 'schemacop/v3/result'
+require 'schemacop/v3/node'
+require 'schemacop/v3/combination_node'
+require 'schemacop/v3/numeric_node'
+require 'schemacop/v3/all_of_node'
+require 'schemacop/v3/any_of_node'
+require 'schemacop/v3/array_node'
+require 'schemacop/v3/boolean_node'
+require 'schemacop/v3/hash_node'
+require 'schemacop/v3/integer_node'
+require 'schemacop/v3/is_not_node'
+require 'schemacop/v3/number_node'
+require 'schemacop/v3/object_node'
+require 'schemacop/v3/one_of_node'
+require 'schemacop/v3/reference_node'
+require 'schemacop/v3/string_node'
+require 'schemacop/v3/symbol_node'
+
+# Register built-in nodes
+Schemacop::V3.register :all_of,    :all_of, Schemacop::V3::AllOfNode
+Schemacop::V3.register :any_of,    :any_of, Schemacop::V3::AnyOfNode
+Schemacop::V3.register :array,     :ary,    Schemacop::V3::ArrayNode
+Schemacop::V3.register :boolean,   :boo,    Schemacop::V3::BooleanNode
+Schemacop::V3.register :integer,   :int,    Schemacop::V3::IntegerNode
+Schemacop::V3.register :is_not,    :is_not, Schemacop::V3::IsNotNode
+Schemacop::V3.register :number,    :num,    Schemacop::V3::NumberNode
+Schemacop::V3.register :hash,      :hsh,    Schemacop::V3::HashNode
+Schemacop::V3.register :one_of,    :one_of, Schemacop::V3::OneOfNode
+Schemacop::V3.register :reference, :ref,    Schemacop::V3::ReferenceNode
+Schemacop::V3.register :object,    :obj,    Schemacop::V3::ObjectNode
+Schemacop::V3.register :string,    :str,    Schemacop::V3::StringNode
+Schemacop::V3.register :symbol,    :sym,    Schemacop::V3::SymbolNode

data/lib/schemacop/v3/all_of_node.rb

@@ -0,0 +1,27 @@
+module Schemacop
+  module V3
+    class AllOfNode < CombinationNode
+      def type
+        :allOf
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        if matches(super_data).size != @items.size
+          result.error 'Does not match all allOf conditions.'
+        end
+      end
+
+      def cast(value)
+        items = matches(value)
+        return value unless items
+
+        casted_value = value.dup
+        items.each { |i| casted_value = i.cast(casted_value) }
+        return casted_value
+      end
+    end
+  end
+end

data/lib/schemacop/v3/any_of_node.rb

@@ -0,0 +1,28 @@
+module Schemacop
+  module V3
+    class AnyOfNode < CombinationNode
+      def type
+        :anyOf
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        match = match(super_data)
+
+        if match
+          match._validate(super_data, result: result)
+        else
+          result.error 'Does not match any anyOf condition.'
+        end
+      end
+
+      def validate_self
+        if @items.empty?
+          fail 'Node "any_of" makes only sense with at least 1 item.'
+        end
+      end
+    end
+  end
+end