Module:About

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

This Lua module is used on 140,000+ pages.

To avoid major disruption and server load, any changes should be tested in the module's /sandbox or /testcases subpages. The tested changes can be added to this page in a single edit. Consider discussing changes on the talk page before implementing them.

Transclusion count updated automatically (see documentation).

This module is subject to page protection. It is a highly visible module in use by a very large number of pages, or is substituted very frequently. Because vandalism or mistakes would affect many pages, and even trivial editing might cause substantial load on the servers, it is protected from editing.

This module implements the {{about}} hatnote template.

Usage

The about function implements the {{about}} template directly, using the frame and applying no options. This should probably only be used in {{about}}.

The _about function can be used from Lua to supply a custom arguments list (its first argument) and/or an options table (its second argument). Options include:
- aboutForm A string that can be used to substitute the form of the initial "about" message. It should include two substitution points: the first for the page type (e.g. "article"), and the second for the description of what the page is about. It should also include a trailing space for easy concatenation or omission. Defaults to 'This %s is about %s. '.
- sectionString Gives the page type string for when the named argument section is specified. Defaults to 'section'.

The above documentation is transcluded from Module:About/doc.

Editors can experiment in this module's sandbox and testcases pages.

Subpages of this module.

        
        
          
            
          
          local
          mArguments
          --initialize lazily
        
        
          
            
          
          local
          mHatnote
          =
          require
          (
          'Module:Hatnote'
          )
        
        
          
            
          
          local
          mHatList
          =
          require
          (
          'Module:Hatnote list'
          )
        
        
          
            
          
          local
          libraryUtil
          =
          require
          (
          'libraryUtil'
          )
        
        
          
            
          
          local
          checkType
          =
          libraryUtil
          .
          checkType
        
        
          
            
          
          local
          p
          =
          {}
        
        
          
            
          
        
        
          
            
          
          function
          p
          .
          about
          (
          frame
          )
        
        
          
            
          
          -- A passthrough that gets args from the frame and all
        
        
          
            
          
          mArguments
          =
          require
          (
          'Module:Arguments'
          )
        
        
          
            
          
          args
          =
          mArguments
          .
          getArgs
          (
          frame
          )
        
        
          
            
          
          return
          p
          .
          _about
          (
          args
          )
        
        
          
            
          
          end
        
        
          
            
          
        
        
          
            
          
        
        
          
            
          
          function
          p
          .
          _about
          (
          args
          ,
          options
          )
        
        
          
            
          
          -- Produces "about" hatnote.
        
        
          
            
          
        
        
          
            
          
          -- Type checks and defaults
        
        
          
            
          
          checkType
          (
          '_about'
          ,
          1
          ,
          args
          ,
          'table'
          ,
          true
          )
        
        
          
            
          
          args
          =
          args
          or
          {}
        
        
          
            
          
          checkType
          (
          '_about'
          ,
          2
          ,
          options
          ,
          'table'
          ,
          true
          )
        
        
          
            
          
          options
          =
          options
          or
          {}
        
        
          
            
          
          local
          defaultOptions
          =
          {
        
        
          
            
          
          aboutForm
          =
          'This %s is about %s. '
          ,
        
        
          
            
          
          PageType
          =
          require
          (
          'Module:Pagetype'
          ).
          main
          (),
        
        
          
            
          
          otherText
          =
          nil
          ,
          --included for complete list
        
        
          
            
          
          sectionString
          =
          'section'
        
        
          
            
          
          }
        
        
          
            
          
          for
          k
          ,
          v
          in
          pairs
          (
          defaultOptions
          )
          do
        
        
          
            
          
          if
          options
          [
          k
          ]
          ==
          nil
          then
          options
          [
          k
          ]
          =
          v
          end
        
        
          
            
          
          end
        
        
          
            
          
        
        
          
            
          
          -- Set initial "about" string
        
        
          
            
          
          local
          pageType
          =
          (
          args
          .
          section
          and
          options
          .
          sectionString
          )
          or
          options
          .
          PageType
        
        
          
            
          
          local
          about
          =
          ''
        
        
          
            
          
          if
          args
          [
          1
          ]
          then
        
        
          
            
          
          about
          =
          string.format
          (
          options
          .
          aboutForm
          ,
          pageType
          ,
          args
          [
          1
          ])
        
        
          
            
          
          end
        
        
          
            
          
        
        
          
            
          
          --Allow passing through certain options
        
        
          
            
          
          local
          fsOptions
          =
          {
        
        
          
            
          
          otherText
          =
          options
          .
          otherText
          ,
        
        
          
            
          
          extratext
          =
          args
          .
          text
        
        
          
            
          
          }
        
        
          
            
          
          local
          hnOptions
          =
          {
        
        
          
            
          
          selfref
          =
          args
          .
          selfref
        
        
          
            
          
          }
        
        
          
            
          
        
        
          
            
          
          -- Set for-see list
        
        
          
            
          
          local
          forSee
          =
          mHatList
          .
          _forSee
          (
          args
          ,
          2
          ,
          fsOptions
          )
        
        
          
            
          
        
        
          
            
          
          -- Concatenate and return
        
        
          
            
          
          return
          mHatnote
          .
          _hatnote
          (
          about
          ..
          forSee
          ,
          hnOptions
          )
        
        
          
            
          
          end
        
        
          
            
          
        
        
          
            
          
          return
          p