Modulo:Wikidata: differenze tra le versioni

Versione delle 22:55, 16 nov 2014

Versione delle 23:12, 16 nov 2014

Riga 28:

-------------------------------------------------------------------------------

local function formatError( key )

return '<span class="error">' .. i18n.errors[key] .. '</span>'

end

local function formatEntityId( entityId, options, formatting )

if formatting == 'raw' then

return entityId

end

local label = mw.wikibase.label( entityId )

local link = mw.wikibase.sitelink( entityId )

if link then

if label then

Riga 50:

end

local function formatTime( value, options )

local year, month, day

local ret = ''

year, month, day = value.time:match( '.+(%d%d%d%d%d)%-(%d%d)%-(%d%d).+' )

if value.precision == 9 then

ret = tonumber( year )

elseif value.precision == 10 then

ret = mw.getLanguage('it'):formatDate('F Y', tonumber(year) .. '-' .. month)

Riga 70:

end

local function formatGlobecoordinate( value, options )

local ret

if options.formatting == 'latitude' then

Riga 82:

end

local function formatFromPattern( str, options )

-- la parentesi () extra serve per non ritornare anche il gsub.count

return ( mw.ustring.gsub( options.pattern, '$1', str ) )

end

local function getEntityIdFromValue( value )

local prefix = ''

if value['entity-type'] == 'item' then

Riga 94:

prefix = 'P'

else

return formatError( 'unknown-entity-type' )

end

return prefix .. value['numeric-id']

end

local function formatDatavalue( datavalue, options, formatting )

local ret

--Default formatters

if datavalue.type == 'wikibase-entityid' then

ret = formatEntityId( getEntityIdFromValue( datavalue.value ), options, formatting )

elseif datavalue.type == 'string' then

ret = datavalue.value

elseif datavalue.type == 'time' then

ret = formatTime( datavalue.value, options )

elseif datavalue.type == 'globecoordinate' then

ret = formatGlobecoordinate( datavalue.value, options )

elseif datavalue.type == 'quantity' then

ret = tonumber(datavalue.value.amount)

else

ret = formatError( 'unknown-datavalue-type' )

end

Riga 120:

end

local function formatSnak( snak, options, formatting )

if snak.snaktype == 'somevalue' then

return i18n['somevalue']

Riga 126:

return i18n['novalue']

elseif snak.snaktype == 'value' then

return formatDatavalue( snak.datavalue, options, formatting )

else

return formatError( 'unknown-snak-type' )

end

end

local function formatStatement( statement, options )

if not statement.type or statement.type ~= 'statement' then

return formatError( 'unknown-claim-type' )

end

return formatSnak( statement.mainsnak, options )

end

local function formatStatements( claims, options )

--Format statement and concat them cleanly

local formattedStatements = {}

Riga 156:

end

for i, claim in pairs( claims ) do

formattedStatement = formatStatement( claim, options )

-- eventuale pattern

if options.pattern then

formattedStatement = formatFromPattern( formattedStatement, options )

end

table.insert( formattedStatements, formattedStatement )

end

if list_end then table.insert( formattedStatements, list_end ) end

return mw.text.listToText( formattedStatements, options.separator, options.conjunction )

end

Riga 174:

-- Ritorna true se lo statement contiene il qualifier richiesto con un dato valore

local function hasQualifierValue( statement, options )

local ret = false

for i, qualifier in pairs( statement.qualifiers[options.qualifier] ) do

if formatSnak( qualifier, options, 'raw' ) == options.qualifiervalue then

ret = true

break

Riga 186:

-- Ritorna i claim con il rank richiesto

local function filterRankValue( claims, rank )

local ret = {}

for i, claim in pairs( claims ) do

if claim.rank == rank then

table.insert( ret, claim )

end

end

Riga 199:

-- Gli statement ritornati sono eventualmente filtrati in base ai parametri:

-- "rank", "qualifier", "qualifiertype" e "n"

local function getClaims( options )

local entity, claims, filteredClaims

Riga 205:

entity = mw.wikibase.getEntityObject()

if not entity then

error( '' ) -- error(formatError( 'entity-not-found' ))

end

-- get property

if not options.property then

error( formatError( 'property-param-not-provided' ) )

end

Riga 223:

if options.rank then

if options.rank == 'best' then

filteredClaims = filterRankValue( claims, 'preferred' )

if #filteredClaims == 0 then

filteredClaims = filterRankValue( claims, 'normal' )

end

else

filteredClaims = filterRankValue( claims, options.rank )

end

claims = filteredClaims

Riga 239:

if claim.qualifiers and claim.qualifiers[options.qualifier] then

if options.qualifiervalue then

if hasQualifierValue( claim, options ) then

table.insert( filteredClaims, claim )

end

else

table.insert( filteredClaims, claim )

end

end

Riga 253:

if options.qualifier and options.qualifiertype == 'latest' then

local latest, latestTime

for i, claim in pairs( claims ) do

if claim.qualifiers and claim.qualifiers[options.qualifier] then

for j, qualifier in pairs( claim.qualifiers[options.qualifier] ) do

if qualifier.datavalue.type == 'time' then

if not latestTime or qualifier.datavalue.value.time > latestTime then

Riga 265:

end

end

claims = latest and { latest } or {}

end

-- con options.n ritorna solo l'n-esimo elemento

if options.n then

local n = tonumber( options.n )

claims = (n and n <= #claims) and { claims[n] } or {}

end

Riga 284:

-- Entry-point per {{#invoke:Wikidata|formatStatements}}

function p.formatStatements( frame )

local args, ret, claims

args = getArgs( frame, { parentOnly = true } )

-- Per riabilitare eventualmente la chiamata al modulo diretta,

-- pur usando sempre solo getParent per il template, sostituire con:

-- args = getArgs( frame, { wrappers = 'Template:Wikidata' } )

-- parametri posizionali

args.property = args[1] and string.upper( args[1] ) or nil

args.value = args[2]

-- fix uppercase

args.qualifier = args.qualifier and string.upper( args.qualifier ) or nil

-- if parameter value is already set, use it

if args.value then

return args.pattern and formatFromPattern( args.value, args ) or args.value

end

-- get claims

ret, claims = pcall( getClaims, args )

if not ret then

return claims:match( '.+%d:%s(.+)$' )

end

return formatStatements( claims, args )

end

-- Entry-point per {{#invoke:Wikidata|getQualifier}}

function p.getQualifier( frame )

local args, ret, claims, formattedQualifier, formattedQualifiers

args = getArgs( frame, { parentOnly = true } )

-- args = getArgs( frame, { wrappers = 'Template:WikidataQ' } )

-- parametri posizionali

args.property = args[1] and string.upper( args[1] ) or nil

args.qualifier = args[2] and string.upper( args[2] ) or nil

args.value = args[3]

-- if parameter value is already set, use it

if args.value then

return args.pattern and formatFromPattern( args.value, args ) or args.value

end

-- get qualifier name

if not args.qualifier then

return formatError( 'qualifier-param-not-provided' )

end

-- get claims

ret, claims = pcall( getClaims, args )

if not ret then

return claims:match( '.+%d:%s(.+)$' )

end

-- get qualifiers and format them

formattedQualifiers = {}

for i, claim in pairs( claims ) do

if claim.qualifiers and claim.qualifiers[args.qualifier] then

for j, qualifier in pairs( claim.qualifiers[args.qualifier] ) do

formattedQualifier = formatSnak( qualifier, args )

if args.pattern then

formattedQualifier = formatFromPattern( formattedQualifier, args )

end

table.insert( formattedQualifiers, formattedQualifier )

end

end

end

return mw.text.listToText( formattedQualifiers, args.separator, args.conjunction )

end

-- Entry-point per {{#invoke:Wikidata|N}}

function p.N( frame )

local args, entity, property, count

args = getArgs( frame, { parentOnly = true } )

-- args = getArgs( frame, { wrappers = 'Template:WikidataN' } )

-- parametri posizionali

property = args[1] and string.upper( args[1] ) or nil

if not property then

return formatError( 'property-param-not-provided' )

end