Port various PoB2 buy similar and comparison tab PRs (#9857)

* Port PoB2 buy similar mod matching and UI

* Fix edit boxes

* Re-export crucible data

* Fix timeless jewel and rebuildurl on league and realm selectors

* Fix league/realm selectors not rebuilding url and make them persistent

* Add findTradeIdOption tests

* Remove stat json

* Port PoB2 socket position views

* Fix window title changing in compare tab

* Fix cluster jewel enchant handling

* Run CI on updated image

* Unfix mod export hashes (unused here and inflate the PR a lot)

* Comment out cluster and crucible hashes

* Regenerate QueryMods.lua

* Apply @LocalIdentity's rebuildUrl() fix instead

* Also add the test

* Fix spell checker issue

* Fix some trade issues + add test

League selections now use the realm
Trade stat lookup is now cached as it wasn't using it before
Use isValueInArray function in place of extra code
Add some tests and fix others

---------

Co-authored-by: LocalIdentity <localidentity2@gmail.com>

Author: vaisest

spec/System/TestCompareBuySimilar_spec.lua

@@ -0,0 +1,260 @@
+describe("Buy similar mod stat matching", function()
+	local bs = LoadModule("Classes/CompareBuySimilar")
+	local dkjson = require "dkjson"
+
+	describe("addModEntries mod matching", function()
+		it("matches impossible escape mods as options", function()
+			local fromNothing = new("Item", [[
+Impossible Escape
+Viridian Jewel
+LevelReq: 0
+Radius: Small
+Limited to: 1
+Implicits: 0
+Passive skills in radius of Elemental Overload can be Allocated without being connected to your tree
+Corrupted]])
+
+			local modSources = {
+				{ list = fromNothing.explicitModLines, type = "explicit" }
+			}
+			local modEntries = bs.addModEntries(fromNothing, modSources)
+			assert.equal(1, #modEntries)
+			assert.same(
+				{
+					formattedLines = { colorCodes.MAGIC .. "Passive skills in radius of Elemental Overload can be Allocated without being connected to your tree" },
+					type = "explicit",
+					isOption = true,
+					invert = false,
+					tradeIds = { "explicit.stat_2422708892" },
+					value = 22088
+				},
+				modEntries[1])
+		end)
+
+		it("matches thread of hope radius as an option", function()
+			local thread = new("Item", [[
+Rarity: UNIQUE
+Thread of Hope
+Crimson Jewel
+Radius: Variable
+Implicits: 0
+Only affects Passives in Massive Ring
+-15% to all Elemental Resistances
+Passive Skills in Radius can be Allocated without being connected to your tree
+Passage]])
+			local modSources = {
+				{ list = thread.explicitModLines, type = "explicit" }
+			}
+			local modEntries = bs.addModEntries(thread, modSources)
+			assert.equal(4, #modEntries)
+			assert.equal("explicit.stat_3642528642", modEntries[1].tradeIds[1])
+			assert.equal(5, modEntries[1].value)
+		end)
+
+		it("combines mods that are the same stat", function()
+			local lifeDiamond = new("Item", [[
+Test Subject
+Diamond
+Implicits: 0
++100 to Maximum Life
++50 to Maximum Life
++50% to Fire Resistance]])
+
+			local entries = bs.addModEntries(lifeDiamond, { { list = lifeDiamond.explicitModLines, type = "explicit" } })
+			assert.equal(2, #entries)
+			assert.equal(2, #entries[1].formattedLines)
+			assert.equal("+100 to Maximum Life", StripEscapes(entries[1].formattedLines[1]))
+			assert.equal("+50 to Maximum Life", StripEscapes(entries[1].formattedLines[2]))
+			assert.equal(150, entries[1].value)
+
+			local lifelessDiamond = new("Item", [[
+Test Subject
+Diamond
+Implicits: 0
+-100 to Maximum Life
++50 to Maximum Life
++50% to Fire Resistance]])
+			local entries = bs.addModEntries(lifelessDiamond,
+				{ { list = lifelessDiamond.explicitModLines, type = "explicit" } })
+			assert.equal(2, #entries)
+			assert.equal(2, #entries[1].formattedLines)
+			assert.equal(-50, entries[1].value)
+		end)
+
+		it("is not case-sensitive", function ()
+			local funnyItem = new("Item", [[
+Test Subject
+Diamond
+Implicits: 1
++50 tO MaxIMum lifE]])
+
+			local entries = bs.addModEntries(funnyItem, {{list = funnyItem.implicitModLines, type = "implicit"}})
+			assert.equal(1, #entries)
+		end)
+
+		it("does not combine implicit and explicit mods", function()
+			local lifelessDiamond = new("Item", [[
+Test Subject
+Diamond
+Implicits: 1
+-100 to Maximum Life
++50 to Maximum Life]])
+			local entries = bs.addModEntries(lifelessDiamond,
+				{ { list = lifelessDiamond.implicitModLines, type = "implicit" }, { list = lifelessDiamond.explicitModLines, type = "explicit" } })
+			assert.equal(2, #entries)
+			assert.equal(-100, entries[1].value)
+			assert.equal(50, entries[2].value)
+		end)
+	end)
+	describe("popup URL controls", function()
+		local originalCopy
+		local originalOpenURL
+		local originalFetchLeagues
+		local copiedUrl
+		local leaguesByRealm = {
+			pc = { "PC League", "PC Event", "Standard" },
+			sony = { "PS4 League", "Standard" },
+			xbox = { "Xbox League", "Standard" },
+		}
+
+		before_each(function()
+			newBuild()
+			originalCopy = _G.Copy
+			originalOpenURL = _G.OpenURL
+			copiedUrl = nil
+			local requests = build.itemsTab.tradeQuery.tradeQueryRequests
+			originalFetchLeagues = requests.FetchLeagues
+			requests.FetchLeagues = function(_, realm, callback)
+				callback(leaguesByRealm[realm])
+			end
+		end)
+
+		after_each(function()
+			build.itemsTab.tradeQuery.tradeQueryRequests.FetchLeagues = originalFetchLeagues
+			_G.Copy = originalCopy
+			_G.OpenURL = originalOpenURL
+			bs.lastRealmIdx = nil
+			bs.lastLeagueByRealm = nil
+			bs.lastListedIndex = nil
+			main:ClosePopup()
+		end)
+
+		local function openPopup(item, slotName)
+			item = item or new("Item", "Rarity: Rare\nTest Ring\nRuby Ring\nImplicits: 0\n+50 to maximum Life")
+			bs.openPopup(item, slotName or "Ring", build)
+			local controls = main.popups[1].controls
+			_G.Copy = function(url) copiedUrl = url end
+			_G.OpenURL = function() end
+			return controls
+		end
+
+		local function getQuery(controls)
+			controls.search.onClick()
+			local queryJson = urlDecode(assert(copiedUrl:match("[?&]q=(.+)$")))
+			return dkjson.decode(queryJson)
+		end
+
+		it("rebuilds the URL when league and listed status change", function()
+			local controls = openPopup()
+			getQuery(controls)
+			local initialUrl = copiedUrl
+
+			controls.leagueDrop:SetSel(isValueInArray(controls.leagueDrop.list, "Standard"))
+			getQuery(controls)
+			assert.not_equal(initialUrl, copiedUrl)
+			assert.is_truthy(copiedUrl:find("/Standard?", 1, true))
+			local standardUrl = copiedUrl
+
+			controls.listedDrop:SetSel(4)
+			local query = getQuery(controls)
+			assert.not_equal(standardUrl, copiedUrl)
+			assert.equal("any", query.query.status.option)
+		end)
+
+		it("persists league choices by name for each realm", function()
+			local controls = openPopup()
+			assert.equal("PC Event", controls.leagueDrop:GetSelValue())
+			controls.leagueDrop:SetSel(2)
+			controls.leagueDrop:SetSel(1)
+			controls.realmDrop:SetSel(3)
+			assert.equal("Xbox League", controls.leagueDrop:GetSelValue())
+			controls.leagueDrop:SetSel(2)
+			controls.realmDrop:SetSel(1)
+			assert.equal("PC Event", controls.leagueDrop:GetSelValue())
+			controls.leagueDrop:SetSel(2)
+			controls.realmDrop:SetSel(3)
+			assert.equal("Standard", controls.leagueDrop:GetSelValue())
+			controls.listedDrop:SetSel(4)
+			main:ClosePopup()
+
+			controls = openPopup()
+			assert.equal(3, bs.lastRealmIdx)
+			assert.equal("Standard", controls.leagueDrop:GetSelValue())
+			assert.equal("Any", controls.listedDrop:GetSelValue())
+		end)
+
+		it("encodes option values in the generated query", function()
+			local item = new("Item", [[
+Rarity: UNIQUE
+Impossible Escape
+Viridian Jewel
+LevelReq: 0
+Radius: Small
+Limited to: 1
+Implicits: 0
+Passive skills in radius of Elemental Overload can be Allocated without being connected to your tree
+Corrupted]])
+			local controls = openPopup(item, "Jewel")
+			controls.mod1Check.state = true
+			controls.mod1Check.changeFunc()
+
+			local filter = getQuery(controls).query.stats[1].filters[1]
+			assert.equal("explicit.stat_2422708892", filter.id)
+			assert.equal(22088, filter.value.option)
+		end)
+
+		it("inverts reduced stat bounds in the generated query", function()
+			local item = new("Item", [[
+Rarity: Rare
+Test Ring
+Ruby Ring
+Implicits: 0
+67% reduced maximum Life]])
+			local controls = openPopup(item)
+			controls.mod1Check.state = true
+			controls.mod1Check.changeFunc()
+
+			local value = getQuery(controls).query.stats[1].filters[1].value
+			assert.is_nil(value.min)
+			assert.equal(-67, value.max)
+		end)
+
+		it("uses a count group for ambiguous trade stats", function()
+			local item = new("Item", [[
+Rarity: Rare
+Test Ring
+Ruby Ring
+Implicits: 0
+Adds 5 to 15 Fire Damage]])
+			local modEntries = bs.addModEntries(item, { { list = item.explicitModLines, type = "explicit" } })
+			local ambiguousIndex
+			for index, entry in ipairs(modEntries) do
+				if #entry.tradeIds > 1 then
+					ambiguousIndex = index
+					break
+				end
+			end
+			assert.is_truthy(ambiguousIndex)
+
+			local controls = openPopup(item)
+			local check = controls["mod" .. ambiguousIndex .. "Check"]
+			check.state = true
+			check.changeFunc()
+
+			local countFilter = getQuery(controls).query.stats[2]
+			assert.equal("count", countFilter.type)
+			assert.equal(1, countFilter.value.min)
+			assert.equal(#modEntries[ambiguousIndex].tradeIds, #countFilter.filters)
+		end)
+	end)
+end)

spec/System/TestTradeHelpers_spec.lua

@@ -0,0 +1,112 @@
+describe("TradeHelpers trade hash matching", function()
+	local tradeHelpers = LoadModule("Classes/TradeHelpers")
+
+	describe("modLineValue", function()
+		it("returns the single number on a line", function()
+			assert.equal(50, tradeHelpers.modLineValue("+50 to maximum Life"))
+		end)
+
+		it("returns the midpoint of a '# to #' range", function()
+			assert.equal(15, tradeHelpers.modLineValue("Adds 10 to 20 Fire Damage"))
+			assert.equal(12.5, tradeHelpers.modLineValue("Adds 10 to 15 Fire Damage"))
+		end)
+
+		it("handles negative numbers", function()
+			assert.equal(-10, tradeHelpers.modLineValue("-10% to Fire Resistance"))
+		end)
+
+		it("returns nil when onlyFromTo is set and there is no range", function()
+			assert.is_nil(tradeHelpers.modLineValue("+50 to maximum Life", true))
+		end)
+	end)
+
+	describe("findTradeIdOption", function()
+		it("matches a '#'-valued option and returns its value", function()
+			local tradeId, value = tradeHelpers.findTradeIdOption("Grants Level 20 Summon Bestial Snake Skill",
+				"explicit")
+			assert.equal("explicit.stat_2878779644", tradeId)
+			assert.equal(3, value)
+		end)
+
+		it("matches an exact-text option and returns no value", function()
+			local tradeId, value = tradeHelpers.findTradeIdOption("Allocates Tranquility", "enchant")
+			assert.equal("enchant.stat_2954116742", tradeId)
+			assert.equal(16246, value)
+		end)
+
+		it("matches a timeless jewel", function()
+			local tradeId, value = tradeHelpers.findTradeIdOption(
+				"Bathed in the blood of 666 sacrificed in the name of Doryani", "explicit")
+			assert.equal("explicit.pseudo_timeless_jewel_doryani", tradeId)
+			assert.equal(666, value)
+		end)
+
+		it("returns nil for an unmatchable line", function()
+			assert.is_nil(tradeHelpers.findTradeIdOption("+100 to IQ", "explicit"))
+		end)
+	end)
+	describe("findTradeHash", function()
+		it("matches a simple mod", function()
+			local ids, value = tradeHelpers.findTradeHash("+50 to maximum Life")
+			assert.equal(50, value)
+			assert.is_truthy(isValueInArray(ids, HashStats({ "base_maximum_life" })))
+		end)
+
+		it("matches a percentage mod", function()
+			local ids, value = tradeHelpers.findTradeHash("25% reduced maximum Energy Shield")
+			assert.equal(25, value)
+			assert.is_truthy(isValueInArray(ids, HashStats({ "maximum_energy_shield_+%" })))
+		end)
+
+		it("matches a # to # mod", function()
+			local ids, value = tradeHelpers.findTradeHash("Adds 5 to 15 Fire Damage")
+			assert.equal(10, value)
+			assert.is_truthy(isValueInArray(ids,
+				HashStats({ "local_minimum_added_fire_damage", "local_maximum_added_fire_damage" })))
+		end)
+
+		it("is case-insensitive", function()
+			local ids = tradeHelpers.findTradeHash(
+				"1 aDDED PASSiVe sKilL IS ONE wITh The ShiELd")
+			assert.is_truthy(isValueInArray(ids, HashStats({ "local_affliction_notable_one_with_the_shield" })))
+		end)
+
+		it("returns no results for an unmatchable line", function()
+			local ids = tradeHelpers.findTradeHash("+100 to IQ")
+			assert.equal(0, #ids)
+		end)
+
+		it("detects inverted mods correctly", function()
+			-- note that this stat is a handwrap mod and doesn't actually exist on the trade site
+			local ids, value, shouldNegate = tradeHelpers.findTradeHash(
+				"Debuffs on you expire 100% slower while affected by Haste")
+			assert.equal(100, value)
+			assert.is_true(shouldNegate)
+			assert.equal(1, #ids)
+
+			local ids, value, shouldNegate = tradeHelpers.findTradeHash("67% reduced maximum life")
+			assert.equal(67, value)
+			assert.is_true(shouldNegate)
+			assert.equal(1, #ids)
+		end)
+		it("detects mods with lua pattern characters correctly", function()
+			local ids, value = tradeHelpers.findTradeHash(
+				"trigger Socketed Spells when you focus, with a 0.25 second cooldown")
+			assert.is_truthy(isValueInArray(ids, HashStats({ "trigger_socketed_spells_when_you_focus_%" })))
+			assert.equal(100, value)
+
+			local ids, value, shouldNegate = tradeHelpers.findTradeHash(
+				"10% reduced effect of Non-Curse Auras from your Skills on your Minions")
+			assert.is_truthy(isValueInArray(ids, HashStats({ "minions_have_non_curse_aura_effect_+%_from_parent_skills" })))
+			assert.equal(10, value)
+			assert.is_true(shouldNegate)
+		end)
+		it("detects passage modline correctly", function()
+			local ids = tradeHelpers.findTradeHash(
+				"Passive Skills in Radius can be Allocated without being connected to your tree")
+			assert.is_truthy(isValueInArray(ids,
+				HashStats({ "local_unique_jewel_nearby_disconnected_passives_can_be_allocated",
+					"unique_thread_of_hope_base_resist_all_elements_%" })))
+		end)
+	end)
+end)