rename eithers to variants

develop/fuzzing/execute_fuzz.lua

@@ -28,20 +28,6 @@ end
 
 ---@param query evolved.query
 local function generate_query(query)
-    local either_set = {}
-    local either_list = {}
-    local either_count = 0
-
-    for _ = 1, math.random(0, #all_fragment_list) do
-        local either = all_fragment_list[math.random(1, #all_fragment_list)]
-
-        if not either_set[either] then
-            either_count = either_count + 1
-            either_set[either] = either_count
-            either_list[either_count] = either
-        end
-    end
-
     local include_set = {}
     local include_list = {}
     local include_count = 0
@@ -70,8 +56,18 @@ local function generate_query(query)
         end
     end
 
-    if either_count > 0 then
-        evo.set(query, evo.EITHERS, either_list)
+    local variant_set = {}
+    local variant_list = {}
+    local variant_count = 0
+
+    for _ = 1, math.random(0, #all_fragment_list) do
+        local variant = all_fragment_list[math.random(1, #all_fragment_list)]
+
+        if not variant_set[variant] then
+            variant_count = variant_count + 1
+            variant_set[variant] = variant_count
+            variant_list[variant_count] = variant
+        end
     end
 
     if include_count > 0 then
@@ -81,6 +77,10 @@ local function generate_query(query)
     if exclude_count > 0 then
         evo.set(query, evo.EXCLUDES, exclude_list)
     end
+
+    if variant_count > 0 then
+        evo.set(query, evo.VARIANTS, variant_list)
+    end
 end
 
 ---@param query_count integer
@@ -189,24 +189,24 @@ local function execute_query(query)
     local query_chunk_set = {}
     local query_entity_set = {}
 
-    local query_either_list = evo.get(query, evo.EITHERS) or {}
     local query_include_list = evo.get(query, evo.INCLUDES) or {}
     local query_exclude_list = evo.get(query, evo.EXCLUDES) or {}
+    local query_variant_list = evo.get(query, evo.VARIANTS) or {}
 
-    local query_either_count = #query_either_list
     local query_include_count = #query_include_list
     local query_exclude_count = #query_exclude_list
-
-    local query_either_set = {}
-    for _, either in ipairs(query_either_list) do
-        query_either_set[either] = true
-    end
+    local query_variant_count = #query_variant_list
 
     local query_include_set = {}
     for _, include in ipairs(query_include_list) do
         query_include_set[include] = true
     end
 
+    local query_variant_set = {}
+    for _, variant in ipairs(query_variant_list) do
+        query_variant_set[variant] = true
+    end
+
     for chunk, entity_list, entity_count in evo.execute(query) do
         assert(not query_chunk_set[chunk])
         query_chunk_set[chunk] = true
@@ -217,10 +217,6 @@ local function execute_query(query)
             query_entity_set[entity] = true
         end
 
-        if query_either_count > 0 then
-            assert(chunk:has_any(__table_unpack(query_either_list)))
-        end
-
         if query_include_count > 0 then
             assert(chunk:has_all(__table_unpack(query_include_list)))
         end
@@ -228,18 +224,22 @@ local function execute_query(query)
         if query_exclude_count > 0 then
             assert(not chunk:has_any(__table_unpack(query_exclude_list)))
         end
+
+        if query_variant_count > 0 then
+            assert(chunk:has_any(__table_unpack(query_variant_list)))
+        end
     end
 
     for i = 1, all_entity_count do
         local entity = all_entity_list[i]
 
         local is_entity_matched =
-            (query_either_count == 0 or evo.has_any(entity, __table_unpack(query_either_list))) and
+            (query_variant_count == 0 or evo.has_any(entity, __table_unpack(query_variant_list))) and
             (query_include_count == 0 or evo.has_all(entity, __table_unpack(query_include_list))) and
             (query_exclude_count == 0 or not evo.has_any(entity, __table_unpack(query_exclude_list)))
 
         for fragment in evo.each(entity) do
-            if evo.has(fragment, evo.EXPLICIT) and not query_either_set[fragment] and not query_include_set[fragment] then
+            if evo.has(fragment, evo.EXPLICIT) and not query_variant_set[fragment] and not query_include_set[fragment] then
                 is_entity_matched = false
             end
         end
@@ -276,11 +276,11 @@ for _ = 1, math.random(1, 5) do
     else
         local r = math.random(1, 3)
         if r == 1 then
-            evo.remove(query, evo.EITHERS)
-        elseif r == 2 then
             evo.remove(query, evo.INCLUDES)
-        else
+        elseif r == 2 then
             evo.remove(query, evo.EXCLUDES)
+        else
+            evo.remove(query, evo.VARIANTS)
         end
     end
 end