schemacop 2.4.7 → 3.0.0.rc0

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

data/lib/schemacop/v3/array_node.rb

@@ -0,0 +1,219 @@
+module Schemacop
+  module V3
+    class ArrayNode < Node
+      ATTRIBUTES = %i[
+        min_items
+        max_items
+        unique_items
+      ].freeze
+
+      supports_children
+
+      def self.allowed_options
+        super + ATTRIBUTES + %i[additional_items]
+      end
+
+      def self.dsl_methods
+        super + NodeRegistry.dsl_methods(false) + %i[dsl_add dsl_list dsl_cont]
+      end
+
+      attr_reader :items
+      attr_accessor :list_item
+      attr_accessor :cont_item
+
+      def dsl_add(type, **options, &block)
+        if @options[:additional_items].is_a?(Node)
+          fail Exceptions::InvalidSchemaError, 'You can only use "add" once to specify additional items.'
+        end
+
+        @options[:additional_items] = create(type, **options, &block)
+      end
+
+      def dsl_list(type, **options, &block)
+        if list_item.is_a?(Node)
+          fail Exceptions::InvalidSchemaError, 'You can only use "list" once.'
+        end
+
+        @list_item = create(type, **options, &block)
+      end
+
+      def dsl_cont(type, **options, &block)
+        if cont_item.is_a?(Node)
+          fail Exceptions::InvalidSchemaError, 'You can only use "cont" once.'
+        end
+
+        @cont_item = create(type, **options, &block)
+      end
+
+      def add_child(node)
+        @items << node
+      end
+
+      def as_json
+        json = { type: :array }
+
+        if cont_item
+          json[:contains] = cont_item.as_json
+        end
+
+        if list?
+          json[:items] = @list_item.as_json
+        elsif @items.any?
+          json[:items] = @items.map(&:as_json)
+          if options[:additional_items] == true
+            json[:additionalItems] = true
+          elsif options[:additional_items].is_a?(Node)
+            json[:additionalItems] = options[:additional_items].as_json
+          else
+            json[:additionalItems] = false
+          end
+        end
+
+        return process_json(ATTRIBUTES, json)
+      end
+
+      def allowed_types
+        { Array => :array }
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        # Validate length #
+        length = super_data.size
+
+        if options[:min_items] && length < options[:min_items]
+          result.error "Array has #{length} items but needs at least #{options[:min_items]}."
+        end
+
+        if options[:max_items] && length > options[:max_items]
+          result.error "Array has #{length} items but needs at most #{options[:max_items]}."
+        end
+
+        if list?
+          # Validate list
+          super_data.each_with_index do |value, index|
+            result.in_path :"[#{index}]" do
+              list_item._validate(value, result: result)
+            end
+          end
+        elsif items.any?
+          # Validate tuple
+          if length == items.size || (options[:additional_items] != false && length >= items.size)
+            items.each_with_index do |child_node, index|
+              value = super_data[index]
+
+              result.in_path :"[#{index}]" do
+                child_node._validate(value, result: result)
+              end
+            end
+
+            # Validate additional items #
+            if options[:additional_items].is_a?(Node)
+              (items.size..(length - 1)).each do |index|
+                additional_item = super_data[index]
+                result.in_path :"[#{index}]" do
+                  options[:additional_items]._validate(additional_item, result: result)
+                end
+              end
+            end
+          else
+            result.error "Array has #{length} items but must have exactly #{items.size}."
+          end
+        end
+
+        if cont_item.present? && super_data.none? { |obj| item_matches?(cont_item, obj) }
+          result.error "At least one entry must match schema #{cont_item.as_json.inspect}."
+        end
+
+        # Validate uniqueness #
+        if options[:unique_items] && super_data.size != super_data.uniq.size
+          result.error 'Array has duplicate items.'
+        end
+      end
+
+      def children
+        (@items + [@cont_item]).compact
+      end
+
+      def cast(value)
+        return default unless value
+
+        result = []
+
+        value.each_with_index do |value_item, index|
+          if cont_item.present? && item_matches?(cont_item, value_item)
+            result << cont_item.cast(value_item)
+          elsif list?
+            result << list_item.cast(value_item)
+          elsif items.any?
+            if options[:additional_items] != false && index >= items.size
+              if options[:additional_items].is_a?(Node)
+                result << options[:additional_items].cast(value_item)
+              else
+                result << value_item
+              end
+            else
+              item = item_for_data(value_item)
+              result << item.cast(value_item)
+            end
+          else
+            result << value_item
+          end
+        end
+
+        return result
+      end
+
+      protected
+
+      def list?
+        list_item.present?
+      end
+
+      def item_for_data(data, force: true)
+        item = children.find { |c| item_matches?(c, data) }
+        return item if item
+        return nil unless force
+
+        fail "Could not find specification for item #{data.inspect}."
+      end
+
+      def init
+        @items = []
+        @cont_item = nil
+
+        if options[:additional_items].nil?
+          options[:additional_items] = false
+        end
+      end
+
+      def validate_self
+        if list? && items.any?
+          fail 'Can\'t use "list" and normal items.'
+        end
+
+        if list? && @options[:additional_items].is_a?(Node)
+          fail 'Can\'t use "list" and additional items.'
+        end
+
+        unless options[:min_items].nil? || options[:min_items].is_a?(Integer)
+          fail 'Option "min_items" must be an "integer"'
+        end
+
+        unless options[:max_items].nil? || options[:max_items].is_a?(Integer)
+          fail 'Option "max_items" must be an "integer"'
+        end
+
+        unless options[:unique_items].nil? || options[:unique_items].is_a?(TrueClass) || options[:unique_items].is_a?(FalseClass)
+          fail 'Option "unique_items" must be a "boolean".'
+        end
+
+        if options[:min_items] && options[:max_items] && options[:min_items] > options[:max_items]
+          fail 'Option "min_items" can\'t be greater than "max_items".'
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/v3/boolean_node.rb

@@ -0,0 +1,16 @@
+module Schemacop
+  module V3
+    class BooleanNode < Node
+      def as_json
+        process_json([], type: :boolean)
+      end
+
+      def allowed_types
+        {
+          TrueClass  => :boolean,
+          FalseClass => :boolean
+        }
+      end
+    end
+  end
+end

data/lib/schemacop/v3/combination_node.rb

@@ -0,0 +1,45 @@
+module Schemacop
+  module V3
+    # @abstract
+    class CombinationNode < Node
+      def self.dsl_methods
+        super + NodeRegistry.dsl_methods(false)
+      end
+
+      supports_children
+
+      def init
+        @items = []
+      end
+
+      def as_json
+        process_json([], type => @items.map(&:as_json))
+      end
+
+      def cast(value)
+        item = match(value)
+        return value unless item
+
+        return item.cast(value)
+      end
+
+      def add_child(node)
+        @items << node
+      end
+
+      protected
+
+      def type
+        fail NotImplementedError
+      end
+
+      def match(data)
+        matches(data).first
+      end
+
+      def matches(data)
+        @items.filter { |i| item_matches?(i, data) }
+      end
+    end
+  end
+end

data/lib/schemacop/v3/context.rb

@@ -0,0 +1,17 @@
+module Schemacop
+  module V3
+    class Context
+      attr_accessor :schemas
+
+      def initialize
+        @schemas = {}.with_indifferent_access.freeze
+      end
+
+      def schema(name, type = :hash, **options, &block)
+        @schemas = @schemas.merge(
+          name => Node.create(type, **options, &block)
+        ).freeze
+      end
+    end
+  end
+end

data/lib/schemacop/v3/dsl_scope.rb

@@ -0,0 +1,46 @@
+module Schemacop
+  module V3
+    class DslScope
+      EXP_NAME = /^dsl_([a-z_]+)([?!])?$/.freeze
+
+      def initialize(node)
+        @node = node
+        @with_name = @node.class.supports_children_options[:name]
+      end
+
+      def method_missing(name, *args, **options, &block)
+        match = EXP_NAME.match(name)
+        return super unless match
+
+        base_name, req_optional = match.captures
+
+        if req_optional == '!'
+          options[:required] = true
+        elsif req_optional == '?'
+          options[:required] = false
+        end
+
+        options[:parent] = @node
+
+        if (klass = NodeRegistry.by_short_name(base_name))
+          if @with_name
+            options[:name] = args.shift
+          end
+          node = klass.create(*args, **options, &block)
+          @node.add_child node
+          return node
+        else
+          return super
+        end
+      end
+
+      def respond_to_missing?(name, *args)
+        match = EXP_NAME.match(name)
+        return super unless match
+
+        base_name, _req_optional = match.captures
+        return NodeRegistry.by_short_name(base_name).present? || super
+      end
+    end
+  end
+end