Modulo:Software: differenze tra le versioni

Versione delle 00:19, 15 mar 2017

Versione delle 17:00, 18 mar 2017

Riga 55:

local function count(t)

local i = 0

for _,___ in pairs(t) do

i = i + 1

end

Riga 69:

end

local function onlySoftwareArguments(frame)

------------------------------- Frontend ---------------------------------------

return getArgs(frame, {wrappers = 'Template:Software'} )

end

--[[

function p.isFreeSoftware(frame)

* Restituisce SOLO l'argomento da dare in pasto a varie funzioni del Modulo:Wikidata

return yesNoNil( p._isFreeSoftware(frame) )

*

* @paramreturn string license|nil

]]

local function fromItem(frame)

return getArgs(frame).from

end

------------------------------- Frontend ---------------------------------------

function p.shouldHaveALanguage(frame)

return yesNo( p._shouldHaveALanguage( onlySoftwareArguments(frame) ) )

end

function p.hasAFreeLicensespecifiesALanguage(frame)

return yesNoNilyesNo( p._hasAFreeLicense_specifiesALanguage( onlySoftwareArguments(frame) ) )

end

function p.hasAProprietaryLicenseisFreeSoftware(frame)

return yesNoNil( p._hasAProprietaryLicense_isFreeSoftware( onlySoftwareArguments(frame) ) )

end

function p.specifiesALanguagehasAFreeLicense(frame)

return yesNoyesNoNil( p._specifiesALanguage_hasAFreeLicense( fromItem(frame) ) )

end

function p.hasAProprietaryLicense(frame)

return yesNoNil( p._isFreeSoftware_hasAProprietaryLicense( fromItem(frame) ) )

end

--[[

* Categorizzazione.

*

* @return string|nil

* ]]

function p.categories(frame)

if not p._categorize( getArgs(frame) ) then

return

end

return p.licenseCategories(frame)

end

--[[

function p.licenseCategories()

* Categorie legate alle licenze.

* @return string

]]

function p.isFreeSoftwarelicenseCategories(frame)

local s = ''

for i, l in pairs( p._licenses( fromItem(frame) ) ) do

l = mWikidata._formatStatement(l, {formatting = 'raw'})

l = conf.licenseCategory[l]

Line 114 ⟶ 132:

end

--[[

* Licenze.

* @return string

]]

function p.licenses(frame)

local s = ''

for i, l in pairs( p._licenses( fromItem(frame) ) ) do

local space = i == 1 and '' or '<br />'

s = s .. space .. mWikidata._formatStatement(l, {formatting = 'raw'})

Line 123 ⟶ 145:

end

--[[

* Linguaggi di programmazione.

*

* @return string

]]

function p.languages(frame)

local s = ''

local args = frame and getArgsonlySoftwareArguments(frame)

--[[

* Argomenti ereditati dal Template:Software e da Wikidata

]]

local args = frame and getArgs(frame)

local categorizza = args['Categorie']

local libero = p.isFreeSoftware(frame)

--[[

* Linguaggi dal Template:Software e da Wikidata

]]

local tl_has = p._templateHasLanguages(frameargs) and true or false

local tl_languages = p._getTemplateLanguages(frameargs)

local wd_languages = mWikidata._getClaims('P277')

local altri = args['LinguaggioAltri']

-- È il namespace principale?

Line 180 ⟶ 201:

else

-- No, `#var` non fa quello che uno si aspetterebbe

if p._templateHasExtraInformations(frameargs) or count(tl_languages) > count(wd_languages) then

-- Nel template c'è qualcosa in più rispetto a Wikidata

s = s .. '[[Categoria:Linguaggio di programmazione differente da Wikidata]]'

Line 209 ⟶ 230:

local i = 0

local liberosoftwareLiberoSiNo = p.isFreeSoftware(frameargs)

for language, note in pairs(tl_languages) do

local glue = i > 0 and '<br />' or ''

s = s .. glue .. frame:expandTemplate{

title = 'Software/Linguaggio',

args = {language, categorizzaargs['Categorie'], liberosoftwareLiberoSiNo}

} .. note

i = i + 1

end

if altriargs['LinguaggioAltri'] then

s = s .. altriargs['LinguaggioAltri']

end

Line 232 ⟶ 254:

* @return true|false|nil

]]

function p._isFreeSoftware(frameargs)

local is_wd = p._isFreeSoftwareByWikidata()

local isnt_wd = p._isProprietarySoftwareByWikidata()

local is_tp = p._isFreeSoftwareByTemplate(frameargs)

local is = nil

if is_wd then

Line 270 ⟶ 293:

* Per quanto riguarda Wikidata è ridondante col campo licenza P275.

*

* @param string from Wikidata item

* @return true|false

]]

function p._isFreeSoftwareByWikidata(from)

-- Q341 free software

-- Q1130645 open-source software

return mWikidata._instanceOf({'Q341', 'Q1130645', from = from}) or p._hasAFreeLicense(from)

end

Line 283 ⟶ 307:

* Per quanto riguarda Wikidata è ridondante col campo licenza P275.

*

* @param from string Wikidata item

* @return true|false

]]

function p._isProprietarySoftwareByWikidata(from)

-- Q218616 proprietary software

-- Q178285 freeware TODO: impropria, subclass of precedente

return mWikidata._instanceOf({'Q218616', 'Q178285', from = from}) or p._hasAProprietaryLicense(from)

end

Line 296 ⟶ 321:

* @return nil|true|false

--]]

function p._isFreeSoftwareByTemplate(frameargs)

local is = nil

local args = frame and getArgs(frame)

local v = args['SoftwareLibero']

if v then

Line 312 ⟶ 336:

* @return true|nil

]]

function p._shouldHaveALanguage(frameargs)

return p._isFreeSoftware(frameargs) or p._specifiesALanguage(frameargs)

end

Line 321 ⟶ 345:

* @return truly|nil

]]

function p._specifiesALanguage(frameargs)

return p._templateHasLanguages(frameargs) or mWikidata._getClaims('P277')

local args = frame and getArgs(frame)

return p._templateHasLanguages(frame) or mWikidata._getClaims('P277')

end

Line 331 ⟶ 354:

* @return truly|nil

]]

function p._templateHasLanguages(frameargs)

local args = frame and getArgs(frame)

return args['Linguaggio'] or args['NotaLinguaggio'] or args['LinguaggioAltri']

end

Line 341 ⟶ 363:

* @return truly|nil

]]

function p._templateHasExtraInformations(frameargs)

local args = frame and getArgs(frame)

return args['LinguaggioAltri'] or args['NotaLinguaggio'] or args['NotaLinguaggio2'] or args['NotaLinguaggio3']

end

Line 353 ⟶ 374:

* 'c++' → 'c++'

*

* @param string

* @see Template:Software/Linguaggio

* @return string

Line 368 ⟶ 390:

* @return string[] = 'c' => 'nota linguaggio c', 'c++' = '', ..

]]

function p._getTemplateLanguages(frameargs)

local languages = {}

local args = frame and getArgs(frame)

local v = args['Linguaggio']

if v then

Line 385 ⟶ 406:

--[[

* Questa licenza è una classe radicedirettamente identificabile?

*

* @param license string Wikidata item

* @return FREE|PROPRIETARY|UNKNOWN

* ]]

function p._singleLicenseType(license)

-- Q3943414 free software license

Line 407 ⟶ 428:

* Fra queste licenze c'è una classe radice identificabile?

*

* @param license string Wikidata item

* @return FREE|PROPRIETARY|UNKNOWN

* ]]

Line 434 ⟶ 455:

* per casi peggiori.

*

* @param license string Wikidata item

* @param int i int|nil Livello di

* @see Modulo:Software/man#Considerazioni implementative

* @param string license

* @param int i Livello di

* @return UNKNOWN|FREE|PROPRIETARY

]]

Line 505 ⟶ 526:

* Licenze da Wikidata.

*

* @param from string|nil Wikidata item

* @return table|nil

]]

local _licenses_cache = false

function p._licenses(from)

if _licenses_cache == false then

_licenses_cache = mWikidata._getClaims('P275', {from = from}) or {}

end

return _licenses_cache

Line 516 ⟶ 538:

--[[

* Ha una licenza di un certo tipo di licenza?

*

* @param type FREE|PROPRIETARY|UNKNOWN

* @param from string|nil Wikidata item

* @return true|false

]]

function p._hasALicenseOfType(type, from)

for _, l in pairs( p._licenses(from) ) do

l = mWikidata._formatStatement(l, {formatting = 'raw'})

if p._licenseType(l) == type then

Line 532 ⟶ 555:

--[[

* La voce ha almeno una licenza di software libero in Wikidata?

*

* @param from string|nil Wikidata item

* @return true|false

]]

function p._hasAFreeLicense(from)

return p._hasALicenseOfType(FREE, from)

end

--[[

* La voce ha almeno una licenza di software proprietario in Wikidata?

*

* @param from string|nil Wikidata item

* @return true|false

]]

function p._hasAProprietaryLicense(from)

return p._hasALicenseOfType(PROPRIETARY, from)

end

Line 554 ⟶ 579:

* Albero inverso di Modulo:Software/Configurazione

*

* 'cpp'@param →string E.g. 'Q2407cpp'

* @return string|nil E.g. 'Q2407'

]]

local _languageSlugToWikidata = {}

Line 576 ⟶ 601:

--[[

* Categorizzare?

*

*@return true|false

]]

function p._categorize(frameargs)

local args = frame and getArgs(frame)

local v = args['Categorie']

if v then