Module:Example and Module:Example/sandbox: Difference between pages

(Difference between pages)
Jump to navigation Jump to search
Page 1
Page 2
imported>QuickQuokka
imported>Awesome Aasim
add ldoc comments to example
 
imported>QuickQuokka
better documentation
 
Line 1: Line 1:
--- Example module.
--------------------------------------------------------------------------------
-- @module example
-- Module:Example
-- @alias p
-- Demonstration of a Lua Module for Wikipedia
--
-- This module serves as an example and guide for creating Lua modules on
-- Wikipedia. It defines several functions that can be invoked via the
-- {{#invoke:}} mechanism. Note that this module is for demonstration purposes
-- only and is not intended for actual production use.
--------------------------------------------------------------------------------


local p = {}  -- Table to hold the module's externally accessible functions.


local p = {}     --All Lua modules on Wikipedia must begin by defining a variable
--------------------------------------------------------------------------------
                    --that will hold their externally accessible functions.
-- Function: p.hello
                    --Such variables can have whatever name you want and may
-- Description: Returns a simple, fixed greeting "Hello World!".
                    --also contain various data as well as functions.
-- Usage: {{#invoke:Example|hello}}
--------------------------------------------------------------------------------
p.hello = function(frame)
    local greeting = "Hello World!"  -- Define the greeting message as a local variable.
    return greeting                  -- Return the greeting to Wikipedia.
end


--- Hello world function
--------------------------------------------------------------------------------
-- @param {table} frame current frame
-- Function: p.hello_to
-- @return Hello world
-- Description: Returns a personalized greeting using the first unnamed parameter.
p.hello = function( frame )    --Add a function to "p".
-- Usage: {{#invoke:Example|hello_to|YourName}}
                                        --Such functions are callable in Wikipedia
--------------------------------------------------------------------------------
                                        --via the #invoke command.
function p.hello_to(frame)
                                        --"frame" will contain the data that Wikipedia
    local name = frame.args[1]       -- Retrieve the first unnamed parameter.
                                        --sends this function when it runs.
    return "Hello, " .. name .. "!"   -- Concatenate and return the personalized greeting.
                                -- 'Hello' is a name of your choice. The same name needs to be referred to when the module is used.
   
    local str = "Hello World!"  --Declare a local variable and set it equal to
                                --"Hello World!". 
   
    return str    --This tells us to quit this function and send the information in
                  --"str" back to Wikipedia.
   
end  -- end of the function "hello"
 
--- Hello world function
-- @param {table} frame current frame
-- @param {string} frame.args[1] name
-- @return Hello world
function p.hello_to(frame) -- Add another function
local name = frame.args[1] -- To access arguments passed to a module, use `frame.args`
    -- `frame.args[1]` refers to the first unnamed parameter
    -- given to the module
return "Hello, " .. name .. "!" -- `..` concatenates strings. This will return a customized
-- greeting depending on the name given, such as "Hello, Fred!"
end
end


--- Counts fruit
--------------------------------------------------------------------------------
-- @param {table} frame current frame
-- Function: p.count_fruit
-- @param {string} frame.args.bananas number of bananas
-- Description: Constructs and returns a sentence indicating the count of bananas
-- @param {string} frame.args.apples number of apples
--             and apples, using proper singular/plural forms.
-- @return Number of apples and bananas
-- Usage: {{#invoke:Example|count_fruit|bananas=5|apples=6}}
--------------------------------------------------------------------------------
function p.count_fruit(frame)
function p.count_fruit(frame)
    -- Convert the named parameters to numbers; default to 0 if conversion fails.
local num_bananas = tonumber(frame.args.bananas) or 0 -- Named arguments ({{#invoke:Example|count_fruit|foo=bar}})
    local num_bananas = tonumber(frame.args.bananas) or 0
local num_apples = tonumber(frame.args.apples) or 0 -- are likewise accessed by indexing `frame.args` by name (`frame.args["bananas"]`,
    local num_apples = tonumber(frame.args.apples) or 0
-- or equivalently `frame.args.bananas`.
 
    -- Determine the correct word for singular or plural form.
local conj_bananas = num_bananas == 1 and 'banana' or 'bananas'
    local banana_label = (num_bananas == 1) and "banana" or "bananas"
     local conj_apples = num_apples == 1 and 'apple' or 'apples'
     local apple_label  = (num_apples == 1) and "apple" or "apples"
    -- Ternary operators assign values based on a condition in a compact way.
 
-- Here, `conj_bananas` gets `'banana'` if `num_bananas` is 1, else `'bananas'`.
    -- Construct and return the complete sentence.
-- Similarly, `conj_apples` gets `'apple'` if `num_apples` is 1, else `'apples'`.
     return "I have " .. num_bananas .. " " .. banana_label ..
   
          " and " .. num_apples .. " " .. apple_label .. "."
     return 'I have ' .. num_bananas .. ' ' .. conj_bananas .. ' and ' .. num_apples .. ' ' .. conj_apples
  -- Like above, concatenate a bunch of strings together to produce
  -- a sentence based on the arguments given.
end
end


--- Lucky function
--------------------------------------------------------------------------------
-- @param {string} a
-- Local Helper Function: lucky
-- @param {string} b
-- Description: Returns a message stating that the given number is "lucky" if the
-- @return Whether a is lucky.
--             second parameter is the string "yeah"; otherwise, it simply returns
local function lucky(a, b) -- One can define custom functions for use. Here we define a function 'lucky' that has two inputs a and b. The names are of your choice.
--             the number.
if b == 'yeah' then -- Condition: if b is the string 'yeah'. Strings require quotes. Remember to include 'then'.
--------------------------------------------------------------------------------
return a .. ' is my lucky number.' -- Outputs 'a is my lucky number.' if the above condition is met. The string concatenation operator is denoted by 2 dots.
local function lucky(a, b)
else -- If no conditions are met, i.e. if b is anything else, output specified on the next line.  'else' should not have 'then'.
    if b == "yeah" then
return a -- Simply output a.
        return a .. " is my lucky number."
end -- The 'if' section should end with 'end'.
    else
end -- As should 'function'.
        return a
    end
end


--- Name2
--------------------------------------------------------------------------------
-- @param {table} frame current frame
-- Function: p.Name2
-- @return Some output
-- Description: Demonstrates the use of both unnamed and named parameters from the
--              frame object. It accesses parameters from the current frame as well as
--              from the parent frame, and returns a message based on the provided values.
-- Usage: Can be invoked with parameters directly or via a parent template.
--------------------------------------------------------------------------------
function p.Name2(frame)
function p.Name2(frame)
-- The next five lines are mostly for convenience only and can be used as is for your module. The output conditions start on line 50.
    -- Retrieve parameters from both the parent frame and the current frame.
local pf = frame:getParent().args -- This line allows template parameters to be used in this code easily. The equal sign is used to define variables. 'pf' can be replaced with a word of your choice.
    -- The parent frame allows template parameters to be used in this code easily.
local f = frame.args -- This line allows parameters from {{#invoke:}} to be used easily. 'f' can be replaced with a word of your choice.
    local parentArgs = frame:getParent().args
local M = f[1] or pf[1] -- f[1] and pf[1], which we just defined, refer to the first parameter. This line shortens them as 'M' for convenience. You could use the original variable names.
    local args = frame.args
local m = f[2] or pf[2] -- Second shortened as 'm'.
 
local l = f.lucky or pf.lucky -- A named parameter 'lucky' is shortend as l. Note that the syntax is different from unnamed parameters.
    -- Use the first and second unnamed parameters, with a fallback to parent arguments.
if m == nil then -- If the second parameter is not used.
    local M = args[1] or parentArgs[1]
return 'Lonely' -- Outputs the string 'Lonely' if the first condition is met.
    local m = args[2] or parentArgs[2]
elseif M > m then -- If the first condition is not met, this line tests a second condition: if M is greater than m.
 
return lucky(M - m, l) -- If the condition is met, the difference is calculated and passed to the self defined function along with l. The output depends on whether l is set to 'yeah'.
    -- Retrieve the named parameter 'lucky' (if provided).
else
    local luckyParam = args.lucky or parentArgs.lucky
return 'Be positive!'
 
end
    -- Determine the output based on the provided parameters.
    if m == nil then
        return "Lonely"  -- If the second parameter is missing, return "Lonely".
    elseif M > m then
        -- If M is greater than m, calculate the difference and use the lucky helper.
        return lucky(M - m, luckyParam)
    else
        return "Be positive!"
    end
end
end


return p    --All modules end by returning the variable containing their functions to Wikipedia.
--------------------------------------------------------------------------------
-- Now we can use this module by calling {{#invoke: Example | hello }},
-- Return the module table to make the functions accessible via {{#invoke:}}.
-- {{#invoke: Example | hello_to | foo }}, or {{#invoke:Example|count_fruit|bananas=5|apples=6}}
--------------------------------------------------------------------------------
-- Note that the first part of the invoke is the name of the Module's wikipage,
return positive
-- and the second part is the name of one of the functions attached to the
-- variable that you returned.
 
-- The "print" function is not allowed in Wikipedia.  All output is accomplished
-- via strings "returned" to Wikipedia.
Retrieved from "http://70.231.62.181/index.php/Special:ComparePages"