bracex 3.2.1__tar.gz → 3.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bracex
-Version: 3.2.1
+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.1 → bracex-3.2.2}/bracex/__init__.py

@@ -38,6 +38,8 @@ RE_INT_ITER = re.compile(
 )
 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
 
@@ -100,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."""
@@ -125,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."""
 
@@ -199,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."""
 
@@ -335,6 +429,7 @@ 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.
@@ -349,6 +444,25 @@ class ExpandBrace:
             self.release_expanding(release)
             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
@@ -537,6 +651,22 @@ 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."""
 

{bracex-3.2.1 → 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.1 → 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, 1, "final")
+__version_info__ = Version(3, 2, 2, "final")
 __version__ = __version_info__._get_canonical()

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

@@ -1,5 +1,11 @@
 # 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.

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

@@ -337,3 +337,28 @@ 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.1 → bracex-3.2.2}/tests/brace-results.txt

@@ -1383,4 +1383,54 @@ A{b,{d,e},{f,g}}Z
 [{١..٣}]
 [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.1 → bracex-3.2.2}/tests/test_brace.py

@@ -83,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.1/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