[diffoscope] 04/08: presenters: PartialString: preserve {{ and }} escapes when partially formatting stuff

Ximin Luo infinity0 at debian.org
Mon Jul 3 20:27:50 CEST 2017


This is an automated email from the git hooks/post-receive script.

infinity0 pushed a commit to branch WIP/humungous-diffs
in repository diffoscope.

commit 12513840839010f4bb48d273e995ad6dd206cbc4
Author: Ximin Luo <infinity0 at debian.org>
Date:   Mon Jun 19 18:02:40 2017 +0200

    presenters: PartialString: preserve {{ and }} escapes when partially formatting stuff
---
 diffoscope/presenters/utils.py | 78 ++++++++++++++++++++++++++++++++++--------
 tests/test_presenters.py       | 19 ++++++++++
 2 files changed, 83 insertions(+), 14 deletions(-)

diff --git a/diffoscope/presenters/utils.py b/diffoscope/presenters/utils.py
index 9f49069..4562e8b 100644
--- a/diffoscope/presenters/utils.py
+++ b/diffoscope/presenters/utils.py
@@ -104,12 +104,19 @@ def create_limited_print_func(print_func, max_page_size):
     return fn
 
 
-class Formatter(string.Formatter):
+class PartialFormatter(string.Formatter):
+    @staticmethod
+    def escape(x):
+        return x.replace("}", "}}").replace("{", "{{")
     def get_value(self, key, args, kwargs):
         return args[key] if isinstance(key, int) else args[int(key)]
     def arg_of_field_name(self, field_name, args):
         x = int(_string.formatter_field_name_split(field_name)[0])
         return x if x >= 0 else len(args) + x
+    def parse(self, *args, **kwargs):
+        # Preserve {{ and }} escapes when formatting
+        return map(lambda x: (self.escape(x[0]),) + x[1:], super().parse(*args, **kwargs))
+    parse_no_escape = string.Formatter.parse
 
 
 class FormatPlaceholder(object):
@@ -186,10 +193,41 @@ class PartialString(object):
     >>> tmpl.pformatl("(first hole)", "(second hole)", "(object hole)")
     PartialString('(first hole) (second hole) (object hole)',)
 
+    CORNER CASES:
+
+    1. If you need to include a literal '{' or '}' in the resulting formatted
+    string, you need to give them as "{{" or "}}" respectively in the fmtstr
+    parameter of PartialString.__init__. PartialString.escape() might help to
+    make this a bit easier:
+
+    >>> tmpl = PartialString.numl("find {0} -name {1} " +
+    ...            PartialString.escape("-exec ls -la {} \;"), 2)
+    >>> tmpl
+    PartialString('find {0} -name {1} -exec ls -la {{}} \\;', ...)
+    >>> tmpl.size(), tmpl.size(4)
+    (33, 39)
+
+    When using pformat, any string arguments will be escaped automatically. You
+    can take advantage of this to simplify the above example:
+
+    >>> tmpl2 = PartialString.numl("find {0} -name {1} -exec ls -la {2} \;", 3)
+    >>> tmpl2 = tmpl2.pformat({2: "{}"})
+    >>> tmpl2 == tmpl
+    True
+
+    As long as you only use pformat, any "{{" "}}" literals will remain escaped
+    in the resulting PartialString. They only become unescaped after going
+    through a full format.
+
+    >>> tmpl.pformatl("my{}path", "my{}file")
+    PartialString('find my{{}}path -name my{{}}file -exec ls -la {{}} \\;',)
+    >>> tmpl.formatl("my{}path", "my{}file")
+    'find my{}path -name my{}file -exec ls -la {} \\;'
+
     CAVEATS:
 
-    Filling up holes using other PartialStrings, does not play very nicely with
-    format specifiers. For example:
+    1. Filling up holes using other PartialStrings, does not play very nicely
+    with format specifiers. For example:
 
     >>> tmpl = PartialString("{0:20} {1.child}", a, b)
     >>> tmpl.pformat({a: tmpl})
@@ -202,12 +240,14 @@ class PartialString(object):
     So you probably want to avoid such usages. The exact behaviour of these
     might change in the future, too.
     """
-    formatter = Formatter()
+    formatter = PartialFormatter()
+    escape = staticmethod(PartialFormatter.escape)
 
     def __init__(self, fmtstr="", *holes):
         # Ensure the format string is valid, and figure out some basic stats
         fmt = self.formatter
-        pieces = [(len(l), f) for l, f, _, _ in fmt.parse(fmtstr)]
+        # use parse_no_escape so lengths are preserved
+        pieces = [(len(l), f) for l, f, _, _ in fmt.parse_no_escape(fmtstr)]
         used_args = set(fmt.arg_of_field_name(f, holes) for _, f in pieces if f is not None)
         self.num_holes = sum(1 for _, f in pieces if f is not None)
         self.base_len = sum(l for l, _ in pieces)
@@ -227,10 +267,14 @@ class PartialString(object):
     def __repr__(self):
         return "%s%r" % (self.__class__.__name__, (self._fmtstr,) + self.holes)
 
+    def _format(self, *mapping):
+        # format a string but preserve {{ and }} escapes
+        return self.formatter.vformat(self._fmtstr, mapping, None)
+
     def _offset_fmtstr(self, offset):
-        return self._fmtstr.format(*(FormatPlaceholder(i + offset) for i in range(len(self.holes))))
+        return self._format(*(FormatPlaceholder(i + offset) for i in range(len(self.holes))))
 
-    def _pformat(self, mapping):
+    def _pformat(self, mapping, escapestr):
         new_holes = []
         real_mapping = []
         for i, k in enumerate(self.holes):
@@ -239,32 +283,38 @@ class PartialString(object):
                 if isinstance(v, PartialString):
                     out = v._offset_fmtstr(len(new_holes))
                     new_holes.extend(v.holes)
+                elif isinstance(v, str) and escapestr:
+                    out = PartialString.escape(v)
                 else:
                     out = v
             else:
                 out = FormatPlaceholder(len(new_holes))
                 new_holes.append(k)
             real_mapping.append(out)
-        return self._fmtstr.format(*real_mapping), new_holes
+        return real_mapping, new_holes
 
     def size(self, hole_size=1):
         return self.base_len + hole_size * self.num_holes
 
-    def pformat(self, mapping):
+    def pformat(self, mapping={}):
         """Partially apply a mapping, returning a new PartialString."""
-        new_fmtstr, new_holes = self._pformat(mapping)
-        return self.__class__(new_fmtstr, *new_holes)
+        real_mapping, new_holes = self._pformat(mapping, True)
+        return self.__class__(self._format(*real_mapping), *new_holes)
 
     def pformatl(self, *args):
         """Partially apply a list, implicitly mapped from self.holes."""
         return self.pformat(dict(zip(self.holes, args)))
 
-    def format(self, mapping):
+    def format(self, mapping={}):
         """Fully apply a mapping, returning a string."""
-        new_fmtstr, new_holes = self._pformat(mapping)
+        real_mapping, new_holes = self._pformat(mapping, False)
         if new_holes:
             raise ValueError("not all holes filled: %r" % new_holes)
-        return new_fmtstr
+        return self._fmtstr.format(*real_mapping)
+
+    def formatl(self, *args):
+        """Fully apply a list, implicitly mapped from self.holes."""
+        return self.format(dict(zip(self.holes, args)))
 
     @classmethod
     def of(cls, obj):
diff --git a/tests/test_presenters.py b/tests/test_presenters.py
index c222993..85e9d17 100644
--- a/tests/test_presenters.py
+++ b/tests/test_presenters.py
@@ -178,8 +178,27 @@ def test_partial_string_cont():
     assert (t.format({key[0]: "line1", key[1]: "line2", key[2]: "line3"})
             == 'x: line1\ny: line2\nz: line3\n')
     assert t.size(hole_size=5) == 27
+
 def test_partial_string_numl():
     tmpl = PartialString.numl("{0} {1} {2}", 2, object())
     assert tmpl.holes[:2] == (0, 1)
     assert tmpl.pformatl("(1)", "(2)", "(o)") == PartialString('(1) (2) (o)')
 
+def test_partial_string_escape():
+    tmpl = PartialString.numl("find {0} -name {1} " +
+               PartialString.escape("-exec ls -la {} \;"), 2)
+    assert tmpl == PartialString('find {0} -name {1} -exec ls -la {{}} \\;', *tmpl.holes)
+    assert tmpl.size() == 33
+    assert tmpl.size(4) == 39
+    assert tmpl == PartialString.numl("find {0} -name {1} -exec ls -la {2} \;", 3).pformat({2: "{}"})
+
+    assert (tmpl.pformatl("my{}path", "my{}file") ==
+        PartialString('find my{{}}path -name my{{}}file -exec ls -la {{}} \\;'))
+    assert (tmpl.formatl("my{}path", "my{}file") ==
+        'find my{}path -name my{}file -exec ls -la {} \\;')
+
+    esc = PartialString("{{}} {0}", None)
+    assert esc.pformat({None: PartialString.of(None)}) == esc
+    assert esc.format({None: "0"}) == "{} 0"
+    with pytest.raises(ValueError):
+        PartialString("{}")

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/reproducible/diffoscope.git


More information about the diffoscope mailing list