[diffoscope] 01/02: presenters: add a PartialString class

Ximin Luo infinity0 at debian.org
Sat Jun 17 14:29:36 UTC 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 8051d6febf11309595d623d9ffaa79fb8096101c
Author: Ximin Luo <infinity0 at debian.org>
Date:   Fri Jun 16 22:56:42 2017 +0200

    presenters: add a PartialString class
---
 diffoscope/presenters/utils.py | 166 +++++++++++++++++++++++++++++++++++++++++
 tests/test_presenters.py       |  18 ++++-
 2 files changed, 183 insertions(+), 1 deletion(-)

diff --git a/diffoscope/presenters/utils.py b/diffoscope/presenters/utils.py
index e69c5d4..b0da209 100644
--- a/diffoscope/presenters/utils.py
+++ b/diffoscope/presenters/utils.py
@@ -19,7 +19,10 @@
 
 import sys
 import codecs
+import collections
 import contextlib
+import string
+import _string
 
 
 class Presenter(object):
@@ -99,3 +102,166 @@ def create_limited_print_func(print_func, max_page_size):
             raise PrintLimitReached()
 
     return fn
+
+
+class Formatter(string.Formatter):
+    def arg_of_field_name(self, field_name):
+        return _string.formatter_field_name_split(field_name)[0]
+
+
+class FormatPlaceholder(object):
+    def __init__(self, ident):
+        self.ident = str(ident)
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.ident)
+    def __format__(self, spec):
+        result = self.ident
+        if spec:
+            result += ":" + spec
+        return "{" + result + "}"
+    def __getitem__(self, key):
+        return FormatPlaceholder(self.ident + "[" + str(key) + "]")
+    def __getattr__(self, attr):
+        return FormatPlaceholder(self.ident + "." + str(attr))
+
+
+class PartialString(object):
+    """A format string where the "holes" are indexed by arbitrary python
+    objects instead of string names or integer indexes. This is useful when you
+    need to compose these objects together, but don't want users of the partial
+    string to have to deal with artificial "indexes" for the holes.
+
+    For example:
+
+    >>> a, b = object(), object()
+    >>> tmpl = PartialString("{0} {1}", a, b)
+    >>> tmpl
+    PartialString('{0} {1}', <object object at ...>, <object object at ...>)
+    >>> tmpl.holes == (a, b)
+    True
+    >>> tmpl.format({a: "Hello,", b: "World!"})
+    'Hello, World!'
+
+    You can partially fill up the holes:
+
+    >>> tmpl.pformat({a: "Hello,"}) == PartialString('Hello, {0}', b)
+    True
+    >>> tmpl.pformat({b: "World!"}) == PartialString('{0} World!', a)
+    True
+
+    You can estimate the size of the filled-up string:
+
+    >>> tmpl.base_len, tmpl.num_holes
+    (1, 2)
+    >>> tmpl.size(hole_size=33)
+    67
+
+    You can also partially fill up the holes using more PartialStrings,
+    even recursively:
+
+    >>> tmpl.pformat({a: PartialString('{0}', b)}) == PartialString('{0} {0}', b)
+    True
+    >>> tmpl.pformat({a: tmpl}) == PartialString('{0} {1} {1}', a, b)
+    True
+    >>> tmpl.pformat({b: tmpl}) == PartialString('{0} {0} {1}', a, b)
+    True
+
+    Finally, the holes have to match what's in the format string:
+
+    >>> tmpl = PartialString("{0} {1} {2}", a, b)
+    Traceback (most recent call last):
+    ...
+    IndexError: tuple index out of range
+
+    CAVEATS:
+
+    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})
+    PartialString('{0:20} {1.child}     {1.child}', <object ...>, <object ...>)
+    >>> tmpl.pformat({b: tmpl})
+    Traceback (most recent call last):
+    ...
+    AttributeError: ... has no attribute 'child'
+
+    So you probably want to avoid such usages. The exact behaviour of these
+    might change in the future, too.
+    """
+    formatter = Formatter()
+
+    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)]
+        used_args = set(fmt.arg_of_field_name(f) 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)
+
+        # Remove unused and duplicates in the holes objects
+        seen = collections.OrderedDict()
+        mapping = tuple(FormatPlaceholder(seen.setdefault(k, len(seen))) if i in used_args else None
+            for i, k in enumerate(holes))
+        self._fmtstr = fmt.vformat(fmtstr, mapping, {})
+        self.holes = tuple(seen.keys())
+
+    def __eq__(self, other):
+        return (self is other or isinstance(other, PartialString) and
+                other._fmtstr == self._fmtstr and
+                other.holes == self.holes)
+
+    def __repr__(self):
+        return "%s%r" % (self.__class__.__name__, (self._fmtstr,) + self.holes)
+
+    def _offset_fmtstr(self, offset):
+        return self._fmtstr.format(*(FormatPlaceholder(i + offset) for i in range(len(self.holes))))
+
+    def _pformat(self, mapping):
+        new_holes = []
+        real_mapping = []
+        for i, k in enumerate(self.holes):
+            if k in mapping:
+                v = mapping[k]
+                if isinstance(v, PartialString):
+                    out = v._offset_fmtstr(len(new_holes))
+                    new_holes.extend(v.holes)
+                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
+
+    def size(self, hole_size=1):
+        return self.base_len + hole_size * self.num_holes
+
+    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)
+
+    def format(self, mapping):
+        """Fully apply a mapping, returning a string."""
+        new_fmtstr, new_holes = self._pformat(mapping)
+        if new_holes:
+            raise ValueError("not all holes filled: %r" % new_holes)
+        return new_fmtstr
+
+    @classmethod
+    def of(cls, obj):
+        """Create a partial string for a single object.
+
+        >>> e = PartialString.of(None)
+        >>> e.pformat({None: e}) == e
+        True
+        """
+        return cls("{0}", obj)
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod(optionflags=doctest.ELLIPSIS)
+    a, b = object(), object()
+    tmpl = PartialString("{0} {1}", a, b)
diff --git a/tests/test_presenters.py b/tests/test_presenters.py
index b604cda..6cc4fa5 100644
--- a/tests/test_presenters.py
+++ b/tests/test_presenters.py
@@ -22,7 +22,7 @@ import re
 import pytest
 
 from diffoscope.main import main
-from diffoscope.presenters.utils import create_limited_print_func, PrintLimitReached
+from diffoscope.presenters.utils import create_limited_print_func, PrintLimitReached, PartialString
 
 from .utils.data import cwd_data, get_data
 
@@ -153,3 +153,19 @@ def test_limited_print():
     p = create_limited_print_func(fake, 5)
     p("123")
     p("456", force=True)
+
+def test_partial_string():
+    a, b = object(), object()
+    tmpl = PartialString("{0} {1}", a, b)
+    assert tmpl.holes == (a, b)
+    assert tmpl.format({a: "Hello,", b: "World!"}) == 'Hello, World!'
+    assert tmpl.pformat({a: "Hello,"}) == PartialString('Hello, {0}', b)
+    assert tmpl.pformat({b: "World!"}) == PartialString('{0} World!', a)
+    assert tmpl.base_len, tmpl.num_holes == (1, 2)
+    assert tmpl.size(hole_size=33) == 67
+    assert tmpl.pformat({a: PartialString('{0}', b)}) == PartialString('{0} {0}', b)
+    assert tmpl.pformat({a: tmpl}) == PartialString('{0} {1} {1}', a, b)
+    assert tmpl.pformat({b: tmpl}) == PartialString('{0} {0} {1}', a, b)
+    PartialString("{1}", a, b)
+    with pytest.raises(IndexError):
+        PartialString("{0} {1} {2}", a, b)

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



More information about the Reproducible-commits mailing list