Merge lp:~jelmer/brz/bundle-keywords into lp:brz

[Jelmer Vernooij]

Bundle the keywords plugin.

[lp:~jelmer/brz/bundle-keywords]

6694. By Jelmer Vernooij on 2018-11-12

Use absolute imports.

Unmerged revisions

6694. By Jelmer Vernooij on 2018-11-12

Use absolute imports.

6693. By Jelmer Vernooij on 2018-11-06

Fix tests with breezy.

6692. By Jelmer Vernooij on 2018-11-06

merge trunk.

6691. By Jelmer Vernooij on 2017-06-13

Bundle keywords plugin.

=== modified file 'breezy/filters/__init__.py'
--- breezy/filters/__init__.py	2018-07-17 22:59:51 +0000
+++ breezy/filters/__init__.py	2018-11-12 21:28:40 +0000
@@ -91,6 +91,9 @@
         """Relative path of file to tree-root."""
         return self._relpath
 
+    def file_id(self):
+        return self.source_tree().path2id(self.relpath())
+
     def source_tree(self):
         """Source Tree object."""
         return self._tree
 
=== added directory 'breezy/plugins/keywords'
=== added file 'breezy/plugins/keywords/NEWS'
--- breezy/plugins/keywords/NEWS	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/NEWS	2018-11-12 21:28:40 +0000
@@ -0,0 +1,18 @@
+##########################
+bzr-keywords Release Notes
+##########################
+
+.. contents::
+
+In Development
+##############
+
+This version is suitable for use with Bazaar 1.14 or later using
+trees in the 1.14 format.
+
+
+0.1 28-Jul-2008
+###############
+
+This version is suitable for testing with the development branch,
+~ian-clatworthy/bzr/bzr.content-filters.
 
=== added file 'breezy/plugins/keywords/README.txt'
--- breezy/plugins/keywords/README.txt	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/README.txt	2018-11-12 21:28:40 +0000
@@ -0,0 +1,43 @@
+bzr-keywords: RCS-like keyword templates
+========================================
+
+Overview
+--------
+
+This plugin adds keyword filtering to selected files. This allows
+you to do things like include the current user and date in a web page.
+
+
+Installation
+------------
+
+The easiest way to install this plugin is to either copy or symlink the
+directory into your ~/.bazaar/plugins directory. Be sure to rename the
+directory to keywords (instead of bzr-keywords).
+
+See http://bazaar-vcs.org/UsingPlugins for other options such as
+using the BZR_PLUGIN_PATH environment variable.
+
+
+Testing
+-------
+
+To test the plugin after installation:
+
+    bzr selftest keywords.tests
+ 
+
+Documentation
+-------------
+
+To see the documentation after installation:
+
+    bzr help keywords
+
+
+Licensing
+---------
+
+This plugin is (C) Copyright Canonical Limited 2008 under the
+GPL Version 2 or later. Please see the file COPYING.txt for the licence
+details.
 
=== added file 'breezy/plugins/keywords/TODO'
--- breezy/plugins/keywords/TODO	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/TODO	2018-11-12 21:28:40 +0000
@@ -0,0 +1,13 @@
+Things to consider:
+  * python_escape (maybe called string_escape) ala xml_escape?
+  * some sort of block construct so easier to include in ReST and properties
+    files, e.g.
+    .. $begin-keywords$
+    :name1: value1
+    :name2: value2
+    .. $end-keywords$
+
+* Add tests for:
+  * untested keyword values (including date formatting)
+  * escaping
+  * style formatting
 
=== added file 'breezy/plugins/keywords/__init__.py'
--- breezy/plugins/keywords/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/__init__.py	2018-11-12 21:28:40 +0000
@@ -0,0 +1,240 @@
+# Copyright (C) 2008 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+r'''Keyword Templating
+==================
+
+Keyword templating is provided as a content filter where Bazaar internally
+stores a canonical format but outputs a convenience format. See
+``bzr help content-filters`` for general information about using these.
+
+Note: Content filtering is only supported in recently added formats,
+e.g. 1.14.
+
+Keyword templates are specified using the following patterns:
+
+ * in canonical/compressed format: $Keyword$
+ * in convenience/expanded format: $Keyword: value $
+
+When expanding, the existing text is retained if an unknown keyword is
+found. If the keyword is already expanded but known, the value is replaced.
+When compressing, the values of known keywords are removed.
+
+Keyword filtering needs to be enabled for selected branches and files via
+rules. See ``bzr help rules`` for general information on defining rules.
+For example, to enable keywords for all ``txt`` files on your system, add
+these lines to your ``BZR_HOME/rules`` file::
+
+  [name *.txt]
+  keywords = on
+
+To disable keywords for ``txt`` files but enable them for ``html`` files::
+
+  [name *.txt]
+  keywords = off
+
+  [name *.html]
+  keywords = xml_escape
+
+``xml_escape`` enables keyword expansion but it escapes special characters
+in keyword values so they can be safely included in HTML or XML files.
+
+The currently supported keywords are given below.
+
+ =============  =========================================================
+ Keyword        Description
+ =============  =========================================================
+ Date           the date and time the file was last modified
+ Committer      the committer (name and email) of the last change
+ Authors        the authors (names and emails) of the last change
+ Revision-Id    the unique id of the revision that last changed the file
+ Path           the relative path of the file in the tree
+ Filename       just the name part of the relative path
+ Directory      just the directory part of the relative path
+ File-Id        the unique id assigned to this file
+ Now            the current date and time
+ User           the current user (name and email)
+ =============  =========================================================
+
+If you want finer control over the formatting of names and email
+addresses, you can use the following keywords.
+
+ =============    =======================================================
+ Keyword          Description
+ =============    =======================================================
+ Committer-Name   just the name of the current committer
+ Committer-Email  just the email address of the current committer
+ Author1-Name     just the name of the first author
+ Author1-Email    just the email address of the first author
+ Author2-Name     just the name of the second author
+ Author2-Email    just the email address of the second author
+ Author3-Name     just the name of the third author
+ Author3-Email    just the email address of the third author
+ User-Name        just the name of the current user
+ User-Email       just the email address of the current user
+ =============    =======================================================
+
+Note: If you have more than 3 authors for a given revision, please
+ask on the Bazaar mailing list for an enhancement to support the
+number you need.
+
+By default, dates/times are output using this format::
+
+  YYYY-MM-DD HH:MM:SS+HH:MM
+
+To specify a custom format, add a configuration setting to
+``BZR_HOME/bazaar.conf`` like this::
+
+  keywords.format.Now = %A, %B %d, %Y
+
+The last part of the key needs to match the keyword name. The value must be
+a legal strftime (http://docs.python.org/lib/module-time.html) format.
+'''
+
+from __future__ import absolute_import
+
+
+from ... import (
+    builtins,
+    commands,
+    filters,
+    option,
+    )
+
+
+def test_suite():
+    """Called by breezy to fetch tests for this plugin"""
+    from unittest import TestSuite, TestLoader
+    from .tests import (
+         test_conversion,
+         test_keywords_in_trees,
+         )
+    loader = TestLoader()
+    suite = TestSuite()
+    for module in [
+        test_conversion,
+        test_keywords_in_trees,
+        ]:
+        suite.addTests(loader.loadTestsFromModule(module))
+    return suite
+
+
+# Define and register the filter stack map
+def _keywords_filter_stack_lookup(k):
+    from .keywords import (
+        _kw_compressor,
+        _normal_kw_expander,
+        _xml_escape_kw_expander,
+        )
+    filter_stack_map = {
+        'off': [],
+        'on':
+            [filters.ContentFilter(_kw_compressor, _normal_kw_expander)],
+        'xml_escape':
+            [filters.ContentFilter(_kw_compressor, _xml_escape_kw_expander)],
+        }
+    return filter_stack_map.get(k)
+
+try:
+    register_filter = filters.filter_stacks_registry.register
+except AttributeError:
+    register_filter = filters.register_filter_stack_map
+
+register_filter('keywords', _keywords_filter_stack_lookup)
+
+
+class cmd_cat(builtins.cmd_cat):
+    """
+    The ``--keywords`` option specifies the keywords expansion
+    style. By default (``raw`` style), no expansion is done.
+    Other styles enable expansion in a ``cooked`` mode where both
+    the keyword and its value are displayed inside $ markers, or in
+    numerous publishing styles - ``publish``, ``publish-values`` and
+    ``publish-names`` - where the $ markers are completely removed.
+    The publishing styles do not support round-tripping back to the
+    raw content but are useful for improving the readability of
+    published web pages for example.
+
+    Note: Files must have the ``keywords`` preference defined for them
+    in order for the ``--keywords`` option to take effect. In particular,
+    the preference specifies how keyword values are encoded for different
+    filename patterns. See ``bzr help keywords`` for more information on
+    how to specify the required preference using rules.
+    """
+
+    # Add a new option to the builtin command and
+    # override the inherited run() and help() methods
+
+    takes_options = builtins.cmd_cat.takes_options + [
+         option.RegistryOption('keywords',
+             lazy_registry=(__name__ + ".keywords",
+                 "_keyword_style_registry"),
+             converter=lambda s: s,
+             help='Keyword expansion style.')]
+
+    def run(self, *args, **kwargs):
+        """Process special options and delegate to superclass."""
+        if 'keywords' in kwargs:
+            from .keywords import (
+                _keyword_style_registry,
+                )
+            # Implicitly set the filters option
+            kwargs['filters'] = True
+            style = kwargs['keywords']
+            _keyword_style_registry.default_key = style
+            del kwargs['keywords']
+        return super(cmd_cat, self).run(*args, **kwargs)
+
+    def help(self):
+      """Return help message including text from superclass."""
+      from inspect import getdoc
+      return getdoc(super(cmd_cat, self)) + '\n\n' + getdoc(self)
+
+
+class cmd_export(builtins.cmd_export):
+    # Add a new option to the builtin command and
+    # override the inherited run() and help() methods
+
+    takes_options = builtins.cmd_export.takes_options + [
+         option.RegistryOption('keywords',
+             lazy_registry=(__name__ + ".keywords",
+                 "_keyword_style_registry"),
+                 converter=lambda s: s,
+                 help='Keyword expansion style.')]
+
+    def run(self, *args, **kwargs):
+        """Process special options and delegate to superclass."""
+        if 'keywords' in kwargs:
+            from .keywords import (
+                _keyword_style_registry,
+                )
+            # Implicitly set the filters option
+            kwargs['filters'] = True
+            style = kwargs['keywords']
+            _keyword_style_registry.default_key = style
+            del kwargs['keywords']
+        return super(cmd_export, self).run(*args, **kwargs)
+
+    def help(self):
+      """Return help message including text from superclass."""
+      from inspect import getdoc
+      # NOTE: Reuse of cmd_cat help below is deliberate, not a bug
+      return getdoc(super(cmd_export, self)) + '\n\n' + getdoc(cmd_cat)
+
+
+# Register the command wrappers
+commands.register_command(cmd_cat, decorate=False)
+commands.register_command(cmd_export, decorate=False)
 
=== added file 'breezy/plugins/keywords/keywords.py'
--- breezy/plugins/keywords/keywords.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/keywords.py	2018-11-12 21:28:40 +0000
@@ -0,0 +1,269 @@
+# Copyright (C) 2008 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+from __future__ import absolute_import
+
+import re, time
+from ... import (
+    debug,
+    osutils,
+    registry,
+    trace,
+    )
+from ...sixish import text_type
+
+# Expansion styles
+# Note: Round-tripping is only required between the raw and cooked styles
+_keyword_style_registry = registry.Registry()
+_keyword_style_registry.register('raw', b'$%(name)s$')
+_keyword_style_registry.register('cooked', b'$%(name)s: %(value)s $')
+_keyword_style_registry.register('publish', b'%(name)s: %(value)s')
+_keyword_style_registry.register('publish-values', b'%(value)s')
+_keyword_style_registry.register('publish-names', b'%(name)s')
+_keyword_style_registry.default_key = 'cooked'
+
+
+# Regular expressions for matching the raw and cooked patterns
+_KW_RAW_RE = re.compile(b'\\$([\\w\\-]+)(:[^$]*)?\\$')
+_KW_COOKED_RE = re.compile(b'\\$([\\w\\-]+):([^$]+)\\$')
+
+
+# The registry of keywords. Other plugins may wish to add entries to this.
+keyword_registry = registry.Registry()
+
+# Revision-related keywords
+keyword_registry.register('Date',
+    lambda c: format_date(c.revision().timestamp, c.revision().timezone,
+    c.config(), 'Date'))
+keyword_registry.register('Committer',
+    lambda c: c.revision().committer)
+keyword_registry.register('Authors',
+    lambda c: ", ".join(c.revision().get_apparent_authors()))
+keyword_registry.register('Revision-Id',
+    lambda c: c.revision_id())
+keyword_registry.register('Path',
+    lambda c: c.relpath())
+keyword_registry.register('Directory',
+    lambda c: osutils.split(c.relpath())[0])
+keyword_registry.register('Filename',
+    lambda c: osutils.split(c.relpath())[1])
+keyword_registry.register('File-Id',
+    lambda c: c.file_id())
+
+# Environment-related keywords
+keyword_registry.register('Now',
+    lambda c: format_date(time.time(), time.timezone, c.config(), 'Now'))
+keyword_registry.register('User',
+    lambda c: c.config().username())
+
+# Keywords for finer control over name & address formatting
+keyword_registry.register('Committer-Name',
+    lambda c: extract_name(c.revision().committer))
+keyword_registry.register('Committer-Email',
+    lambda c: extract_email(c.revision().committer))
+keyword_registry.register('Author1-Name',
+    lambda c: extract_name_item(c.revision().get_apparent_authors(), 0))
+keyword_registry.register('Author1-Email',
+    lambda c: extract_email_item(c.revision().get_apparent_authors(), 0))
+keyword_registry.register('Author2-Name',
+    lambda c: extract_name_item(c.revision().get_apparent_authors(), 1))
+keyword_registry.register('Author2-Email',
+    lambda c: extract_email_item(c.revision().get_apparent_authors(), 1))
+keyword_registry.register('Author3-Name',
+    lambda c: extract_name_item(c.revision().get_apparent_authors(), 2))
+keyword_registry.register('Author3-Email',
+    lambda c: extract_email_item(c.revision().get_apparent_authors(), 2))
+keyword_registry.register('User-Name',
+    lambda c: extract_name(c.config().username()))
+keyword_registry.register('User-Email',
+    lambda c: extract_email(c.config().username()))
+
+
+def format_date(timestamp, offset=0, cfg=None, name=None):
+    """Return a formatted date string.
+
+    :param timestamp: Seconds since the epoch.
+    :param offset: Timezone offset in seconds east of utc.
+    """
+    if cfg is not None and name is not None:
+        cfg_key = 'keywords.format.%s' % (name,)
+        format = cfg.get_user_option(cfg_key)
+    else:
+        format = None
+    return osutils.format_date(timestamp, offset, date_fmt=format)
+
+
+def extract_name(userid):
+    """Extract the name out of a user-id string.
+
+    user-id strings have the format 'name <email>'.
+    """
+    if userid and userid[-1] == '>':
+        return userid[:-1].rsplit('<', 1)[0].rstrip()
+    else:
+        return userid
+
+
+def extract_email(userid):
+    """Extract the email address out of a user-id string.
+
+    user-id strings have the format 'name <email>'.
+    """
+    if userid and userid[-1] == '>':
+        return userid[:-1].rsplit('<', 1)[1]
+    else:
+        return userid
+
+def extract_name_item(seq, n):
+    """Extract the name out of the nth item in a sequence of user-ids.
+
+    :return: the user-name or an empty string
+    """
+    try:
+        return extract_name(seq[n])
+    except IndexError:
+        return ""
+
+
+def extract_email_item(seq, n):
+    """Extract the email out of the nth item in a sequence of user-ids.
+
+    :return: the email address or an empty string
+    """
+    try:
+        return extract_email(seq[n])
+    except IndexError:
+        return ""
+
+
+def compress_keywords(s, keyword_dicts):
+    """Replace cooked style keywords with raw style in a string.
+
+    Note: If the keyword is not known, the text is not modified.
+
+    :param s: the string
+    :param keyword_dicts: an iterable of keyword dictionaries.
+    :return: the string with keywords compressed
+    """
+    _raw_style = _keyword_style_registry.get('raw')
+    result = b''
+    rest = s
+    while True:
+        match = _KW_COOKED_RE.search(rest)
+        if not match:
+            break
+        result += rest[:match.start()]
+        keyword = match.group(1)
+        expansion = _get_from_dicts(keyword_dicts, keyword.decode('ascii'))
+        if expansion is None:
+            # Unknown expansion - leave as is
+            result += match.group(0)
+        else:
+            result += _raw_style % {b'name': keyword}
+        rest = rest[match.end():]
+    return result + rest
+
+
+def expand_keywords(s, keyword_dicts, context=None, encoder=None, style=None):
+    """Replace raw style keywords with another style in a string.
+
+    Note: If the keyword is already in the expanded style, the value is
+    not replaced.
+
+    :param s: the string
+    :param keyword_dicts: an iterable of keyword dictionaries. If values
+      are callables, they are executed to find the real value.
+    :param context: the parameter to pass to callable values
+    :param style: the style of expansion to use of None for the default
+    :return: the string with keywords expanded
+    """
+    _expanded_style = _keyword_style_registry.get(style)
+    result = b''
+    rest = s
+    while True:
+        match = _KW_RAW_RE.search(rest)
+        if not match:
+            break
+        result += rest[:match.start()]
+        keyword = match.group(1)
+        expansion = _get_from_dicts(keyword_dicts, keyword.decode('ascii'))
+        if callable(expansion):
+            try:
+                expansion = expansion(context)
+            except AttributeError as err:
+                if 'error' in debug.debug_flags:
+                    trace.note("error evaluating %s for keyword %s: %s",
+                        expansion, keyword, err)
+                expansion = b"(evaluation error)"
+        if isinstance(expansion, text_type):
+            expansion = expansion.encode('utf-8')
+        if expansion is None:
+            # Unknown expansion - leave as is
+            result += match.group(0)
+            rest = rest[match.end():]
+            continue
+        if b'$' in expansion:
+            # Expansion is not safe to be collapsed later
+            expansion = b"(value unsafe to expand)"
+        if encoder is not None:
+            expansion = encoder(expansion)
+        params = {b'name': keyword, b'value': expansion}
+        result += _expanded_style % params
+        rest = rest[match.end():]
+    return result + rest
+
+
+def _get_from_dicts(dicts, key, default=None):
+    """Search a sequence of dictionaries or registries for a key.
+
+    :return: the value, or default if not found
+    """
+    for dict in dicts:
+        if key in dict:
+            return dict.get(key)
+    return default
+
+
+def _xml_escape(s):
+    """Escape a string so it can be included safely in XML/HTML."""
+    # Compile the regular expressions if not already done
+    from ... import xml8
+    xml8._ensure_utf8_re()
+    # Convert and strip the trailing quote
+    return xml8._encode_and_escape(s)[:-1]
+
+
+def _kw_compressor(chunks, context=None):
+    """Filter that replaces keywords with their compressed form."""
+    text = b''.join(chunks)
+    return [compress_keywords(text, [keyword_registry])]
+
+
+def _kw_expander(chunks, context, encoder=None):
+    """Keyword expander."""
+    text = b''.join(chunks)
+    return [expand_keywords(text, [keyword_registry], context=context,
+        encoder=encoder)]
+
+
+def _normal_kw_expander(chunks, context=None):
+    """Filter that replaces keywords with their expanded form."""
+    return _kw_expander(chunks, context)
+
+
+def _xml_escape_kw_expander(chunks, context=None):
+    """Filter that replaces keywords with a form suitable for use in XML."""
+    return _kw_expander(chunks, context, encoder=_xml_escape)
 
=== added directory 'breezy/plugins/keywords/tests'
=== added file 'breezy/plugins/keywords/tests/__init__.py'
--- breezy/plugins/keywords/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/tests/__init__.py	2018-11-12 21:28:40 +0000
@@ -0,0 +1,19 @@
+# Copyright (C) 2008 Canonical Limited.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+
+"""Tests for bzr-keywords."""
+
+from __future__ import absolute_import
 
=== added file 'breezy/plugins/keywords/tests/test_conversion.py'
--- breezy/plugins/keywords/tests/test_conversion.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/tests/test_conversion.py	2018-11-12 21:28:40 +0000
@@ -0,0 +1,82 @@
+# Copyright (C) 2008 Canonical Limited.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+
+from __future__ import absolute_import
+
+"""Tests for keyword expansion/contraction."""
+
+
+from .... import tests
+from ..keywords import (
+    compress_keywords,
+    expand_keywords,
+    )
+
+
+# Sample unexpanded and expanded pairs for a keyword dictionary
+_keywords = {'Foo': 'FOO!', 'Bar': 'bar', 'CallMe': lambda c: "now!"}
+_keywords_dicts = [{'Foo': 'FOO!'}, {'Bar': 'bar', 'CallMe': lambda c: "now!"}]
+_samples = [
+    (b'$Foo$',           b'$Foo: FOO! $'),
+    (b'$Foo',            b'$Foo'),
+    (b'Foo$',            b'Foo$'),
+    (b'$Foo$ xyz',       b'$Foo: FOO! $ xyz'),
+    (b'abc $Foo$',       b'abc $Foo: FOO! $'),
+    (b'abc $Foo$ xyz',   b'abc $Foo: FOO! $ xyz'),
+    (b'$Foo$$Bar$',      b'$Foo: FOO! $$Bar: bar $'),
+    (b'abc $Foo$ xyz $Bar$ qwe', b'abc $Foo: FOO! $ xyz $Bar: bar $ qwe'),
+    (b'$Unknown$$Bar$',  b'$Unknown$$Bar: bar $'),
+    (b'$Unknown: unkn $$Bar$',  b'$Unknown: unkn $$Bar: bar $'),
+    (b'$Foo$$Unknown$',  b'$Foo: FOO! $$Unknown$'),
+    (b'$CallMe$',        b'$CallMe: now! $'),
+    ]
+
+
+class TestKeywordsConversion(tests.TestCase):
+
+    def test_compression(self):
+        # Test keyword expansion
+        for raw, cooked in _samples:
+            self.assertEqual(raw, compress_keywords(cooked, [_keywords]))
+
+    def test_expansion(self):
+        # Test keyword expansion
+        for raw, cooked in _samples:
+            self.assertEqual(cooked, expand_keywords(raw, [_keywords]))
+
+    def test_expansion_across_multiple_dictionaries(self):
+        # Check all still works when keywords in different dictionaries
+        for raw, cooked in _samples:
+            self.assertEqual(cooked, expand_keywords(raw, _keywords_dicts))
+
+    def test_expansion_feedback_when_unsafe(self):
+        kw_dict = {'Xxx': 'y$z'}
+        self.assertEqual(b'$Xxx: (value unsafe to expand) $',
+            expand_keywords(b'$Xxx$', [kw_dict]))
+
+    def test_expansion_feedback_when_error(self):
+        kw_dict = {'Xxx': lambda ctx: ctx.unknownMethod}
+        self.assertEqual(b'$Xxx: (evaluation error) $',
+            expand_keywords(b'$Xxx$', [kw_dict]))
+
+    def test_expansion_replaced_if_already_expanded(self):
+        s = b'$Xxx: old value $'
+        kw_dict = {'Xxx': 'new value'}
+        self.assertEqual(b'$Xxx: new value $', expand_keywords(s, [kw_dict]))
+
+    def test_expansion_ignored_if_already_expanded_but_unknown(self):
+        s = b'$Xxx: old value $'
+        self.assertEqual(b'$Xxx: old value $', expand_keywords(s, [{}]))
 
=== added file 'breezy/plugins/keywords/tests/test_keywords_in_trees.py'
--- breezy/plugins/keywords/tests/test_keywords_in_trees.py	1970-01-01 00:00:00 +0000
+++ breezy/plugins/keywords/tests/test_keywords_in_trees.py	2018-11-12 21:28:40 +0000
@@ -0,0 +1,123 @@
+# Copyright (C) 2009 Canonical Limited.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+
+from __future__ import absolute_import
+
+"""Tests for keyword expansion/contraction in trees."""
+
+## TODO: add tests for xml_escaped
+
+from .... import rules
+from ....tests import TestCaseWithTransport
+from ....workingtree import WorkingTree
+
+
+# Sample files. We exclude keywords that change from one run to another,
+# TODO: Test Date, Path, Now, User, User-Email
+_sample_text_raw = b"""
+Committer:      $Committer$
+Committer-Name: $Committer-Name$
+Authors:        $Authors$
+Author1-Email:  $Author1-Email$
+Revision-Id:    $Revision-Id$
+Filename:       $Filename$
+Directory:      $Directory$
+File-Id:        $File-Id$
+"""
+#User:         $User$
+#User-Email:   $User-Email$
+_sample_text_cooked = b"""
+Committer:      $Committer: Jane Smith <[e-mail]> $
+Committer-Name: $Committer-Name: Jane Smith $
+Authors:        $Authors: Sue Smith <[e-mail]> $
+Author1-Email:  $Author1-Email: [e-mail] $
+Revision-Id:    $Revision-Id: rev1-id $
+Filename:       $Filename: file1 $
+Directory:      $Directory:  $
+File-Id:        $File-Id: file1-id $
+"""
+#User:         $User: Dave Smith <[e-mail]>$
+#User-Email:   $User-Email: [e-mail] $
+_sample_binary = _sample_text_raw + b"""\x00"""
+
+
+class TestKeywordsInTrees(TestCaseWithTransport):
+
+    def patch_rules_searcher(self, keywords):
+        """Patch in a custom rules searcher with a given keywords setting."""
+        if keywords is None:
+            WorkingTree._get_rules_searcher = self.real_rules_searcher
+        else:
+            def custom__rules_searcher(tree, default_searcher):
+                return rules._IniBasedRulesSearcher([
+                    '[name *]\n',
+                    'keywords=%s\n' % keywords,
+                    ])
+            WorkingTree._get_rules_searcher = custom__rules_searcher
+
+    def prepare_tree(self, content, keywords=None):
+        """Prepare a working tree and commit some content."""
+        def restore_real_rules_searcher():
+            WorkingTree._get_rules_searcher = self.real_rules_searcher
+        self.real_rules_searcher = WorkingTree._get_rules_searcher
+        self.addCleanup(restore_real_rules_searcher)
+        self.patch_rules_searcher(keywords)
+        t = self.make_branch_and_tree('tree1')
+        # Patch is a custom username
+        #def custom_global_config():
+        #    config_file = StringIO(
+        #        "[DEFAULT]\nemail=Dave Smith <[e-mail]>\n")
+        #    my_config = config.GlobalConfig()
+        #    my_config._parser = my_config._get_parser(file=config_file)
+        #    return my_config
+        #t.branch.get_config()._get_global_config = custom_global_config
+        self.build_tree_contents([('tree1/file1', content)])
+        t.add(['file1'], [b'file1-id'])
+        t.commit("add file1", rev_id=b"rev1-id",
+            committer="Jane Smith <[e-mail]>",
+            authors=["Sue Smith <[e-mail]>"])
+        basis = t.basis_tree()
+        basis.lock_read()
+        self.addCleanup(basis.unlock)
+        return t, basis
+
+    def assertNewContentForSetting(self, wt, keywords, expected):
+        """Clone a working tree and check the convenience content."""
+        self.patch_rules_searcher(keywords)
+        wt2 = wt.controldir.sprout('tree-%s' % keywords).open_workingtree()
+        # To see exactly what got written to disk, we need an unfiltered read
+        content = wt2.get_file_text('file1', filtered=False)
+        self.assertEqual(expected, content)
+
+    def assertContent(self, wt, basis, expected_raw, expected_cooked):
+        """Check the committed content and content in cloned trees."""
+        basis_content = basis.get_file_text('file1')
+        self.assertEqualDiff(expected_raw, basis_content)
+        self.assertNewContentForSetting(wt, None, expected_raw)
+        self.assertNewContentForSetting(wt, 'on', expected_cooked)
+        self.assertNewContentForSetting(wt, 'off', expected_raw)
+
+    def test_keywords_no_rules(self):
+        wt, basis = self.prepare_tree(_sample_text_raw)
+        self.assertContent(wt, basis, _sample_text_raw, _sample_text_cooked)
+
+    def test_keywords_on(self):
+        wt, basis = self.prepare_tree(_sample_text_raw, keywords='on')
+        self.assertContent(wt, basis, _sample_text_raw, _sample_text_cooked)
+
+    def test_keywords_off(self):
+        wt, basis = self.prepare_tree(_sample_text_raw, keywords='off')
+        self.assertContent(wt, basis, _sample_text_raw, _sample_text_cooked)