schemacop 2.4.5 → 3.0.0.rc2

data/lib/schemacop/v3/node.rb

@@ -0,0 +1,215 @@
+module Schemacop
+  module V3
+    class Node
+      attr_reader :name
+      attr_reader :default
+      attr_reader :title
+      attr_reader :description
+      attr_reader :options
+      attr_reader :parent
+
+      class_attribute :_supports_children
+      self._supports_children = nil
+
+      def self.supports_children(name: false)
+        self._supports_children = { name: name }
+      end
+
+      def self.supports_children_options
+        _supports_children
+      end
+
+      def self.resolve_class(type)
+        NodeRegistry.find(type)
+      end
+
+      def self.create(type = self, **options, &block)
+        klass = resolve_class(type)
+        fail "Could not find node for type #{type.inspect}." unless klass
+
+        node = klass.new(**options, &block)
+
+        if options.delete(:cast_str)
+          format = NodeRegistry.name(klass)
+          one_of_options = {
+            required: options.delete(:required),
+            name:     options.delete(:name)
+          }
+          node = create(:one_of, **one_of_options) do
+            self.node node
+            str format: format, format_options: options
+          end
+        end
+
+        return node
+      end
+
+      def self.allowed_options
+        %i[name required default description examples enum parent options cast_str title]
+      end
+
+      def self.dsl_methods
+        %i[dsl_scm dsl_node]
+      end
+
+      def allowed_types
+        {}
+      end
+
+      def used_external_schemas
+        children.map(&:used_external_schemas).flatten.uniq
+      end
+
+      def children
+        []
+      end
+
+      def initialize(**options, &block)
+        # Check options #
+        disallowed_options = options.keys - self.class.allowed_options
+
+        if disallowed_options.any?
+          fail "Options #{disallowed_options.inspect} are not allowed for this node."
+        end
+
+        # Assign attributes #
+        @name = options.delete(:name)
+        @name = @name.to_s unless @name.nil? || @name.is_a?(Regexp)
+        @required = !!options.delete(:required)
+        @default = options.delete(:default)
+        @title = options.delete(:title)
+        @description = options.delete(:description)
+        @examples = options.delete(:examples)
+        @enum = options.delete(:enum)&.to_set
+        @parent = options.delete(:parent)
+        @options = options
+        @schemas = {}
+
+        # Run subclass init #
+        init
+
+        # Run DSL block #
+        if block_given?
+          unless self.class.supports_children_options
+            fail "Node #{self.class} does not support blocks."
+          end
+
+          scope = DslScope.new(self)
+          env = ScopedEnv.new(self, self.class.dsl_methods, scope, :dsl_)
+          env.instance_exec(&block)
+        end
+
+        # Validate self #
+        begin
+          validate_self
+        rescue StandardError => e
+          fail Exceptions::InvalidSchemaError, e.message
+        end
+      end
+
+      def create(type, **options, &block)
+        options[:parent] = self
+        return Node.create(type, **options, &block)
+      end
+
+      def init; end
+
+      def dsl_scm(name, type = :hash, **options, &block)
+        @schemas[name] = create(type, **options, &block)
+      end
+
+      def dsl_node(node, *_args, **_kwargs)
+        add_child node
+      end
+
+      def schemas
+        (parent&.schemas || {}).merge(@schemas)
+      end
+
+      def required?
+        @required
+      end
+
+      def as_json
+        process_json([], {})
+      end
+
+      def cast(value)
+        value || default
+      end
+
+      def validate(data)
+        result = Result.new(self, data)
+        _validate(data, result: result)
+        return result
+      end
+
+      protected
+
+      def item_matches?(item, data)
+        item_result = Result.new(self)
+        item._validate(data, result: item_result)
+        return item_result.errors.none?
+      end
+
+      def process_json(attrs, json)
+        if @schemas.any?
+          json[:definitions] = {}
+          @schemas.each do |name, subschema|
+            json[:definitions][name] = subschema.as_json
+          end
+        end
+        attrs.each do |attr|
+          if options.include?(attr)
+            json[attr.to_s.camelize(:lower).to_sym] = options[attr]
+          end
+        end
+
+        json[:title] = @title if @title
+        json[:examples] = @examples if @examples
+        json[:description] = @description if @description
+        json[:default] = @default if @default
+        json[:enum] = @enum.to_a if @enum
+
+        return json.as_json
+      end
+
+      def type_assertion_method
+        :is_a?
+      end
+
+      def _validate(data, result:)
+        # Validate nil #
+        if data.nil? && required?
+          result.error 'Value must be given.'
+          return nil
+        end
+
+        # Apply default #
+        if data.nil?
+          if default
+            data = default
+          else
+            return nil
+          end
+        end
+
+        # Validate type #
+        if allowed_types.any? && allowed_types.keys.none? { |c| data.send(type_assertion_method, c) }
+          collection = allowed_types.values.map { |t| "\"#{t}\"" }.uniq.sort.join(' or ')
+          result.error %(Invalid type, expected #{collection}.)
+          return nil
+        end
+
+        # Validate enums #
+        if @enum && !@enum.include?(data)
+          result.error "Value not included in enum #{@enum.to_a.inspect}."
+        end
+
+        return data
+      end
+
+      def validate_self; end
+    end
+  end
+end

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