schemacop 2.4.7 → 3.0.0.rc4

data/lib/schemacop/v2/node.rb

@@ -0,0 +1,142 @@
+module Schemacop
+  module V2
+    class Node
+      attr_reader :options
+
+      class_attribute :allowed_options
+      self.allowed_options = {}.freeze
+
+      class_attribute :symbols
+      self.symbols = [].freeze
+
+      class_attribute :klasses
+      self.klasses = [].freeze
+
+      def self.option(key, default: nil)
+        self.allowed_options = allowed_options.merge(key => default)
+      end
+
+      option :if
+      option :check
+      option :cast
+      option :default
+
+      def type_label
+        str = (symbols.first || 'unknown').to_s
+        str += '*' if option?(:if)
+        return str
+      end
+
+      def self.symbol(symbol)
+        self.symbols += [symbol]
+      end
+
+      def self.clear_symbols
+        self.symbols = [].freeze
+      end
+
+      def self.klass(klass)
+        self.klasses += [klass]
+      end
+
+      def self.clear_klasses
+        self.klasses = [].freeze
+      end
+
+      def self.register(symbols: [], klasses: [], clear: true, before: nil)
+        NodeResolver.register(self, before: before)
+        symbols = [*symbols]
+        klasses = [*klasses]
+        if clear
+          clear_symbols
+          clear_klasses
+        end
+        symbols.each { |s| symbol s }
+        klasses.each { |k| klass k }
+      end
+
+      def self.type_matches?(type)
+        symbol_matches?(type) || class_matches?(type)
+      end
+
+      def self.symbol_matches?(type)
+        return false unless type.is_a?(Symbol)
+
+        symbols.include?(type)
+      end
+
+      def self.class_matches?(type)
+        return false unless type.is_a?(Class)
+
+        klasses.each do |klass|
+          return true if type <= klass
+        end
+        return false
+      end
+
+      def self.build(options, &block)
+        new(options, &block)
+      end
+
+      def initialize(options = {})
+        # Check and save given options
+        @options = self.class.allowed_options.merge(options)
+        if (obsolete_opts = @options.keys - self.class.allowed_options.keys).any?
+          fail Exceptions::InvalidSchemaError,
+               "Unrecognized option(s) #{obsolete_opts.inspect} for #{self.class.inspect}, allowed options: #{self.class.allowed_options.keys.inspect}."
+        end
+
+        if option?(:cast) && self.class.klasses.size > 1
+          fail Exceptions::InvalidSchemaError,
+               "Casting is only allowed for single-value datatypes, but type #{self.class.inspect} has classes "\
+               "#{self.class.klasses.map(&:inspect)}."
+        end
+      end
+
+      def option(key)
+        options[key]
+      end
+
+      def option?(key)
+        !!options[key]
+      end
+
+      def exec_block
+        fail Exceptions::InvalidSchemaError, 'Node does not support block.' if block_given?
+      end
+
+      def resolve_type_klass(type)
+        klass = NodeResolver.resolve(type)
+        unless klass
+          fail Exceptions::InvalidSchemaError, "No validation class found for type #{type.inspect}."
+        end
+
+        return klass
+      end
+
+      def validate(data, collector)
+        validate_custom_check(data, collector)
+      end
+
+      def type_matches?(data)
+        self.class.type_matches?(data.class) && type_filter_matches?(data)
+      end
+
+      def type_filter_matches?(data)
+        !option?(:if) || option(:if).call(data)
+      end
+
+      protected
+
+      def validate_custom_check(data, collector)
+        if option?(:check) && (check_result = option(:check).call(data)) != true
+          if check_result.is_a?(String)
+            collector.error "Custom :check failed: #{check_result}."
+          else
+            collector.error 'Custom :check failed.'
+          end
+        end
+      end
+    end
+  end
+end

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