schemurai 3.0.1 → 3.0.2

data/lib/schemurai/container_checks/array_diagnostics.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "../evaluation"
+require_relative "../error_message"
+
+module Schemurai
+  module Internal
+    module ContainerChecks
+      module ArrayDiagnostics
+        private def check_array(rules, value, prior_evaluation)
+          evaluation = nil
+          if rules.max_items && value.length > rules.max_items
+            return Evaluation.invalid unless collecting_array_errors?
+
+            array_error("maxItems", rules, value)
+          end
+          if rules.min_items && value.length < rules.min_items
+            return Evaluation.invalid unless collecting_array_errors?
+
+            array_error("minItems", rules, value)
+          end
+          if rules.unique && !unique_items?(value)
+            return Evaluation.invalid unless collecting_array_errors?
+
+            array_error("uniqueItems", rules, value)
+          end
+
+          if (prefix_items = rules.prefix_items)
+            prefix_items.each_with_index do |child, index|
+              @budget&.checkpoint
+              break if index >= value.length
+              valid = evaluate_child_at(child, value[index], index, "prefixItems", index)
+              return Evaluation.invalid if !valid && !collecting_array_errors?
+              (evaluation ||= tracked_evaluation).record_item(index)
+            end
+          end
+
+          items = rules.items
+          if rules.items_list
+            items.each_with_index do |child, index|
+              @budget&.checkpoint
+              break if index >= value.length
+              valid = evaluate_child_at(child, value[index], index, "items", index)
+              return Evaluation.invalid if !valid && !collecting_array_errors?
+              (evaluation ||= tracked_evaluation).record_item(index)
+            end
+            if value.length > items.length && (additional = rules.additional)
+              (items.length...value.length).each do |index|
+                @budget&.checkpoint
+                valid = evaluate_child_at(additional, value[index], index, "additionalItems")
+                return Evaluation.invalid if !valid && !collecting_array_errors?
+                (evaluation ||= tracked_evaluation).record_item(index)
+              end
+            end
+          elsif items
+            start = rules.prefix_items&.length || 0
+            (start...value.length).each do |index|
+              @budget&.checkpoint
+              valid = evaluate_child_at(items, value[index], index, "items")
+              return Evaluation.invalid if !valid && !collecting_array_errors?
+              (evaluation ||= tracked_evaluation).record_item(index)
+            end
+          end
+
+          if (contains = rules.contains)
+            matched = nil
+            index = 0
+            while index < value.length
+              @budget&.checkpoint
+              (matched ||= []) << index if trial(contains, value[index]).valid?
+              index += 1
+            end
+            matched_count = matched ? matched.length : 0
+            unless matched_count.between?(rules.min_contains, rules.max_contains)
+              return Evaluation.invalid unless collecting_array_errors?
+
+              array_error("contains", rules, value, matched_count)
+            end
+            if matched
+              matched.each { |index| (evaluation ||= tracked_evaluation).record_item(index) }
+            end
+          end
+
+          if (unevaluated = rules.unevaluated)
+            prior_items = prior_evaluation.evaluated_items
+            index = 0
+            while index < value.length
+              @budget&.checkpoint
+              if prior_items.include?(index) || evaluation&.evaluated_items&.include?(index)
+                index += 1
+                next
+              end
+              valid = evaluate_child_at(unevaluated, value[index], index, "unevaluatedItems")
+              return Evaluation.invalid if !valid && !collecting_array_errors?
+              (evaluation ||= tracked_evaluation).record_item(index)
+              index += 1
+            end
+          end
+          return Evaluation.valid unless evaluation
+
+          evaluation
+        end
+
+        private def collecting_array_errors? = @errors
+
+        private def array_error(keyword, rules, value, actual = nil)
+          add_error(keyword) do
+            case keyword
+            when "maxItems" then ErrorMessage.size(keyword, rules.max_items, value.length)
+            when "minItems" then ErrorMessage.size(keyword, rules.min_items, value.length)
+            when "uniqueItems" then ErrorMessage.unique_items
+            when "contains" then ErrorMessage.contains(actual, rules.min_contains, rules.max_contains)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schemurai/container_checks/object_diagnostics.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative "../evaluation"
+require_relative "../error_message"
+
+module Schemurai
+  module Internal
+    module ContainerChecks
+      module ObjectDiagnostics
+        MISSING_SEGMENT = Object.new.freeze
+
+        private def check_object(rules, value, prior_evaluation)
+          evaluation = nil
+          if rules.max_properties && value.length > rules.max_properties
+            return Evaluation.invalid unless collecting_object_errors?
+
+            object_error("maxProperties", rules, value)
+          end
+          if rules.min_properties && value.length < rules.min_properties
+            return Evaluation.invalid unless collecting_object_errors?
+
+            object_error("minProperties", rules, value)
+          end
+          if (required = rules.required)
+            required.each do |name|
+              object_budget&.checkpoint
+              next if value.key?(name)
+              return Evaluation.invalid unless collecting_object_errors?
+
+              object_error("required", rules, value, name)
+            end
+          end
+
+          properties = rules.properties
+          patterns = rules.patterns
+          value.each do |name, property_value|
+            object_budget&.checkpoint
+            matched = false
+            if (child = properties[name])
+              matched = true
+              valid = evaluate_child_at(child, property_value, name, "properties", name)
+              return Evaluation.invalid if !valid && !collecting_object_errors?
+              (evaluation ||= tracked_evaluation).record_property(name)
+            end
+            if patterns
+              patterns.each do |pattern, child|
+                object_budget&.checkpoint
+                next unless ecma_regexp(pattern).match?(name)
+                matched = true
+                valid = evaluate_child_at(child, property_value, name, "patternProperties", pattern)
+                return Evaluation.invalid if !valid && !collecting_object_errors?
+                (evaluation ||= tracked_evaluation).record_property(name)
+              end
+            end
+            if !matched && (additional = rules.additional)
+              valid = evaluate_child_at(additional, property_value, name, "additionalProperties")
+              return Evaluation.invalid if !valid && !collecting_object_errors?
+              (evaluation ||= tracked_evaluation).record_property(name)
+            end
+          end
+
+          if (property_names = rules.property_names)
+            value.each_key do |name|
+              object_budget&.checkpoint
+              valid = evaluate_child_at(property_names, name, name, "propertyNames")
+              return Evaluation.invalid if !valid && !collecting_object_errors?
+            end
+          end
+          if (dependencies = rules.dependencies)
+            dependencies.each do |name, dependency|
+              object_budget&.checkpoint
+              next unless value.key?(name)
+              if dependency.is_a?(Array)
+                dependency.each do |required_name|
+                  object_budget&.checkpoint
+                  unless value.key?(required_name)
+                    return Evaluation.invalid unless collecting_object_errors?
+
+                    object_error("dependencies", rules, value, name, required_name)
+                  end
+                end
+              else
+                result = evaluate_at(dependency, value, MISSING_SEGMENT, "dependencies", name)
+                if result.valid? && !result.evaluated_properties.empty?
+                  result.evaluated_properties.each do |property|
+                    object_budget&.checkpoint
+                    (evaluation ||= tracked_evaluation).record_property(property)
+                  end
+                end
+              end
+            end
+          end
+          if (dependent_required = rules.dependent_required)
+            dependent_required.each do |name, required_names|
+              object_budget&.checkpoint
+              next unless value.key?(name)
+              required_names.each do |required_name|
+                object_budget&.checkpoint
+                unless value.key?(required_name)
+                  return Evaluation.invalid unless collecting_object_errors?
+
+                  object_error("dependentRequired", rules, value, name, required_name)
+                end
+              end
+            end
+          end
+          if (dependent_schemas = rules.dependent_schemas)
+            dependent_schemas.each do |name, child|
+              object_budget&.checkpoint
+              next unless value.key?(name)
+              result = evaluate_at(child, value, MISSING_SEGMENT, "dependentSchemas", name)
+              if result.valid? && !result.evaluated_properties.empty?
+                result.evaluated_properties.each do |property|
+                  object_budget&.checkpoint
+                  (evaluation ||= tracked_evaluation).record_property(property)
+                end
+              end
+            end
+          end
+          if (unevaluated = rules.unevaluated)
+            prior_properties = prior_evaluation.evaluated_properties
+            value.each_key do |name|
+              object_budget&.checkpoint
+              next if prior_properties.include?(name) || evaluation&.evaluated_properties&.include?(name)
+
+              valid = evaluate_child_at(unevaluated, value[name], name, "unevaluatedProperties")
+              return Evaluation.invalid if !valid && !collecting_object_errors?
+              (evaluation ||= tracked_evaluation).record_property(name)
+            end
+          end
+          return Evaluation.valid unless evaluation
+
+          evaluation
+        end
+
+        private def object_budget = @budget
+        private def collecting_object_errors? = @errors
+
+        private def object_error(keyword, rules, value, name = nil, required_name = nil)
+          add_error(keyword) do
+            case keyword
+            when "maxProperties" then ErrorMessage.size(keyword, rules.max_properties, value.length)
+            when "minProperties" then ErrorMessage.size(keyword, rules.min_properties, value.length)
+            when "required" then ErrorMessage.required(name)
+            when "dependencies", "dependentRequired" then ErrorMessage.dependent_required(name, required_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end