schemacop 2.4.7 → 3.0.0.rc0

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/{node_supporting_field.rb → v2/node_supporting_field.rb}

@@ -1,4 +1,4 @@
-module Schemacop
+module Schemacop::V2
   class NodeSupportingField < NodeWithBlock
     block_method :req?
     block_method :req!
@@ -23,7 +23,7 @@ module Schemacop
       field(*args, required: true, allow_nil: false, &block)
     end
 
-    alias_method :req, :req!
+    alias req req!
 
     def opt?(*args, &block)
       field(*args, required: false, allow_nil: true, &block)
@@ -33,7 +33,7 @@ module Schemacop
       field(*args, required: false, allow_nil: false, &block)
     end
 
-    alias_method :opt, :opt?
+    alias opt opt?
 
     protected
 
@@ -42,14 +42,12 @@ module Schemacop
 
       if @fields[name]
         @fields[name].type(*args, &block)
-      else
-        if args.any?
-          @fields[name] = FieldNode.new(name, required) do
-            type(*args, &block)
-          end
-        else
-          @fields[name] = FieldNode.new(name, required, &block)
+      elsif args.any?
+        @fields[name] = FieldNode.new(name, required) do
+          type(*args, &block)
         end
+      else
+        @fields[name] = FieldNode.new(name, required, &block)
       end
 
       @fields[name].type(:nil) if allow_nil

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
 
@@ -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
 
@@ -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/root_node.rb

@@ -0,0 +1,6 @@
+module Schemacop
+  module V2
+    class RootNode < NodeSupportingType
+    end
+  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