"మాడ్యూల్:Italic title" కూర్పుల మధ్య తేడాలు

Jump to navigation Jump to search
replace with an object-based framework, and add a dabonly function for Template:Italic dab
(replace underscores with spaces in namespace names)
(replace with an object-based framework, and add a dabonly function for Template:Italic dab)
-- This module implements {{italic title}}.
 
require('Module:No globals')
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local checkTypeForNamedArg = libraryUtil.checkTypeForNamedArg
local yesno = require('Module:Yesno')
 
--------------------------------------------------------------------------------
-- ItalicTitle class
--------------------------------------------------------------------------------
 
local ItalicTitle = {}
 
do
----------------------------------------------------------------------------
-- Class attributes and functions
-- Things that belong to the class are here. Things that belong to each
-- object are in the constructor.
----------------------------------------------------------------------------
 
-- Keys of title parts that can be italicized.
local italicizableKeys = {
namespace = true,
title = true,
dab = true,
}
 
----------------------------------------------------------------------------
-- ItalicTitle constructor
-- This contains all the dynamic attributes and methods.
----------------------------------------------------------------------------
 
function ItalicTitle.new()
local obj = {}
 
-- Function for checking self variable in methods.
local checkSelf = libraryUtil.makeCheckSelfFunction(
'ItalicTitle',
'obj',
obj,
'ItalicTitle object'
)
 
-- Checks a key is present in a lookup table.
-- Param: name - the function name.
-- Param: argId - integer position of the key in the argument list.
-- Param: key - the key.
-- Param: lookupTable - the table to look the key up in.
local function checkKey(name, argId, key, lookupTable)
if not lookupTable[key] then
error(string.format(
"bad argument #%d to '%s' ('%s' is not a valid key)",
argId,
name,
key
), 3)
end
end
 
-- Set up object structure.
local parsed = false
local categories = {}
local italicizedKeys = {}
local italicizedSubstrings = {}
 
-- Parses a title object into its namespace text, title, and
-- disambiguation text.
-- Param: options - a table of options with the following keys:
-- title - the title object to parse
-- ignoreDab - ignore any disambiguation parentheses
-- Returns the current object.
function obj:parseTitle(options)
checkSelf(self, 'parseTitle')
checkType('parseTitle', 1, options, 'table')
checkTypeForNamedArg('parseTitle', 'title', options.title, 'table')
local title = options.title
-- Title and dab text
local prefix, parentheses
if not options.ignoreDab then
prefix, parentheses = mw.ustring.match(
title.text,
'^(.+) %(([^%(%)]+)%)$'
)
end
if prefix and parentheses then
self.title = prefix
self.dab = parentheses
else
self.title = title.text
end
-- Namespace
local namespace = mw.site.namespaces[title.namespace].name
if namespace and #namespace >= 1 then
self.namespace = namespace
end
 
-- Register the object as having parsed a title.
parsed = true
return self
end
 
-- Italicizes part of the title.
-- Param: key - the key of the title part to be italicized. Possible
-- keys are contained in the italicizableKeys table.
-- Returns the current object.
function obj:italicize(key)
checkSelf(self, 'italicize')
checkType('italicize', 1, key, 'string')
checkKey('italicize', 1, key, italicizableKeys)
italicizedKeys[key] = true
return self
end
 
-- Un-italicizes part of the title.
-- Param: key - the key of the title part to be un-italicized. Possible
-- keys are contained in the italicizableKeys table.
-- Returns the current object.
function obj:unitalicize(key)
checkSelf(self, 'unitalicize')
checkType('unitalicize', 1, key, 'string')
checkKey('unitalicize', 1, key, italicizableKeys)
italicizedKeys[key] = nil
return self
end
 
-- Italicizes a substring in the title. This only affects the main part
-- of the title, not the namespace or the disambiguation text.
-- Param: s - the substring to be italicized.
-- Returns the current object.
function obj:italicizeSubstring(s)
checkSelf(self, 'italicizeSubstring')
checkType('italicizeSubstring', 1, s, 'string')
italicizedSubstrings[s] = true
return self
end
 
-- Un-italicizes a substring in the title. This only affects the main
-- part of the title, not the namespace or the disambiguation text.
-- Param: s - the substring to be un-italicized.
-- Returns the current object.
function obj:unitalicizeSubstring(s)
checkSelf(self, 'unitalicizeSubstring')
checkType('unitalicizeSubstring', 1, s, 'string')
italicizedSubstrings[s] = nil
return self
end
 
-- Renders the object into a page name. If no title has yet been parsed,
-- the current title is used.
-- Returns string
function obj:renderTitle()
checkSelf(self, 'renderTitle')
 
-- Italicizes a string
-- Param: s - the string to italicize
-- Returns string.
local function italicize(s)
assert(type(s) == 'string', 's was not a string')
assert(s ~= '', 's was the empty string')
return string.format('<i>%s</i>', s)
end
-- Escape characters in a string that are magic in Lua patterns.
-- Param: pattern - the pattern to escape
-- Returns string.
local function escapeMagicCharacters(s)
assert(type(s) == 'string', 's was not a string')
return s:gsub('%p', '%%%0')
end
 
-- If a title hasn't been parsed yet, parse the current title.
if not parsed then
self:parseTitle{title = mw.title.getCurrentTitle()}
end
 
-- Italicize the different parts of the title and store them in a
-- titleParts table to be joined together later.
local titleParts = {}
 
-- Italicize the italicizable keys.
for key in pairs(italicizableKeys) do
if self[key] then
if italicizedKeys[key] then
titleParts[key] = italicize(self[key])
else
titleParts[key] = self[key]
end
end
end
 
-- Italicize substrings. If there are any substrings to be
-- italicized then start from the raw title, as this overrides any
-- italicization of the main part of the title.
if next(italicizedSubstrings) then
titleParts.title = self.title
for s in pairs(italicizedSubstrings) do
local pattern = escapeMagicCharacters(s)
local italicizedTitle, nReplacements = titleParts.title:gsub(
pattern,
italicize
)
titleParts.title = italicizedTitle
 
-- If we didn't make any replacements then it means that we
-- have been passed a bad substring or that the page has
-- been moved to a bad title, so add a tracking category.
if nReplacements < 1 then
categories['Pages using italic title with no matching string'] = true
end
end
end
 
-- Assemble the title together from the parts.
local ret = ''
if titleParts.namespace then
ret = ret .. titleParts.namespace .. ':'
end
ret = ret .. titleParts.title
if titleParts.dab then
ret = ret .. ' (' .. titleParts.dab .. ')'
end
 
return ret
end
 
-- Returns an expanded DISPLAYTITLE parser function called with the
-- result of obj:renderTitle, plus any other optional arguments.
-- Returns string
function obj:renderDisplayTitle(...)
checkSelf(self, 'renderDisplayTitle')
return mw.getCurrentFrame():callParserFunction(
'DISPLAYTITLE',
self:renderTitle(),
...
)
end
 
-- Returns an expanded DISPLAYTITLE parser function called with the
-- result of obj:renderTitle, plus any other optional arguments, plus
-- any tracking categories.
-- Returns string
function obj:render(...)
checkSelf(self, 'render')
local ret = self:renderDisplayTitle(...)
for cat in pairs(categories) do
ret = ret .. string.format(
'[[Category:%s]]',
cat
)
end
return ret
end
 
return obj
end
end
 
--------------------------------------------------------------------------------
-- Exports
--------------------------------------------------------------------------------
 
local p = {}
 
local function p._maingetArgs(args, frame, titlewrapper)
assert(type(wrapper) == 'string', 'wrapper was not a string')
args = args or {}
return require('Module:Arguments').getArgs(frame, {
frame = frame or mw.getCurrentFrame()
wrappers = wrapper
title = title or mw.title.getCurrentTitle()
})
local prefix, parentheses = mw.ustring.match(title.text, '^(.+) (%([^%(%)]+%))$')
end
local result
 
if prefix and parentheses and args.all ~= 'yes' then
-- Main function for {{italic title}}
result = string.format("<i>%s</i> %s", prefix, parentheses)
function p._main(args)
checkType('_main', 1, args, 'table')
local italicTitle = ItalicTitle.new()
italicTitle:parseTitle{
title = mw.title.getCurrentTitle(),
ignoreDab = yesno(args.all, false)
}
if args.string then
italicTitle:italicizeSubstring(args.string)
else
italicTitle:italicize('title')
result = string.format("<i>%s</i>", title.text)
end
return italicTitle:render(args[1])
if title.namespace ~= 0 then
result = title.nsText:gsub('_', ' ') .. ':' .. result
end
return frame:callParserFunction('DISPLAYTITLE', result, args[1])
end
 
function p.main(frame)
localreturn args = require('Module:Arguments')p._main(getArgs(frame, {'Template:Italic title'))
wrappers = 'Template:Italic title'
})
return p._main(args, frame)
end
 
function p._dabonly(args)
return ItalicTitle.new()
:italicize('dab')
:render(args[1])
end
 
function p.dabonly(frame)
return p._dabonly(getArgs(frame, 'Template:Italic dab'))
end
 
 
return p
"https://te.wikipedia.org/wiki/ప్రత్యేక:MobileDiff/2042356" నుండి వెలికితీశారు

మార్గదర్శకపు మెనూ