Template:Template:Terminate sentence

{{#vardefine:txt|}} {{#vardefine:mark|.}} {{#vardefine:ref|}} {{#vardefine:trim|yes}}

{{#vardefine:txt|

 {{#var:txt}}

}}

{{#vardefine:lastIsTerm|

 0

}}

{{#vardefine:needsMark|

 1

}}

 {{#var:txt}}{{#var:mark}}
 {{#var:ref}}

Examples

Template sandbox and testcases for TEMPLATE_NAME

Overview

This page provides a clean workflow to safely edit and validate TEMPLATE_NAME:

• Sandbox: Template:TEMPLATE_NAME/sandbox — a working copy where you make changes.
• Testcases: Template:TEMPLATE_NAME/testcases — inputs that exercise typical and edge cases.
• Live: Template:TEMPLATE_NAME — the production version. Do not edit directly without review.

Use this page to:

• Preview sandbox output against fixed testcases without touching the live template.
• Compare actual vs expected output for each testcase.
• Track recent changes and invite reviewers.

Quick links

• Live template: Template:TEMPLATE_NAME
• Sandbox: Template:TEMPLATE_NAME/sandbox
• Testcases: Template:TEMPLATE_NAME/testcases
• Documentation: Template:TEMPLATE_NAME/doc (optional)
• Talk page: Template talk:TEMPLATE_NAME

How to test

1. Edit the sandbox at Template:TEMPLATE_NAME/sandbox. 2. Open this test page and click “Show preview” to render the sandbox with inputs below. 3. Verify each testcase: Does the “Actual output” match the “Expected output”? 4. If all pass, consider copying sandbox to live using an edit summary like:

  “Sync from /sandbox: passes all /testcases as of YYYY-MM-DD.”

Previewing tips

• Use “Preview page with this template” gadget or the built-in preview.
• Check parser output in different skins and mobile view.
• Validate accessibility: headings order, link text, ARIA where applicable.
• Internationalization: test with non-ASCII parameters and RTL where relevant.

Test harness

The following sections render the sandbox template against curated inputs. Each testcase shows:

• Parameters passed to the template
• Expected output (as plain wikitext target)
• Actual output (rendered via sandbox transclusion)

Testcase A: Minimal invocation

Parameters: {{TEMPLATE_NAME}}

Expected output: [Minimal successful output with defaults: e.g., a neutral message or basic box]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase B: Common parameters

Parameters: {{TEMPLATE_NAME | param1 = Alpha | param2 = Beta | flag = yes }}

Expected output: [Example: shows "Alpha" and "Beta" in designated slots; flag toggles enhanced styling]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase C: Edge values and escaping

Parameters: {{TEMPLATE_NAME | param1 = [[Linked target|Visible text]] | param2 = {{subst:CURRENTTIMESTAMP}} | raw = <code><span class="x">escaped</span></code> }}

Expected output: [Links render correctly; timestamp subst is literal in expected; raw shows escaped markup]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase D: Internationalization (i18n)

Parameters: {{TEMPLATE_NAME | lang = ja | text = こんにちは世界 }}

Expected output: [Text displays correctly for non-ASCII; applies lang attribute or rtl/ltr where applicable]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase E: Error handling

Parameters: {{TEMPLATE_NAME | param1 = | required = <!-- intentionally omitted --> }}

Expected output: [Shows a gentle error or maintenance category; does not break page layout]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

Maintenance

• Add new testcases when introducing features or fixing bugs.
• Keep “Expected output” updated; include rationale in edit summaries.
• When deprecating parameters, add tests demonstrating legacy behavior and warnings.

Copy-paste skeletons

Below are ready-to-use skeletons for the sandbox and testcases subpages.

Skeleton: Template:TEMPLATE_NAME/sandbox

<!-- Sandbox for TEMPLATE_NAME --> <!-- Copy the entire template source here; edit safely. --> {{#if:{{{required|}}} | <!-- normal output --> <div class="tmpl"> <b>{{{param1|}}}</b> · <i>{{{param2|}}}</i> {{#if:{{{flag|}}}|<span class="flag">✓</span>|}} {{#if:{{{raw|}}}|<span class="raw">{{{raw}}}</span>|}} </div> | <!-- error / missing required --> <span class="error">TEMPLATE_NAME: missing required parameter</span> [[Category:Pages with TEMPLATE_NAME errors]] }}

Skeleton: Template:TEMPLATE_NAME/testcases

<!-- Testcases for TEMPLATE_NAME; render against /sandbox --> ; Minimal : {{TEMPLATE_NAME/sandbox}} ; Common params : {{TEMPLATE_NAME/sandbox | param1 = Alpha | param2 = Beta | flag = yes }} ; Edge and escaping : {{TEMPLATE_NAME/sandbox | param1 = [[Linked target|Visible text]] | param2 = 20250101T000000Z | raw = <code><span class="x">escaped</span></code> }} ; I18n : {{TEMPLATE_NAME/sandbox | lang = ja | text = こんにちは世界 }} ; Error handling : {{TEMPLATE_NAME/sandbox | required = }}

Review checklist

• Output is stable across re-parses; no expensive parser functions without need.
• No unexpected categorization in mainspace; errors go to maintenance cats.
• Template is documented at Template:TEMPLATE_NAME/doc with parameters, examples, and tracking.
• Style is minimal; avoid inline CSS unless necessary; consider using existing module or template styles.

Template:Terminate sentence ensures a sentence ends with a specified terminator (default: a period). It avoids adding duplicate terminators and can optionally trim trailing spaces. It attempts to ignore trailing closing quotes or brackets when deciding whether a terminator is already present.

Usage

Basic:

{{Terminate sentence|This is a sentence}}
→ This is a sentence.

Named parameters:

{{Terminate sentence
 |text=He said "Hello"
 |term=.
}}
→ He said "Hello".

Custom terminator:

{{Terminate sentence|text=Warning|term=!}}
→ Warning!

Avoid duplicate terminator:

{{Terminate sentence|text=Already done.|term=.}}
→ Already done.

Trim trailing spaces:

{{Terminate sentence|text=Ends with space   |trim=yes}}
→ Ends with space.

Skip processing:

{{Terminate sentence|text=No changes here|skip=yes}}
→ No changes here

Append a note:

{{Terminate sentence|text=Complete|note=(source: 2025)}}
→ Complete. (source: 2025)

Parameters

1 / text

The input text to terminate.

term

The terminator to enforce at the end. Default is .. Common choices: !, ?.

trim

If yes/true/1, strips trailing spaces before checking.

skip

If yes/true/1, returns text unchanged (still appends note if provided).

allowdup

If yes/true/1, allows duplicate terminators (e.g., ellipses). Default disallows duplicates.

note

Optional text appended after a space, unaffected by termination logic.

Behavior details

• Terminator detection attempts to ignore trailing closing quotes/brackets (", ', ”, ), ], }).
• If the last visible character equals term, no extra terminator is added unless allowdup=yes.
• If trim=yes, trailing spaces are removed before detection.
• If note is present, it is added with a leading space after the final text.

Examples

• Quotes:

{{Terminate sentence|text=He whispered "hush"|term=.}}

 → He whispered "hush".

• Parentheses:

{{Terminate sentence|text=Complete (verified)|term=.}}

 → Complete (verified).

• Exclamation:

{{Terminate sentence|text=Alert|term=!}}

 → Alert!

• Ellipsis (allow duplicates):

{{Terminate sentence|text=Wait...|term=.|allowdup=yes}}

 → Wait....

Best practices

• Prefer using term that matches the sentence intent (., !, ?).
• For complex punctuation, consider the Lua-powered variant below.
• Document usage in your template’s /doc page where you incorporate this helper.

Lua-powered variant (optional)

For more robust detection (including multilingual quotes and punctuation), create Module:TerminateUtil with:

-- Module:TerminateUtil
local M = {}

local closing = {
  [")"] = true, ["]"] = true, ["}"] = true,
  ['"'] = true, ["'"] = true, ["”"] = true, ["’"] = true, ["»"] = true, ["›"] = true
}

local function trimRight(s)
  return (s:gsub("%s+$",""))
end

function M.lastVisibleChar(args)
  local s = args.s or ""
  s = trimRight(s)
  local i = #s
  while i > 0 do
    local c = s:sub(i,i)
    if closing[c] then
      i = i - 1
    else
      return c
    end
  end
  return ""
end

return M

Then update the template to call:

{{#invoke:TerminateUtil|lastVisibleChar|s=text}}

This improves detection for closing quotes and brackets.

See also

• Help:Templates
• Help:ParserFunctions
• Wikipedia:Template documentation

Template sandbox and testcases for TEMPLATE_NAME

Overview

This page provides a clean workflow to safely edit and validate TEMPLATE_NAME:

• Sandbox: Template:TEMPLATE_NAME/sandbox — a working copy where you make changes.
• Testcases: Template:TEMPLATE_NAME/testcases — inputs that exercise typical and edge cases.
• Live: Template:TEMPLATE_NAME — the production version. Do not edit directly without review.

Use this page to:

• Preview sandbox output against fixed testcases without touching the live template.
• Compare actual vs expected output for each testcase.
• Track recent changes and invite reviewers.

Quick links

• Live template: Template:TEMPLATE_NAME
• Sandbox: Template:TEMPLATE_NAME/sandbox
• Testcases: Template:TEMPLATE_NAME/testcases
• Documentation: Template:TEMPLATE_NAME/doc (optional)
• Talk page: Template talk:TEMPLATE_NAME

How to test

1. Edit the sandbox at Template:TEMPLATE_NAME/sandbox. 2. Open this test page and click “Show preview” to render the sandbox with inputs below. 3. Verify each testcase: Does the “Actual output” match the “Expected output”? 4. If all pass, consider copying sandbox to live using an edit summary like:

  “Sync from /sandbox: passes all /testcases as of YYYY-MM-DD.”

Previewing tips

• Use “Preview page with this template” gadget or the built-in preview.
• Check parser output in different skins and mobile view.
• Validate accessibility: headings order, link text, ARIA where applicable.
• Internationalization: test with non-ASCII parameters and RTL where relevant.

Test harness

The following sections render the sandbox template against curated inputs. Each testcase shows:

• Parameters passed to the template
• Expected output (as plain wikitext target)
• Actual output (rendered via sandbox transclusion)

Testcase A: Minimal invocation

Parameters: {{TEMPLATE_NAME}}

Expected output: [Minimal successful output with defaults: e.g., a neutral message or basic box]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase B: Common parameters

Parameters: {{TEMPLATE_NAME | param1 = Alpha | param2 = Beta | flag = yes }}

Expected output: [Example: shows "Alpha" and "Beta" in designated slots; flag toggles enhanced styling]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase C: Edge values and escaping

Parameters: {{TEMPLATE_NAME | param1 = [[Linked target|Visible text]] | param2 = {{subst:CURRENTTIMESTAMP}} | raw = <code><span class="x">escaped</span></code> }}

Expected output: [Links render correctly; timestamp subst is literal in expected; raw shows escaped markup]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase D: Internationalization (i18n)

Parameters: {{TEMPLATE_NAME | lang = ja | text = こんにちは世界 }}

Expected output: [Text displays correctly for non-ASCII; applies lang attribute or rtl/ltr where applicable]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase E: Error handling

Parameters: {{TEMPLATE_NAME | param1 = | required = <!-- intentionally omitted --> }}

Expected output: [Shows a gentle error or maintenance category; does not break page layout]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

Maintenance

• Add new testcases when introducing features or fixing bugs.
• Keep “Expected output” updated; include rationale in edit summaries.
• When deprecating parameters, add tests demonstrating legacy behavior and warnings.

Copy-paste skeletons

Below are ready-to-use skeletons for the sandbox and testcases subpages.

Skeleton: Template:TEMPLATE_NAME/sandbox

<!-- Sandbox for TEMPLATE_NAME --> <!-- Copy the entire template source here; edit safely. --> {{#if:{{{required|}}} | <!-- normal output --> <div class="tmpl"> <b>{{{param1|}}}</b> · <i>{{{param2|}}}</i> {{#if:{{{flag|}}}|<span class="flag">✓</span>|}} {{#if:{{{raw|}}}|<span class="raw">{{{raw}}}</span>|}} </div> | <!-- error / missing required --> <span class="error">TEMPLATE_NAME: missing required parameter</span> [[Category:Pages with TEMPLATE_NAME errors]] }}

Skeleton: Template:TEMPLATE_NAME/testcases

<!-- Testcases for TEMPLATE_NAME; render against /sandbox --> ; Minimal : {{TEMPLATE_NAME/sandbox}} ; Common params : {{TEMPLATE_NAME/sandbox | param1 = Alpha | param2 = Beta | flag = yes }} ; Edge and escaping : {{TEMPLATE_NAME/sandbox | param1 = [[Linked target|Visible text]] | param2 = 20250101T000000Z | raw = <code><span class="x">escaped</span></code> }} ; I18n : {{TEMPLATE_NAME/sandbox | lang = ja | text = こんにちは世界 }} ; Error handling : {{TEMPLATE_NAME/sandbox | required = }}

Review checklist

• Output is stable across re-parses; no expensive parser functions without need.
• No unexpected categorization in mainspace; errors go to maintenance cats.
• Template is documented at Template:TEMPLATE_NAME/doc with parameters, examples, and tracking.
• Style is minimal; avoid inline CSS unless necessary; consider using existing module or template styles.

Template:Terminate sentence ensures a sentence ends with a specified terminator (default: a period). It avoids adding duplicate terminators and can optionally trim trailing spaces. It attempts to ignore trailing closing quotes or brackets when deciding whether a terminator is already present.

Usage

Basic:

{{Terminate sentence|This is a sentence}}
→ This is a sentence.

Named parameters:

{{Terminate sentence
 |text=He said "Hello"
 |term=.
}}
→ He said "Hello".

Custom terminator:

{{Terminate sentence|text=Warning|term=!}}
→ Warning!

Avoid duplicate terminator:

{{Terminate sentence|text=Already done.|term=.}}
→ Already done.

Trim trailing spaces:

{{Terminate sentence|text=Ends with space   |trim=yes}}
→ Ends with space.

Skip processing:

{{Terminate sentence|text=No changes here|skip=yes}}
→ No changes here

Append a note:

{{Terminate sentence|text=Complete|note=(source: 2025)}}
→ Complete. (source: 2025)

Parameters

1 / text

The input text to terminate.

term

The terminator to enforce at the end. Default is .. Common choices: !, ?.

trim

If yes/true/1, strips trailing spaces before checking.

skip

If yes/true/1, returns text unchanged (still appends note if provided).

allowdup

If yes/true/1, allows duplicate terminators (e.g., ellipses). Default disallows duplicates.

note

Optional text appended after a space, unaffected by termination logic.

Behavior details

• Terminator detection attempts to ignore trailing closing quotes/brackets (", ', ”, ), ], }).
• If the last visible character equals term, no extra terminator is added unless allowdup=yes.
• If trim=yes, trailing spaces are removed before detection.
• If note is present, it is added with a leading space after the final text.

Examples

• Quotes:

{{Terminate sentence|text=He whispered "hush"|term=.}}

 → He whispered "hush".

• Parentheses:

{{Terminate sentence|text=Complete (verified)|term=.}}

 → Complete (verified).

• Exclamation:

{{Terminate sentence|text=Alert|term=!}}

 → Alert!

• Ellipsis (allow duplicates):

{{Terminate sentence|text=Wait...|term=.|allowdup=yes}}

 → Wait....

Best practices

• Prefer using term that matches the sentence intent (., !, ?).
• For complex punctuation, consider the Lua-powered variant below.
• Document usage in your template’s /doc page where you incorporate this helper.

Lua-powered variant (optional)

For more robust detection (including multilingual quotes and punctuation), create Module:TerminateUtil with:

-- Module:TerminateUtil
local M = {}

local closing = {
  [")"] = true, ["]"] = true, ["}"] = true,
  ['"'] = true, ["'"] = true, ["”"] = true, ["’"] = true, ["»"] = true, ["›"] = true
}

local function trimRight(s)
  return (s:gsub("%s+$",""))
end

function M.lastVisibleChar(args)
  local s = args.s or ""
  s = trimRight(s)
  local i = #s
  while i > 0 do
    local c = s:sub(i,i)
    if closing[c] then
      i = i - 1
    else
      return c
    end
  end
  return ""
end

return M

Then update the template to call:

{{#invoke:TerminateUtil|lastVisibleChar|s=text}}

This improves detection for closing quotes and brackets.

See also

• Help:Templates
• Help:ParserFunctions
• Wikipedia:Template documentation

Template sandbox and testcases for TEMPLATE_NAME

Overview

This page provides a clean workflow to safely edit and validate TEMPLATE_NAME:

• Sandbox: Template:TEMPLATE_NAME/sandbox — a working copy where you make changes.
• Testcases: Template:TEMPLATE_NAME/testcases — inputs that exercise typical and edge cases.
• Live: Template:TEMPLATE_NAME — the production version. Do not edit directly without review.

Use this page to:

• Preview sandbox output against fixed testcases without touching the live template.
• Compare actual vs expected output for each testcase.
• Track recent changes and invite reviewers.

Quick links

• Live template: Template:TEMPLATE_NAME
• Sandbox: Template:TEMPLATE_NAME/sandbox
• Testcases: Template:TEMPLATE_NAME/testcases
• Documentation: Template:TEMPLATE_NAME/doc (optional)
• Talk page: Template talk:TEMPLATE_NAME

How to test

1. Edit the sandbox at Template:TEMPLATE_NAME/sandbox. 2. Open this test page and click “Show preview” to render the sandbox with inputs below. 3. Verify each testcase: Does the “Actual output” match the “Expected output”? 4. If all pass, consider copying sandbox to live using an edit summary like:

  “Sync from /sandbox: passes all /testcases as of YYYY-MM-DD.”

Previewing tips

• Use “Preview page with this template” gadget or the built-in preview.
• Check parser output in different skins and mobile view.
• Validate accessibility: headings order, link text, ARIA where applicable.
• Internationalization: test with non-ASCII parameters and RTL where relevant.

Test harness

The following sections render the sandbox template against curated inputs. Each testcase shows:

• Parameters passed to the template
• Expected output (as plain wikitext target)
• Actual output (rendered via sandbox transclusion)

Testcase A: Minimal invocation

Parameters: {{TEMPLATE_NAME}}

Expected output: [Minimal successful output with defaults: e.g., a neutral message or basic box]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase B: Common parameters

Parameters: {{TEMPLATE_NAME | param1 = Alpha | param2 = Beta | flag = yes }}

Expected output: [Example: shows "Alpha" and "Beta" in designated slots; flag toggles enhanced styling]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase C: Edge values and escaping

Parameters: {{TEMPLATE_NAME | param1 = [[Linked target|Visible text]] | param2 = {{subst:CURRENTTIMESTAMP}} | raw = <code><span class="x">escaped</span></code> }}

Expected output: [Links render correctly; timestamp subst is literal in expected; raw shows escaped markup]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase D: Internationalization (i18n)

Parameters: {{TEMPLATE_NAME | lang = ja | text = こんにちは世界 }}

Expected output: [Text displays correctly for non-ASCII; applies lang attribute or rtl/ltr where applicable]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase E: Error handling

Parameters: {{TEMPLATE_NAME | param1 = | required = <!-- intentionally omitted --> }}

Expected output: [Shows a gentle error or maintenance category; does not break page layout]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

Maintenance

• Add new testcases when introducing features or fixing bugs.
• Keep “Expected output” updated; include rationale in edit summaries.
• When deprecating parameters, add tests demonstrating legacy behavior and warnings.

Copy-paste skeletons

Below are ready-to-use skeletons for the sandbox and testcases subpages.

Skeleton: Template:TEMPLATE_NAME/sandbox

<!-- Sandbox for TEMPLATE_NAME --> <!-- Copy the entire template source here; edit safely. --> {{#if:{{{required|}}} | <!-- normal output --> <div class="tmpl"> <b>{{{param1|}}}</b> · <i>{{{param2|}}}</i> {{#if:{{{flag|}}}|<span class="flag">✓</span>|}} {{#if:{{{raw|}}}|<span class="raw">{{{raw}}}</span>|}} </div> | <!-- error / missing required --> <span class="error">TEMPLATE_NAME: missing required parameter</span> [[Category:Pages with TEMPLATE_NAME errors]] }}

Skeleton: Template:TEMPLATE_NAME/testcases

<!-- Testcases for TEMPLATE_NAME; render against /sandbox --> ; Minimal : {{TEMPLATE_NAME/sandbox}} ; Common params : {{TEMPLATE_NAME/sandbox | param1 = Alpha | param2 = Beta | flag = yes }} ; Edge and escaping : {{TEMPLATE_NAME/sandbox | param1 = [[Linked target|Visible text]] | param2 = 20250101T000000Z | raw = <code><span class="x">escaped</span></code> }} ; I18n : {{TEMPLATE_NAME/sandbox | lang = ja | text = こんにちは世界 }} ; Error handling : {{TEMPLATE_NAME/sandbox | required = }}

Review checklist

• Output is stable across re-parses; no expensive parser functions without need.
• No unexpected categorization in mainspace; errors go to maintenance cats.
• Template is documented at Template:TEMPLATE_NAME/doc with parameters, examples, and tracking.
• Style is minimal; avoid inline CSS unless necessary; consider using existing module or template styles.

Template:Terminate sentence ensures a sentence ends with a specified terminator (default: a period). It avoids adding duplicate terminators and can optionally trim trailing spaces. It attempts to ignore trailing closing quotes or brackets when deciding whether a terminator is already present.

Usage

Basic:

{{Terminate sentence|This is a sentence}}
→ This is a sentence.

Named parameters:

{{Terminate sentence
 |text=He said "Hello"
 |term=.
}}
→ He said "Hello".

Custom terminator:

{{Terminate sentence|text=Warning|term=!}}
→ Warning!

Avoid duplicate terminator:

{{Terminate sentence|text=Already done.|term=.}}
→ Already done.

Trim trailing spaces:

{{Terminate sentence|text=Ends with space   |trim=yes}}
→ Ends with space.

Skip processing:

{{Terminate sentence|text=No changes here|skip=yes}}
→ No changes here

Append a note:

{{Terminate sentence|text=Complete|note=(source: 2025)}}
→ Complete. (source: 2025)

Parameters

1 / text

The input text to terminate.

term

The terminator to enforce at the end. Default is .. Common choices: !, ?.

trim

If yes/true/1, strips trailing spaces before checking.

skip

If yes/true/1, returns text unchanged (still appends note if provided).

allowdup

If yes/true/1, allows duplicate terminators (e.g., ellipses). Default disallows duplicates.

note

Optional text appended after a space, unaffected by termination logic.

Behavior details

• Terminator detection attempts to ignore trailing closing quotes/brackets (", ', ”, ), ], }).
• If the last visible character equals term, no extra terminator is added unless allowdup=yes.
• If trim=yes, trailing spaces are removed before detection.
• If note is present, it is added with a leading space after the final text.

Examples

• Quotes:

{{Terminate sentence|text=He whispered "hush"|term=.}}

 → He whispered "hush".

• Parentheses:

{{Terminate sentence|text=Complete (verified)|term=.}}

 → Complete (verified).

• Exclamation:

{{Terminate sentence|text=Alert|term=!}}

 → Alert!

• Ellipsis (allow duplicates):

{{Terminate sentence|text=Wait...|term=.|allowdup=yes}}

 → Wait....

Best practices

• Prefer using term that matches the sentence intent (., !, ?).
• For complex punctuation, consider the Lua-powered variant below.
• Document usage in your template’s /doc page where you incorporate this helper.

Lua-powered variant (optional)

For more robust detection (including multilingual quotes and punctuation), create Module:TerminateUtil with:

-- Module:TerminateUtil
local M = {}

local closing = {
  [")"] = true, ["]"] = true, ["}"] = true,
  ['"'] = true, ["'"] = true, ["”"] = true, ["’"] = true, ["»"] = true, ["›"] = true
}

local function trimRight(s)
  return (s:gsub("%s+$",""))
end

function M.lastVisibleChar(args)
  local s = args.s or ""
  s = trimRight(s)
  local i = #s
  while i > 0 do
    local c = s:sub(i,i)
    if closing[c] then
      i = i - 1
    else
      return c
    end
  end
  return ""
end

return M

Then update the template to call:

{{#invoke:TerminateUtil|lastVisibleChar|s=text}}

This improves detection for closing quotes and brackets.

See also

• Help:Templates
• Help:ParserFunctions
• Wikipedia:Template documentation

Template sandbox and testcases for TEMPLATE_NAME

Overview

This page provides a clean workflow to safely edit and validate TEMPLATE_NAME:

• Sandbox: Template:TEMPLATE_NAME/sandbox — a working copy where you make changes.
• Testcases: Template:TEMPLATE_NAME/testcases — inputs that exercise typical and edge cases.
• Live: Template:TEMPLATE_NAME — the production version. Do not edit directly without review.

Use this page to:

• Preview sandbox output against fixed testcases without touching the live template.
• Compare actual vs expected output for each testcase.
• Track recent changes and invite reviewers.

Quick links

• Live template: Template:TEMPLATE_NAME
• Sandbox: Template:TEMPLATE_NAME/sandbox
• Testcases: Template:TEMPLATE_NAME/testcases
• Documentation: Template:TEMPLATE_NAME/doc (optional)
• Talk page: Template talk:TEMPLATE_NAME

How to test

1. Edit the sandbox at Template:TEMPLATE_NAME/sandbox. 2. Open this test page and click “Show preview” to render the sandbox with inputs below. 3. Verify each testcase: Does the “Actual output” match the “Expected output”? 4. If all pass, consider copying sandbox to live using an edit summary like:

  “Sync from /sandbox: passes all /testcases as of YYYY-MM-DD.”

Previewing tips

• Use “Preview page with this template” gadget or the built-in preview.
• Check parser output in different skins and mobile view.
• Validate accessibility: headings order, link text, ARIA where applicable.
• Internationalization: test with non-ASCII parameters and RTL where relevant.

Test harness

The following sections render the sandbox template against curated inputs. Each testcase shows:

• Parameters passed to the template
• Expected output (as plain wikitext target)
• Actual output (rendered via sandbox transclusion)

Testcase A: Minimal invocation

Parameters: {{TEMPLATE_NAME}}

Expected output: [Minimal successful output with defaults: e.g., a neutral message or basic box]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase B: Common parameters

Parameters: {{TEMPLATE_NAME | param1 = Alpha | param2 = Beta | flag = yes }}

Expected output: [Example: shows "Alpha" and "Beta" in designated slots; flag toggles enhanced styling]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase C: Edge values and escaping

Parameters: {{TEMPLATE_NAME | param1 = [[Linked target|Visible text]] | param2 = {{subst:CURRENTTIMESTAMP}} | raw = <code><span class="x">escaped</span></code> }}

Expected output: [Links render correctly; timestamp subst is literal in expected; raw shows escaped markup]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase D: Internationalization (i18n)

Parameters: {{TEMPLATE_NAME | lang = ja | text = こんにちは世界 }}

Expected output: [Text displays correctly for non-ASCII; applies lang attribute or rtl/ltr where applicable]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase E: Error handling

Parameters: {{TEMPLATE_NAME | param1 = | required = <!-- intentionally omitted --> }}

Expected output: [Shows a gentle error or maintenance category; does not break page layout]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

Maintenance

• Add new testcases when introducing features or fixing bugs.
• Keep “Expected output” updated; include rationale in edit summaries.
• When deprecating parameters, add tests demonstrating legacy behavior and warnings.

Copy-paste skeletons

Below are ready-to-use skeletons for the sandbox and testcases subpages.

Skeleton: Template:TEMPLATE_NAME/sandbox

<!-- Sandbox for TEMPLATE_NAME --> <!-- Copy the entire template source here; edit safely. --> {{#if:{{{required|}}} | <!-- normal output --> <div class="tmpl"> <b>{{{param1|}}}</b> · <i>{{{param2|}}}</i> {{#if:{{{flag|}}}|<span class="flag">✓</span>|}} {{#if:{{{raw|}}}|<span class="raw">{{{raw}}}</span>|}} </div> | <!-- error / missing required --> <span class="error">TEMPLATE_NAME: missing required parameter</span> [[Category:Pages with TEMPLATE_NAME errors]] }}

Skeleton: Template:TEMPLATE_NAME/testcases

<!-- Testcases for TEMPLATE_NAME; render against /sandbox --> ; Minimal : {{TEMPLATE_NAME/sandbox}} ; Common params : {{TEMPLATE_NAME/sandbox | param1 = Alpha | param2 = Beta | flag = yes }} ; Edge and escaping : {{TEMPLATE_NAME/sandbox | param1 = [[Linked target|Visible text]] | param2 = 20250101T000000Z | raw = <code><span class="x">escaped</span></code> }} ; I18n : {{TEMPLATE_NAME/sandbox | lang = ja | text = こんにちは世界 }} ; Error handling : {{TEMPLATE_NAME/sandbox | required = }}

Review checklist

• Output is stable across re-parses; no expensive parser functions without need.
• No unexpected categorization in mainspace; errors go to maintenance cats.
• Template is documented at Template:TEMPLATE_NAME/doc with parameters, examples, and tracking.
• Style is minimal; avoid inline CSS unless necessary; consider using existing module or template styles.

Template:Terminate sentence ensures a sentence ends with a specified terminator (default: a period). It avoids adding duplicate terminators and can optionally trim trailing spaces. It attempts to ignore trailing closing quotes or brackets when deciding whether a terminator is already present.

Usage

Basic:

{{Terminate sentence|This is a sentence}}
→ This is a sentence.

Named parameters:

{{Terminate sentence
 |text=He said "Hello"
 |term=.
}}
→ He said "Hello".

Custom terminator:

{{Terminate sentence|text=Warning|term=!}}
→ Warning!

Avoid duplicate terminator:

{{Terminate sentence|text=Already done.|term=.}}
→ Already done.

Trim trailing spaces:

{{Terminate sentence|text=Ends with space   |trim=yes}}
→ Ends with space.

Skip processing:

{{Terminate sentence|text=No changes here|skip=yes}}
→ No changes here

Append a note:

{{Terminate sentence|text=Complete|note=(source: 2025)}}
→ Complete. (source: 2025)

Parameters

1 / text

The input text to terminate.

term

The terminator to enforce at the end. Default is .. Common choices: !, ?.

trim

If yes/true/1, strips trailing spaces before checking.

skip

If yes/true/1, returns text unchanged (still appends note if provided).

allowdup

If yes/true/1, allows duplicate terminators (e.g., ellipses). Default disallows duplicates.

note

Optional text appended after a space, unaffected by termination logic.

Behavior details

• Terminator detection attempts to ignore trailing closing quotes/brackets (", ', ”, ), ], }).
• If the last visible character equals term, no extra terminator is added unless allowdup=yes.
• If trim=yes, trailing spaces are removed before detection.
• If note is present, it is added with a leading space after the final text.

Examples

• Quotes:

{{Terminate sentence|text=He whispered "hush"|term=.}}

 → He whispered "hush".

• Parentheses:

{{Terminate sentence|text=Complete (verified)|term=.}}

 → Complete (verified).

• Exclamation:

{{Terminate sentence|text=Alert|term=!}}

 → Alert!

• Ellipsis (allow duplicates):

{{Terminate sentence|text=Wait...|term=.|allowdup=yes}}

 → Wait....

Best practices

• Prefer using term that matches the sentence intent (., !, ?).
• For complex punctuation, consider the Lua-powered variant below.
• Document usage in your template’s /doc page where you incorporate this helper.

Lua-powered variant (optional)

For more robust detection (including multilingual quotes and punctuation), create Module:TerminateUtil with:

-- Module:TerminateUtil
local M = {}

local closing = {
  [")"] = true, ["]"] = true, ["}"] = true,
  ['"'] = true, ["'"] = true, ["”"] = true, ["’"] = true, ["»"] = true, ["›"] = true
}

local function trimRight(s)
  return (s:gsub("%s+$",""))
end

function M.lastVisibleChar(args)
  local s = args.s or ""
  s = trimRight(s)
  local i = #s
  while i > 0 do
    local c = s:sub(i,i)
    if closing[c] then
      i = i - 1
    else
      return c
    end
  end
  return ""
end

return M

Then update the template to call:

{{#invoke:TerminateUtil|lastVisibleChar|s=text}}

This improves detection for closing quotes and brackets.

See also

• Help:Templates
• Help:ParserFunctions
• Wikipedia:Template documentation

Template sandbox and testcases for TEMPLATE_NAME

Overview

This page provides a clean workflow to safely edit and validate TEMPLATE_NAME:

• Sandbox: Template:TEMPLATE_NAME/sandbox — a working copy where you make changes.
• Testcases: Template:TEMPLATE_NAME/testcases — inputs that exercise typical and edge cases.
• Live: Template:TEMPLATE_NAME — the production version. Do not edit directly without review.

Use this page to:

• Preview sandbox output against fixed testcases without touching the live template.
• Compare actual vs expected output for each testcase.
• Track recent changes and invite reviewers.

Quick links

• Live template: Template:TEMPLATE_NAME
• Sandbox: Template:TEMPLATE_NAME/sandbox
• Testcases: Template:TEMPLATE_NAME/testcases
• Documentation: Template:TEMPLATE_NAME/doc (optional)
• Talk page: Template talk:TEMPLATE_NAME

How to test

1. Edit the sandbox at Template:TEMPLATE_NAME/sandbox. 2. Open this test page and click “Show preview” to render the sandbox with inputs below. 3. Verify each testcase: Does the “Actual output” match the “Expected output”? 4. If all pass, consider copying sandbox to live using an edit summary like:

  “Sync from /sandbox: passes all /testcases as of YYYY-MM-DD.”

Previewing tips

• Use “Preview page with this template” gadget or the built-in preview.
• Check parser output in different skins and mobile view.
• Validate accessibility: headings order, link text, ARIA where applicable.
• Internationalization: test with non-ASCII parameters and RTL where relevant.

Test harness

The following sections render the sandbox template against curated inputs. Each testcase shows:

• Parameters passed to the template
• Expected output (as plain wikitext target)
• Actual output (rendered via sandbox transclusion)

Testcase A: Minimal invocation

Parameters: {{TEMPLATE_NAME}}

Expected output: [Minimal successful output with defaults: e.g., a neutral message or basic box]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase B: Common parameters

Parameters: {{TEMPLATE_NAME | param1 = Alpha | param2 = Beta | flag = yes }}

Expected output: [Example: shows "Alpha" and "Beta" in designated slots; flag toggles enhanced styling]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase C: Edge values and escaping

Parameters: {{TEMPLATE_NAME | param1 = [[Linked target|Visible text]] | param2 = {{subst:CURRENTTIMESTAMP}} | raw = <code><span class="x">escaped</span></code> }}

Expected output: [Links render correctly; timestamp subst is literal in expected; raw shows escaped markup]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase D: Internationalization (i18n)

Parameters: {{TEMPLATE_NAME | lang = ja | text = こんにちは世界 }}

Expected output: [Text displays correctly for non-ASCII; applies lang attribute or rtl/ltr where applicable]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase E: Error handling

Parameters: {{TEMPLATE_NAME | param1 = | required = <!-- intentionally omitted --> }}

Expected output: [Shows a gentle error or maintenance category; does not break page layout]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

Maintenance

• Add new testcases when introducing features or fixing bugs.
• Keep “Expected output” updated; include rationale in edit summaries.
• When deprecating parameters, add tests demonstrating legacy behavior and warnings.

Copy-paste skeletons

Below are ready-to-use skeletons for the sandbox and testcases subpages.

Skeleton: Template:TEMPLATE_NAME/sandbox

<!-- Sandbox for TEMPLATE_NAME --> <!-- Copy the entire template source here; edit safely. --> {{#if:{{{required|}}} | <!-- normal output --> <div class="tmpl"> <b>{{{param1|}}}</b> · <i>{{{param2|}}}</i> {{#if:{{{flag|}}}|<span class="flag">✓</span>|}} {{#if:{{{raw|}}}|<span class="raw">{{{raw}}}</span>|}} </div> | <!-- error / missing required --> <span class="error">TEMPLATE_NAME: missing required parameter</span> [[Category:Pages with TEMPLATE_NAME errors]] }}

Skeleton: Template:TEMPLATE_NAME/testcases

<!-- Testcases for TEMPLATE_NAME; render against /sandbox --> ; Minimal : {{TEMPLATE_NAME/sandbox}} ; Common params : {{TEMPLATE_NAME/sandbox | param1 = Alpha | param2 = Beta | flag = yes }} ; Edge and escaping : {{TEMPLATE_NAME/sandbox | param1 = [[Linked target|Visible text]] | param2 = 20250101T000000Z | raw = <code><span class="x">escaped</span></code> }} ; I18n : {{TEMPLATE_NAME/sandbox | lang = ja | text = こんにちは世界 }} ; Error handling : {{TEMPLATE_NAME/sandbox | required = }}

Review checklist

• Output is stable across re-parses; no expensive parser functions without need.
• No unexpected categorization in mainspace; errors go to maintenance cats.
• Template is documented at Template:TEMPLATE_NAME/doc with parameters, examples, and tracking.
• Style is minimal; avoid inline CSS unless necessary; consider using existing module or template styles.

Template:Terminate sentence ensures a sentence ends with a specified terminator (default: a period). It avoids adding duplicate terminators and can optionally trim trailing spaces. It attempts to ignore trailing closing quotes or brackets when deciding whether a terminator is already present.

Usage

Basic:

{{Terminate sentence|This is a sentence}}
→ This is a sentence.

Named parameters:

{{Terminate sentence
 |text=He said "Hello"
 |term=.
}}
→ He said "Hello".

Custom terminator:

{{Terminate sentence|text=Warning|term=!}}
→ Warning!

Avoid duplicate terminator:

{{Terminate sentence|text=Already done.|term=.}}
→ Already done.

Trim trailing spaces:

{{Terminate sentence|text=Ends with space   |trim=yes}}
→ Ends with space.

Skip processing:

{{Terminate sentence|text=No changes here|skip=yes}}
→ No changes here

Append a note:

{{Terminate sentence|text=Complete|note=(source: 2025)}}
→ Complete. (source: 2025)

Parameters

1 / text

The input text to terminate.

term

The terminator to enforce at the end. Default is .. Common choices: !, ?.

trim

If yes/true/1, strips trailing spaces before checking.

skip

If yes/true/1, returns text unchanged (still appends note if provided).

allowdup

If yes/true/1, allows duplicate terminators (e.g., ellipses). Default disallows duplicates.

note

Optional text appended after a space, unaffected by termination logic.

Behavior details

• Terminator detection attempts to ignore trailing closing quotes/brackets (", ', ”, ), ], }).
• If the last visible character equals term, no extra terminator is added unless allowdup=yes.
• If trim=yes, trailing spaces are removed before detection.
• If note is present, it is added with a leading space after the final text.

Examples

• Quotes:

{{Terminate sentence|text=He whispered "hush"|term=.}}

 → He whispered "hush".

• Parentheses:

{{Terminate sentence|text=Complete (verified)|term=.}}

 → Complete (verified).

• Exclamation:

{{Terminate sentence|text=Alert|term=!}}

 → Alert!

• Ellipsis (allow duplicates):

{{Terminate sentence|text=Wait...|term=.|allowdup=yes}}

 → Wait....

Best practices

• Prefer using term that matches the sentence intent (., !, ?).
• For complex punctuation, consider the Lua-powered variant below.
• Document usage in your template’s /doc page where you incorporate this helper.

Lua-powered variant (optional)

For more robust detection (including multilingual quotes and punctuation), create Module:TerminateUtil with:

-- Module:TerminateUtil
local M = {}

local closing = {
  [")"] = true, ["]"] = true, ["}"] = true,
  ['"'] = true, ["'"] = true, ["”"] = true, ["’"] = true, ["»"] = true, ["›"] = true
}

local function trimRight(s)
  return (s:gsub("%s+$",""))
end

function M.lastVisibleChar(args)
  local s = args.s or ""
  s = trimRight(s)
  local i = #s
  while i > 0 do
    local c = s:sub(i,i)
    if closing[c] then
      i = i - 1
    else
      return c
    end
  end
  return ""
end

return M

Then update the template to call:

{{#invoke:TerminateUtil|lastVisibleChar|s=text}}

This improves detection for closing quotes and brackets.

See also

• Help:Templates
• Help:ParserFunctions
• Wikipedia:Template documentation

Template sandbox and testcases for TEMPLATE_NAME

Overview

This page provides a clean workflow to safely edit and validate TEMPLATE_NAME:

• Sandbox: Template:TEMPLATE_NAME/sandbox — a working copy where you make changes.
• Testcases: Template:TEMPLATE_NAME/testcases — inputs that exercise typical and edge cases.
• Live: Template:TEMPLATE_NAME — the production version. Do not edit directly without review.

Use this page to:

• Preview sandbox output against fixed testcases without touching the live template.
• Compare actual vs expected output for each testcase.
• Track recent changes and invite reviewers.

Quick links

• Live template: Template:TEMPLATE_NAME
• Sandbox: Template:TEMPLATE_NAME/sandbox
• Testcases: Template:TEMPLATE_NAME/testcases
• Documentation: Template:TEMPLATE_NAME/doc (optional)
• Talk page: Template talk:TEMPLATE_NAME

How to test

1. Edit the sandbox at Template:TEMPLATE_NAME/sandbox. 2. Open this test page and click “Show preview” to render the sandbox with inputs below. 3. Verify each testcase: Does the “Actual output” match the “Expected output”? 4. If all pass, consider copying sandbox to live using an edit summary like:

  “Sync from /sandbox: passes all /testcases as of YYYY-MM-DD.”

Previewing tips

• Use “Preview page with this template” gadget or the built-in preview.
• Check parser output in different skins and mobile view.
• Validate accessibility: headings order, link text, ARIA where applicable.
• Internationalization: test with non-ASCII parameters and RTL where relevant.

Test harness

The following sections render the sandbox template against curated inputs. Each testcase shows:

• Parameters passed to the template
• Expected output (as plain wikitext target)
• Actual output (rendered via sandbox transclusion)

Testcase A: Minimal invocation

Parameters: {{TEMPLATE_NAME}}

Expected output: [Minimal successful output with defaults: e.g., a neutral message or basic box]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase B: Common parameters

Parameters: {{TEMPLATE_NAME | param1 = Alpha | param2 = Beta | flag = yes }}

Expected output: [Example: shows "Alpha" and "Beta" in designated slots; flag toggles enhanced styling]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase C: Edge values and escaping

Parameters: {{TEMPLATE_NAME | param1 = [[Linked target|Visible text]] | param2 = {{subst:CURRENTTIMESTAMP}} | raw = <code><span class="x">escaped</span></code> }}

Expected output: [Links render correctly; timestamp subst is literal in expected; raw shows escaped markup]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase D: Internationalization (i18n)

Parameters: {{TEMPLATE_NAME | lang = ja | text = こんにちは世界 }}

Expected output: [Text displays correctly for non-ASCII; applies lang attribute or rtl/ltr where applicable]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

---

Testcase E: Error handling

Parameters: {{TEMPLATE_NAME | param1 = | required = <!-- intentionally omitted --> }}

Expected output: [Shows a gentle error or maintenance category; does not break page layout]

Actual output (sandbox):

Character and language test sandbox

This sandbox is used to test how Template:TEMPLATE NAME behaves with special characters (such as Greek letters) and language-specific spans.

Basic examples

• Greek letter (direct character): α
• Greek letter (HTML entity): γ
• German span example: A

Within the template

Below are example calls of the template using these characters as parameters.

{{TEMPLATE NAME | title = Greek test: α γ | summary = Demonstrating Greek letters: α, β, γ, and entities like γ. | attr1 = Direct Greek: α β γ δ | attr2 = Entity Greek: α β γ δ | attr3 = German label: <span lang="de">A</span>, English label: A }}

Preview the page to check if:

• Greek characters (α, β, γ, δ) display correctly.
• HTML entities (α, β, γ, δ) render as the expected symbols.
• The A is kept as a German-language span and does not break the layout.

Notes

• Use this sandbox to experiment with different scripts (Greek, Cyrillic, etc.).
• Test right-to-left scripts by adding spans with lang="ar" or lang="he".
• If the template trims or escapes some of these, adjust the template code accordingly.

Maintenance

• Add new testcases when introducing features or fixing bugs.
• Keep “Expected output” updated; include rationale in edit summaries.
• When deprecating parameters, add tests demonstrating legacy behavior and warnings.

Copy-paste skeletons

Below are ready-to-use skeletons for the sandbox and testcases subpages.

Skeleton: Template:TEMPLATE_NAME/sandbox

<!-- Sandbox for TEMPLATE_NAME --> <!-- Copy the entire template source here; edit safely. --> {{#if:{{{required|}}} | <!-- normal output --> <div class="tmpl"> <b>{{{param1|}}}</b> · <i>{{{param2|}}}</i> {{#if:{{{flag|}}}|<span class="flag">✓</span>|}} {{#if:{{{raw|}}}|<span class="raw">{{{raw}}}</span>|}} </div> | <!-- error / missing required --> <span class="error">TEMPLATE_NAME: missing required parameter</span> [[Category:Pages with TEMPLATE_NAME errors]] }}

Skeleton: Template:TEMPLATE_NAME/testcases

<!-- Testcases for TEMPLATE_NAME; render against /sandbox --> ; Minimal : {{TEMPLATE_NAME/sandbox}} ; Common params : {{TEMPLATE_NAME/sandbox | param1 = Alpha | param2 = Beta | flag = yes }} ; Edge and escaping : {{TEMPLATE_NAME/sandbox | param1 = [[Linked target|Visible text]] | param2 = 20250101T000000Z | raw = <code><span class="x">escaped</span></code> }} ; I18n : {{TEMPLATE_NAME/sandbox | lang = ja | text = こんにちは世界 }} ; Error handling : {{TEMPLATE_NAME/sandbox | required = }}

Review checklist

• Output is stable across re-parses; no expensive parser functions without need.
• No unexpected categorization in mainspace; errors go to maintenance cats.
• Template is documented at Template:TEMPLATE_NAME/doc with parameters, examples, and tracking.
• Style is minimal; avoid inline CSS unless necessary; consider using existing module or template styles.

Template:Terminate sentence ensures a sentence ends with a specified terminator (default: a period). It avoids adding duplicate terminators and can optionally trim trailing spaces. It attempts to ignore trailing closing quotes or brackets when deciding whether a terminator is already present.

Usage

Basic:

{{Terminate sentence|This is a sentence}}
→ This is a sentence.

Named parameters:

{{Terminate sentence
 |text=He said "Hello"
 |term=.
}}
→ He said "Hello".

Custom terminator:

{{Terminate sentence|text=Warning|term=!}}
→ Warning!

Avoid duplicate terminator:

{{Terminate sentence|text=Already done.|term=.}}
→ Already done.

Trim trailing spaces:

{{Terminate sentence|text=Ends with space   |trim=yes}}
→ Ends with space.

Skip processing:

{{Terminate sentence|text=No changes here|skip=yes}}
→ No changes here

Append a note:

{{Terminate sentence|text=Complete|note=(source: 2025)}}
→ Complete. (source: 2025)

Parameters

1 / text

The input text to terminate.

term

The terminator to enforce at the end. Default is .. Common choices: !, ?.

trim

If yes/true/1, strips trailing spaces before checking.

skip

If yes/true/1, returns text unchanged (still appends note if provided).

allowdup

If yes/true/1, allows duplicate terminators (e.g., ellipses). Default disallows duplicates.

note

Optional text appended after a space, unaffected by termination logic.

Behavior details

• Terminator detection attempts to ignore trailing closing quotes/brackets (", ', ”, ), ], }).
• If the last visible character equals term, no extra terminator is added unless allowdup=yes.
• If trim=yes, trailing spaces are removed before detection.
• If note is present, it is added with a leading space after the final text.

Examples

• Quotes:

{{Terminate sentence|text=He whispered "hush"|term=.}}

 → He whispered "hush".

• Parentheses:

{{Terminate sentence|text=Complete (verified)|term=.}}

 → Complete (verified).

• Exclamation:

{{Terminate sentence|text=Alert|term=!}}

 → Alert!

• Ellipsis (allow duplicates):

{{Terminate sentence|text=Wait...|term=.|allowdup=yes}}

 → Wait....

Best practices

• Prefer using term that matches the sentence intent (., !, ?).
• For complex punctuation, consider the Lua-powered variant below.
• Document usage in your template’s /doc page where you incorporate this helper.

Lua-powered variant (optional)

For more robust detection (including multilingual quotes and punctuation), create Module:TerminateUtil with:

-- Module:TerminateUtil
local M = {}

local closing = {
  [")"] = true, ["]"] = true, ["}"] = true,
  ['"'] = true, ["'"] = true, ["”"] = true, ["’"] = true, ["»"] = true, ["›"] = true
}

local function trimRight(s)
  return (s:gsub("%s+$",""))
end

function M.lastVisibleChar(args)
  local s = args.s or ""
  s = trimRight(s)
  local i = #s
  while i > 0 do
    local c = s:sub(i,i)
    if closing[c] then
      i = i - 1
    else
      return c
    end
  end
  return ""
end

return M

Then update the template to call:

{{#invoke:TerminateUtil|lastVisibleChar|s=text}}

This improves detection for closing quotes and brackets.

See also

• Help:Templates
• Help:ParserFunctions
• Wikipedia:Template documentation