schemacop 2.4.5 → 3.0.0.rc2

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

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,256 @@
+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, **_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| [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?
+
+        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.name] = prop.cast(data_hash[prop.name])
+
+          if result[prop.name].nil? && !data_hash.include?(prop.name)
+            result.delete(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