bracex 3.2__tar.gz → 3.2.2__tar.gz

{bracex-3.2 → bracex-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bracex
-Version: 3.2
+Version: 3.2.2
 Summary: Bash style brace expander.
 Project-URL: Homepage, https://github.com/facelessuser/bracex
 Author-email: Isaac Muse <Isaac.Muse@gmail.com>

{bracex-3.2 → bracex-3.2.2}/bracex/__init__.py

@@ -33,8 +33,13 @@ __version_info__ = __meta__.__version_info__
 _alpha = [chr(x) if x != 0x5c else '' for x in range(ord('A'), ord('z') + 1)]
 _nalpha = list(reversed(_alpha))
 
-RE_INT_ITER = re.compile(r'(-?((?:0(?=\d))*)\d+)\.{2}(-?((?:0(?=\d))*)\d+)(?:\.{2}-?(((?:0(?=\d))*)\d+))?(?=\})')
-RE_CHR_ITER = re.compile(r'([A-Za-z])\.{2}([A-Za-z])(?:\.{2}-?(((?:0(?=\d))*)\d+))?(?=\})')
+RE_INT_ITER = re.compile(
+    r'([-+]?((?:0(?=\d))*)\d+)\.{2}([-+]?((?:0(?=\d))*)\d+)(?:\.{2}[-+]?(((?:0(?=\d))*)\d+))?(?=\})', re.ASCII
+)
+RE_CHR_ITER = re.compile(r'([A-Za-z])\.{2}([A-Za-z])(?:\.{2}[-+]?(((?:0(?=\d))*)\d+))?(?=\})', re.ASCII)
+RE_SEQ_SEP = re.compile(r'\.(?!\})')
+RE_SEQ_TERM = re.compile(r'(?:[-+]?\d|[A-Za-z]\.)', re.ASCII)
+RE_SEQ_TERM_END = re.compile(r'(?:[-+]?\d|[A-Za-z][.}])', re.ASCII)
 
 DEFAULT_LIMIT = 1000
 
@@ -97,6 +102,8 @@ class StringIter:
 
         self._string = string
         self._index = 0
+        self._last_seq = string.rfind('..')
+        self.scan_memo = {}  # type: dict[int, tuple[int, bool]]
 
     def __iter__(self) -> "StringIter":  # pragma: no cover
         """Iterate."""
@@ -122,6 +129,18 @@ class StringIter:
 
         return self._index
 
+    @property
+    def last_seq(self) -> int:
+        """Get the index of the last `..`, or -1 if there are none."""
+
+        return self._last_seq
+
+    @property
+    def string(self) -> str:
+        """Get the string being iterated."""
+
+        return self._string
+
     def previous(self) -> str:  # pragma: no cover
         """Get previous char."""
 
@@ -196,6 +215,84 @@ class ExpandBrace:
         if release:
             self.expanding = False
 
+    def scan_group(self, i: StringIter, index: int, bounded: bool) -> tuple[int, bool]:
+        """
+        Scan ahead, like Bash to find the `}` that ends the group starting at `index`.
+
+        Returns the index of the closing `}` (or -1 if there is none) and whether Bash would treat the group
+        as a sequence candidate: a top level `..` (not directly followed by `}`) and no top level comma.
+
+        Bash only ever sees the slot a nested group is in, so when `bounded`, a top level `}` that doesn't end the
+        group can only be the end of the slot, which means there is no closing `}`.
+
+        Groups nested in the one being scanned are tracked as they are passed, as their outcome (as a bounded
+        group) is known as soon as they close. These are remembered so they don't have to be scanned again.
+        """
+
+        string = i.string
+        memo = i.scan_memo
+        if bounded:
+            result = memo.get(index)
+            if result is not None:
+                return result
+
+        # Open nested groups as `[start, found a separator, is a sequence]`, and `None` for a `${`.
+        stack = []  # type: list[list[Any] | None]
+        found = False  # A top level comma or `..` has been found, which allows a top level `}` to end the group.
+        is_seq = False
+        size = len(string)
+        while index < size:
+            c = string[index]
+            if c == '\\':
+                index += 1
+            elif c == '$' and string.startswith('{', index + 1):
+                stack.append(None)
+                index += 1
+            elif c == '{':
+                stack.append([index + 1, False, False])
+            elif c == '}':
+                if stack:
+                    nested = stack.pop()
+                    if nested is not None:
+                        memo[nested[0]] = (index, nested[2]) if nested[1] else (-1, False)
+                elif found:
+                    return index, is_seq
+                elif bounded:  # pragma: no cover
+                    # A nested group is normally already known from the scan of the group around it.
+                    break
+            elif c == ',' or (c == '.' and string.startswith('..', index) and string[index + 2:index + 3] != '}'):
+                if not stack:
+                    if c == ',' or not found:
+                        found = True
+                        is_seq = c == '.'
+                else:
+                    top = stack[-1]
+                    if top is not None and (c == ',' or not top[1]):
+                        top[1:] = [True, c == '.']
+            index += 1
+        return -1, False
+
+    def looks_like_sequence(self, group: str) -> bool:
+        """
+        Check whether the group (with its closing `}`) starts like a sequence.
+
+        This is Bash's loose `valid_seqterm` check: both sides of the first `..` must start like the same kind
+        of term (integer or letter). Whether the sequence is really valid is not considered here.
+        """
+
+        index = group.find('..')
+        if index < 1 or group[0] == '.':
+            return False
+        left = RE_SEQ_TERM.match(group)
+        right = RE_SEQ_TERM_END.match(group, index + 2)
+        return bool(left and right and group[0].isalpha() == group[index + 2].isalpha())
+
+    def literal_text(self, text: str) -> str:
+        """Resolve escapes in text that is kept literally."""
+
+        i = StringIter(text)
+        return ''.join(self.get_escape(c, i) if c == '\\' else c for c in i)
+
     def get_escape(self, c: str, i: StringIter) -> str:
         """Get an escape."""
 
@@ -241,7 +338,7 @@ class ExpandBrace:
         i: StringIter,
         depth: int,
         ignore_end: bool = False
-    ) -> tuple[list[str | Iterator[str]], int]:
+    ) -> tuple[list[str | Iterator[str]], int, bool]:
         """
         Get a string literal.
 
@@ -250,9 +347,12 @@ class ExpandBrace:
         """
 
         result = []  # type: list[str | Iterator[str]]
+        word_start = 0
         is_dollar = False
+        dollar_depth = 0
         count = 1
         literal = ''
+        has_seq = False
 
         try:
             while c:
@@ -266,7 +366,11 @@ class ExpandBrace:
                 elif c == '\\':
                     literal += self.get_escape(c, i)
 
-                elif not ignore_brace and c == '{':
+                elif (ignore_brace and c == '{') or (dollar_depth and c == '}'):
+                    literal += c
+                    dollar_depth += 1 if c == '{' else -1
+
+                elif c == '{':
 
                     if literal:
                         result.append(literal)
@@ -274,7 +378,10 @@ class ExpandBrace:
 
                     # Try and get the group
                     try:
-                        seq, scount = self.get_sequence(next(i), i, depth + 1)
+                        seq, scount, expanded = self.get_sequence(next(i), i, depth + 1, word_start)
+                        if expanded:
+                            # Bash expands each postamble as a new word.
+                            word_start = i.index
                         count *= scount
                         result.append(seq)
                     except StopIteration:
@@ -283,7 +390,7 @@ class ExpandBrace:
                         literal += c
                         raise
 
-                elif self.is_expanding() and (c == ',' or (c == '}' and not ignore_end)):
+                elif self.is_expanding() and not dollar_depth and (c == ',' or (c == '}' and not ignore_end)):
                     # We are Expanding within a group and found a group delimiter
                     # Return what we gathered before the group delimiters.
 
@@ -294,6 +401,14 @@ class ExpandBrace:
 
                     i.rewind(1)
                     break
+
+                elif not dollar_depth and c == '.' and i.match(RE_SEQ_SEP):
+                    # Bash counts `..` like a comma when looking for the `}` that ends a top level group,
+                    # unless `}` follows it, so the next `}` can end the group.
+                    ignore_end = False
+                    has_seq = True
+                    literal += '..'
+
                 else:
                     literal += c
 
@@ -303,9 +418,9 @@ class ExpandBrace:
             if literal:
                 result.append(literal)
 
-        return result, self.account(count)
+        return result, self.account(count), has_seq
 
-    def get_sequence(self, c: str, i: StringIter, depth: int) -> tuple[Iterator[str], int]:
+    def get_sequence(self, c: str, i: StringIter, depth: int, word_start: int) -> tuple[Iterator[str], int, bool]:
         """
         Get the sequence.
 
@@ -314,8 +429,10 @@ class ExpandBrace:
         """
 
         result = []  # type: list[str | Iterator[str] | Iterable[str | Iterator[str]]]
+        group_start = i.index - 1  # Index of the first character within the group.
         release = self.set_expanding()
         has_comma = False  # Used to indicate validity of group (`{1..2}` are an exception).
+        has_seq = False  # Used to indicate a top level `..` that lets the next `}` end the group.
         is_empty = True  # Tracks whether the current slot is empty `{slot,slot,slot}`.
         counts = []
 
@@ -325,15 +442,34 @@ class ExpandBrace:
         i.advance(1)
         if item is not None:
             self.release_expanding(release)
-            return item, self.account(count)
+            return item, self.account(count), True
+
+        # Bash decides up front whether a group is a sequence candidate and, if so, whether it looks like a sequence.
+        # A group that looks like one but isn't valid is kept as text, nested groups and all. A group that doesn't
+        # even look like one is abandoned: Bash skips just the `{` and tries again with what follows.
+        # Without a `..` ahead, the group can't be a sequence candidate, so skip the scan.
+        end, is_seq = self.scan_group(i, group_start, depth > 1) if i.last_seq >= group_start else (-1, False)
+        if is_seq and end != -1:
+            self.release_expanding(release)
+            if self.looks_like_sequence(i.string[group_start:end + 1]):
+                i.advance(end + 1 - i.index)
+                return iter(['{' + self.literal_text(i.string[group_start:end]) + '}']), 1, False
+            if depth == 1:
+                # Continue the current word from just after the `{`.
+                i.rewind(i.index - group_start)
+                return iter(['{']), 1, False
+            # Nested groups are confined to their slot, so expand what follows the `{` on its own.
+            sub, scount = self.expand_isolated(i.string[group_start:end + 1])
+            i.advance(end + 1 - i.index)
+            return self.squash(iter(['{']), sub), scount, False
 
         try:
             while True:
                 # Bash has some special top level logic. if `}` follows `{` but hasn't matched
-                # a group yet, keep going except when the first 2 bytes are `{}` which gets
-                # completely ignored.
-                keep_looking = depth == 1 and not has_comma
-                if (c == '}' and (not keep_looking or i.index == 2)):
+                # a group yet, keep going except when the first 2 bytes of the current
+                # postamble are `{}` which gets completely ignored.
+                keep_looking = depth == 1 and not has_comma and not has_seq
+                if (c == '}' and (not keep_looking or i.index == word_start + 2)):
                     self.release_expanding(release)
 
                     # Handle empty slot
@@ -349,7 +485,7 @@ class ExpandBrace:
                         for r in self.flatten(result):
                             temp = self.squash(temp, [r] if isinstance(r, str) else r)
                         temp = self.squash(temp, ['}'])
-                        return temp, self.account(math.prod(counts, start=1))
+                        return temp, self.account(math.prod(counts, start=1)), False
 
                     # Format return for a sequence
                     fin = iter([])  # type: Iterator[str]
@@ -369,7 +505,7 @@ class ExpandBrace:
                             start = e + 1
                     if start < l:
                         fin = self.chain(fin, result[start:])
-                    return fin, self.account(sum(counts))
+                    return fin, self.account(sum(counts)), True
 
                 elif c == ',':
                     # Must be the first element in the list.
@@ -382,7 +518,7 @@ class ExpandBrace:
 
                 else:
                     # Lower level: Try to find group, but give up if cannot acquire.
-                    value, lcount = self.get_literals(c, i, depth, keep_looking)
+                    value, lcount, has_seq = self.get_literals(c, i, depth, keep_looking)
                     counts.append(lcount)
                     if value is not None:
                         if len(value) > 1:
@@ -408,7 +544,7 @@ class ExpandBrace:
             for r in self.flatten([slot]):
                 member = self.squash(member, [r] if isinstance(r, str) else r)
             temp2 = self.squash(temp2, member)
-        return temp2, self.account(math.prod(counts, start=1))
+        return temp2, self.account(math.prod(counts, start=1)), False
 
     def get_range(self, i: StringIter) -> tuple[Iterator[str] | None, int]:
         """
@@ -461,9 +597,15 @@ class ExpandBrace:
         last = int64(end)
         inc = max(1, int64(increment))
 
+        # Bash's zero-padding rule: padding is only enabled when an operand, as written,
+        # starts with `0` (or `-0`). A unary `+` sign never enables padding, but once
+        # padding is enabled by either operand, the full written width of both operands
+        # (signs included) is honored.
+        arm = bool((spad[1] - spad[0]) and not start.startswith('+'))
+        arm = arm or bool((epad[1] - epad[0]) and not end.startswith('+'))
         spad_len = spad[1] - spad[0]
         epad_len = epad[1] - epad[0]
-        padding = max(spad_len + len(start), epad_len + len(end)) if spad_len or epad_len else 0
+        padding = max(spad_len + len(start), epad_len + len(end)) if arm else 0
 
         if first < last:
             span = abs(last - first + 1)
@@ -509,11 +651,27 @@ class ExpandBrace:
             r = range(first, last - 1, -inc)
         return (alpha[i] for i in r), count
 
+    def expand_isolated(self, string: str) -> tuple[Iterator[str], int]:
+        """Expand a piece of text on its own, as though it were not inside a group."""
+
+        expanding = self.expanding
+        self.expanding = False
+        try:
+            i = StringIter(string)
+            values, count, _ = self.get_literals(next(i), i, 0)
+        finally:
+            self.expanding = expanding
+
+        results = iter([EMPTY])  # type: Iterator[str]
+        for v in values:
+            results = self.squash(results, [v] if isinstance(v, str) else v)
+        return results, count
+
     def expand_str(self, string: str) -> Iterator[str]:
         """Expand the string."""
 
         i = StringIter(string)
-        values, _ = self.get_literals(next(i), i, 0)
+        values, _, _ = self.get_literals(next(i), i, 0)
 
         # Squash the nested list by calculating the combinations
         results = iter([EMPTY])  # type: Iterator[str]

{bracex-3.2 → bracex-3.2.2}/bracex/__main__.py

@@ -24,7 +24,7 @@ import argparse
 import bracex
 
 
-def main(argv: str | None = None) -> None:
+def main(argv: list[str] | None = None) -> None:
     """Accept command line arguments and output brace expansion to stdout."""
     parser = argparse.ArgumentParser(
         prog='python -m bracex',

{bracex-3.2 → bracex-3.2.2}/bracex/__meta__.py

@@ -193,5 +193,5 @@ def parse_version(ver: str) -> Version:
     return Version(major, minor, micro, release, pre, post, dev)
 
 
-__version_info__ = Version(3, 2, 0, "final")
+__version_info__ = Version(3, 2, 2, "final")
 __version__ = __version_info__._get_canonical()

bracex-3.2.2/docs/src/dictionary/en-custom.txt

@@ -0,0 +1,45 @@
+API
+Accessors
+Backport
+Bracex
+Changelog
+Formatter
+GitHub
+Gitter
+KiB
+MERCHANTABILITY
+MkDocs
+NONINFRINGEMENT
+NUL
+Preprocess
+PyPI
+Setuptools
+TODO
+Tox
+Twemoji
+Virtualenv
+Willmer
+Zensical
+accessor
+backend
+deprecations
+expander
+formatter
+globbing
+incrementer
+iterables
+linter
+postamble
+pre
+prerelease
+prereleases
+pytest
+regex
+santhreal
+stdout
+sublicense
+tuple
+uncatchable
+validator
+wordlist
+unary

{bracex-3.2 → bracex-3.2.2}/docs/src/markdown/about/changelog.md

@@ -1,5 +1,20 @@
 # Changes
 
+## 3.2.2
+
+-   **FIX**: Match Bash 5.3 for groups that contain a top level `..` but are not valid sequences. If the group starts
+    like a sequence, such as `{1..3{a,b}}`, it is kept as text without expanding nested groups. If it doesn't, such as
+    `{a..x{b}},}`, only the opening `{` is skipped and what follows is parsed again, as in Bash.
+
+## 3.2.1
+
+-   **FIX**: Keep numeric sequences with non-ASCII digits literal, matching Bash.
+-   **FIX**: Preserve an initial empty brace group after a valid expansion.
+-   **FIX**: Fix `${...}` inside a brace group ending the group early.
+-   **FIX**: Fix an invalid sequence such as `{1..a}` being split at a later comma instead of being kept as text.
+-   **FIX**: Fix numeric and character sequences with unary `+` signs (`{+1..3}`, `{1..+3..2}`, `{a..z..+2}`)
+    being left as literal text instead of expanded like Bash, including Bash's zero-padding rule for `+` operands.
+
 ## 3.2
 
 -   **NEW**: Drop Python 3.10 support.

{bracex-3.2 → bracex-3.2.2}/pyproject.toml

@@ -40,11 +40,10 @@ include = [
     "/docs/src/markdown/**/*.md",
     "/docs/src/markdown/**/*.gif",
     "/docs/src/markdown/**/*.png",
-    "/docs/src/markdown/dictionary/*.txt",
+    "/docs/src/dictionary/*.txt",
     "/docs/theme/**/*.css",
     "/docs/theme/**/*.js",
     "/docs/theme/**/*.html",
-    "/requirements/*.txt",
     "/bracex/**/*.py",
     "/bracex/py.typed",
     "/tests/**/*.py",
@@ -53,7 +52,7 @@ include = [
     "/tools/**/*.py",
     "/.pyspelling.yml",
     "/.coveragerc",
-    "/mkdocs.yml"
+    "/zensical.yml"
 ]
 
 [tool.mypy]

{bracex-3.2 → bracex-3.2.2}/tests/brace-cases.txt

@@ -289,3 +289,76 @@ a{b},
 {a,b{c,d}
 {a,b{
 {2{
+# A top level `..` that is not followed by `}` lets the next `}` end the group
+{1..a},b}
+{a...},c}
+a{1..a},b}c
+{1..a},{b,c}}
+{1..},b}
+# An initial empty group is literal in the postamble after a valid expansion
+{a,b}{},c}
+{1..2}{},c}
+prefix{a,b}{},tail}
+{a,b}x{},c}
+{a,b}{}{},c}
+{word}{},c}
+{a{b,c}}{},d}
+{+1..3}
+{+1..+3}
+{3..+1}
+{+1..+3..2}
+{1..+3..2}
+{+1..+3..+2}
+{+3..1..+2}
+{+05..8}
+{+005..8}
+{05..+8}
+{+5..+08}
+{+05..+05}
+{+05..08}
+{+10..08}
+{-05..+2}
+{+5..05}
+{+5..08}
+{08..+5}
+{+003..1}
+{a..z..+2}
+a{+1..2}b
+{a,{+1..2},b}
+{+9223372036854775806..+9223372036854775807}
+{١..٣}
+{１..３}
+{1..٣}
+{١..3}
+{1..3..٢}
+{a..e..٢}
+{0١..03}
+x{١..٣}y
+{a,{١..٣},b}
+{+١..+٣}
+{-١..٣}
+{1..3{a,b}}
+{1..3{a,b}}x
+x{1..3{a,b}}y{c,d}
+{1..3{a,b}c}
+{1..3{1..3}}
+{a..c{1,2}}
+{1{a,b}..3}
+{a{b,c}..d}
+{1..{a,b}}
+{1..3{a,b},z}
+{{a,b}..c}
+{{1..3}..b}
+x{{1..3}..b}y
+{x{1..3}..y}
+{{1..3}...}
+{{11}..3{1..3}b}
+{{11}..3{1..3}b}z
+{x,{{11}..3{1..3}b}}
+{a..b{c}}x,y}
+{a..x{b}},}
+{..x{b}}1x,}
+{x,{a..x{b}},y}
+{1..3{a,b}}{c,d}
+{a,{b}..c}
+{x,{b}..c,y}

{bracex-3.2 → bracex-3.2.2}/tests/brace-results.txt

@@ -1262,4 +1262,175 @@ A{b,{d,e},{f,g}}Z
 [{a,bc]
 [{a,bd]><><><><{a,b{
 [{a,b{]><><><><{2{
-[{2{]><><><><
+[{2{]><><><><{1..a},b}
+[{1..a},b}]><><><><{a...},c}
+[{a...},c}]><><><><a{1..a},b}c
+[a{1..a},b}c]><><><><{1..a},{b,c}}
+[{1..a},b}]
+[{1..a},c}]><><><><{1..},b}
+[1..}]
+[b]><><><><{a,b}{},c}
+[a{},c}]
+[b{},c}]><><><><{1..2}{},c}
+[1{},c}]
+[2{},c}]><><><><prefix{a,b}{},tail}
+[prefixa{},tail}]
+[prefixb{},tail}]><><><><{a,b}x{},c}
+[ax}]
+[axc]
+[bx}]
+[bxc]><><><><{a,b}{}{},c}
+[a{}}]
+[a{}c]
+[b{}}]
+[b{}c]><><><><{word}{},c}
+[word}{}]
+[c]><><><><{a{b,c}}{},d}
+[ab}{}]
+[ac}{}]
+[d]><><><><{+1..3}
+[1]
+[2]
+[3]><><><><{+1..+3}
+[1]
+[2]
+[3]><><><><{3..+1}
+[3]
+[2]
+[1]><><><><{+1..+3..2}
+[1]
+[3]><><><><{1..+3..2}
+[1]
+[3]><><><><{+1..+3..+2}
+[1]
+[3]><><><><{+3..1..+2}
+[3]
+[1]><><><><{+05..8}
+[5]
+[6]
+[7]
+[8]><><><><{+005..8}
+[5]
+[6]
+[7]
+[8]><><><><{05..+8}
+[05]
+[06]
+[07]
+[08]><><><><{+5..+08}
+[5]
+[6]
+[7]
+[8]><><><><{+05..+05}
+[5]><><><><{+05..08}
+[005]
+[006]
+[007]
+[008]><><><><{+10..08}
+[010]
+[009]
+[008]><><><><{-05..+2}
+[-05]
+[-04]
+[-03]
+[-02]
+[-01]
+[000]
+[001]
+[002]><><><><{+5..05}
+[05]><><><><{+5..08}
+[05]
+[06]
+[07]
+[08]><><><><{08..+5}
+[08]
+[07]
+[06]
+[05]><><><><{+003..1}
+[3]
+[2]
+[1]><><><><{a..z..+2}
+[a]
+[c]
+[e]
+[g]
+[i]
+[k]
+[m]
+[o]
+[q]
+[s]
+[u]
+[w]
+[y]><><><><a{+1..2}b
+[a1b]
+[a2b]><><><><{a,{+1..2},b}
+[a]
+[1]
+[2]
+[b]><><><><{+9223372036854775806..+9223372036854775807}
+[9223372036854775806]
+[9223372036854775807]><><><><{١..٣}
+[{١..٣}]><><><><{１..３}
+[{１..３}]><><><><{1..٣}
+[{1..٣}]><><><><{١..3}
+[{١..3}]><><><><{1..3..٢}
+[{1..3..٢}]><><><><{a..e..٢}
+[{a..e..٢}]><><><><{0١..03}
+[{0١..03}]><><><><x{١..٣}y
+[x{١..٣}y]><><><><{a,{١..٣},b}
+[a]
+[{١..٣}]
+[b]><><><><{+١..+٣}
+[{+١..+٣}]><><><><{-١..٣}
+[{-١..٣}]><><><><{1..3{a,b}}
+[{1..3{a,b}}]><><><><{1..3{a,b}}x
+[{1..3{a,b}}x]><><><><x{1..3{a,b}}y{c,d}
+[x{1..3{a,b}}yc]
+[x{1..3{a,b}}yd]><><><><{1..3{a,b}c}
+[{1..3{a,b}c}]><><><><{1..3{1..3}}
+[{1..3{1..3}}]><><><><{a..c{1,2}}
+[{a..c1}]
+[{a..c2}]><><><><{1{a,b}..3}
+[{1{a,b}..3}]><><><><{a{b,c}..d}
+[{ab..d}]
+[{ac..d}]><><><><{1..{a,b}}
+[{1..a}]
+[{1..b}]><><><><{1..3{a,b},z}
+[1..3a]
+[1..3b]
+[z]><><><><{{a,b}..c}
+[{a..c}]
+[{b..c}]><><><><{{1..3}..b}
+[{1..b}]
+[{2..b}]
+[{3..b}]><><><><x{{1..3}..b}y
+[x{1..b}y]
+[x{2..b}y]
+[x{3..b}y]><><><><{x{1..3}..y}
+[{x1..y}]
+[{x2..y}]
+[{x3..y}]><><><><{{1..3}...}
+[{1...}]
+[{2...}]
+[{3...}]><><><><{{11}..3{1..3}b}
+[{{11}..3{1..3}b}]><><><><{{11}..3{1..3}b}z
+[{{11}..3{1..3}b}z]><><><><{x,{{11}..3{1..3}b}}
+[x]
+[{{11}..3{1..3}b}]><><><><{a..b{c}}x,y}
+[{a..bc}}x]
+[{a..by]><><><><{a..x{b}},}
+[{a..xb}}]
+[{a..x]><><><><{..x{b}}1x,}
+[{..xb}}1x]
+[{..x]><><><><{x,{a..x{b}},y}
+[x]
+[{a..x{b}}]
+[y]><><><><{1..3{a,b}}{c,d}
+[{1..3{a,b}}c]
+[{1..3{a,b}}d]><><><><{a,{b}..c}
+[a]
+[{b}..c]><><><><{x,{b}..c,y}
+[x]
+[{b}..c]
+[y]><><><><

bracex-3.2.2/tests/generate.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -e
+
+# Bash 5.3 changed how brace groups that look like sequences are validated (invalid candidates are skipped
+# and later braces are still expanded), so results differ from 5.2 and earlier. Generate against 5.3 only.
+if [[ "${BASH_VERSINFO[0]}.${BASH_VERSINFO[1]}" != "5.3" ]]; then
+  echo "this script requires bash 5.3" >&2
+  exit 1
+fi
+
+CDPATH= cd "$(dirname "$0")"
+
+cat brace-cases.txt | \
+  while read case; do
+    if [ "${case:0:1}" = "#" ]; then
+      continue;
+    fi;
+    b="$($BASH -c 'for c in '"$case"'; do echo "[$c]"; done')"
+    echo "$case"
+    echo -n "$b><><><><";
+  done > brace-results.txt

{bracex-3.2 → bracex-3.2.2}/tests/test_brace.py

@@ -50,7 +50,18 @@ class TestBraces:
     dollar_cases = [
         ['${1..3}', ['${1..3}']],
         ['${a,b}${c,d}', ['${a,b}${c,d}']],
-        ['x${a,b}x${c,d}x', ['x${a,b}x${c,d}x']]
+        ['x${a,b}x${c,d}x', ['x${a,b}x${c,d}x']],
+        ['{a,${b}}', ['a', '${b}']],
+        ['{${a,b},c}', ['${a,b}', 'c']],
+        ['{a,${b{c}d}e}', ['a', '${b{c}d}e']],
+        [r'{a,${b\}c}}', ['a', '${b}c}']],
+        ['${x{1..2}}', ['${x1}', '${x2}']],
+        ['${x{a,b}}', ['${xa}', '${xb}']],
+        ['{a,${x{1..2}}}', ['a', '${x1}', '${x2}']],
+        ['{a,${x{c,d}}}', ['a', '${xc}', '${xd}']],
+        ['x${y{a,b}}z', ['x${ya}z', 'x${yb}z']],
+        ['q{b}${b,c}z', ['q{b}${b,c}z']],
+        ['{a${x:-..b}},c}', ['a${x:-..b}}', 'c']]
     ]
 
     empty_cases = [
@@ -72,7 +83,13 @@ class TestBraces:
     nested_cases = [
         ['{a,b{1..3},c}', ['a', 'b1', 'b2', 'b3', 'c']],
         ['{{A..Z},{a..z}}', list('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')],
-        ['ppp{,config,oe{,conf}}', ['ppp', 'pppconfig', 'pppoe', 'pppoeconf']]
+        ['ppp{,config,oe{,conf}}', ['ppp', 'pppconfig', 'pppoe', 'pppoeconf']],
+        # Bash keeps a group that starts like a sequence as text, nested groups included
+        ['{1..3{a,b}}', ['{1..3{a,b}}']],
+        ['x{1..3{a,b}}y{c,d}', ['x{1..3{a,b}}yc', 'x{1..3{a,b}}yd']],
+        ['{1..3{a,b\\}}}', ['{1..3{a,b}}}']],
+        # But if it doesn't even start like a sequence, nested groups still expand
+        ['{1..{a,b}}', ['{1..a}', '{1..b}']]
     ]
 
     order_cases = [

bracex-3.2.2/zensical.yml

@@ -0,0 +1,164 @@
+site_name: Bracex
+site_url: https://facelessuser.github.io/bracex
+repo_url: https://github.com/facelessuser/bracex
+edit_uri: tree/master/docs/src/markdown
+site_description: Python spell checker.
+copyright: |
+  Copyright &copy; 2018 - 2026 <a href="https://github.com/facelessuser"  target="_blank" rel="noopener">Isaac Muse</a>
+
+docs_dir: docs/src/markdown
+theme:
+  name: zensical_pymdownx
+  custom_dir: docs/theme
+  features:
+    - announce.dismiss
+    - navigation.tabs
+    - navigation.top
+    - navigation.instant
+    - navigation.indexes
+    - navigation.path
+    - navigation.footer
+    - toc.follow
+    - content.tabs.link
+    - search.share
+    - search.highlight
+    - search.suggest
+    - content.code.copy
+    - content.tabs.link
+    - content.code.annotations
+
+nav:
+  - Home:
+    - Usage: index.md
+  - About:
+    - Contributing &amp; Support: about/contributing.md
+    - Development: about/development.md
+    - Changelog: about/changelog.md
+    - License: about/license.md
+
+markdown_extensions:
+  - toc:
+      slugify: !!python/object/apply:pymdownx.slugs.slugify {kwds: {case: lower}}
+      permalink: ""
+  - smarty:
+      smart_quotes: false
+  - pymdownx.betterem:
+  - attr_list:
+  - tables:
+  - abbr:
+  - footnotes:
+  - md_in_html:
+  - pymdownx.superfences:
+      preserve_tabs: true
+      relaxed_headers: true
+      custom_fences:
+        - name: py
+          class: 'highlight'
+          format: !!python/object/apply:tools.pycon.py_command_formatter
+            kwds:
+              init: |
+                import bracex
+          validator: !!python/name:tools.pycon.py_command_validator
+          reset: !!python/name:tools.pycon.py_command_reset
+        - name: python
+          class: 'highlight'
+          format: !!python/object/apply:tools.pycon.py_command_formatter
+            kwds:
+              init: |
+                import bracex
+          validator: !!python/name:tools.pycon.py_command_validator
+          reset: !!python/name:tools.pycon.py_command_reset
+  - pymdownx.highlight:
+      line_spans: __codeline
+      line_anchors: __codelineno
+      anchor_linenums: True
+  - pymdownx.inlinehilite:
+  - pymdownx.magiclink:
+      repo_url_shortener: true
+      repo_url_shorthand: true
+      social_url_shorthand: true
+      user: facelessuser
+      repo: bracex
+  - pymdownx.tilde:
+  - pymdownx.caret:
+  - pymdownx.smartsymbols:
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+  - pymdownx.escapeall:
+      hardbreak: True
+      nbsp: True
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - pymdownx.progressbar:
+  - pymdownx.striphtml:
+  - pymdownx.snippets:
+      base_path:
+      - docs/src/markdown/.snippets
+      - LICENSE.md
+      auto_append:
+      - refs.md
+  - pymdownx.keys:
+      separator: "\uff0b"
+  - pymdownx.saneheaders:
+  - pymdownx.blocks.admonition:
+      types:
+      - new
+      - settings
+      - note
+      - abstract
+      - info
+      - tip
+      - success
+      - question
+      - warning
+      - failure
+      - danger
+      - bug
+      - example
+      - quote
+  - pymdownx.blocks.details:
+      types:
+      - name: details-new
+        class: new
+      - name: details-settings
+        class: settings
+      - name: details-note
+        class: note
+      - name: details-abstract
+        class: abstract
+      - name: details-info
+        class: info
+      - name: details-tip
+        class: tip
+      - name: details-success
+        class: success
+      - name: details-question
+        class: question
+      - name: details-warning
+        class: warning
+      - name: details-failure
+        class: failure
+      - name: details-danger
+        class: danger
+      - name: details-bug
+        class: bug
+      - name: details-example
+        class: example
+      - name: details-quote
+        class: quote
+  - pymdownx.blocks.html:
+  - pymdownx.blocks.definition:
+  - pymdownx.blocks.tab:
+      alternate_style: True
+      combine_header_slug: True
+      slugify: !!python/object/apply:pymdownx.slugs.slugify {kwds: {case: lower}}
+  - pymdownx.quotes:
+      callouts: true
+
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/facelessuser
+  zensical_pymdownx:
+    sponsor: https://github.com/sponsors/facelessuser

bracex-3.2/tests/generate.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-# Bash 4.3 - 5.0 because of arbitrary need to pick a single standard.
-if ! [[ "${BASH_VERSINFO[0]}.${BASH_VERSINFO[1]}" =~ (4\.[^1-2]|5\.[0-3])(\.\d+)? ]]; then
-  echo "this script requires bash 4.3, 4.4, or 5.0" >&2
-  exit 1
-fi
-
-CDPATH= cd "$(dirname "$0")"
-
-cat brace-cases.txt | \
-  while read case; do
-    if [ "${case:0:1}" = "#" ]; then
-      continue;
-    fi;
-    b="$($BASH -c 'for c in '"$case"'; do echo "[$c]"; done')"
-    echo "$case"
-    echo -n "$b><><><><";
-  done > brace-results.txt