rolly 1.0.0__tar.gz

rolly-1.0.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.3
+Name: rolly
+Version: 1.0.0
+Summary: Roll dice on the command line because why not?
+Author: George Lesica
+Author-email: George Lesica <george@lesica.com>
+Requires-Dist: click>=8.3.0
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+![Rolly Mascot](mascot.png)
+
+# Rolly
+
+Rolling dice the boring way.
+
+## Introduction
+
+A roll is expressed as a single string of text that contains a
+sequence of instructions. Whitespace between instructions is entirely
+ignored. There are different ways to express the same roll,
+some being shorter than others. Below, we roll 3 D20s with
+advantage in three different ways.
+
+```
+d20 d20 d20+
+
+d20 x3+
+
+d20 d20x2 +
+```
+
+## Instructions
+
+The available instructions are listed below.
+
+  * A die to be rolled: `dN`, `N` is the number of sides
+  * Roll multiple dice: `xM`, `M` is the number of the previous die to roll
+  * Advantage on the roll: `+` anywhere in the string
+  * Disadvantage on the roll: `-` anywhere in the string
+
+## Examples
+
+So a number prefixed with `d` implies `x1` and a space between a number
+and a count is ignored. Advantage is indicated by a `+` anywhere in the
+string, disadvantage is a `-`.
+
+```
+d20x2 +
+a d20 d20
+d20x2-
+```
+
+## CLI
+
+The CLI is straightforward. Once the package is installed, it can be run
+as a module:
+
+```
+$ python -m rolly
+```
+
+This will show the help text. The primary command is `roll`, which takes
+a string of instructions and displays the result.
+
+```
+$ python -m rolly roll d20x3
+   ▄▄▄▄              ▄▄▄     ▄▄▄▄▄▄▄▄           ▄▄▄▄▄
+  ██▀▀▀█            █▀██     ▀▀▀▀▀███          █▀▀▀▀██▄
+ ██ ▄▄▄               ██         ▄██                ▄██
+ ███▀▀██▄             ██         ██              █████
+ ██    ██             ██        ██                  ▀██
+ ▀██▄▄██▀          ▄▄▄██▄▄▄    ██              █▄▄▄▄██▀
+   ▀▀▀▀            ▀▀▀▀▀▀▀▀   ▀▀                ▀▀▀▀▀
+```
+
+The default uses ASCII art, but passing the `--plain` (`-p`) flag will
+cause it to use plain text.
+```
+$ python -m rolly roll d20x3
+6 17 3
+```
+
+It is also possible to sum the dice automatically using the `--add` (`-a`)
+flag:
+
+```
+$ python -m rolly roll -ap d20x3
+16 12 7
+= 35
+```
+
+The ASCII art theme can be changed with the `--theme` (`-t`) option and
+the available themes can be listed with the `themes` command.

rolly-1.0.0/README.md

@@ -0,0 +1,84 @@
+![Rolly Mascot](mascot.png)
+
+# Rolly
+
+Rolling dice the boring way.
+
+## Introduction
+
+A roll is expressed as a single string of text that contains a
+sequence of instructions. Whitespace between instructions is entirely
+ignored. There are different ways to express the same roll,
+some being shorter than others. Below, we roll 3 D20s with
+advantage in three different ways.
+
+```
+d20 d20 d20+
+
+d20 x3+
+
+d20 d20x2 +
+```
+
+## Instructions
+
+The available instructions are listed below.
+
+  * A die to be rolled: `dN`, `N` is the number of sides
+  * Roll multiple dice: `xM`, `M` is the number of the previous die to roll
+  * Advantage on the roll: `+` anywhere in the string
+  * Disadvantage on the roll: `-` anywhere in the string
+
+## Examples
+
+So a number prefixed with `d` implies `x1` and a space between a number
+and a count is ignored. Advantage is indicated by a `+` anywhere in the
+string, disadvantage is a `-`.
+
+```
+d20x2 +
+a d20 d20
+d20x2-
+```
+
+## CLI
+
+The CLI is straightforward. Once the package is installed, it can be run
+as a module:
+
+```
+$ python -m rolly
+```
+
+This will show the help text. The primary command is `roll`, which takes
+a string of instructions and displays the result.
+
+```
+$ python -m rolly roll d20x3
+   ▄▄▄▄              ▄▄▄     ▄▄▄▄▄▄▄▄           ▄▄▄▄▄
+  ██▀▀▀█            █▀██     ▀▀▀▀▀███          █▀▀▀▀██▄
+ ██ ▄▄▄               ██         ▄██                ▄██
+ ███▀▀██▄             ██         ██              █████
+ ██    ██             ██        ██                  ▀██
+ ▀██▄▄██▀          ▄▄▄██▄▄▄    ██              █▄▄▄▄██▀
+   ▀▀▀▀            ▀▀▀▀▀▀▀▀   ▀▀                ▀▀▀▀▀
+```
+
+The default uses ASCII art, but passing the `--plain` (`-p`) flag will
+cause it to use plain text.
+```
+$ python -m rolly roll d20x3
+6 17 3
+```
+
+It is also possible to sum the dice automatically using the `--add` (`-a`)
+flag:
+
+```
+$ python -m rolly roll -ap d20x3
+16 12 7
+= 35
+```
+
+The ASCII art theme can be changed with the `--theme` (`-t`) option and
+the available themes can be listed with the `themes` command.

rolly-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "rolly"
+version = "1.0.0"
+description = "Roll dice on the command line because why not?"
+readme = "README.md"
+authors = [
+    { name = "George Lesica", email = "george@lesica.com" }
+]
+requires-python = ">=3.14"
+dependencies = [
+    "click>=8.3.0",
+]
+
+[project.scripts]
+rolly = "rolly:main"
+
+[build-system]
+requires = ["uv_build>=0.9.7,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.2",
+]

rolly-1.0.0/src/rolly/__init__.py

@@ -0,0 +1,27 @@
+from .roll import (
+    Roll as Roll,
+)
+
+from .output import (
+    Formatter as Formatter,
+    ArtFormatter as ArtFormatter,
+    TextFormatter as TextFormatter,
+)
+
+from .themes import (
+    Theme as Theme,
+    get_theme as get_theme,
+)
+
+
+# CLI interface for Rolly
+
+def main():
+    import click
+
+    from .cli import entry
+
+    try:
+        entry()
+    except RuntimeError as e:
+        click.echo(e)

rolly-1.0.0/src/rolly/char.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+from typing import Dict
+
+
+@dataclass
+class Character:
+    _data: Dict
+
+    _abil: Dict[str, int]
+    _save: Dict[str, int]
+
+    def __init__(self, path: str):
+        with open(path, 'rb') as f:
+            import tomllib
+            data = tomllib.load(f)
+
+        for sec, data in data:
+            match (sec, data):
+                case ('abilities', {
+                    'str': int(),
+                    'dex': int(),
+                    'con': int(),
+                    'int': int(),
+                    'wis': int(),
+                    'cha': int(),
+                }):
+                    for attr in ('str', 'dex', 'con', 'int', 'wis', 'cha'):
+                        self._abil[attr] = data[attr]
+
+                case ('saves', {
+                    'str': int(),
+                    'dex': int(),
+                    'con': int(),
+                    'int': int(),
+                    'wis': int(),
+                    'cha': int(),
+                }):
+                    for attr in ('str', 'dex', 'con', 'int', 'wis', 'cha'):
+                        self._save[attr] = data[attr]
+
+                case _:
+                    raise RuntimeError(f'invalid character section: {sec}')
+
+    def has_attr(self, attr: str) -> bool:
+        return attr in self._abil or attr in self._save
+
+    def abil_val(self, attr: str) -> int:
+        if self.has_attr(attr):
+            return self._abil[attr]
+        return 0
+
+    def save_val(self, attr: str) -> int:
+        if self.has_attr(attr):
+            return self._save[attr]
+        return 0

rolly-1.0.0/src/rolly/cli.py

@@ -0,0 +1,73 @@
+from typing import Tuple
+
+import click
+
+
+@click.group()
+def entry():
+    pass
+
+
+@entry.command()
+def themes():
+    from .themes import get_themes
+
+    click.echo("Available themes:")
+    for name in get_themes():
+        click.echo(f"  {name}")
+
+
+# TODO: The formatter (and theme) can be determined automatically
+# Use click to decode the value passed (I think)
+
+@entry.command()
+@click.option("--plain", "-p", is_flag=True, flag_value=True, help="Display the coin flip as plain text")
+@click.option("--theme", "-t", type=str, default='default', help="Name of the display theme to use")
+def flip(plain: bool, theme: str):
+    from .roll import Roll
+    from .output import TextFormatter, ArtFormatter
+    from .themes import get_theme
+
+    if plain:
+        fmt = TextFormatter()
+    else:
+        t = get_theme(theme)
+        fmt = ArtFormatter(t)
+
+    letters = {1: 'H', 2: 'T'}
+
+    v = Roll("d2").roll()[0]
+
+    out = fmt.text(letters[v])
+    click.echo(out)
+
+
+@entry.command()
+@click.argument("s", type=str, nargs=-1, required=True)
+@click.option("--add", "-a", is_flag=True, flag_value=True, help="Add up the dice and display a total")
+@click.option("--plain", "-p", is_flag=True, flag_value=True, help="Display the roll as plain text")
+@click.option("--theme", "-t", type=str, default='default', help="Name of the display theme to use")
+def roll(s: Tuple[str, ...], add: bool, plain: bool, theme: str):
+    from .roll import Roll
+    from .output import TextFormatter, ArtFormatter
+    from .themes import get_theme
+
+    if plain:
+        fmt = TextFormatter()
+    else:
+        t = get_theme(theme)
+        fmt = ArtFormatter(t)
+
+    in_str = ' '.join(s)
+
+    r = Roll()
+    r.parse(in_str)
+
+    vs = r.roll()
+
+    out = ' '.join(str(v) for v in vs)
+    if add:
+        out += f'\n= {str(sum(vs))}'
+
+    fmt_out = fmt.text(out)
+    click.echo(fmt_out)

rolly-1.0.0/src/rolly/output.py

@@ -0,0 +1,39 @@
+from typing import List, Protocol
+
+from .themes import Theme
+
+
+class Formatter(Protocol):
+    def nums(self, vs: List[int], sep: str = '') -> str:
+        raise NotImplementedError
+
+    def num(self, v: int) -> str:
+        raise NotImplementedError
+
+    def text(self, s: str) -> str:
+        raise NotImplementedError
+
+
+class ArtFormatter(Formatter):
+    def __init__(self, theme: Theme):
+        self._theme = theme
+
+    def nums(self, vs: List[int], sep: str = '') -> str:
+        return self._theme.render(sep.join(str(v) for v in vs))
+
+    def num(self, v: int) -> str:
+        return self.nums([v])
+
+    def text(self, s: str) -> str:
+        return self._theme.render(s)
+
+
+class TextFormatter(Formatter):
+    def nums(self, vs: List[int], sep: str = '') -> str:
+        return sep.join(str(v) for v in vs)
+
+    def num(self, v: int) -> str:
+        return self.nums([v])
+
+    def text(self, s: str) -> str:
+        return s

rolly-1.0.0/src/rolly/roll.py

@@ -0,0 +1,147 @@
+from dataclasses import dataclass
+from secrets import randbelow
+from typing import List, Callable
+
+from .char import Character
+
+# A Roller just accepts a maximum value and returns a random
+# value in the closed interval [1, max], to simulate rolling
+# a die with max sides.
+Roller = Callable[[int], int]
+
+
+def default_roller(bound: int) -> int:
+    return randbelow(bound) + 1
+
+
+@dataclass
+class Roll:
+    _dice: List[int]
+    _roller: Roller
+    _adv: bool = False
+    _dis: bool = False
+    _bonus: int = 0
+
+    def __init__(self, roll: str = '', roller: Roller = default_roller):
+        self._dice = []
+        self._roller = roller
+
+        if roll != '':
+            self.parse(roll)
+
+    @property
+    def bonus(self) -> int:
+        return self._bonus
+
+    def add_die(self, value: int):
+        self._dice.append(value)
+
+    def advantage(self, value: bool):
+        self._adv = value
+
+    def disadvantage(self, value: bool):
+        self._dis = value
+
+    def roll(self) -> List[int]:
+        one = self._roll()
+
+        if self._adv and not self._dis:
+            two = self._roll()
+            if sum(two) > sum(one):
+                return two
+
+        if self._dis and not self._adv:
+            two = self._roll()
+            if sum(two) < sum(one):
+                return two
+
+        return one
+
+    def _roll(self) -> List[int]:
+        values = []
+
+        for d in self._dice:
+            value = self._roller(d)
+            values.append(value)
+
+        return values
+
+    def reset(self):
+        self._dice.clear()
+        self._adv = False
+        self._dis = False
+        self._bonus = 0
+
+    def parse(self, roll: str, character: Character | None = None):
+        self.reset()
+
+        # Burn whitespace from the ends to handle line endings
+        roll = roll.strip()
+
+        attr = ''
+        save = False
+
+        while len(roll) > 0:
+            if roll.startswith('d'):
+                # Reading a die
+                roll = roll[1:]
+
+                value = 0
+                while len(roll) > 0 and roll[0] in '0123456789':
+                    value = value * 10 + int(roll[0])
+                    roll = roll[1:]
+
+                self._dice.append(value)
+                continue
+
+            if roll.startswith('x'):
+                # Reading a count for the previous die
+                roll = roll[1:]
+
+                if len(self._dice) == 0:
+                    raise RuntimeError('invalid syntax: count found before dice')
+
+                value = 0
+                while len(roll) > 0 and roll[0] in '0123456789':
+                    value = value * 10 + int(roll[0])
+                    roll = roll[1:]
+
+                self._dice.extend([self._dice[-1]] * (value - 1))
+                continue
+
+            if roll.startswith('+'):
+                # Advantage indicator
+                roll = roll[1:]
+
+                self._adv = True
+                continue
+
+            if roll.startswith('-'):
+                # Disadvantage indicator
+                self._dis = True
+                roll = roll[1:]
+                continue
+
+            if roll.startswith('save'):
+                save = True
+                roll = roll[4:]
+                continue
+
+            if character is not None and len(roll) >= 3 and character.has_attr(roll[:3]):
+                attr = roll[:3]
+                roll = roll[3:]
+                continue
+
+            if roll.startswith(' '):
+                # Whitespace is ignored
+                roll = roll[1:]
+                continue
+
+            # If we didn't hit anything, then we never will, so we bail
+            raise RuntimeError(f'invalid syntax: unknown directive ({roll})')
+
+        if attr != '':
+            if save:
+                self._bonus += character.save_val(attr)
+            else:
+                self._bonus += character.abil_val(attr)

rolly-1.0.0/src/rolly/roll_test.py

@@ -0,0 +1,78 @@
+from dataclasses import dataclass
+from typing import List
+
+from .roll import Roll
+
+
+def test_roll():
+    r = Roll()
+    r._dice.extend([2, 2, 2])
+    r1 = r.roll()
+
+    assert len(r1) == 3
+    assert r1[0] == 1 or r1[0] == 2
+    assert r1[1] == 1 or r1[1] == 2
+    assert r1[2] == 1 or r1[2] == 2
+
+
+@dataclass
+class FakeRoller:
+    seq: List[int]
+    index: int = -1
+
+    def roll(self, bound: int) -> int:
+        self.index += 1
+
+        value = self.seq[self.index]
+        if value >= bound:
+            raise RuntimeError(f"Value {value} exceeds bound {bound}")
+
+        return value
+
+
+def test_roll_adv():
+    r = Roll(roller=FakeRoller([1, 2]).roll)
+    r._dice.extend([20])
+    r._adv = True
+    vs = r.roll()
+
+    assert len(vs) == 1
+    assert vs[0] == 2
+
+
+def test_roll_dis():
+    r = Roll(roller=FakeRoller([2, 1]).roll)
+    r._dice.extend([20])
+    r._dis = True
+    vs = r.roll()
+
+    assert len(vs) == 1
+    assert vs[0] == 1
+
+
+def test_parse_dice():
+    r = Roll()
+    r.parse('d6 d10 d20 d14')
+
+    assert r._dice == [6, 10, 20, 14]
+
+
+def test_parse_count():
+    r = Roll()
+    r.parse('d6x3')
+
+    assert r._dice == [6, 6, 6]
+
+
+def test_parse_adv():
+    r = Roll()
+    r.parse('d20+')
+
+    assert r._adv
+
+
+def test_parse_dis():
+    r = Roll()
+    r.parse('d20-')
+
+    assert r._dis

rolly-1.0.0/src/rolly/themes.py

@@ -0,0 +1,141 @@
+from typing import List, Dict, Optional
+
+
+class Theme:
+    _chars: str = 'HT0123456789='
+
+    def __init__(self, templ: str, widths: Optional[Dict[str, int]] = None, padding: int = 0, width: int = 0, space_width: int = 2):
+        self._templ: List[str] = templ.split('\n')[1:-1]
+
+        self._height = len(self._templ)
+        if self._height == 0:
+            raise RuntimeError('invalid theme: no template specified')
+
+        if widths is None:
+            self._widths = {}
+        else:
+            self._widths = widths
+
+        self._pad = padding
+        self._width = width
+        self._space_width = space_width
+
+        self._validate()
+
+    def render(self, s: str) -> str:
+        out_lines = [''] * self._height
+        out_str = ''
+
+        # A leading or trailing newline makes things weird
+        # and isn't necessary anyway, so drop them
+        in_str = s.strip('\n')
+
+        for c in in_str:
+            if c == '\n':
+                out_str += '\n'.join(out_lines) + '\n'
+                out_lines = [''] * self._height
+                continue
+
+            if c == ' ':
+                for line_index in range(self._height):
+                    out_lines[line_index] += ' ' * self._space_width
+                continue
+
+            if c not in self._chars:
+                raise RuntimeError(f'invalid string: character {c} is not supported')
+
+            offset = self._get_offset(c)
+            width = self._get_width(c)
+            for line_index in range(self._height):
+                out_lines[line_index] += self._templ[line_index][offset:offset + width].ljust(width)
+
+        return out_str + '\n'.join(out_lines)
+
+    def _validate(self):
+        self.render(self._chars)
+
+    def _get_offset(self, c: str):
+        offset = 0
+        ci = self._chars.index(c)
+
+        # Account for everything before the character we want
+        for i in range(ci):
+            offset += self._get_width(self._chars[i])
+            offset += self._pad
+
+        return offset
+
+    def _get_width(self, c: str) -> int:
+        w = 0
+        if c in self._widths:
+            w = self._widths[c]
+
+        if w == 0:
+            if self._width == 0:
+                raise RuntimeError(f'invalid theme: no width specified for char {c}')
+            w = self._width
+
+        return w
+
+
+DEFAULT = r'''
+ ▄▄    ▄▄  ▄▄▄▄▄▄▄▄    ▄▄▄▄      ▄▄▄      ▄▄▄▄▄     ▄▄▄▄▄        ▄▄▄   ▄▄▄▄▄▄▄     ▄▄▄▄    ▄▄▄▄▄▄▄▄    ▄▄▄▄      ▄▄▄▄             
+ ██    ██  ▀▀▀██▀▀▀   ██▀▀██    █▀██     █▀▀▀▀██▄  █▀▀▀▀██▄     ▄███   ██▀▀▀▀▀    ██▀▀▀█   ▀▀▀▀▀███  ▄██▀▀██▄  ▄██▀▀██▄           
+ ██    ██     ██     ██    ██     ██           ██       ▄██    █▀ ██   ██▄▄▄▄    ██ ▄▄▄        ▄██   ██▄  ▄██  ██    ██  ▄▄▄▄▄▄▄▄ 
+ ████████     ██     ██ ██ ██     ██         ▄█▀     █████   ▄█▀  ██   █▀▀▀▀██▄  ███▀▀██▄      ██     ██████   ▀██▄▄███  ▀▀▀▀▀▀▀▀ 
+ ██    ██     ██     ██    ██     ██       ▄█▀          ▀██  ████████        ██  ██    ██     ██     ██▀  ▀██    ▀▀▀ ██  ▄▄▄▄▄▄▄▄ 
+ ██    ██     ██      ██▄▄██   ▄▄▄██▄▄▄  ▄██▄▄▄▄▄  █▄▄▄▄██▀       ██   █▄▄▄▄██▀  ▀██▄▄██▀    ██      ▀██▄▄██▀   █▄▄▄██   ▀▀▀▀▀▀▀▀ 
+ ▀▀    ▀▀     ▀▀       ▀▀▀▀    ▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀   ▀▀▀▀▀         ▀▀    ▀▀▀▀▀      ▀▀▀▀     ▀▀         ▀▀▀▀      ▀▀▀▀             
+'''
+
+ALPHA = r'''
+ H  H     TTTTTT      000       11       22      333      4  4     5555       6       77777      888       9999         
+ H  H       TT       0  00     111      2  2        3     4  4     5         6           7      8   8     9   9     === 
+ HHHH       TT       0 0 0      11        2       33      4444     555      6666        7        888       9999         
+ H  H       TT       00  0      11       2          3        4        5     6   6       7       8   8        9      === 
+ H  H       TT        000      1111     2222     333         4     555       666        7        888        9           
+'''
+
+OUTLINE = r'''
+ _    _   _______    ___    __   ___    ____    _  _     _____     __    ______    ___     ___           
+| |  | | |__   __|  / _ \  /_ | |__ \  |___ \  | || |   | ____|   / /   |____  |  / _ \   / _ \   ______ 
+| |__| |    | |    | | | |  | |    ) |   __) | | || |_  | |__    / /_       / /  | (_) | | (_) | |______|
+|  __  |    | |    | | | |  | |   / /   |__ <  |__   _| |___ \  | '_ \     / /    > _ <   \__, |  ______ 
+| |  | |    | |    | |_| |  | |  / /_   ___) |    | |    ___) | | (_) |   / /    | (_) |    / /  |______|
+|_|  |_|    |_|     \___/   |_| |____| |____/     |_|   |____/   \___/   /_/      \___/    /_/           
+'''
+
+
+ALL_THEMES: Dict[str, Theme] = {
+    'default': Theme(DEFAULT, width=10, space_width=8),
+    'alpha': Theme(ALPHA, {
+        'T': 8,
+        '0': 7,
+        '6': 7,
+        '7': 7,
+        '8': 7,
+        '9': 7,
+        '=': 5,
+    }, width=6, padding=3, space_width=5),
+    'outline': Theme(OUTLINE, {
+        'H': 8,
+        'T': 9,
+        '1': 4,
+        '2': 6,
+        '4': 8,
+        '7': 8,
+        '=': 8,
+    }, width=7, padding=1, space_width=3)
+}
+
+
+def get_themes() -> List[str]:
+    return list(ALL_THEMES.keys())
+
+
+def get_theme(name: str) -> Theme:
+    key = name.strip().lower()
+    if key in ALL_THEMES:
+        return ALL_THEMES[key]
+
+    raise RuntimeError(f'invalid theme name: {name}')

rolly-1.0.0/src/rolly/themes_test.py

@@ -0,0 +1,61 @@
+from .themes import Theme
+
+
+TEST_THEME = r'''
+H T 0 1 2 3 4 5 6 7 8 9 =
+H T 0 1 2 3 4 5 6 7 8 9 =
+'''
+
+
+def test_first_letter():
+    t = Theme(TEST_THEME, width=1, padding=1)
+    assert t.render('H') == 'H\nH'
+
+
+def test_last_letter():
+    t = Theme(TEST_THEME, width=1, padding=1)
+    assert t.render('=') == '=\n='
+
+
+def test_middle_letter():
+    t = Theme(TEST_THEME, width=1, padding=1)
+    assert t.render('5') == '5\n5'
+
+
+def test_space():
+    t = Theme(TEST_THEME, width=1, padding=1, space_width=1)
+    assert t.render(' ') == ' \n '
+
+
+def test_multiple_letters():
+    t = Theme(TEST_THEME, width=1, padding=1, space_width=2)
+    assert t.render('H T') == 'H  T\nH  T'
+
+
+TEST_THEME_WIDE = r'''
+HH TT 00 11 22 33 44 55 66 77 88 99 ==
+HH TT 00 11 22 33 44 55 66 77 88 99 ==
+'''
+
+
+def test_wide_theme():
+    t = Theme(TEST_THEME_WIDE, width=2, padding=1, space_width=3)
+    assert t.render('H') == 'HH\nHH'
+    assert t.render('=') == '==\n=='
+    assert t.render('5') == '55\n55'
+    assert t.render(' ') == '   \n   '
+    assert t.render('H T') == 'HH   TT\nHH   TT'
+
+
+TEST_THEME_VARIED = r'''
+HHH TT 00 11 22 33 44 555 66 77 88 99 ===
+HHH TT 00 11 22 33 44 555 66 77 88 99 ===
+'''
+
+
+def test_wide_varied():
+    t = Theme(TEST_THEME_VARIED, widths={'H': 3, '5': 3, '=': 3}, width=2, padding=1)
+    assert t.render('H') == 'HHH\nHHH'
+    assert t.render('=') == '===\n==='
+    assert t.render('5') == '555\n555'
+    assert t.render('H T') == 'HHH  TT\nHHH  TT'