schemurai 2.2.1 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad9362bcb75b8b6f51fb74a2d15858766793620d348fc4924746c44eaa210fc3
-  data.tar.gz: ba30c2b4f45525b6953019dda82a3f4b1cbcc41405925e19c2f4550b58dfccd1
+  metadata.gz: c4620544f45920ada46eda1beff7cbb6461fb1633031f78d2964c4e963716d82
+  data.tar.gz: b0a66f4e369181d9182a10715d1622924ebac68cfe32a1169b844714a7b6a038
 SHA512:
-  metadata.gz: 1773b839b4b8de56dc0f0087e1070f6236602f3ad9a5aec39bcebe2586c5632a45865a6326365bba505f49728d006e1c9c6dbe63f9f1075d00a3398241d953d0
-  data.tar.gz: bfd5d96cd648547bfc1a97bd7d0f566ba5d86a4f39e8ceb89a27ebc536ce45ac8563614024a2d10c73cb6c61dd568a0f271069a7525510d6bd214de52ba53a3c
+  metadata.gz: b6dd9a631fa90e9600e0a60ba4e2ecfca492497a69376a11801cf1a4bfb799fb71eea3546f417b394279b7c3795ace0d2ff8422c8fa8c0b9c9cf6e7530ca8f86
+  data.tar.gz: b8b2e1bdaccdfc420b1aa2cec9fc2bef856157d450ccb547dcf230693b4b959baa77f9901b9df920c5c73bd6ef982b468249655397c0160e55c3b57772b1c2c5

data/lib/schemurai/evaluator.rb

@@ -4,10 +4,13 @@ require "json"
 require "base64"
 require_relative "evaluation"
 require_relative "error_message"
+require_relative "unique_items"
 
 module Schemurai
   module Internal
     class Evaluator
+      include UniqueItems
+
       MISSING_SEGMENT = Object.new.freeze
 
       def backend = :ruby
@@ -226,11 +229,7 @@ module Schemurai
         length = value.length
         return false if schema.key?("maxItems") && length > schema["maxItems"]
         return false if schema.key?("minItems") && length < schema["minItems"]
-        if schema["uniqueItems"]
-          value.each_with_index do |item, index|
-            return false if value[0...index].any? { |previous| json_equal?(previous, item) }
-          end
-        end
+        return false if schema["uniqueItems"] && !unique_items?(value)
 
         prefix_items = schema["prefixItems"]
         if prefix_items.is_a?(Array)
@@ -555,12 +554,7 @@ module Schemurai
         limit(schema, "maxItems", value.length) { |actual, expected| actual <= expected }
         limit(schema, "minItems", value.length) { |actual, expected| actual >= expected }
 
-        if schema["uniqueItems"]
-          duplicate = value.each_with_index.any? do |item, index|
-            value[0...index].any? { |previous| json_equal?(previous, item) }
-          end
-          add_error("uniqueItems") { ErrorMessage.unique_items } if duplicate
-        end
+        add_error("uniqueItems") { ErrorMessage.unique_items } if schema["uniqueItems"] && !unique_items?(value)
 
         prefix_items = schema["prefixItems"]
         if prefix_items.is_a?(Array)

data/lib/schemurai/unique_items.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Schemurai
+  module Internal
+    module UniqueItems
+      private def unique_items?(values)
+        # Avoid building an index for small arrays and early duplicates.
+        if values.length <= 16
+          values.each_with_index do |item, index|
+            index.times { |previous| return false if json_equal?(values[previous], item) }
+          end
+          return true
+        end
+
+        buckets = {}
+        # Store a single index until a collision needs a bucket array.
+        index = 0
+        while index < values.length
+          item = values[index]
+          fingerprint = json_fingerprint(item)
+          if (bucket = buckets[fingerprint])
+            if bucket.is_a?(Integer)
+              return false if json_equal?(values[bucket], item)
+
+              buckets[fingerprint] = [bucket, index]
+            else
+              return false if bucket.any? { |previous| json_equal?(values[previous], item) }
+
+              bucket << index
+            end
+          else
+            buckets[fingerprint] = index
+          end
+          index += 1
+        end
+        true
+      end
+
+      private def json_fingerprint(value)
+        case value
+        when Numeric
+          # JSON numbers compare across Integer/Float. Converting integral
+          # floats to integers also preserves precision for large integers.
+          return value.hash if value.is_a?(Integer)
+
+          number = value.to_f
+          (number.finite? && number == number.to_i) ? number.to_i.hash : number.hash
+        when Array
+          # Mask before multiplication to keep intermediate values immediate
+          # integers; hash each step to retain order without temporary arrays.
+          fingerprint = value.class.hash
+          value.each { |item| fingerprint = (((fingerprint & 0x1fffffff) * 31) ^ json_fingerprint(item)).hash }
+          fingerprint
+        when Hash
+          # Object key order is immaterial. Hash collisions are resolved using
+          # json_equal?, so this fingerprint never decides equality itself.
+          entries = 0
+          value.each_pair { |key, item| entries ^= (((key.hash & 0x1fffffff) * 31) ^ json_fingerprint(item)).hash }
+          (value.class.hash ^ value.length ^ entries).hash
+        else
+          value.hash
+        end
+      end
+    end
+  end
+end

data/lib/schemurai/version.rb

@@ -2,5 +2,5 @@
 
 module Schemurai
   # The installed Schemurai version.
-  VERSION = "2.2.1"
+  VERSION = "2.2.3"
 end

data/lib/schemurai/vm/evaluator.rb

@@ -2,8 +2,10 @@
 
 require "base64"
 require "json"
+require "set" # rubocop:disable Lint/RedundantRequireStatement -- Required on Ruby 3.4.
 require_relative "../evaluation"
 require_relative "../error_message"
+require_relative "../unique_items"
 require_relative "compiler"
 
 module Schemurai
@@ -12,8 +14,10 @@ module Schemurai
       attr_reader :evaluated_properties, :evaluated_items
 
       def initialize
-        @evaluated_properties = []
-        @evaluated_items = []
+        # Applicators can overlap. Array membership makes collecting and merging
+        # their annotations quadratic in the number of instance locations.
+        @evaluated_properties = Set.new
+        @evaluated_items = Set.new
       end
 
       def valid? = true
@@ -25,30 +29,30 @@ module Schemurai
       end
 
       def record_property(name)
-        @evaluated_properties << name unless @evaluated_properties.include?(name)
+        @evaluated_properties.add(name)
         self
       end
 
       def record_item(index)
-        @evaluated_items << index unless @evaluated_items.include?(index)
+        @evaluated_items.add(index)
         self
       end
 
       def merge(other)
         return Evaluation.invalid unless other.valid?
 
-        merge_locations(@evaluated_properties, other.evaluated_properties)
-        merge_locations(@evaluated_items, other.evaluated_items)
+        properties = other.evaluated_properties
+        items = other.evaluated_items
+        @evaluated_properties.merge(properties) unless properties.empty?
+        @evaluated_items.merge(items) unless items.empty?
         self
       end
-
-      private def merge_locations(target, locations)
-        locations.each { |location| target << location unless target.include?(location) }
-      end
     end
     private_constant :EvaluationBuffer
 
     class Evaluator
+      include Internal::UniqueItems
+
       MISSING_SEGMENT = Object.new.freeze
       DECIMAL_CACHE_LIMIT = 16
 
@@ -552,17 +556,7 @@ module Schemurai
         length = value.length
         return false if rules.max_items && length > rules.max_items
         return false if rules.min_items && length < rules.min_items
-        if rules.unique
-          index = 1
-          while index < length
-            previous_index = 0
-            while previous_index < index
-              return false if json_equal?(value[previous_index], value[index])
-              previous_index += 1
-            end
-            index += 1
-          end
-        end
+        return false if rules.unique && !unique_items?(value)
 
         if (prefix_items = rules.prefix_items)
           prefix_items.each_with_index do |child, index|
@@ -616,25 +610,10 @@ module Schemurai
 
           add_error("minItems") { Internal::ErrorMessage.size("minItems", rules.min_items, value.length) }
         end
-        if rules.unique
-          duplicate = false
-          index = 1
-          while index < value.length && !duplicate
-            previous_index = 0
-            while previous_index < index
-              if json_equal?(value[previous_index], value[index])
-                duplicate = true
-                break
-              end
-              previous_index += 1
-            end
-            index += 1
-          end
-          if duplicate
-            return Evaluation.invalid unless @errors
+        if rules.unique && !unique_items?(value)
+          return Evaluation.invalid unless @errors
 
-            add_error("uniqueItems") { Internal::ErrorMessage.unique_items }
-          end
+          add_error("uniqueItems") { Internal::ErrorMessage.unique_items }
         end
 
         if (prefix_items = rules.prefix_items)
@@ -674,7 +653,7 @@ module Schemurai
           matched = nil
           index = 0
           while index < value.length
-            (matched ||= []) << index if trial_at(contains, value[index], index, "contains").valid?
+            (matched ||= []) << index if trial(contains, value[index]).valid?
             index += 1
           end
           matched_count = matched ? matched.length : 0
@@ -895,7 +874,7 @@ module Schemurai
           matches = 0
           index = 0
           while index < operand.length
-            result = trial_at(operand[index], value, MISSING_SEGMENT, "anyOf", index)
+            result = trial(operand[index], value)
             if result.valid?
               matches += 1
               evaluation = evaluation.merge(result)
@@ -908,7 +887,7 @@ module Schemurai
           matched_evaluation = nil
           index = 0
           while index < operand.length
-            result = trial_at(operand[index], value, MISSING_SEGMENT, "oneOf", index)
+            result = trial(operand[index], value)
             if result.valid?
               matches += 1
               matched_evaluation = result
@@ -921,9 +900,9 @@ module Schemurai
             add_error("oneOf") { Internal::ErrorMessage.one_of(matches) }
           end
         when :not
-          add_error("not") { Internal::ErrorMessage.not } if trial_at(operand, value, MISSING_SEGMENT, "not").valid?
+          add_error("not") { Internal::ErrorMessage.not } if trial(operand, value).valid?
         when :conditional
-          condition = trial_at(operand.condition, value, MISSING_SEGMENT, "if")
+          condition = trial(operand.condition, value)
           condition_valid = condition.valid?
           evaluation = evaluation.merge(condition) if condition_valid
           if condition_valid && operand.then_branch
@@ -938,12 +917,24 @@ module Schemurai
       private def trial(program, value)
         saved_errors = @errors
         saved_count = @error_count
+        saved_instance_path = @instance_path
         @errors = nil
         @error_count = 0
+        # Trials retain annotations, but discard errors. Descendants therefore
+        # need neither instance nor schema paths until the trial has returned.
+        if saved_instance_path
+          saved_schema_path = @schema_path
+          @instance_path = nil
+          @schema_path = nil
+        end
         evaluate(program, value)
       ensure
         @errors = saved_errors
         @error_count = saved_count
+        if saved_instance_path
+          @instance_path = saved_instance_path
+          @schema_path = saved_schema_path
+        end
       end
 
       private def evaluate_at(program, instance, instance_segment, schema_segment, child_segment = MISSING_SEGMENT)
@@ -971,23 +962,6 @@ module Schemurai
         @instance_path.pop unless instance_segment.equal?(MISSING_SEGMENT)
       end
 
-      private def trial_at(program, instance, instance_segment, schema_segment, child_segment = MISSING_SEGMENT)
-        return trial(program, instance) unless @instance_path
-
-        trial_at_with_path(program, instance, instance_segment, schema_segment, child_segment)
-      end
-
-      private def trial_at_with_path(program, instance, instance_segment, schema_segment, child_segment)
-        @instance_path << instance_segment unless instance_segment.equal?(MISSING_SEGMENT)
-        @schema_path << schema_segment
-        @schema_path << child_segment unless child_segment.equal?(MISSING_SEGMENT)
-        trial(program, instance)
-      ensure
-        @schema_path.pop unless child_segment.equal?(MISSING_SEGMENT)
-        @schema_path.pop
-        @instance_path.pop unless instance_segment.equal?(MISSING_SEGMENT)
-      end
-
       private def add_error(keyword, message = nil, append_keyword: true)
         @error_count += 1
         return false unless @errors

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: schemurai
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.2.3
 platform: ruby
 authors:
 - Kuya KOHARA (oakcask)
@@ -53,6 +53,7 @@ files:
 - lib/schemurai/schema_domain.rb
 - lib/schemurai/schema_graph.rb
 - lib/schemurai/schema_node.rb
+- lib/schemurai/unique_items.rb
 - lib/schemurai/version.rb
 - lib/schemurai/vm/compiler.rb
 - lib/schemurai/vm/evaluator.rb
@@ -63,7 +64,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/oakcask/schemurai
   source_code_uri: https://github.com/oakcask/schemurai/tree/main
-  documentation_uri: https://rubydoc.info/gems/schemurai/2.2.1
+  documentation_uri: https://rubydoc.info/gems/schemurai/2.2.3
   rubygems_mfa_required: 'true'
 rdoc_options:
 - "--main"
@@ -87,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: A fast, Ractor-safe, pure Ruby JSON Schema Draft 7+ validator
 test_files: []