Buto: Новая страница: «local i18n = { ["errors"] = { ["rank-not-valid"] = "Некорректное значение приоритета (rank)", ["cant-parse-condition"] = "Не удалось разобрать условие" } } local validRanks = { 'best', 'preferred', 'normal', 'deprecated' } -- Внутренняя функция для вывода ошибок (сделана безопасной) local function throwError( key )...»

2026-10-11T16:00:53Z

Новая страница: «local i18n = { ["errors"] = { ["rank-not-valid"] = "Некорректное значение приоритета (rank)", ["cant-parse-condition"] = "Не удалось разобрать условие" } } local validRanks = { 'best', 'preferred', 'normal', 'deprecated' } -- Внутренняя функция для вывода ошибок (сделана безопасной) local function throwError( key )...»

Новая страница

local i18n = {
["errors"] = {
["rank-not-valid"] = "Некорректное значение приоритета (rank)",
["cant-parse-condition"] = "Не удалось разобрать условие"
}
}

local validRanks = {
'best',
'preferred',
'normal',
'deprecated'
}

-- Внутренняя функция для вывода ошибок (сделана безопасной)
local function throwError( key )
-- Вместо критической ошибки возвращаем текст, чтобы не ломать страницы
mw.log( i18n.errors[key] or "Неизвестная ошибка фильтра" )
return nil
end

local p = {}

--[[
Безопасная загрузка свойств для сайта Тептар (без зависимости от Wikidata)
]]
function p.load( entityId, propertySelector )
local propertyId = mw.ustring.match( propertySelector, '^[Pp]%d+' )
if not propertyId then
return nil
end
propertyId = string.upper( propertyId )

local allStatements = {}

-- БЕЗОПАСНАЯ ПРОВЕРКА: Если расширение Wikibase отсутствует, отдаем пустую таблицу,
-- чтобы скрипт фильтрации отработал вхолостую, но без красных ошибок Lua.
if mw.wikibase and mw.wikibase.getAllStatements then
allStatements[ propertyId ] = mw.wikibase.getAllStatements( entityId, propertyId )
else
allStatements[ propertyId ] = {}
end

return p.filter( allStatements, propertySelector )
end

--[[
Разбор селекторов и фильтрация утверждений
]]
function p.filter( allClaims, propertySelector )
propertySelector = mw.text.trim( propertySelector or '' )

local propertyId = mw.ustring.match( propertySelector, '^[Pp]%d+' )
if not propertyId then
propertyId = ''
end
local initPos = #propertyId + 1
propertyId = string.upper( propertyId )

if ( not allClaims ) then
return nil
end
local allPropertyClaims = allClaims[propertyId]
if ( not allPropertyClaims ) then
return nil
end

local rules = p.matchSelectors( propertySelector, initPos )

local isRanked = false
for i, subRules in ipairs( rules ) do
for j, rule in ipairs( subRules ) do
if rule['type'] == 'rank' then
isRanked = true
break
end
end
end
if not isRanked then
table.insert( rules, 1, { { type = 'rank', value = 'best' } } )
end

allPropertyClaims = p.applyRules( allPropertyClaims, rules )

return allPropertyClaims
end

--[[
Сбор правил селекторов
]]
function p.matchSelectors( selectorsString, initPos )
local rules = {}
local rawRulePattern = '^%s*%[%s*[^%[%]]+%s*%]%s*'
local rulePattern = '^%s*%[%s*([^%[%]]+)%s*%]%s*$'

if not initPos then
initPos = 1
end

local rawRule = mw.ustring.match( selectorsString, rawRulePattern, initPos )

while rawRule do
initPos = initPos + #rawRule
local rule = mw.ustring.match( rawRule, rulePattern )
rule = mw.text.trim( rule )

local subRules = mw.text.split( rule, '%s*,%s*' )
local commands = {}

for i, subRule in ipairs( subRules ) do
local isInversed = false
if mw.ustring.match( subRule, '^!' ) then
isInversed = true
subRule = mw.ustring.match( subRule, '^!%s*(.+)$' )
end

if mw.ustring.match( subRule, '^%d+$' ) then
table.insert( commands, {
type = 'position',
value = subRule,
inversed = isInversed
} )

elseif mw.ustring.match( subRule, '^rank%s*:%s*(%a+)$' ) then
local rank = mw.ustring.match( subRule, '^rank%s*:%s*(%a+)$' )
table.insert( commands, {
type = 'rank',
value = rank,
inversed = isInversed
} )

elseif mw.ustring.match( subRule, '^language%s*:%s*([%a%-]+)$' ) then
local value = mw.ustring.match( subRule, '^language%s*:%s*([%a%-]+)$' )
table.insert( commands, {
type = 'language',
value = value,
inversed = isInversed
} )

elseif mw.ustring.match( subRule, '^language%s*!:%s*([%a%-]+)$' ) then
local value = mw.ustring.match( subRule, '^language%s*!:%s*([%a%-]+)$' )
table.insert( commands, {
type = 'language',
value = value,
inversed = not isInversed
} )

elseif mw.ustring.match( subRule, '^min$' ) then
table.insert( commands, { type = 'value_min' } )

elseif mw.ustring.match( subRule, '^max$' ) then
table.insert( commands, { type = 'value_max' } )

elseif mw.ustring.match( subRule, '^min%s*:%s*[Pp]%d+$' ) then
local value = mw.ustring.match( subRule, ':%s*([Pp]%d+)$' )
table.insert( commands, {
type = 'qualifier_min',
qualifier = value
} )

elseif mw.ustring.match( subRule, '^max%s*:%s*[Pp]%d+$' ) then
local value = mw.ustring.match( subRule, ':%s*([Pp]%d+)$' )
table.insert( commands, {
type = 'qualifier_max',
qualifier = value
} )

elseif mw.ustring.match( subRule, '^unit%s*:%s*[^%[%],:]+$' ) then
local value = mw.ustring.match( subRule, ':%s*([^%[%],:]+)$' )
table.insert( commands, {
type = 'unit',
value = value,
inversed = isInversed
} )

elseif mw.ustring.match( subRule, '^unit%s*!:%s*[^%[%],:]+$' ) then
local value = mw.ustring.match( subRule, '!:%s*([^%[%],:]+)$' )
table.insert( commands, {
type = 'unit',
value = value,
inversed = not isInversed
} )

elseif mw.ustring.match( subRule, '^[Pp]%d+$' ) then
local qualifier = mw.ustring.match( subRule, '^[Pp]%d+' )
table.insert( commands, {
type = 'qualifier',
qualifier = qualifier,
value = nil,
inversed = isInversed
} )

elseif mw.ustring.match( subRule, '^[Pp]%d+%s*:%s*[^%[%],:]+$' ) then
local qualifier = mw.ustring.match( subRule, '^([Pp]%d+)%s*:?' )
local value = mw.ustring.match( subRule, ':%s*([^%[%],:]+)$' )
table.insert( commands, {
type = 'qualifier',
qualifier = qualifier,
value = value,
inversed = isInversed
} )

elseif mw.ustring.match( subRule, '^[Pp]%d+%s*!:%s*[^%[%],:]+$' ) then
local qualifier = mw.ustring.match( subRule, '^([Pp]%d+)%s*!:?' )
local value = mw.ustring.match( subRule, '!:%s*([^%[%],:]+)$' )
table.insert( commands, {
type = 'qualifier',
qualifier = qualifier,
value = value,
inversed = not isInversed
} )

elseif mw.ustring.match( subRule, '^[Qq]%d+$' ) then
local value = mw.ustring.match( subRule, '^[Qq]%d+' )
table.insert( commands, {
type = 'value',
value = value,
inversed = isInversed
} )
else
-- Игнорируем неизвестные условия, вместо того чтобы крашить парсер
mw.log( i18n.errors['cant-parse-condition'] )
end
end

if #commands > 0 then
table.insert( rules, commands )
end

rawRule = mw.ustring.match( selectorsString, rawRulePattern, initPos )
end

return rules
end

--[[
Перехват и фильтрация утверждений
]]
function p.applyRules( claims, rules )
for i, subRules in ipairs( rules ) do
local newClaims = {}
for j, rule in ipairs( subRules ) do
if rule['type'] == 'rank' then
table.insert( newClaims, p.filterByRank( claims, rule['value'], rule['inversed'] ) )
elseif rule['type'] == 'language' then
table.insert( newClaims, p.filterByLanguage( claims, rule['value'], rule['inversed'] ) )
elseif rule['type'] == 'unit' then
table.insert( newClaims, p.filterByUnit( claims, rule['value'], rule['inversed'] ) )
elseif rule['type'] == 'position' then
table.insert( newClaims, p.filterByPosition( claims, rule['value'], rule['inversed'] ) )
elseif rule['type'] == 'qualifier' then
table.insert( newClaims, p.filterByQualifier( claims, rule['qualifier'], rule['value'], rule['inversed'] ) )
elseif rule['type'] == 'qualifier_min' then
table.insert( newClaims, p.filterUtterByQualifier( claims, rule['qualifier'], true ) )
elseif rule['type'] == 'qualifier_max' then
table.insert( newClaims, p.filterUtterByQualifier( claims, rule['qualifier'], false ) )
elseif rule['type'] == 'value' then
table.insert( newClaims, p.filterByValue( claims, rule['value'], rule['inversed'] ) )
elseif rule['type'] == 'value_min' then
table.insert( newClaims, p.filterUtter( claims, true ) )
elseif rule['type'] == 'value_max' then
table.insert( newClaims, p.filterUtter( claims, false ) )
end
end
claims = {}

for j, newSubClaims in ipairs( newClaims ) do
for k, newClaim in ipairs( newSubClaims ) do
local isNew = true
for l, oldClaim in ipairs( claims ) do
if oldClaim['id'] == newClaim['id'] then
isNew = false
break
end
end
if isNew then
table.insert( claims, newClaim )
end
end
end
end

return claims
end

function p.filterByRank( claims, rank, inversed )
if not inversed then inversed = false end
if not rank then rank = 'best' end

local isValidRank = false
for i, validRank in ipairs( validRanks ) do
if rank == validRank then
isValidRank = true
break
end
end
if not isValidRank then return claims end -- Безопасный возврат вместо ошибки

if rank == 'best' then
rank = 'normal'
for i, statement in pairs( claims ) do
if (statement.rank == 'preferred') then
rank = 'preferred'
break
end
end
end

local resultClaims = {};
for i, statement in pairs( claims ) do
if ( statement.rank == rank ) ~= inversed then
table.insert( resultClaims, statement )
end
end

return resultClaims
end

function p.filterByLanguage( claims, language, inversed )
if not inversed then inversed = false end

local resultClaims = {}
local mulStatement = {}
for i, statement in ipairs( claims ) do
local isMatchLanguage = false
if statement['mainsnak']
and statement['mainsnak']['datavalue']
and statement['mainsnak']['datavalue']['value']
and statement['mainsnak']['datavalue']['value']['language'] then

if statement['mainsnak']['datavalue']['value']['language'] == language then
isMatchLanguage = true
end
if statement['mainsnak']['datavalue']['value']['language'] == 'mul' then
mulStatement = statement
end
end
if isMatchLanguage ~= inversed then
table.insert( resultClaims, statement )
end
end

if next(resultClaims) == nil and next(mulStatement) ~= nil then
table.insert( resultClaims, mulStatement )
end

return resultClaims
end

function p.filterByUnit( claims, unit, inversed )
if not inversed then inversed = false end
unit = 'http://www.wikidata.org/entity/' .. string.upper( unit )

local resultClaims = {}
for i, statement in ipairs( claims ) do
local isMatchUnit = false
if statement['mainsnak']
and statement['mainsnak']['datavalue']
and statement['mainsnak']['datavalue']['value']
and statement['mainsnak']['datavalue']['value']['unit']
and statement['mainsnak']['datavalue']['value']['unit'] == unit then
isMatchUnit = true
end
if isMatchUnit ~= inversed then
table.insert( resultClaims, statement )
break
end
end

return resultClaims
end

function p.filterByPosition( claims, position, inversed )
if not inversed then inversed = false end

local resultClaims = {};
for statementPosition, statement in ipairs( claims ) do
if ( statementPosition == tonumber( position ) ) ~= inversed then
table.insert( resultClaims, statement )
break
end
end

return resultClaims
end

function p.filterByQualifier( claims, qualifierId, value, inversed )
if not inversed then inversed = false end
qualifierId = string.upper( qualifierId )

local resultClaims = {}
for i, statement in ipairs( claims ) do
if statement['qualifiers'] and statement['qualifiers'][qualifierId] then
if value == nil then
if ( #statement['qualifiers'][qualifierId] > 0 ) ~= inversed then
table.insert( resultClaims, statement )
end
else
local isQualifierFound = false
for j, qualifier in ipairs( statement['qualifiers'][qualifierId] ) do
if qualifier['datavalue'] then
local qualifierValue = qualifier['datavalue']['value']
if qualifier['datavalue']['type'] == 'wikibase-entityid' then
qualifierValue = qualifierValue.id
value = string.upper( value )
end

if qualifierValue == value then
isQualifierFound = true
break
end
end
end
if isQualifierFound ~= inversed then
table.insert( resultClaims, statement )
end
end
elseif inversed then
table.insert( resultClaims, statement )
end
end
return resultClaims
end

function p.filterByValue( claims, value, inversed )
inversed = inversed or false

local resultClaims = {}
for i, statement in ipairs( claims ) do
local statementValue
if statement['mainsnak']
and statement['mainsnak']['datavalue']
and statement['mainsnak']['datavalue']['type']
then
statementValue = statement['mainsnak']['datavalue']['value']
if statement['mainsnak']['datavalue']['type'] == 'quantity' then
statementValue = statementValue.amount
end
if statement['mainsnak']['datavalue']['type'] == 'time' then
statementValue = statementValue.time
end
if statement['mainsnak']['datavalue']['type'] == 'wikibase-entityid' then
statementValue = statementValue.id
value = string.upper( value )
end
end

if ( statementValue == value ) ~= inversed then
table.insert( resultClaims, statement )
end
end

return resultClaims
end

function p.filterUtter( claims, asc, inversed )
local resultValue = nil
for i, statement in ipairs( claims ) do
local statementValue
if statement['mainsnak'] and
statement['mainsnak']['datavalue'] and
statement['mainsnak']['datavalue']['type']
then
statementValue = statement['mainsnak']['datavalue']['value']
if statement['mainsnak']['datavalue']['type'] == 'quantity' then
statementValue = statementValue.amount
end
if statement['mainsnak']['datavalue']['type'] == 'time' then
statementValue = statementValue.time
end
if statement['mainsnak']['datavalue']['type'] == 'wikibase-entityid' then
statementValue = statementValue.id
end

if not resultValue or ( statementValue < resultValue ) == asc then
resultValue = statementValue
end
end
end

return p.filterByValue( claims, resultValue, inversed )
end

function p.filterUtterByQualifier( claims, qualifierId, asc )
qualifierId = string.upper( qualifierId )

local resultValue = nil
local resultStatement = nil
for i, statement in ipairs( claims ) do
if not statement['qualifiers'] and not statement['qualifiers'][qualifierId] then
if resultStatement == nil then
resultStatement = statement
end
else
for _, qualifier in ipairs( statement['qualifiers'][qualifierId] ) do
if qualifier['datavalue'] then
local qualifierValue = qualifier['datavalue']['value']
if qualifier['datavalue']['type'] == 'quantity' then
qualifierValue = qualifierValue.amount
end
if qualifier['datavalue']['type'] == 'time' then
qualifierValue = qualifierValue.time
end
if qualifier['datavalue']['type'] == 'wikibase-entityid' then
qualifierValue = qualifierValue.id
end

if not resultValue or ( qualifierValue < resultValue ) == asc then
resultStatement = statement
resultValue = qualifierValue
end
end
end
end
end

if resultStatement then
return { resultStatement }
else
return {}
end
end

return p

Модуль:WikidataSelectors - История изменений