schemacop 2.4.6 → 3.0.0.rc3

data/lib/schemacop/v3/hash_node.rb

@@ -0,0 +1,258 @@
+module Schemacop
+  module V3
+    class HashNode < Node
+      ATTRIBUTES = %i[
+        type
+        min_properties
+        max_properties
+        dependencies
+        property_names
+      ].freeze
+
+      supports_children(name: true)
+
+      attr_reader :properties
+
+      def self.allowed_options
+        super + ATTRIBUTES - %i[dependencies] + %i[additional_properties]
+      end
+
+      def self.dsl_methods
+        super + NodeRegistry.dsl_methods(true) + %i[dsl_dep dsl_add]
+      end
+
+      def self.sanitize_exp(exp)
+        exp = exp.to_s
+        if exp.start_with?('(?-mix:')
+          exp = exp.to_s.gsub(/^\(\?-mix:/, '').gsub(/\)$/, '')
+        end
+        return exp
+      end
+
+      def add_child(node)
+        unless node.name
+          fail Exceptions::InvalidSchemaError, 'Child nodes must have a name.'
+        end
+
+        @properties[node.name] = node
+      end
+
+      def dsl_add(type, **options, &block)
+        if @options[:additional_properties].is_a?(Node)
+          fail Exceptions::InvalidSchemaError, 'You can only use "add" once to specify additional properties.'
+        end
+
+        @options[:additional_properties] = create(type, **options, &block)
+      end
+
+      def dsl_dep(source, *targets, **_kwargs)
+        @options[:dependencies] ||= {}
+        @options[:dependencies][source] = targets
+      end
+
+      def as_json
+        properties = {}
+        pattern_properties = {}
+
+        @properties.each do |name, property|
+          if name.is_a?(Regexp)
+            pattern_properties[name] = property
+          else
+            properties[name] = property
+          end
+        end
+
+        json = {}
+        json[:properties] = Hash[properties.values.map { |p| [p.name, p.as_json] }] if properties.any?
+        json[:patternProperties] = Hash[pattern_properties.values.map { |p| [self.class.sanitize_exp(p.name), p.as_json] }] if pattern_properties.any?
+
+        # In schemacop, by default, additional properties are not allowed,
+        # the users explicitly need to enable additional properties
+        if options[:additional_properties] == true
+          json[:additionalProperties] = true
+        elsif options[:additional_properties].is_a?(Node)
+          json[:additionalProperties] = options[:additional_properties].as_json
+        else
+          json[:additionalProperties] = false
+        end
+
+        required_properties = @properties.values.select(&:required?).map(&:name)
+
+        if required_properties.any?
+          json[:required] = required_properties
+        end
+
+        return process_json(ATTRIBUTES, json)
+      end
+
+      def allowed_types
+        { Hash => :object }
+      end
+
+      def _validate(data, result: Result.new)
+        super_data = super
+        return if super_data.nil?
+
+        original_data_hash = super_data.dup
+        data_hash = super_data.with_indifferent_access
+
+        if original_data_hash.size != data_hash.size
+          ambiguous_properties = original_data_hash.keys - data_hash.keys
+
+          result.error "Has #{ambiguous_properties.size} ambiguous properties: #{ambiguous_properties}."
+        end
+
+        # Validate min_properties #
+        if options[:min_properties] && data_hash.size < options[:min_properties]
+          result.error "Has #{data_hash.size} properties but needs at least #{options[:min_properties]}."
+        end
+
+        # Validate max_properties #
+        if options[:max_properties] && data_hash.size > options[:max_properties]
+          result.error "Has #{data_hash.size} properties but needs at most #{options[:max_properties]}."
+        end
+
+        # Validate specified properties #
+        @properties.each_value do |node|
+          result.in_path(node.name) do
+            next if node.name.is_a?(Regexp)
+
+            node._validate(data_hash[node.name], result: result)
+          end
+        end
+
+        # Validate additional properties #
+        specified_properties = @properties.keys.to_set
+        additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s) }
+
+        property_patterns = {}
+
+        @properties.each_value do |property|
+          if property.name.is_a?(Regexp)
+            property_patterns[property.name] = property
+          end
+        end
+
+        property_names = options[:property_names]
+        property_names = Regexp.compile(property_names) if property_names
+
+        additional_properties.each do |name, additional_property|
+          if property_names && !property_names.match?(name)
+            result.error "Property name #{name.inspect} does not match #{options[:property_names].inspect}."
+          end
+
+          if options[:additional_properties].blank?
+            match = property_patterns.keys.find { |p| p.match?(name.to_s) }
+            if match
+              result.in_path(name) do
+                property_patterns[match]._validate(additional_property, result: result)
+              end
+            else
+              result.error "Obsolete property #{name.to_s.inspect}."
+            end
+          elsif options[:additional_properties].is_a?(Node)
+            result.in_path(name) do
+              options[:additional_properties]._validate(additional_property, result: result)
+            end
+          end
+        end
+
+        # Validate dependencies #
+        options[:dependencies]&.each do |source, targets|
+          targets.each do |target|
+            if data_hash[source].present? && data_hash[target].blank?
+              result.error "Missing property #{target.to_s.inspect} because #{source.to_s.inspect} is given."
+            end
+          end
+        end
+      end
+
+      def children
+        @properties.values
+      end
+
+      def cast(data)
+        result = {}.with_indifferent_access
+        data ||= default
+        return nil if data.nil?
+
+        original_data_hash = data.dup
+        data_hash = data.with_indifferent_access
+
+        if original_data_hash.size != data_hash.size
+          ambiguous_properties = original_data_hash.keys - data_hash.keys
+
+          result.error "Has #{ambiguous_properties.size} ambiguous properties: #{ambiguous_properties}."
+        end
+
+        property_patterns = {}
+
+        @properties.each_value do |prop|
+          if prop.name.is_a?(Regexp)
+            property_patterns[prop.name] = prop
+            next
+          end
+
+          result[prop.as || prop.name] = prop.cast(data_hash[prop.name])
+
+          if result[prop.as || prop.name].nil? && !data_hash.include?(prop.name)
+            result.delete(prop.as || prop.name)
+          end
+        end
+
+        # Handle regex properties
+        specified_properties = @properties.keys.to_set
+        additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s.to_sym) }
+
+        if additional_properties.any? && property_patterns.any?
+          additional_properties.each do |name, additional_property|
+            match_key = property_patterns.keys.find { |p| p.match?(name.to_s) }
+            match = property_patterns[match_key]
+            result[name] = match.cast(additional_property)
+          end
+        end
+
+        # Handle additional properties
+        if options[:additional_properties] == true
+          result = data_hash.merge(result)
+        elsif options[:additional_properties].is_a?(Node)
+          specified_properties = @properties.keys.to_set
+          additional_properties = data_hash.reject { |k, _v| specified_properties.include?(k.to_s.to_sym) }
+          if additional_properties.any?
+            additional_properties_result = {}
+            additional_properties.each do |key, value|
+              additional_properties_result[key] = options[:additional_properties].cast(value)
+            end
+            result = additional_properties_result.merge(result)
+          end
+        end
+
+        return result
+      end
+
+      protected
+
+      def init
+        @properties = {}
+        @options[:type] = :object
+        unless @options[:additional_properties].nil? || @options[:additional_properties].is_a?(TrueClass) || @options[:additional_properties].is_a?(FalseClass)
+          fail Schemacop::Exceptions::InvalidSchemaError, 'Option "additional_properties" must be a boolean value'
+        end
+      end
+
+      def validate_self
+        unless options[:min_properties].nil? || options[:min_properties].is_a?(Integer)
+          fail 'Option "min_properties" must be an "integer"'
+        end
+
+        unless options[:max_properties].nil? || options[:max_properties].is_a?(Integer)
+          fail 'Option "max_properties" must be an "integer"'
+        end
+
+        if @properties.values.any? { |p| p.name.is_a?(Regexp) && p.required? }
+          fail 'Pattern properties can\'t be required.'
+        end
+      end
+    end
+  end
+end

data/lib/schemacop/v3/integer_node.rb

@@ -0,0 +1,13 @@
+module Schemacop
+  module V3
+    class IntegerNode < NumericNode
+      def as_json
+        process_json(ATTRIBUTES, type: :integer)
+      end
+
+      def allowed_types
+        { Integer => :integer }
+      end
+    end
+  end
+end

data/lib/schemacop/v3/is_not_node.rb

@@ -0,0 +1,32 @@
+module Schemacop
+  module V3
+    class IsNotNode < CombinationNode
+      def type
+        :not
+      end
+
+      def _validate(data, result:)
+        super_data = super
+        return if super_data.nil?
+
+        if matches(super_data).any?
+          result.error "Must not match schema: #{@items.first.as_json.as_json.inspect}."
+        end
+      end
+
+      def as_json
+        process_json([], type => @items.first.as_json)
+      end
+
+      def validate_self
+        if @items.count != 1
+          fail 'Node "is_not" only allows exactly one item.'
+        end
+      end
+
+      def cast(data)
+        data
+      end
+    end
+  end
+end

data/lib/schemacop/v3/node.rb

@@ -0,0 +1,219 @@
+module Schemacop
+  module V3
+    class Node
+      attr_reader :name
+      attr_reader :as
+      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),
+            as:          options.delete(:as),
+            description: options.delete(:description)
+          }
+          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 as]
+      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)
+        @as = options.delete(:as)
+        @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