schemacop 2.4.7 → 3.0.0.rc0

data/lib/schemacop/v3/node_registry.rb

@@ -0,0 +1,49 @@
+module Schemacop
+  module V3
+    class NodeRegistry
+      @by_name = {}
+      @by_short_name = {}
+      @by_class = {}
+
+      def self.register(name, short_name, klass)
+        @by_name[name.to_sym] = klass
+        @by_short_name[short_name.to_sym] = klass
+        @by_class[klass] = { name: name.to_sym, short_name: short_name.to_sym }
+      end
+
+      def self.dsl_methods(bang)
+        return @by_short_name.keys.map do |short_name|
+          if bang
+            ["dsl_#{short_name}!", "dsl_#{short_name}?"]
+          else
+            ["dsl_#{short_name}"]
+          end
+        end.flatten.map(&:to_sym)
+      end
+
+      def self.find(name_or_klass)
+        if name_or_klass.is_a?(Class)
+          return name_or_klass
+        else
+          return by_name(name_or_klass)
+        end
+      end
+
+      def self.by_name(name)
+        @by_name[name.to_sym]
+      end
+
+      def self.by_short_name(short_name)
+        @by_short_name[short_name.to_sym]
+      end
+
+      def self.name(klass)
+        @by_class[klass][:name]
+      end
+
+      def self.short_name(klass)
+        @by_class[klass][:short_name]
+      end
+    end
+  end
+end

data/lib/schemacop/v3/number_node.rb

@@ -0,0 +1,18 @@
+module Schemacop
+  module V3
+    class NumberNode < NumericNode
+      def as_json
+        process_json(ATTRIBUTES, type: :number)
+      end
+
+      def allowed_types
+        {
+          Integer    => :integer,
+          Float      => :float,
+          Rational   => :rational,
+          BigDecimal => :big_decimal
+        }
+      end
+    end
+  end
+end

data/lib/schemacop/v3/numeric_node.rb

@@ -0,0 +1,76 @@
+module Schemacop
+  module V3
+    # @abstract
+    class NumericNode < Node
+      ATTRIBUTES = %i[
+        minimum
+        exclusive_minimum
+        maximum
+        exclusive_maximum
+        multiple_of
+      ].freeze
+
+      def self.allowed_options
+        super + ATTRIBUTES
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        # Validate minimum #
+        if options[:minimum] && super_data < options[:minimum]
+          result.error "Value must have a minimum of #{options[:minimum]}."
+        end
+
+        if options[:exclusive_minimum] && super_data <= options[:exclusive_minimum]
+          result.error "Value must have an exclusive minimum of #{options[:exclusive_minimum]}."
+        end
+
+        # Validate maximum #
+        if options[:maximum] && super_data > options[:maximum]
+          result.error "Value must have a maximum of #{options[:maximum]}."
+        end
+
+        if options[:exclusive_maximum] && super_data >= options[:exclusive_maximum]
+          result.error "Value must have an exclusive maximum of #{options[:exclusive_maximum]}."
+        end
+
+        # Validate multiple of #
+        if options[:multiple_of] && !compare_float((super_data % options[:multiple_of]), 0.0)
+          result.error "Value must be a multiple of #{options[:multiple_of]}."
+        end
+      end
+
+      def validate_self
+        # Check that the options have the correct type
+        ATTRIBUTES.each do |attribute|
+          next if options[attribute].nil?
+          next unless allowed_types.keys.none? { |c| options[attribute].send(type_assertion_method, c) }
+
+          collection = allowed_types.values.map { |t| "\"#{t}\"" }.uniq.sort.join(' or ')
+          fail "Option \"#{attribute}\" must be a #{collection}"
+        end
+
+        if options[:minimum] && options[:maximum] && options[:minimum] > options[:maximum]
+          fail 'Option "minimum" can\'t be greater than "maximum".'
+        end
+
+        if options[:exclusive_minimum] && options[:exclusive_maximum]\
+           && options[:exclusive_minimum] > options[:exclusive_maximum]
+          fail 'Option "exclusive_minimum" can\'t be greater than "exclusive_maximum".'
+        end
+
+        if options[:multiple_of]&.zero?
+          fail 'Option "multiple_of" can\'t be 0.'
+        end
+      end
+
+      private
+
+      def compare_float(first, second)
+        (first - second).abs < Float::EPSILON
+      end
+    end
+  end
+end

data/lib/schemacop/v3/object_node.rb

@@ -0,0 +1,40 @@
+module Schemacop
+  module V3
+    class ObjectNode < Node
+      def self.allowed_options
+        super + %i[classes strict]
+      end
+
+      def self.create(classes, **options, &block)
+        options[:classes] = classes
+        super(**options, &block)
+      end
+
+      def as_json
+        {} # Not supported by Json Schema
+      end
+
+      protected
+
+      def allowed_types
+        Hash[@classes.map { |c| [c, c.name] }]
+      end
+
+      def init
+        @classes = Array(options.delete(:classes) || [])
+        @strict = options.delete(:strict)
+        @strict = true if @strict.nil?
+      end
+
+      def type_assertion_method
+        @strict ? :instance_of? : :is_a?
+      end
+
+      def validate_self
+        unless @strict.is_a?(TrueClass) || @strict.is_a?(FalseClass)
+          fail 'Option "strict" must be a "boolean".'
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/v3/one_of_node.rb

@@ -0,0 +1,28 @@
+module Schemacop
+  module V3
+    class OneOfNode < CombinationNode
+      def type
+        :oneOf
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        matches = matches(super_data)
+
+        if matches.size == 1
+          matches.first._validate(super_data, result: result)
+        else
+          result.error "Matches #{matches.size} definitions but should match exactly 1."
+        end
+      end
+
+      def validate_self
+        if @items.size < 2
+          fail 'Node "one_of" makes only sense with at least 2 items.'
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/v3/reference_node.rb

@@ -0,0 +1,49 @@
+module Schemacop
+  module V3
+    class ReferenceNode < Node
+      def self.allowed_options
+        super + %i[path]
+      end
+
+      def self.create(path, **options, &block)
+        options[:path] = path
+        super(**options, &block)
+      end
+
+      def as_json
+        process_json([], '$ref': "#/definitions/#{@path}")
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        # Lookup schema #
+        node = target
+        fail "Schema #{@path.to_s.inspect} not found." unless node
+
+        # Validate schema #
+        node._validate(super_data, result: result)
+      end
+
+      def target
+        schemas[@path] || Schemacop.context.schemas[@path] || GlobalContext.schema_for(@path)
+      end
+
+      def cast(data)
+        data = default if data.nil?
+        return target.cast(data)
+      end
+
+      def used_external_schemas
+        schemas.include?(@path) ? [] : [@path]
+      end
+
+      protected
+
+      def init
+        @path = options.delete(:path)
+      end
+    end
+  end
+end

data/lib/schemacop/v3/result.rb

@@ -0,0 +1,58 @@
+module Schemacop
+  class Result
+    attr_reader :current_path
+    attr_reader :errors
+
+    def initialize(root = nil, original_data = nil)
+      @current_path = []
+      @errors = {}
+      @root = root
+      @original_data = original_data
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def data
+      if errors.any?
+        return nil
+      else
+        return @data ||= @root.cast(@original_data)
+      end
+    end
+
+    def error(message)
+      @errors[current_path] ||= []
+      @errors[current_path] << message
+    end
+
+    def messages_by_path
+      @errors.transform_keys { |k| "/#{k.join('/')}" }
+    end
+
+    def exception_message
+      messages.join("\n")
+    end
+
+    def messages
+      messages = []
+
+      @errors.each do |path, path_messages|
+        messages += path_messages.map do |path_message|
+          "/#{path.join('/')}: #{path_message}"
+        end
+      end
+
+      return messages
+    end
+
+    def in_path(segment)
+      prev_path = @current_path
+      @current_path += [segment]
+      yield
+    ensure
+      @current_path = prev_path
+    end
+  end
+end

data/lib/schemacop/v3/string_node.rb

@@ -0,0 +1,124 @@
+module Schemacop
+  module V3
+    class StringNode < Node
+      ATTRIBUTES = %i[
+        min_length
+        max_length
+        pattern
+        format
+      ].freeze
+
+      # rubocop:disable Layout/LineLength
+      FORMAT_PATTERNS = {
+        date:        /^([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])$/,
+        'date-time': /^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
+        time:        /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(\.[0-9]+)?(Z|[+-](?:2[0-3]|[01][0-9]):[0-5][0-9])?$/,
+        email:       URI::MailTo::EMAIL_REGEXP,
+        boolean:     /^(true|false)$/,
+        binary:      nil,
+        integer:     /^-?[0-9]+$/,
+        number:      /^-?[0-9]+(\.[0-9]+)?$/
+      }.freeze
+      # rubocop:enable Layout/LineLength
+
+      def self.allowed_options
+        super + ATTRIBUTES - %i[cast_str] + %i[format_options]
+      end
+
+      def allowed_types
+        { String => :string }
+      end
+
+      def as_json
+        process_json(ATTRIBUTES, type: :string)
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        # Validate length #
+        length = super_data.size
+
+        if options[:min_length] && length < options[:min_length]
+          result.error "String is #{length} characters long but must be at least #{options[:min_length]}."
+        end
+
+        if options[:max_length] && length > options[:max_length]
+          result.error "String is #{length} characters long but must be at most #{options[:max_length]}."
+        end
+
+        # Validate pattern #
+        if options[:pattern] && !super_data.match?(Regexp.compile(options[:pattern]))
+          result.error "String does not match pattern #{options[:pattern].inspect}."
+        end
+
+        # Validate format #
+        if options[:format] && FORMAT_PATTERNS.include?(options[:format])
+          pattern = FORMAT_PATTERNS[options[:format]]
+          if pattern && !super_data.match?(pattern)
+            result.error "String does not match format #{options[:format].to_s.inspect}."
+          elsif options[:format_options] && Node.resolve_class(options[:format])
+            node = create(options[:format], **options[:format_options])
+            node._validate(cast(super_data), result: result)
+          end
+        end
+      end
+
+      def cast(value)
+        case options[:format]
+        when :boolean
+          return value == 'true'
+        when :date
+          return Date.parse(value)
+        when :'date-time'
+          return DateTime.parse(value)
+        when :time
+          Time.parse(value)
+        when :integer
+          return Integer(value)
+        when :number
+          return Float(value)
+        else
+          return value || default
+        end
+      end
+
+      protected
+
+      def init
+        if options.include?(:format)
+          options[:format] = options[:format].to_s.dasherize.to_sym
+        end
+      end
+
+      def validate_self
+        if options.include?(:format) && !FORMAT_PATTERNS.include?(options[:format])
+          fail "Format #{options[:format].to_s.inspect} is not supported."
+        end
+
+        unless options[:min_length].nil? || options[:min_length].is_a?(Integer)
+          fail 'Option "min_length" must be an "integer"'
+        end
+
+        unless options[:max_length].nil? || options[:max_length].is_a?(Integer)
+          fail 'Option "max_length" must be an "integer"'
+        end
+
+        if options[:min_length] && options[:max_length] && options[:min_length] > options[:max_length]
+          fail 'Option "min_length" can\'t be greater than "max_length".'
+        end
+
+        if options[:pattern]
+          fail 'Option "pattern" must be a string.' unless options[:pattern].is_a?(String)
+
+          begin
+            Regexp.compile(options[:pattern])
+          rescue RegexpError => e
+            fail "Option \"pattern\" can't be parsed: #{e.message}."
+          end
+        end
+      end
+    end
+  end
+end