schemacop 2.4.7 → 3.0.0.rc0

data/lib/schemacop/v3/global_context.rb

@@ -0,0 +1,114 @@
+module Schemacop
+  module V3
+    class GlobalContext < Context
+      DSL_METHODS = %i[schema].freeze
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def self.eager_load!
+        instance.eager_load!
+      end
+
+      def self.schemas
+        instance.schemas
+      end
+
+      def self.schema_for(path)
+        instance.schema_for(path)
+      end
+
+      def schema(type = :hash, **options, &block)
+        @current_schemas << Node.create(type, **options, &block)
+      end
+
+      def schema_for(path)
+        path = path.to_sym
+        load_schema(path) unless @eager_loaded
+        @schemas[path]
+      end
+
+      def eager_load!
+        @schemas = {}
+
+        fail "Global context can't be eager loaded more than once." if @eager_loaded
+
+        Schemacop.load_paths.each do |load_path|
+          Dir.glob(File.join(load_path, '**', '*.rb')).sort.each do |file|
+            load_file(file, load_path)
+          end
+        end
+
+        @eager_loaded = true
+      end
+
+      private
+
+      def initialize
+        super
+        @schemas = {}
+        @load_paths_by_schemas = {}
+        @eager_loaded = false
+        @current_virtual_path = nil
+      end
+
+      def path_for(virtual_path)
+        "#{virtual_path.to_s.underscore}.rb"
+      end
+
+      def virtual_path_for(path, load_path)
+        Pathname.new(path).relative_path_from(load_path).to_s.underscore.gsub(/\.rb$/, '').to_sym
+      end
+
+      def load_schema(virtual_path)
+        path = path_for(virtual_path)
+
+        @schemas = schemas.except(virtual_path).freeze
+        @load_paths_by_schemas = @load_paths_by_schemas.except(virtual_path)
+
+        Schemacop.load_paths.each do |load_path|
+          path_in_load_path = File.join(load_path, path)
+
+          if File.exist?(path_in_load_path)
+            load_file(path_in_load_path, load_path)
+          end
+        end
+      end
+
+      def load_file(path, load_path)
+        return false unless File.exist?(path)
+
+        # Determine virtual path
+        virtual_path = virtual_path_for(path, load_path)
+
+        # Run file and collect schemas
+        begin
+          @current_schemas = []
+          env = ScopedEnv.new(self, DSL_METHODS)
+          env.instance_eval IO.read(path)
+        rescue StandardError => e
+          fail "Could not load schema #{path.inspect}: #{e.message}"
+        end
+
+        # Load schemas
+        case @current_schemas.size
+        when 0
+          fail "Schema #{path.inspect} does not define any schema."
+        when 1
+          if @schemas.include?(virtual_path)
+            fail "Schema #{virtual_path.to_s.inspect} is defined in both load paths "\
+                 "#{@load_paths_by_schemas[virtual_path].inspect} and #{load_path.inspect}."
+          end
+
+          @load_paths_by_schemas[virtual_path] = load_path
+          @schemas = @schemas.merge(virtual_path => @current_schemas.first)
+        else
+          fail "Schema #{path.inspect} defines multiple schemas."
+        end
+
+        return true
+      end
+    end
+  end
+end

data/lib/schemacop/v3/hash_node.rb

@@ -0,0 +1,217 @@
+module Schemacop
+  module V3
+    class HashNode < Node
+      ATTRIBUTES = %i[
+        type
+        min_properties
+        max_properties
+        dependencies
+        property_names
+      ].freeze
+
+      supports_children(name: true)
+
+      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 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)
+        @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| [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 sanitize_exp(exp)
+        exp = exp.to_s
+        if exp.start_with?('(?-mix:')
+          exp = exp.to_s.gsub(/^\(\?-mix:/, '').gsub(/\)$/, '')
+        end
+        return exp
+      end
+
+      def allowed_types
+        { Hash => :object }
+      end
+
+      def _validate(data, result: Result.new)
+        super_data = super
+        return if super_data.nil?
+
+        # Validate min_properties #
+        if options[:min_properties] && super_data.size < options[:min_properties]
+          result.error "Has #{super_data.size} properties but needs at least #{options[:min_properties]}."
+        end
+
+        # Validate max_properties #
+        if options[:max_properties] && super_data.size > options[:max_properties]
+          result.error "Has #{super_data.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(super_data[node.name], result: result)
+          end
+        end
+
+        # Validate additional properties #
+        specified_properties = @properties.keys.to_set
+        additional_properties = super_data.reject { |k, _v| specified_properties.include?(k.to_s.to_sym) }
+
+        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 super_data[source].present? && super_data[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 = {}
+        data ||= default
+        return nil if data.nil?
+
+        # TODO: How to handle regex / etc.?
+        @properties.each_value do |prop|
+          result[prop.name] = prop.cast(data[prop.name])
+
+          if result[prop.name].nil? && !data.include?(prop.name)
+            result.delete(prop.name)
+          end
+        end
+
+        # Handle additional properties
+        if options[:additional_properties] == true
+          result = data.merge(result)
+        elsif options[:additional_properties].is_a?(Node)
+          specified_properties = @properties.keys.to_set
+          additional_properties = data.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
+      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,214 @@
+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)
+        @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)
+        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