Wikipedia

Module:About

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

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'.

        
        
          
            
          
          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
        
      
What is this?