Wikipedia

Module:Labelled list hatnote

Module documentation[view] [edit] [history] [purge]
This module provides a handful of functions that make it easy to implement hatnotes that take the form of a label in front of a list of pages, e.g.

Usage

labelledList

Invoking the labelledList() function is enough to implement most such templates:

{{#invoke:Labelled list hatnote|labelledList|Universal label}}

or

{{#invoke:Labelled list hatnote|labelledList|Singular label|Plural label}}

For example, providing "See also" instead of "Universal label" duplicates the functionality of {{see also}}, while providing "Main article" and "Main articles" instead of "Singular label" and "Plural label" duplicates the (article namespace) functionality of {{main}}.

preprocessDisplays

The preprocessDisplays() function takes a raw list of arguments and combines in any display arguments. For example, {{see also|1|l1=One}} initially has the arguments table {'1', ['l1'] = 'One'}; this table would combine those into the table {'1|One'}. It overrides manual piping (e.g. {{see also|1{{!}}2|l1=One}}{'1|One'}) and compresses sparse arrays if a parameter is skipped or left empty.

Example:
localmLabelledList=require('Module:Labelled list hatnote')localpages=mLabelledList.preprocessDisplays(args)

_labelledList

For modules that need to modify the functionality slightly while still using it, _labelledList() provides some flexibility. It takes three parameters:

  1. A pages list, preferably preprocessed and compressed by preprocessDisplays
  2. A labels table, where the first item is the singular or universal label, and the second either a plural label or a copy of the first.
  3. An options table, preferably containing:
    • a template string with the full title of the template. Defaults to the title of this module.
    • a category string (or nil) as taken by makeWikitextError from Module:Hatnote, to optionally disable error categories
    • a selfref string (or nil) as taken by _hatnote to enable the selfref option
Example:
localmLabelledList=require('Module:Labelled list hatnote')returnmLabelledList._labelledList(pages,labels,options)

Errors

This module causes templates based on it to produce an error message if no page names are provided as template parameters. Normally, these should lead back to "Errors" sections in the documentation of those templates. However, if those templates use a module with _labelledList() and don't provide a template item in their options table, that error defaults to leading back here. The error can be solved by providing at least one valid page-name parameter to the template in question; the problem in the template can be fixed by providing some value to the template item of the _labelledList() options table.

        
        
          
            
          
          --------------------------------------------------------------------------------
        
        
          
            
          
          --                               Labelled list                                --
        
        
          
            
          
          --                                                                            --
        
        
          
            
          
          -- This module does the core work of creating a hatnote composed of a list    --
        
        
          
            
          
          -- prefixed by a colon-terminated label, i.e. "LABEL: [andList of pages]",    --
        
        
          
            
          
          -- for {{see also}} and similar templates.                                    --
        
        
          
            
          
          --------------------------------------------------------------------------------
        
        
          
            
          
        
        
          
            
          
          local
          mHatnote
          =
          require
          (
          'Module:Hatnote'
          )
        
        
          
            
          
          local
          mHatlist
          =
          require
          (
          'Module:Hatnote list'
          )
        
        
          
            
          
          local
          mArguments
          --initialize lazily
        
        
          
            
          
          local
          p
          =
          {}
        
        
          
            
          
        
        
          
            
          
          -- Defaults global to this module
        
        
          
            
          
          local
          defaults
          =
          {
        
        
          
            
          
          label
          =
          'See also'
          ,
          --Final fallback for label argument
        
        
          
            
          
          labelForm
          =
          '%s: %s'
          ,
        
        
          
            
          
          prefixes
          =
          {
          'label'
          ,
          'label '
          ,
          'l'
          },
        
        
          
            
          
          template
          =
          'Module:Labelled list hatnote'
        
        
          
            
          
          }
        
        
          
            
          
        
        
          
            
          
          -- Helper function that pre-combines display parameters into page arguments.
        
        
          
            
          
          -- Also compresses sparse arrays, as a desirable side-effect.
        
        
          
            
          
          function
          p
          .
          preprocessDisplays
          (
          args
          ,
          prefixes
          )
        
        
          
            
          
          -- Prefixes specify which parameters, in order, to check for display options
        
        
          
            
          
          -- They each have numbers auto-appended, e.g. 'label1', 'label 1', & 'l1'
        
        
          
            
          
          prefixes
          =
          prefixes
          or
          defaults
          .
          prefixes
        
        
          
            
          
          local
          pages
          =
          {}
        
        
          
            
          
          for
          k
          ,
          v
          in
          pairs
          (
          args
          )
          do
        
        
          
            
          
          if
          type
          (
          k
          )
          ==
          'number'
          then
        
        
          
            
          
          local
          display
        
        
          
            
          
          for
          i
          =
          1
          ,
          #
          prefixes
          do
        
        
          
            
          
          display
          =
          args
          [
          prefixes
          [
          i
          ]
          ..
          k
          ]
        
        
          
            
          
          if
          display
          then
          break
          end
        
        
          
            
          
          end
        
        
          
            
          
          local
          page
          =
          display
          and
        
        
          
            
          
          string.format
          (
          '%s|%s'
          ,
          string.gsub
          (
          v
          ,
          '|.*$'
          ,
          ''
          ),
          display
          )
          or
          v
        
        
          
            
          
          pages
          [
          #
          pages
          +
          1
          ]
          =
          page
        
        
          
            
          
          end
        
        
          
            
          
          end
        
        
          
            
          
          return
          pages
        
        
          
            
          
          end
        
        
          
            
          
        
        
          
            
          
          -- Produces a labelled pages-list hatnote.
        
        
          
            
          
          -- The main frame (template definition) takes 1 or 2 arguments, for a singular
        
        
          
            
          
          -- and (optionally) plural label respectively:
        
        
          
            
          
          -- * {{#invoke:Labelled list hatnote|labelledList|Singular label|Plural label}}
        
        
          
            
          
          -- The resulting template takes pagename & label parameters normally.
        
        
          
            
          
          function
          p
          .
          labelledList
          (
          frame
          )
        
        
          
            
          
          mArguments
          =
          require
          (
          'Module:Arguments'
          )
        
        
          
            
          
          local
          labels
          =
          {
          frame
          .
          args
          [
          1
          ]
          or
          defaults
          .
          label
          }
        
        
          
            
          
          labels
          [
          2
          ]
          =
          frame
          .
          args
          [
          2
          ]
          or
          labels
          [
          1
          ]
        
        
          
            
          
          local
          template
          =
          frame
          :
          getParent
          ():
          getTitle
          ()
        
        
          
            
          
          local
          args
          =
          mArguments
          .
          getArgs
          (
          frame
          ,
          {
          parentOnly
          =
          true
          })
        
        
          
            
          
          local
          pages
          =
          p
          .
          preprocessDisplays
          (
          args
          )
        
        
          
            
          
          local
          options
          =
          {
        
        
          
            
          
          extraclasses
          =
          frame
          .
          args
          .
          extraclasses
          ,
        
        
          
            
          
          category
          =
          args
          .
          category
          ,
        
        
          
            
          
          selfref
          =
          frame
          .
          args
          .
          selfref
          or
          args
          .
          selfref
          ,
        
        
          
            
          
          template
          =
          template
        
        
          
            
          
          }
        
        
          
            
          
          return
          p
          .
          _labelledList
          (
          pages
          ,
          labels
          ,
          options
          )
        
        
          
            
          
          end
        
        
          
            
          
        
        
          
            
          
          function
          p
          .
          _labelledList
          (
          pages
          ,
          labels
          ,
          options
          )
        
        
          
            
          
          labels
          =
          labels
          or
          {}
        
        
          
            
          
          if
          #
          pages
          ==
          0
          then
        
        
          
            
          
          return
          mHatnote
          .
          makeWikitextError
          (
        
        
          
            
          
          'no page names specified'
          ,
        
        
          
            
          
          (
          options
          .
          template
          or
          defaults
          .
          template
          )
          ..
          '#Errors'
          ,
        
        
          
            
          
          options
          .
          category
        
        
          
            
          
          )
        
        
          
            
          
          end
        
        
          
            
          
          label
          =
          (
          #
          pages
          ==
          1
          and
          labels
          [
          1
          ]
          or
          labels
          [
          2
          ])
          or
          defaults
          .
          label
        
        
          
            
          
          local
          text
          =
          string.format
          (
        
        
          
            
          
          options
          .
          labelForm
          or
          defaults
          .
          labelForm
          ,
        
        
          
            
          
          label
          ,
        
        
          
            
          
          mHatlist
          .
          andList
          (
          pages
          ,
          true
          )
        
        
          
            
          
          )
        
        
          
            
          
          local
          hnOptions
          =
          {
        
        
          
            
          
          extraclasses
          =
          options
          .
          extraclasses
          ,
        
        
          
            
          
          selfref
          =
          options
          .
          selfref
        
        
          
            
          
          }
        
        
          
            
          
          return
          mHatnote
          .
          _hatnote
          (
          text
          ,
          hnOptions
          )
        
        
          
            
          
          end
        
        
          
            
          
        
        
          
            
          
          return
          p
        
      
What is this?