Module:UtilsArg/Documentation/Snippets

This module contains snippets used to generate documentation and unit tests for Module:UtilsArg.

---

local p = {}

local Franchise = require("Module:Franchise")
local utilsArg = require("Module:UtilsArg")

function p.parsePositionalAndNamedArgs()
	local args = {"OoT", page = "Boss Key"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "game",
				desc = "A game",
			},
			page = {
				desc = "A page on the wiki",
			},	
		}
	})
end

function p.parseTrailingArgs()
	local args = {"OoT", "MM", "TWW", "TP"}
	return utilsArg.parse(args, {
		params = {
			["..."] = {
				name = "games",
			},
		},
	})
end

function p.parseTrailingArgsWithPositionalArgs()
	local args = {"foo", "bar", "OoT", "MM", "TWW", "TP"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "foo"
			},
			[2] = {
				name = "bar",
			},
			["..."] = {
				name = "games",
			},
		},
	})
end

function p.parseRequiredArgs()
	local args = {nil, nil, "Baz"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "foo",
				required = true,
			},
			[2] = {
				name = "bar",
				required = "Category:Custom Category Name",
			},
			[3] = {
				name = "baz",
				required = true,
			},
		}
	})
end

function p.parseRequiredArgsWithAliases()
	local args = { oldName = "foo" }
	return utilsArg.parse(args, {
		params = {
			newName = {
				aliases = {"oldName"}	
			},
		}
	})
end

function p.parseDeprecated()
	local args = {
		oldArg = "foo",
		oldArg2 = "bar",
	}
	return utilsArg.parse(args, {
		params = {
			oldArg = {
				deprecated = true
			},
			oldArg2 = {
				deprecated = "Category:Custom Deprecation Category",
			},
		}
	})
end

function p.parseUnknown()
	local args = {
		foo = "bar"
	}
	return utilsArg.parse(args, {
		params = {} -- template has no args defined and yet "foo" is used as one
	}) 
end

function p.parseBoolean()
	local args = {
		foo = "anything",
		bar = "false",
		baz = " ",
	}
	return utilsArg.parse(args, {
		params = {
			foo = {
				type = "boolean"
			},
			bar = {
				type = "boolean",
			},
			baz = {
				type = "boolean",
			},
		}
	})
end

function p.parseNumber()
	local args = {
		foo = "9000",
		bar = " ",
	}
	return utilsArg.parse(args, {
		params = {
			foo = {
				type = "number"
			},
			bar = {
				type = "number",
			},
		}
	})
end

function p.parseInvalidNumber()
	local args = {
		foo = "notANumber",
	}
	return utilsArg.parse(args, {
		params = {
			foo = {
				type = "number"
			}
		}
	})
end

function p.parseDefault()
	local args = {[3] = "", [4] = ""}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "someParamWithDefault",
				type = "string",
				default = "foo",
			},
			[2] = {
				name = "someParamWithDefaultNumber",
				type = "number",
				default = 1,
			},
			[3] = {
				name = "param3",
				type = "string",
				default = "bar",
				nilIfEmpty = true,
			},
			[4] = {
				name = "param4",
				type = "string",
				default = "baz",
			}
		}
	})
end

function p.parseTrim()
	local args = {" foo   \n"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "someParam",
				trim = true,
			},
		}
	})
end

function p.parseNilIfEmpty()
	local args = {
		foo = ""
	}
	return utilsArg.parse(args, {
		params = {
			foo = {
				nilIfEmpty = true,
			},
		}
	})
end

function p.parseSplit()
	local args = {
		foo = "  a, b  , c,"
	}
	return utilsArg.parse(args, {
		params = {
			foo = {
				trim = true,
				split = true,
			}
		}
	})
end

function p.parseSplitPattern()
	local args = {
		foo = "abc"
	}
	return utilsArg.parse(args, {
		params = {
			foo = {
				split = "",
			}
		}
	})
end

function p.parseNilIfEmptyWithRequiredArgs()
	local args = {""}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "game",
				nilIfEmpty = true,
				required = true,
				desc = "A game",
			},
		}
	})
end

function p.parseTrimNilIfEmptyRequired()
	local args = {"  \n"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "game",
				desc = "A game",
				trim = true,
				nilIfEmpty = true,
				required = true,
			},
		}
	})
end

function p.parseEnum()
	local args = {"Kooloo", "Limpah", "ALttZ"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "triforce1",
				enum = {"Courage", "Power", "Wisdom"}
			},
			[2] = {
				name = "triforce2",
				enum = {"Courage", "Power", "Wisdom", reference = "[[Triforce]]"},
			},
			[3] = {
				name = "game",
				enum = Franchise.enum(), -- from [[Module:Franchise]]
			}
		}
	})
end

function p.parseSplitEnum()
	local args = {
		games = "OoT, fakeGame, BotW",
	}
	return utilsArg.parse(args, {
		params = {
			games = {
				split = true,
				enum = Franchise.enum(),
			},
		},
	})
end

function p.parseSplitEnumSortAndRemoveDuplicates()
	local args = {
		games = "BotW, BotW, fakeGame, OoT, OoT",
	}
	return utilsArg.parse(args, {
		params = {
			games = {
				split = true,
				enum = Franchise.enum(),
				sortAndRemoveDuplicates = true,
			},
		},
	})
end

function p.parseEnumDependsOn()
	local validTermsForGame = {
		OoT = {"Dinolfos"},
		TP = {"Dynalfos"},
	}
	local args = {"TP", "Dinolfos"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "game",
				required = true,
			},
			[2] = {
				name = "term",
				enumDependsOn = "game",
				enum = function(game)
					return validTermsForGame[game]
				end,
			}
		}
	})
end

function p.parseEnumDependsOnNil()
	local validTermsForGame = {
		OoT = {"Dinolfos"},
		TP = {"Dynalfos"},
	}
	local args = {nil, "Dinolfos"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "game",
				required = true,
			},
			[2] = {
				name = "term",
				enumDependsOn = "game",
				enum = function(game)
					return validTermsForGame[game]
				end,
			}
		}
	})
end

function p.parseTermStorePass()
	local args = {"Dinolfos", games = "OoT, MM", plural = nil}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "term",
				nilIfEmpty = true,
				required = true,
			},
			games = {
				split = true,
				enum = Franchise.enum(),
			},
			plural = {
				deprecated = true,
			}
		}
	})
end

function p.parseTermStoreFail()
	local args = {"", games = "YY, ZZ", plural = "true"}
	return utilsArg.parse(args, {
		params = {
			[1] = {
				name = "term",
				nilIfEmpty = true,
				required = true,
			},
			games = {
				split = true,
				enum = Franchise.enum(),
			},
			plural = {
				deprecated = true,
			},
		}
	})
end

function p.parseTrailingArgsStringTrimNilIfEmptyEnum()
	local args = {"\n  OoT", "", "MM ", "ALttZ"}
	return utilsArg.parse(args, {
		params = {
			["..."] = {
				name = "games",
				trim = true,
				nilIfEmpty = true,
				enum = Franchise.enum()
			},
		}
	})
end

function p.parseRepeatedGroup()
	local args = {
		tab1 = "Tab 1",
		content1 = "Content 1",
		
		tab2= "Tab 2",
		content2 = "Content 2",
		
		-- missing tab3, content3
		
		tab4 = "Tab 4",
		-- missing content4
		
		--missing tab5
		content5 = "Content 5",
	}
	return utilsArg.parse(args, {
		params = {
			["tab"] = { required = true },
			["content"] = { required = true },
		},
		repeatedGroup = {
			name = "tabs",
			params = {"tab", "content"},
		},
	})
end

function p.schemaValidatePasses()
	local mySchema = {
		oneOf = {
			{
				type = "string"
			},
			{
				type = "array",
				items = {
					type = "string",
					enum = {"Kooloo", "Limpah"},
				}
			}
		}
	}
	local magicWords = "Alakazam"
	return utilsArg.schemaValidate(mySchema, "mySchema", magicWords, "magicWords")
end

function p.schemaValidateFails()
	local mySchema = {
		oneOf = {
			{
				type = "string"
			},
			{
				type = "array",
				items = {
					type = "string",
					enum = {"Kooloo", "Limpah"}
				}
			}
		}
	}
	local magicWords = {"Alakazam"}
	return utilsArg.schemaValidate(mySchema, "mySchema", magicWords, "magicWords")
end

return p