Wikipedia

Module:Asbox

Module documentation [view] [edit] [history] [purge]

Usage

This module implements the {{Asbox}} template. Please see the template page for usage instructions.



Acknowledgements

In addition to the contributors listed in the contribution histories of Template:Asbox and Module:Asbox, this module also implements ideas from the deleted Template:Asbox/templatepage, which primary author is User:MSGJ and included code contributions from User:WOSlinker, and User:Od_Mishehu.

Tracking category

        
        --[[
        This module was created by User:CodeHydro (Alexander Zhikun He).
        User:Jackmcbarn and User:Mr._Stradivarius provided a great deal of assistance in writting p.main()
        p.main() draw heavily from the following version of Template:Asbox of the English Wikipedia, authored primarily by User:Rich_Farmbrough
        https://en.wikipedia.org/w/index.php?title=Template:Asbox&oldid=619510287
        p.templatepage() is derived from the following revision of Template:Asbox/templatepage, authored primarily by User:MSGJ
        https://en.wikipedia.org/w/index.php?title=Template:Asbox/templatepage&oldid=632914791
        Both templates had significant contributions from numerous others listed in the revision history tab of their respective pages.
        --]]
        local
        WRAPPER_TEMPLATE
        ,
        args
        =
        'Template:Asbox'
        local
        p
        ,
        Buffer
        ,
        stubCats
        =
        {
        --Prevents dupli-cats... get it? Maybe not?
        cats
        =
        setmetatable
        ({},
        {
        __newindex
        =
        function
        (
        t
        ,
        i
        ,
        v
        )
        if
        not
        rawget
        (
        t
        ,
        i
        )
        then
        rawset
        (
        t
        ,
        i
        ,
        v
        )
        table.insert
        (
        t
        ,
        i
        )
        end
        end
        }),
        --initializes variables required by both p.main and p.templatepage
        init
        =
        function
        (
        self
        ,
        frame
        ,
        page
        )
        args
        ,
        page
        =
        args
        or
        require
        (
        'Module:Arguments'
        ).
        getArgs
        (
        frame
        ,
        {
        wrappers
        =
        WRAPPER_TEMPLATE
        }),
        page
        or
        mw
        .
        title
        .
        getCurrentTitle
        ()
        --Ensures demo parameter will never affect category() output for articles
        self
        .
        demo
        =
        self
        .
        demo
        or
        page
        .
        namespace
        ~=
        0
        and
        args
        .
        demo
        return
        args
        ,
        page
        end
        },
        require
        (
        'Module:Buffer'
        )
        --[[
        Formats category links. Stores them until called with cat.done=true
        Takes multiple or single categories in the form of 'cat'
        or a table of strings and/or tables containing parts. (See below)
        ]]
        local
        attention
        ,
        catTag
        ,
        catKey
        =
        Buffer
        'Stub message templates needing attention'
        ,
        '[[Category:%s]]'
        ,
        '%s|%s%s'
        local
        function
        category
        (
        cat
        )
        for
        _
        ,
        v
        in
        ipairs
        ((
        tostring
        (
        cat
        )
        ==
        cat
        or
        cat
        .
        t
        )
        and
        {
        cat
        }
        or
        cat
        )
        do
        --[[
        		If v is a table:
        			[1] = full category name; defaults to local attention if blank
        			k = Category sort key. Prefix before v.t
        			t = page.text or args.tempsort#; appended after k (or in its place if omitted). Required if v is not a string
        		Basically the same as v = (v[1] or attention) .. ' | ' .. (v.k or '') .. v.t
        		]]
        if
        v
        and
        v
        ~=
        true
        then
        --reject v = nil, false, or true
        p
        .
        cats
        [
        catTag
        :
        format
        (
        tostring
        (
        v
        )
        ==
        v
        and
        v
        or
        (
        v
        [
        1
        ]
        and
        Buffer
        (
        v
        [
        1
        ])
        or
        attention
        ):
        _in
        (
        v
        .
        k
        ):
        _
        (
        v
        .
        t
        ):
        _str
        (
        2
        ,
        nil
        ,
        nil
        ,
        '|'
        )
        )]
        =
        true
        end
        end
        return
        cat
        .
        done
        and
        table.concat
        (
        p
        .
        cats
        ,
        p
        .
        demo
        and
        ' | '
        or
        nil
        )
        or
        ''
        end
        --[[
        Makes an ombox warning;
        Takes table {ifNot = Boolean, text, {cat. sort key, cat. sort name}}
        Will return an empty string instead when ifNot evaluates to true 
        ]]
        local
        function
        ombox
        (
        v
        )
        if
        v
        .
        ifNot
        then
        return
        end
        p
        .
        ombox
        =
        p
        .
        ombox
        or
        require
        (
        'Module:Message box'
        ).
        ombox
        category
        {
        v
        [
        2
        ]}
        return
        p
        .
        ombox
        {
        type
        =
        'content'
        ,
        text
        =
        v
        [
        1
        ]
        }
        end
        --[[
        Unlike original template, module now takes unlimited cats! This function also performs
        most stub category error checks except for the ombox for when main |category= is omitted (See p.template())
        ]]
        local
        function
        catStub
        (
        page
        ,
        pageDoc
        )
        stubCats
        =
        {
        missing
        =
        {},
        v
        =
        {}}
        local
        code
        for
        k
        ,
        _
        in
        pairs
        (
        args
        )
        do
        --Find category parameters and store the number (main cat = '')
        table.insert
        (
        stubCats
        ,
        string.match
        (
        k
        ,
        '^category(%d*)$'
        ))
        end
        table.sort
        (
        stubCats
        )
        for
        k
        ,
        v
        in
        ipairs
        (
        stubCats
        )
        do
        --Get category names and, if called by p.templatepage, the optional sort key
        local
        tsort
        ,
        cat
        =
        args
        [
        'tempsort'
        ..
        v
        ],
        mw
        .
        ustring
        .
        gsub
        (
        args
        [
        'category'
        ..
        v
        ],
        '[^%w%p%s]'
        ,
        ''
        )
        --remove all hidden unicode chars 
        --Do not place template in main category if |tempsort = 'no'. However, DO place articles of that template in the main category.
        table.insert
        (
        stubCats
        .
        v
        ,
        page
        and
        (
        --p.templatepage passes page; p.main does not, i.e. articles are categorized without sort keys.
        v
        ==
        ''
        and
        tsort
        ==
        'no'
        --if true, inserts 'true' in table, which category() will reject
        or
        tsort
        and
        {
        cat
        ,
        k
        =
        ' '
        ,
        t
        =
        tsort
        }
        or
        {
        cat
        ,
        k
        =
        ' *'
        ,
        t
        =
        page
        .
        text
        }
        --note space in front of sort key
        )
        or
        cat
        )
        --Check category existance only if on the template page (i.e. stub documentation)
        if
        page
        then
        if
        not
        mw
        .
        title
        .
        new
        (
        'Category:'
        ..
        cat
        ).
        exists
        then
        code
        =
        code
        or
        mw
        .
        html
        .
        create
        'code'
        :
        wikitext
        '|category'
        table.insert
        (
        stubCats
        .
        missing
        ,
        tostring
        (
        mw
        .
        clone
        (
        code
        ):
        wikitext
        (
        v
        )))
        end
        --[[
        			Checks non-demo stub template for documentation and flags if doc is present.
        			All stub cats names are checked and flagged if it does not match 'Category: [] stub'.
        			The main stub cat is exempt from the name check if the stub template has its own doc
        			(presumably, this doc would have an explanation as to why the main stub cat is non-conforming).
        			]]
        table.insert
        (
        stubCats
        .
        v
        ,
        v
        ==
        ''
        and
        not
        p
        .
        demo
        and
        pageDoc
        .
        exists
        and
        'Stub message templates with documentation subpages'
        or
        not
        cat
        :
        match
        ' stubs$'
        and
        {
        k
        =
        'S'
        ,
        t
        =
        page
        .
        text
        }
        )
        end
        end
        --Add category names after loop is completed
        category
        (
        stubCats
        .
        v
        )
        return
        #
        stubCats
        .
        missing
        >
        0
        and
        ombox
        {
        --Changed, original msg:
        --One or more of the stub categories defined in this template do not seem to exist!
        --Please double-check the parameters {{para|category}}, {{para|category1}} and {{para|category2}}.
        'The following parameter'
        ..
        (
        #
        stubCats
        .
        missing
        ==
        1
        and
        ' defines a stub category that does'
        or
        's define stub categories that do'
        )
        ..
        ' not exist: '
        ..
        mw
        .
        text
        .
        listToText
        (
        stubCats
        .
        missing
        ),
        {
        k
        =
        'N'
        ,
        t
        =
        page
        .
        text
        }
        }
        end
        --Shows population of categories found by catStub(). Outputs demo values if none
        local
        function
        population
        ()
        local
        wikitext
        ,
        base
        =
        {},
        '* [[:Category:%s]] (population: %s)
        \n
        '
        if
        not
        args
        .
        category
        and
        stubCats
        [
        1
        ]
        ~=
        false
        then
        table.insert
        (
        stubCats
        ,
        1
        ,
        false
        )
        end
        for
        _
        ,
        v
        in
        ipairs
        (
        stubCats
        )
        do
        table.insert
        (
        wikitext
        ,
        base
        :
        format
        (
        v
        and
        args
        [
        'category'
        ..
        v
        ]
        or
        '{{{category}}}'
        ,
        v
        and
        mw
        .
        site
        .
        stats
        .
        pagesInCategory
        (
        args
        [
        'category'
        ..
        v
        ],
        'all'
        )
        or
        0
        ))
        end
        return
        table.concat
        (
        wikitext
        )
        end
        --Includes standard stub documention and flags stub templates with bad parameter values.
        function
        p
        .
        templatepage
        (
        frame
        ,
        page
        )
        args
        ,
        page
        =
        p
        :
        init
        (
        frame
        ,
        page
        )
        local
        tStubDoc
        =
        mw
        .
        title
        .
        new
        'Template:Stub documentation'
        local
        pageDoc
        =
        page
        :
        subPageTitle
        (
        'doc'
        )
        --Reorganization note: Original Asbox alternates between outputting categories and checking on params |category#=.
        --Rather than checking multiple times and switching tasks, all stub category param operations have been rolled into catStub()
        return
        Buffer
        (
        ombox
        {
        --Show ombox warnings for missing args.
        ifNot
        =
        args
        .
        category
        ,
        'The <code>|category</code> parameter is not set. Please add an appropriate stub category.'
        ,
        {
        k
        =
        'C'
        ,
        t
        =
        page
        .
        text
        }
        })
        :
        _
        (
        ombox
        {
        ifNot
        =
        args
        .
        subject
        or
        args
        .
        article
        or
        args
        .
        qualifier
        ,
        'This stub template contains no description! At least one of the parameters <code>|subject</code>, <code>|article</code> or <code>|qualifier</code> must be defined.'
        ,
        {
        k
        =
        'D'
        ,
        t
        =
        page
        .
        text
        }
        })
        :
        _
        (
        catStub
        (
        page
        ,
        pageDoc
        ))
        --catStub() may also return an ombox if there are non-existing categories
        :
        _
        (
        category
        {
        done
        =
        p
        .
        demo
        ~=
        'doc'
        ,
        --Outputs categories if not doc demo
        'Stub message templates'
        ,
        'Exclude in print'
        ,
        args
        .
        icon
        and
        'Stub message templates using icon parameter'
        or
        args
        .
        image
        and
        (
        mw
        .
        title
        .
        new
        (
        'Media:'
        ..
        mw
        .
        text
        .
        split
        (
        args
        .
        image
        ,
        '|'
        )[
        1
        ]).
        exists
        --do nothing if exists. category() will reject true
        or
        {
        k
        =
        'B'
        ,
        t
        =
        page
        .
        text
        }
        )
        or
        'Stub message templates without images'
        ,
        args
        .
        imagealt
        and
        {
        k
        =
        'I'
        ,
        t
        =
        page
        .
        text
        },
        })
        :
        _
        ((
        not
        p
        .
        demo
        or
        p
        .
        demo
        ==
        'doc'
        )
        and
        --Add standard stub template documentation
        require
        (
        'Module:Documentation'
        ).
        main
        {
        content
        =
        Buffer
        (
        page
        .
        text
        ~=
        'Stub'
        and
        --This comparison performed in {{Asbox/stubtree}} before it invokes Module:Asbox stubtree
        require
        (
        'Module:Asbox stubtree'
        ).
        subtree
        {
        args
        =
        {
        pagename
        =
        page
        .
        text
        }}
        )
        :
        _in
        '
        \n
        == About this template ==
        \n
        This template is used to identify a'
        :
        _
        (
        args
        .
        subject
        ):
        _
        'stub'
        :
        _
        (
        args
        .
        qualifier
        ):
        _out
        ' '
        --space
        :
        _
        '. It uses {{[[Template:Asbox|asbox]]}}, which is a meta-template designed to ease the process of creating and maintaining stub templates.
        \n
        === Usage ===
        \n
        Typing '
        :
        _
        (
        mw
        .
        html
        .
        create
        'code'
        :
        wikitext
        (
        '{{'
        ,
        page
        .
        text
        ==
        'Stub'
        and
        'stub'
        or
        page
        .
        text
        ,
        '}}'
        )
        )
        :
        _
        ' produces the message shown at the beginning, and adds the article to the following categor'
        :
        _
        (
        #
        stubCats
        >
        1
        and
        'ies'
        or
        'y'
        )
        :
        _
        ':
        \n
        '
        :
        _
        (
        population
        ())
        :
        _
        (
        pageDoc
        .
        exists
        and
        --transclusion of /doc if it exists
        frame
        :
        expandTemplate
        {
        title
        =
        pageDoc
        .
        text
        }
        )
        :
        _
        '
        \n
        == General information ==
        \n
        '
        :
        _
        (
        frame
        :
        expandTemplate
        {
        title
        =
        tStubDoc
        .
        text
        })
        :
        _
        '
        \n\n
        '
        (),
        [
        'link box'
        ]
        =
        Buffer
        'This documentation is automatically generated by [[Module:Asbox]].'
        :
        _in
        'The general information is transcluded from [[Template:Stub documentation]]. '
        :
        _
        (
        mw
        .
        html
        .
        create
        'span'
        :
        cssText
        'font-size:smaller;font-style:normal;line-height:130%'
        :
        node
        ((
        '([%s edit] | [%s history])'
        ):
        format
        (
        tStubDoc
        :
        fullUrl
        (
        'action=edit'
        ,
        'relative'
        ),
        tStubDoc
        :
        fullUrl
        (
        'action=history'
        ,
        'relative'
        )
        ))
        )
        :
        _out
        ()
        :
        _
        (
        page
        .
        protectionLevels
        .
        edit
        and
        page
        .
        protectionLevels
        .
        edit
        [
        1
        ]
        ==
        'sysop'
        and
        "This template is [[WP:PROTECT|fully protected]] and any [[WP:CAT|categories]] should be added to the template's ["
        ..
        pageDoc
        :
        fullUrl
        (
        'action=edit&preload=Template:Category_interwiki/preload'
        ,
        'relative'
        )
        ..
        '| /doc] subpage, which is not protected.'
        )
        ' <br/>'
        }
        )()
        end
        function
        p
        .
        main
        (
        frame
        ,
        page
        )
        args
        ,
        page
        =
        p
        :
        init
        (
        frame
        ,
        page
        )
        local
        output
        =
        mw
        .
        html
        .
        create
        'table'
        :
        addClass
        'metadata plainlinks stub'
        :
        css
        {
        background
        =
        'transparent'
        }
        :
        attr
        {
        role
        =
        'presentation'
        }
        :
        tag
        'tr'
        :
        node
        ((
        args
        .
        icon
        or
        args
        .
        image
        )
        and
        mw
        .
        html
        .
        create
        'td'
        :
        wikitext
        (
        args
        .
        icon
        or
        (
        '[[File:%s|%spx|alt=%s]]'
        ):
        format
        (
        args
        .
        image
        or
        ''
        ,
        args
        .
        pix
        or
        '40x30'
        ,
        args
        .
        imagealt
        or
        'Stub icon'
        ))
        )
        :
        tag
        'td'
        :
        tag
        'i'
        :
        wikitext
        (
        Buffer
        'This'
        :
        _
        (
        args
        .
        subject
        ):
        _
        (
        args
        .
        article
        or
        'article'
        ):
        _
        (
        args
        .
        qualifier
        )
        ' '
        ,
        --space
        ' is a [[Wikipedia:stub|stub]]. You can help Wikipedia by ['
        ,
        page
        :
        fullUrl
        (
        'action=edit'
        ,
        'relative'
        ),
        ' expanding it].'
        )
        :
        done
        ()
        :
        node
        (
        args
        .
        name
        and
        require
        'Module:Navbar'
        .
        _navbar
        {
        args
        .
        name
        ,
        mini
        =
        'yes'
        ,
        style
        =
        'position: absolute; right: 15px; display: none;'
        }
        )
        :
        node
        (
        args
        .
        note
        and
        mw
        .
        html
        .
        create
        ()
        :
        tag
        'br'
        :
        done
        ()
        :
        tag
        'span'
        :
        css
        {[
        'font-style'
        ]
        =
        'normal'
        ,
        [
        'font-size'
        ]
        =
        'smaller'
        }
        :
        wikitext
        (
        args
        .
        note
        )
        :
        done
        ()
        )
        :
        allDone
        ()
        --[[
        	Stub categories for templates include a sort key; this ensures that all stub tags appear at the beginning of their respective categories.
        	Articles using the template do not need a sort key since they have unique names.
        	When p.demo equals 'doc', the demo stub categories will appear as those for a stub template.
        	Otherwise, any non-nil p.demo will emulate article space categories (plus any error cats unless set to 'art')
        	]]
        if
        page
        .
        namespace
        ==
        0
        then
        -- Main namespace
        category
        'All stub articles'
        catStub
        ()
        elseif
        p
        .
        demo
        then
        if
        p
        .
        demo
        ~=
        'doc'
        then
        catStub
        ()
        end
        --Unless p.demo is set to 'art', it will also include error categories normally only shown on
        --the template but not in the article. The elseif after namespace == 0 means demo cats will never show in article space.
        p
        .
        demodoc
        =
        p
        .
        demo
        ~=
        'art'
        and
        p
        .
        templatepage
        (
        frame
        ,
        page
        )
        output
        =
        mw
        .
        html
        .
        create
        ()
        :
        node
        (
        output
        )
        :
        tag
        'small'
        :
        wikitext
        (
        'Demo categories: '
        ,
        (
        category
        {
        done
        =
        true
        }:
        gsub
        (
        '(%[%[)(Category:)([^|%]]-)(%|)'
        ,
        '%1%2%3|%2%3%4'
        ):
        gsub
        (
        '(%[%[)(Category:)'
        ,
        '%1:%2'
        ))
        ):
        done
        ()
        :
        wikitext
        (
        p
        .
        demo
        ==
        'doc'
        and
        p
        .
        demodoc
        or
        nil
        )
        else
        --Checks for valid name; emulates original template's check using {{FULLPAGENAME:{{{name|}}}}}
        local
        normalizedName
        =
        mw
        .
        title
        .
        new
        (
        args
        .
        name
        or
        ''
        )
        if
        normalizedName
        and
        normalizedName
        .
        fullText
        ==
        page
        .
        fullText
        then
        output
        =
        mw
        .
        html
        .
        create
        ():
        node
        (
        output
        ):
        wikitext
        (
        p
        .
        templatepage
        (
        frame
        ,
        page
        ))
        elseif
        not
        page
        .
        isSubpage
        and
        page
        .
        namespace
        ==
        10
        then
        -- Template namespace and not a subpage
        category
        {{
        k
        =
        args
        .
        name
        and
        'E'
        or
        'W'
        ,
        t
        =
        page
        .
        text
        }}
        end
        end
        return
        output
        :
        wikitext
        (
        not
        p
        .
        demo
        and
        category
        {
        done
        =
        true
        }
        or
        nil
        )
        end
        return
        p
      
What is this?