Version 0.4.0
- restructured files - extract functions and color codes - filter channelsmaster
parent
b572203dd2
commit
cc26683328
@ -0,0 +1,245 @@
|
||||
-- import addon read namespace from global env
|
||||
local _G = _G
|
||||
local Grichelde = _G.Grichelde
|
||||
|
||||
local ipairs, tContains, tFilter, tInsert, tConcat, find, sub, gsub, match, toLower, trim, length
|
||||
= Grichelde.functions.ipairs, Grichelde.functions.tContains, Grichelde.functions.tFilter, Grichelde.functions.tInsert, Grichelde.functions.tConcat, Grichelde.functions.find, Grichelde.functions.sub, Grichelde.functions.gsub, Grichelde.functions.match, Grichelde.functions.toLower, Grichelde.functions.trim, Grichelde.functions.length
|
||||
|
||||
--- Before a chat message is sent, check if replacement is required and replace the text accordingly.
|
||||
--- @param message string
|
||||
--- @param type string
|
||||
--- @param language string
|
||||
--- @param channel string
|
||||
function Grichelde:SendChatMessage(message, type, language, channel, ...)
|
||||
local replacedText = self:CheckAndReplace(message, type)
|
||||
|
||||
self:DebugPrint("SendChatMessage : replacedText: " .. replacedText)
|
||||
|
||||
-- Send text in chunks if length exceeds 255 bytes after replacement
|
||||
local chunks = self:SplitText(replacedText)
|
||||
self:DebugPrint("SendChatMessage : #chunks: " .. #chunks)
|
||||
|
||||
for _, chunk in ipairs(chunks) do
|
||||
self.hooks["SendChatMessage"](chunk, type, language, channel, ...);
|
||||
end
|
||||
end
|
||||
|
||||
function Grichelde:CheckAndReplace(message, type)
|
||||
local text = message
|
||||
if (self:CheckReplacement(text, type)) then
|
||||
if (_G.Misspelled) then
|
||||
self:DebugPrint("Misspelled detected: cleansing message")
|
||||
text = _G.Misspelled:RemoveHighlighting(text)
|
||||
end
|
||||
text = self:ReplaceText(trim(text))
|
||||
end
|
||||
return text
|
||||
end
|
||||
|
||||
function Grichelde:CheckReplacement(text, channel)
|
||||
if (not self.db.profile.enabled) then
|
||||
self:DebugPrint("CheckReplacement : disabled")
|
||||
return false
|
||||
end
|
||||
|
||||
-- check channel type
|
||||
local allowedChannels = tFilter(self.db.profile.channels,
|
||||
function(_,v) return v == true end,
|
||||
function(k,_) return k end
|
||||
)
|
||||
self:DebugPrint("CheckReplacement : allowed channels: %s", tConcat(allowedChannels, ", "))
|
||||
local type = self:ConvertBlizChannelToType(channel)
|
||||
if (type ~= nil and not tContains(allowedChannels, type)) then
|
||||
self:DebugPrint("CheckReplacement : skip channel type %s", type)
|
||||
return false
|
||||
end
|
||||
|
||||
-- don't replace slash commands except chat related commands
|
||||
if sub(text, 1, 1) == "/" then
|
||||
local firstWord, _ = self:SplitOnFirstMatch(text)
|
||||
-- todo: adapt allowed slash commands
|
||||
if (firstWord == nil or not tContains(self.slashCommands, firstWord)) then
|
||||
self:DebugPrint("CheckReplacement : ignore slash command")
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- in any other case
|
||||
return true
|
||||
end
|
||||
|
||||
function Grichelde:ConvertBlizChannelToType(channel)
|
||||
local type = toLower(channel)
|
||||
self:DebugPrint("ConvertBlizChannelToType : convert %s to %s", channel, type)
|
||||
return type
|
||||
end
|
||||
|
||||
--- Checks if the text starts with a preversable ignore pattern, such as itemLinks, textures or raid target icons
|
||||
--- and returns the end location of the match, or 0 if no pattern was found
|
||||
--- @param text string
|
||||
--- @return number
|
||||
function Grichelde:CheckForPreversableText(text)
|
||||
self:DebugPrint("CheckForPreversableText : text is " .. text)
|
||||
|
||||
-- do not replace these patterns
|
||||
local ignorePatterns = {
|
||||
"|[Cc]%x%x%x%x%x%x%x%x.-|r", -- colored items (or links)
|
||||
"|H.-|h", -- item links (http://www.wowwiki.com/ItemLink)
|
||||
"|T.-|t", -- textures
|
||||
"|n", -- newline
|
||||
"{rt[1-8]}", -- rumbered raid target icons
|
||||
"{Star}", -- named raid target icon 1
|
||||
"{Circle}", -- named raid target icon 2
|
||||
"{Coin}", -- named raid target icon 2
|
||||
"{Diamond}", -- named raid target icon 3
|
||||
"{Triangle}", -- named raid target icon 4
|
||||
"{Moon}", -- named raid target icon 5
|
||||
"{Square}", -- named raid target icon 6
|
||||
"{Cross}", -- named raid target icon 7
|
||||
"{X}", -- named raid target icon 7
|
||||
"{Skull}" -- named raid target icon 8
|
||||
}
|
||||
|
||||
-- Calling find on ever pattern might be inefficient but its way less code.
|
||||
for _, pattern in ipairs(ignorePatterns) do
|
||||
local pos1, pos2 = find(text, pattern)
|
||||
if pos1 == 1 and pos2 ~= nil then
|
||||
self:DebugPrint("CheckForPreversableText : Found ignore pattern \"%s\" at (%d, %d)", pattern, pos1, pos2)
|
||||
return pos2
|
||||
end
|
||||
end
|
||||
self:DebugPrint("CheckForPreversableText : no ignore pattern found")
|
||||
return 0
|
||||
end
|
||||
|
||||
--- Replaces all character occurrences for which replacements have been defined in the options,
|
||||
--- while preserving any itemLinks or textures. (http://www.wowwiki.com/ItemLink)
|
||||
--- @param text string
|
||||
--- @return string
|
||||
function Grichelde:ReplaceText(text)
|
||||
local finalText = ""
|
||||
local newText = text
|
||||
|
||||
-- don't replace non-chat related slash commands
|
||||
local firstWord, line = self:SplitOnFirstMatch(text)
|
||||
if (firstWord ~= nil and tContains(self.slashCommands, firstWord)) then
|
||||
self:DebugPrint("ReplaceText : Found slash command %s", firstWord )
|
||||
-- skip chat slash command
|
||||
finalText = finalText .. firstWord .. ' '
|
||||
newText = line
|
||||
end
|
||||
|
||||
local current = 1
|
||||
local lastStart = 1
|
||||
|
||||
while current <= length(newText) do
|
||||
local currentChar = sub(newText, current, current)
|
||||
self:DebugPrint("current/char : %s,%s", current, currentChar)
|
||||
|
||||
if currentChar ~= '|' and currentChar ~= '{' then
|
||||
current = current + 1
|
||||
else
|
||||
|
||||
-- lookahead-check for itemLinks, textures and raid target icons
|
||||
local textAhead = sub(newText, current)
|
||||
local posEnd = self:CheckForPreversableText(textAhead)
|
||||
if posEnd > 0 then
|
||||
self:DebugPrint("ReplaceText : Found an ignore pattern")
|
||||
|
||||
local textBehind = sub(newText, lastStart, current - 1)
|
||||
local replacement = self:ReplaceCharacters(textBehind)
|
||||
local preservedText = sub(textAhead, 1, posEnd)
|
||||
|
||||
finalText = finalText .. replacement .. preservedText
|
||||
current = current + posEnd
|
||||
lastStart = current
|
||||
self:DebugPrint("ReplaceText : restarting at " .. lastStart)
|
||||
else
|
||||
-- no corresponding end was found to start pattern, continue loop with next char
|
||||
current = current + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- cleanup remaining text to the end
|
||||
local remainingText = sub(newText, lastStart)
|
||||
local replacement = self:ReplaceCharacters(remainingText)
|
||||
finalText = finalText .. replacement
|
||||
|
||||
self:DebugPrint("ReplaceText : replaced \"" .. text .. "\"")
|
||||
self:DebugPrint("ReplaceText : with \"" .. finalText .. "\"")
|
||||
return finalText
|
||||
end
|
||||
|
||||
--- Replaces all character occurrences for which replacements have been defined in the options
|
||||
--- @param text string
|
||||
--- @return string
|
||||
function Grichelde:ReplaceCharacters(text)
|
||||
-- todo: read from options
|
||||
-- todo: case (in)sensitivity
|
||||
-- todo: consolidate consecutive
|
||||
-- todo: prevent infinite loops - is that even possible?
|
||||
local replacement = text
|
||||
replacement = gsub(replacement, "s", "ch")
|
||||
replacement = gsub(replacement, "S", "Ch")
|
||||
replacement = gsub(replacement, "t", "k")
|
||||
replacement = gsub(replacement, "T", "K")
|
||||
self:DebugPrint("ReplaceCharacters : replaced \"%s\" with \"%s\"", text, replacement)
|
||||
return replacement
|
||||
end
|
||||
|
||||
--- Splits a long text in longest possible chunks of <= 255 length, split at last available space
|
||||
--- @param text string
|
||||
--- @return table
|
||||
function Grichelde:SplitText(text)
|
||||
local chunks = {}
|
||||
local splitText = text
|
||||
local textSize = length(splitText)
|
||||
|
||||
while textSize > 255 do
|
||||
local chunk = sub(splitText, 1, 255)
|
||||
local remaining = ""
|
||||
|
||||
-- special case: if space is the start of the next chunk, don't split this chunk
|
||||
if sub(splitText, 256, 256) ~= ' ' then
|
||||
-- split at last space, don't assign directly as nil might be returned
|
||||
local left, right = self:SplitOnLastMatch(chunk)
|
||||
if left ~= nil then
|
||||
chunk = left
|
||||
end
|
||||
if right ~= nil then
|
||||
remaining = right
|
||||
end
|
||||
end
|
||||
|
||||
self:DebugPrint("SplitText : chunk: " .. chunk )
|
||||
|
||||
tInsert(chunks, chunk)
|
||||
splitText = remaining .. sub(splitText, 256)
|
||||
textSize = length(splitText)
|
||||
end
|
||||
|
||||
-- pickup remaining text < 255
|
||||
self:DebugPrint("SplitText : last chunk: " .. splitText)
|
||||
tInsert(chunks, splitText)
|
||||
|
||||
return chunks
|
||||
end
|
||||
|
||||
-- split at first word of a text line
|
||||
function Grichelde:SplitOnFirstMatch(text, start)
|
||||
self:DebugPrint("SplitOnFirstMatch : text: %s, start: %d", text, start)
|
||||
local pos = start or 1
|
||||
local left, right = match(text, "^.- .+", pos)
|
||||
self:DebugPrint("SplitOnFirstMatch : left: %s, right: %s", left, right)
|
||||
return left or text, right
|
||||
end
|
||||
|
||||
-- split at last word of a text line
|
||||
function Grichelde:SplitOnLastMatch(text, start)
|
||||
self:DebugPrint("SplitOnLastMatch : text: %s, start: %d", text, start)
|
||||
local pos = start or 1
|
||||
local left, right = match(text, ".+ .-$", pos)
|
||||
self:DebugPrint("SplitOnLastMatch : left: %s, right: %s", left, right)
|
||||
return left, right or text
|
||||
end
|
||||
@ -0,0 +1,94 @@
|
||||
-- read namespace from global env
|
||||
local _G = _G
|
||||
local Grichelde = _G.Grichelde
|
||||
|
||||
-- upvalues and constants
|
||||
|
||||
-- faster function lookups by mapping to local refs
|
||||
Grichelde.functions = {}
|
||||
Grichelde.functions.type = _G.type
|
||||
Grichelde.functions.print = _G.print
|
||||
Grichelde.functions.pairs = _G.pairs
|
||||
Grichelde.functions.ipairs = _G.ipairs
|
||||
Grichelde.functions.tContains = _G.tContains
|
||||
Grichelde.functions.tFilter = function(t, cond, extr)
|
||||
local filtered = {}
|
||||
for key, value in Grichelde.functions.pairs(t) do
|
||||
if cond(key, value) then
|
||||
local val = extr(key, value)
|
||||
Grichelde.functions.tInsert(filtered, #filtered + 1, val)
|
||||
end
|
||||
end
|
||||
return filtered
|
||||
end
|
||||
Grichelde.functions.tInsert = _G.table.insert
|
||||
Grichelde.functions.tConcat = _G.table.concat
|
||||
Grichelde.functions.select = _G.select
|
||||
Grichelde.functions.unpack = _G.unpack
|
||||
Grichelde.functions.find = _G.string.find
|
||||
Grichelde.functions.sub = _G.string.sub
|
||||
Grichelde.functions.gsub = _G.string.gsub
|
||||
Grichelde.functions.match = _G.strmatch
|
||||
Grichelde.functions.join = _G.strjoin
|
||||
Grichelde.functions.toLower = _G.strlower
|
||||
Grichelde.functions.toUpper = _G.strupper
|
||||
Grichelde.functions.format = _G.string.format
|
||||
Grichelde.functions.rep = _G.string.rep
|
||||
Grichelde.functions.trim = _G.strtrim
|
||||
Grichelde.functions.length = _G.string.len
|
||||
Grichelde.functions.toString = _G.tostring
|
||||
|
||||
-- colors:
|
||||
Grichelde.COLOR_CODES = {}
|
||||
Grichelde.COLOR_CODES.PREFIX = "|c00FFAA00"
|
||||
-- https://github.com/stoneharry/Misc-WoW-Stuff/blob/master/EoC%20Interface/FrameXML/Constants.lua
|
||||
Grichelde.COLOR_CODES.NORMAL = _G.NORMAL_FONT_COLOR_CODE or "|cffffd200";
|
||||
Grichelde.COLOR_CODES.HIGHLIGHT = _G.HIGHLIGHT_FONT_COLOR_CODE or "|cffffffff";
|
||||
Grichelde.COLOR_CODES.RED = _G.RED_FONT_COLOR_CODE or "|cffff2020";
|
||||
Grichelde.COLOR_CODES.GREEN = _G.GREEN_FONT_COLOR_CODE or "|cff20ff20";
|
||||
Grichelde.COLOR_CODES.GRAY = _G.GRAY_FONT_COLOR_CODE or "|cff808080";
|
||||
Grichelde.COLOR_CODES.YELLOW = _G.YELLOW_FONT_COLOR_CODE or "|cffffff00";
|
||||
Grichelde.COLOR_CODES.LIGHTYELLOW = _G.LIGHTYELLOW_FONT_COLOR_CODE or "|cffffff9a";
|
||||
Grichelde.COLOR_CODES.ORANGE = _G.ORANGE_FONT_COLOR_CODE or "|cffff7f3f";
|
||||
Grichelde.COLOR_CODES.CLOSE = _G.FONT_COLOR_CODE_CLOSE or "|r";
|
||||
|
||||
Grichelde.slashCommands = { "/s", "/say", "/e", "/em", "/me", "/emote", "/y", "/yell", "/sh", "/shout", "/p", "/party", "/pl", "/partyleader", "/g", "/gc", "/guild", "/o", "/osay", "/officer", "/raid", "/rsay", "/rl", "/raidleader", "/rw", "/raidwarning", "/i", "/instance", "/bg", "/battleground", "/w", "/whisper", "/t", "/tell", "/send", "/r", "/reply" }
|
||||
|
||||
Grichelde.defaultConfig = {
|
||||
global = {},
|
||||
profile = {
|
||||
enabled = true,
|
||||
channels = {
|
||||
["*"] = false,
|
||||
say = true,
|
||||
emote = false,
|
||||
yell = true,
|
||||
party = true,
|
||||
partyLeader = true,
|
||||
guild = true,
|
||||
officer = true,
|
||||
},
|
||||
replacements = {
|
||||
["**"] = {
|
||||
searchText = "",
|
||||
replaceText = "",
|
||||
caseSensitive = false,
|
||||
consolidate = true,
|
||||
},
|
||||
replacement_0 = {
|
||||
order = 1,
|
||||
searchText = "s",
|
||||
replaceText = "ch",
|
||||
caseSensitive = false,
|
||||
consolidate = true,
|
||||
},
|
||||
replacement_1 = {
|
||||
order = 2,
|
||||
searchText = "t",
|
||||
replaceText = "ck",
|
||||
caseSensitive = false,
|
||||
consolidate = true,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,103 @@
|
||||
-- import addon read namespace from global env
|
||||
local _G = _G
|
||||
local Grichelde = _G.Grichelde
|
||||
|
||||
local type, print, pairs, select, unpack, format, rep, toString
|
||||
= Grichelde.functions.type, Grichelde.functions.print, Grichelde.functions.pairs, Grichelde.functions.select, Grichelde.functions.unpack, Grichelde.functions.format, Grichelde.functions.rep, Grichelde.functions.toString
|
||||
|
||||
function Grichelde:Format(message, ...)
|
||||
local msg = message
|
||||
local l = select("#", ...)
|
||||
if l > 0 then
|
||||
-- sanitize nil values in vararg
|
||||
local packed = { ... }
|
||||
for i = 1, l do
|
||||
packed[i] = toString(packed[i]) or "nil"
|
||||
end
|
||||
-- print("packed = ", packed)
|
||||
-- self:tPrint(packed)
|
||||
-- cannot assign unpacked to a vararg variable and print it for debug
|
||||
msg = format(message, unpack(packed))
|
||||
end
|
||||
return msg or "nil"
|
||||
end
|
||||
|
||||
function Grichelde:Print(...)
|
||||
print(self:Format(...))
|
||||
end
|
||||
|
||||
local function prefixedPrint(colorCode, prefix, endClose, ...)
|
||||
print(colorCode .. prefix .. endClose .. ": " .. ...)
|
||||
end
|
||||
|
||||
function Grichelde:PrefixedPrint(...)
|
||||
prefixedPrint(self.COLOR_CODES.PREFIX, self.L.AddonName, self.COLOR_CODES.CLOSE, self:Format(...))
|
||||
end
|
||||
|
||||
function Grichelde:DebugPrint(...)
|
||||
if (self.debug) then
|
||||
prefixedPrint(self.COLOR_CODES.GRAY, self.L.AddonName, self.COLOR_CODES.CLOSE, self:Format(...))
|
||||
end
|
||||
end
|
||||
|
||||
local function tLen(t)
|
||||
local count = 0
|
||||
for _ in pairs(t) do count = count + 1 end
|
||||
return count
|
||||
end
|
||||
|
||||
-- show strings differently to distinguish them from numbers
|
||||
function Grichelde:PlainValue(val)
|
||||
if val == nil then
|
||||
return "<nil>"
|
||||
elseif type(val) == "string" then
|
||||
return '"' .. val .. '"'
|
||||
elseif type(val) == "table" then
|
||||
if tLen(val) > 0 then
|
||||
return toString(val)
|
||||
else
|
||||
return "{}"
|
||||
end
|
||||
else
|
||||
return toString(val)
|
||||
end
|
||||
end
|
||||
|
||||
--- Prints any value to default channel, do NOT return a string.
|
||||
function Grichelde:tPrint(val, indent, known)
|
||||
if (not self.debug) then return end
|
||||
|
||||
indent = indent or 0
|
||||
known = known or {}
|
||||
|
||||
if val == nil then
|
||||
print(rep(" ", indent) .. "<nil>")
|
||||
elseif type(val) == "string" then
|
||||
print(rep(" ", indent) .. "\"" .. val .. "\"")
|
||||
elseif type(val) == "table" then
|
||||
if tLen(val) > 0 then
|
||||
for key, value in pairs(val) do
|
||||
if value == nil then
|
||||
print(rep(" ", indent) .. self:PlainValue(key) .. "= <nil>")
|
||||
elseif type(value) == "table" then
|
||||
print(rep(" ", indent) .. self:PlainValue(key) .. "= {")
|
||||
if tLen(value) > 0 then
|
||||
if not known[value] then
|
||||
self:tPrint(value, indent + 4, known)
|
||||
known[value] = true
|
||||
else
|
||||
print("<known table> " .. self:PlainValue(value))
|
||||
end
|
||||
end
|
||||
print(rep(" ", indent) .. "}")
|
||||
else
|
||||
print(rep(" ", indent) .. self:PlainValue(key) .. " = " .. self:PlainValue(value))
|
||||
end
|
||||
end
|
||||
else
|
||||
print(rep(" ", indent) .. "{}")
|
||||
end
|
||||
else
|
||||
print(rep(" ", indent) .. toString(val))
|
||||
end
|
||||
end
|
||||
Loading…
Reference in New Issue