Merge lp:~jelmer/brz/fast-import-cmds into lp:brz

[Jelmer Vernooij]

Remove the fast-import-{query,info,filter} commands.

Remove the fast-import-{query,info,filter} commands.

These are generic fast-import commands, and don't particularly need to be in
Breezy; I'm adding them to python-fastimport instead.

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-dev/118/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-dev/137/

=== modified file 'breezy/plugins/fastimport/__init__.py'
--- breezy/plugins/fastimport/__init__.py	2017-06-05 23:15:32 +0000
+++ breezy/plugins/fastimport/__init__.py	2018-05-07 11:48:26 +0000
@@ -46,9 +46,6 @@
 reporting on fast-import streams, see the online help for the commands::
 
   bzr help fast-import
-  bzr help fast-import-filter
-  bzr help fast-import-info
-  bzr help fast-import-query
 
 Finally, you may wish to generate a fast-import dump file from a Bazaar
 repository. The fast-export command is provided for that purpose.
@@ -70,6 +67,11 @@
         from ...errors import DependencyNotPresent
         raise DependencyNotPresent("fastimport",
             "fastimport requires the fastimport python module")
+    if fastimport.__version__ < (0, 9, 8):
+        from ...errors import DependencyNotPresent
+        raise DependencyNotPresent("fastimport",
+            "fastimport requires at least version 0.9.8 of the "
+            "fastimport python module")
 
 
 def test_suite():
@@ -79,9 +81,6 @@
 
 for name in [
         "fast_import",
-        "fast_import_filter",
-        "fast_import_info",
-        "fast_import_query",
         "fast_export",
         ]:
     plugin_cmds.register_lazy("cmd_%s" % name, [], "breezy.plugins.fastimport.cmds")

=== modified file 'breezy/plugins/fastimport/cache_manager.py'
--- breezy/plugins/fastimport/cache_manager.py	2018-01-22 02:23:22 +0000
+++ breezy/plugins/fastimport/cache_manager.py	2018-05-07 11:48:26 +0000
@@ -27,7 +27,7 @@
 from . import (
     branch_mapper,
     )
-from .reftracker import (
+from fastimport.reftracker import (
     RefTracker,
     )
 from .helpers import (

=== modified file 'breezy/plugins/fastimport/cmds.py'
--- breezy/plugins/fastimport/cmds.py	2017-11-12 02:01:00 +0000
+++ breezy/plugins/fastimport/cmds.py	2018-05-07 11:48:26 +0000
@@ -324,7 +324,7 @@
         from fastimport import parser
         from fastimport.errors import ParsingError
         from ...errors import BzrCommandError
-        from .processors import info_processor
+        from fastimport.processors import info_processor
         stream = _get_source_stream(source)
         output = StringIO()
         try:
@@ -341,230 +341,6 @@
         return lines
 
 
-class cmd_fast_import_filter(Command):
-    """Filter a fast-import stream to include/exclude files & directories.
-
-    This command is useful for splitting a subdirectory or bunch of
-    files out from a project to create a new project complete with history
-    for just those files. It can also be used to create a new project
-    repository that removes all references to files that should not have
-    been committed, e.g. security-related information (like passwords),
-    commercially sensitive material, files with an incompatible license or
-    large binary files like CD images.
-
-    To specify standard input as the input stream, use a source name
-    of '-'. If the source name ends in '.gz', it is assumed to be
-    compressed in gzip format.
-
-    :File/directory filtering:
-
-     This is supported by the -i and -x options. Excludes take precedence
-     over includes.
-
-     When filtering out a subdirectory (or file), the new stream uses the
-     subdirectory (or subdirectory containing the file) as the root. As
-     fast-import doesn't know in advance whether a path is a file or
-     directory in the stream, you need to specify a trailing '/' on
-     directories passed to the `--includes option`. If multiple files or
-     directories are given, the new root is the deepest common directory.
-
-     Note: If a path has been renamed, take care to specify the *original*
-     path name, not the final name that it ends up with.
-
-    :User mapping:
-
-     Some source repositories store just the user name while Bazaar
-     prefers a full email address. You can adjust user-ids
-     by using the --user-map option. The argument is a
-     text file with lines in the format::
-
-       old-id = new-id
-
-     Blank lines and lines beginning with # are ignored.
-     If old-id has the special value '@', then users without an
-     email address will get one created by using the matching new-id
-     as the domain, unless a more explicit address is given for them.
-     For example, given the user-map of::
-
-       @ = example.com
-       bill = William Jones <[e-mail]>
-
-     then user-ids are mapped as follows::
-
-      maria => maria <[e-mail]>
-      bill => William Jones <[e-mail]>
-
-     .. note::
-
-        User mapping is supported by both the fast-import and
-        fast-import-filter commands.
-
-    :History rewriting:
-
-     By default fast-import-filter does quite aggressive history rewriting.
-     Empty commits (or commits which had all their content filtered out) will
-     be removed, and so are the references to commits not included in the stream.
-
-     Flag --dont-squash-empty-commits reverses this behavior and makes it possible to
-     use fast-import-filter on incremental streams.
-
-    :Examples:
-
-     Create a new project from a library (note the trailing / on the
-     directory name of the library)::
-
-       front-end | bzr fast-import-filter -i lib/xxx/ > xxx.fi
-       bzr fast-import xxx.fi mylibrary.bzr
-       (lib/xxx/foo is now foo)
-
-     Create a new repository without a sensitive file::
-
-       front-end | bzr fast-import-filter -x missile-codes.txt > clean.fi
-       bzr fast-import clean.fi clean.bzr
-    """
-    hidden = False
-    _see_also = ['fast-import']
-    takes_args = ['source?']
-    takes_options = ['verbose',
-                    ListOption('include_paths', short_name='i', type=text_type,
-                        help="Only include commits affecting these paths."
-                             " Directories should have a trailing /."
-                        ),
-                    ListOption('exclude_paths', short_name='x', type=text_type,
-                        help="Exclude these paths from commits."
-                        ),
-                    Option('user-map', type=text_type,
-                        help="Path to file containing a map of user-ids.",
-                        ),
-                    Option('dont-squash-empty-commits',
-                        help="Preserve all commits and links between them"
-                        ),
-                     ]
-    encoding_type = 'exact'
-    def run(self, source=None, verbose=False, include_paths=None,
-        exclude_paths=None, user_map=None, dont_squash_empty_commits=False):
-        from ...errors import BzrCommandError
-        load_fastimport()
-        from fastimport.processors import filter_processor
-        params = {
-            'include_paths': include_paths,
-            'exclude_paths': exclude_paths,
-            }
-        if ('squash_empty_commits' in
-                filter_processor.FilterProcessor.known_params):
-            params['squash_empty_commits'] = (not dont_squash_empty_commits)
-        else:
-            if dont_squash_empty_commits:
-                raise BzrCommandError("installed python-fastimport does not "
-                    "support not squashing empty commits. Please install "
-                    " a newer python-fastimport to use "
-                    "--dont-squash-empty-commits")
-
-        from fastimport.errors import ParsingError
-        from fastimport import parser
-        stream = _get_source_stream(source)
-        user_mapper = _get_user_mapper(user_map)
-        proc = filter_processor.FilterProcessor(params=params, verbose=verbose)
-        p = parser.ImportParser(stream, verbose=verbose, user_mapper=user_mapper)
-        try:
-            return proc.process(p.iter_commands)
-        except ParsingError as e:
-            raise BzrCommandError("%d: Parse error: %s" % (e.lineno, e))
-
-
-class cmd_fast_import_info(Command):
-    """Output information about a fast-import stream.
-
-    This command reads a fast-import stream and outputs
-    statistics and interesting properties about what it finds.
-    When run in verbose mode, the information is output as a
-    configuration file that can be passed to fast-import to
-    assist it in intelligently caching objects.
-
-    To specify standard input as the input stream, use a source name
-    of '-'. If the source name ends in '.gz', it is assumed to be
-    compressed in gzip format.
-
-    :Examples:
-
-     Display statistics about the import stream produced by front-end::
-
-      front-end | bzr fast-import-info -
-
-     Create a hints file for running fast-import on a large repository::
-
-       front-end | bzr fast-import-info -v - > front-end.cfg
-    """
-    hidden = False
-    _see_also = ['fast-import']
-    takes_args = ['source']
-    takes_options = ['verbose']
-    def run(self, source, verbose=False):
-        load_fastimport()
-        from .processors import info_processor
-        return _run(source, info_processor.InfoProcessor, verbose=verbose)
-
-
-class cmd_fast_import_query(Command):
-    """Query a fast-import stream displaying selected commands.
-
-    To specify standard input as the input stream, use a source name
-    of '-'. If the source name ends in '.gz', it is assumed to be
-    compressed in gzip format.
-
-    To specify a commit to display, give its mark using the
-    --commit-mark option. The commit will be displayed with
-    file-commands included but with inline blobs hidden.
-
-    To specify the commands to display, use the -C option one or
-    more times. To specify just some fields for a command, use the
-    syntax::
-
-      command=field1,...
-
-    By default, the nominated fields for the nominated commands
-    are displayed tab separated. To see the information in
-    a name:value format, use verbose mode.
-
-    Note: Binary fields (e.g. data for blobs) are masked out
-    so it is generally safe to view the output in a terminal.
-
-    :Examples:
-
-     Show the commit with mark 429::
-
-      bzr fast-import-query xxx.fi -m429
-
-     Show all the fields of the reset and tag commands::
-
-      bzr fast-import-query xxx.fi -Creset -Ctag
-
-     Show the mark and merge fields of the commit commands::
-
-      bzr fast-import-query xxx.fi -Ccommit=mark,merge
-    """
-    hidden = True
-    _see_also = ['fast-import', 'fast-import-filter']
-    takes_args = ['source']
-    takes_options = ['verbose',
-                    Option('commit-mark', short_name='m', type=text_type,
-                        help="Mark of the commit to display."
-                        ),
-                    ListOption('commands', short_name='C', type=text_type,
-                        help="Display fields for these commands."
-                        ),
-                     ]
-    def run(self, source, verbose=False, commands=None, commit_mark=None):
-        load_fastimport()
-        from fastimport.processors import query_processor
-        from . import helpers
-        params = helpers.defines_to_dict(commands) or {}
-        if commit_mark:
-            params['commit-mark'] = commit_mark
-        return _run(source, query_processor.QueryProcessor, params=params,
-            verbose=verbose)
-
-
 class cmd_fast_export(Command):
     """Generate a fast-import stream from a Bazaar branch.
 

=== modified file 'breezy/plugins/fastimport/helpers.py'
--- breezy/plugins/fastimport/helpers.py	2017-08-26 15:17:57 +0000
+++ breezy/plugins/fastimport/helpers.py	2018-05-07 11:48:26 +0000
@@ -178,26 +178,3 @@
         return single
     else:
         return plural
-
-
-def invert_dictset(d):
-    """Invert a dictionary with keys matching a set of values, turned into lists."""
-    # Based on recipe from ASPN
-    result = {}
-    for k, c in d.items():
-        for v in c:
-            keys = result.setdefault(v, [])
-            keys.append(k)
-    return result
-
-
-def invert_dict(d):
-    """Invert a dictionary with keys matching each value turned into a list."""
-    # Based on recipe from ASPN
-    result = {}
-    for k, v in d.items():
-        keys = result.setdefault(v, [])
-        keys.append(k)
-    return result
-
-

=== modified file 'breezy/plugins/fastimport/processors/generic_processor.py'
--- breezy/plugins/fastimport/processors/generic_processor.py	2018-03-25 02:55:15 +0000
+++ breezy/plugins/fastimport/processors/generic_processor.py	2018-05-07 11:48:26 +0000
@@ -47,6 +47,9 @@
     errors as plugin_errors,
     processor,
     )
+from fastimport.helpers import (
+    invert_dictset,
+    )
 
 
 # How many commits before automatically reporting progress
@@ -342,7 +345,7 @@
         # Update the branches
         self.note("Updating branch information ...")
         updater = branch_updater.BranchUpdater(self.repo, self.branch,
-            self.cache_mgr, helpers.invert_dictset(
+            self.cache_mgr, invert_dictset(
                 self.cache_mgr.reftracker.heads),
             self.cache_mgr.reftracker.last_ref, self.tags)
         branches_updated, branches_lost = updater.update()

=== removed file 'breezy/plugins/fastimport/processors/info_processor.py'
--- breezy/plugins/fastimport/processors/info_processor.py	2017-06-05 22:01:28 +0000
+++ breezy/plugins/fastimport/processors/info_processor.py	1970-01-01 00:00:00 +0000
@@ -1,282 +0,0 @@
-# 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, see <http://www.gnu.org/licenses/>.
-
-"""Import processor that dump stats about the input (and doesn't import)."""
-
-from __future__ import absolute_import
-
-from .. import (
-    reftracker,
-    )
-from ..helpers import (
-    invert_dict,
-    invert_dictset,
-    )
-from fastimport import (
-    commands,
-    processor,
-    )
-import stat
-
-
-class InfoProcessor(processor.ImportProcessor):
-    """An import processor that dumps statistics about the input.
-
-    No changes to the current repository are made.
-
-    As well as providing useful information about an import
-    stream before importing it, this processor is useful for
-    benchmarking the speed at which data can be extracted from
-    the source.
-    """
-
-    def __init__(self, params=None, verbose=0, outf=None):
-        processor.ImportProcessor.__init__(self, params, verbose,
-            outf=outf)
-
-    def pre_process(self):
-        # Init statistics
-        self.cmd_counts = {}
-        for cmd in commands.COMMAND_NAMES:
-            self.cmd_counts[cmd] = 0
-        self.file_cmd_counts = {}
-        for fc in commands.FILE_COMMAND_NAMES:
-            self.file_cmd_counts[fc] = 0
-        self.parent_counts = {}
-        self.max_parent_count = 0
-        self.committers = set()
-        self.separate_authors_found = False
-        self.symlinks_found = False
-        self.executables_found = False
-        self.sha_blob_references = False
-        self.lightweight_tags = 0
-        # Blob usage tracking
-        self.blobs = {}
-        for usage in ['new', 'used', 'unknown', 'unmarked']:
-            self.blobs[usage] = set()
-        self.blob_ref_counts = {}
-        # Head tracking
-        self.reftracker = reftracker.RefTracker()
-        # Stuff to cache: a map from mark to # of times that mark is merged
-        self.merges = {}
-        # Stuff to cache: these are maps from mark to sets
-        self.rename_old_paths = {}
-        self.copy_source_paths = {}
-
-    def post_process(self):
-        # Dump statistics
-        cmd_names = commands.COMMAND_NAMES
-        fc_names = commands.FILE_COMMAND_NAMES
-        self._dump_stats_group("Command counts",
-            [(c, self.cmd_counts[c]) for c in cmd_names], str)
-        self._dump_stats_group("File command counts", 
-            [(c, self.file_cmd_counts[c]) for c in fc_names], str)
-
-        # Commit stats
-        if self.cmd_counts['commit']:
-            p_items = []
-            for i in range(self.max_parent_count + 1):
-                if i in self.parent_counts:
-                    count = self.parent_counts[i]
-                    p_items.append(("parents-%d" % i, count))
-            merges_count = len(self.merges)
-            p_items.append(('total revisions merged', merges_count))
-            flags = {
-                'separate authors found': self.separate_authors_found,
-                'executables': self.executables_found,
-                'symlinks': self.symlinks_found,
-                'blobs referenced by SHA': self.sha_blob_references,
-                }
-            self._dump_stats_group("Parent counts", p_items, str)
-            self._dump_stats_group("Commit analysis", flags.items(), _found)
-            heads = invert_dictset(self.reftracker.heads)
-            self._dump_stats_group("Head analysis", heads.items(), None,
-                                    _iterable_as_config_list)
-            # note("\t%d\t%s" % (len(self.committers), 'unique committers'))
-            self._dump_stats_group("Merges", self.merges.items(), None)
-            # We only show the rename old path and copy source paths when -vv
-            # (verbose=2) is specified. The output here for mysql's data can't
-            # be parsed currently so this bit of code needs more work anyhow ..
-            if self.verbose >= 2:
-                self._dump_stats_group("Rename old paths",
-                    self.rename_old_paths.items(), len,
-                    _iterable_as_config_list)
-                self._dump_stats_group("Copy source paths",
-                    self.copy_source_paths.items(), len,
-                    _iterable_as_config_list)
-
-        # Blob stats
-        if self.cmd_counts['blob']:
-            # In verbose mode, don't list every blob used
-            if self.verbose:
-                del self.blobs['used']
-            self._dump_stats_group("Blob usage tracking",
-                self.blobs.items(), len, _iterable_as_config_list)
-        if self.blob_ref_counts:
-            blobs_by_count = invert_dict(self.blob_ref_counts)
-            blob_items = sorted(blobs_by_count.items())
-            self._dump_stats_group("Blob reference counts",
-                blob_items, len, _iterable_as_config_list)
-
-        # Other stats
-        if self.cmd_counts['reset']:
-            reset_stats = {
-                'lightweight tags': self.lightweight_tags,
-                }
-            self._dump_stats_group("Reset analysis", reset_stats.items())
-
-    def _dump_stats_group(self, title, items, normal_formatter=None,
-        verbose_formatter=None):
-        """Dump a statistics group.
-        
-        In verbose mode, do so as a config file so
-        that other processors can load the information if they want to.
-        :param normal_formatter: the callable to apply to the value
-          before displaying it in normal mode
-        :param verbose_formatter: the callable to apply to the value
-          before displaying it in verbose mode
-        """
-        if self.verbose:
-            self.outf.write("[%s]\n" % (title,))
-            for name, value in items:
-                if verbose_formatter is not None:
-                    value = verbose_formatter(value)
-                if type(name) == str:
-                    name = name.replace(' ', '-')
-                self.outf.write("%s = %s\n" % (name, value))
-            self.outf.write("\n")
-        else:
-            self.outf.write("%s:\n" % (title,))
-            for name, value in items:
-                if normal_formatter is not None:
-                    value = normal_formatter(value)
-                self.outf.write("\t%s\t%s\n" % (value, name))
-
-    def progress_handler(self, cmd):
-        """Process a ProgressCommand."""
-        self.cmd_counts[cmd.name] += 1
-
-    def blob_handler(self, cmd):
-        """Process a BlobCommand."""
-        self.cmd_counts[cmd.name] += 1
-        if cmd.mark is None:
-            self.blobs['unmarked'].add(cmd.id)
-        else:
-            self.blobs['new'].add(cmd.id)
-            # Marks can be re-used so remove it from used if already there.
-            # Note: we definitely do NOT want to remove it from multi if
-            # it's already in that set.
-            try:
-                self.blobs['used'].remove(cmd.id)
-            except KeyError:
-                pass
-
-    def checkpoint_handler(self, cmd):
-        """Process a CheckpointCommand."""
-        self.cmd_counts[cmd.name] += 1
-
-    def commit_handler(self, cmd):
-        """Process a CommitCommand."""
-        self.cmd_counts[cmd.name] += 1
-        self.committers.add(cmd.committer)
-        if cmd.author is not None:
-            self.separate_authors_found = True
-        for fc in cmd.iter_files():
-            self.file_cmd_counts[fc.name] += 1
-            if isinstance(fc, commands.FileModifyCommand):
-                if fc.mode & 0111:
-                    self.executables_found = True
-                if stat.S_ISLNK(fc.mode):
-                    self.symlinks_found = True
-                if fc.dataref is not None:
-                    if fc.dataref[0] == ':':
-                        self._track_blob(fc.dataref)
-                    else:
-                        self.sha_blob_references = True
-            elif isinstance(fc, commands.FileRenameCommand):
-                self.rename_old_paths.setdefault(cmd.id, set()).add(fc.old_path)
-            elif isinstance(fc, commands.FileCopyCommand):
-                self.copy_source_paths.setdefault(cmd.id, set()).add(fc.src_path)
-
-        # Track the heads
-        parents = self.reftracker.track_heads(cmd)
-
-        # Track the parent counts
-        parent_count = len(parents)
-        if self.parent_counts.has_key(parent_count):
-            self.parent_counts[parent_count] += 1
-        else:
-            self.parent_counts[parent_count] = 1
-            if parent_count > self.max_parent_count:
-                self.max_parent_count = parent_count
-
-        # Remember the merges
-        if cmd.merges:
-            #self.merges.setdefault(cmd.ref, set()).update(cmd.merges)
-            for merge in cmd.merges:
-                if merge in self.merges:
-                    self.merges[merge] += 1
-                else:
-                    self.merges[merge] = 1
-
-    def reset_handler(self, cmd):
-        """Process a ResetCommand."""
-        self.cmd_counts[cmd.name] += 1
-        if cmd.ref.startswith('refs/tags/'):
-            self.lightweight_tags += 1
-        else:
-            if cmd.from_ is not None:
-                self.reftracker.track_heads_for_ref(
-                    cmd.ref, cmd.from_)
-
-    def tag_handler(self, cmd):
-        """Process a TagCommand."""
-        self.cmd_counts[cmd.name] += 1
-
-    def feature_handler(self, cmd):
-        """Process a FeatureCommand."""
-        self.cmd_counts[cmd.name] += 1
-        feature = cmd.feature_name
-        if feature not in commands.FEATURE_NAMES:
-            self.warning("feature %s is not supported - parsing may fail"
-                % (feature,))
-
-    def _track_blob(self, mark):
-        if mark in self.blob_ref_counts:
-            self.blob_ref_counts[mark] += 1
-            pass
-        elif mark in self.blobs['used']:
-            self.blob_ref_counts[mark] = 2
-            self.blobs['used'].remove(mark)
-        elif mark in self.blobs['new']:
-            self.blobs['used'].add(mark)
-            self.blobs['new'].remove(mark)
-        else:
-            self.blobs['unknown'].add(mark)
-
-def _found(b):
-    """Format a found boolean as a string."""
-    return ['no', 'found'][b]
-
-def _iterable_as_config_list(s):
-    """Format an iterable as a sequence of comma-separated strings.
-    
-    To match what ConfigObj expects, a single item list has a trailing comma.
-    """
-    items = sorted(s)
-    if len(items) == 1:
-        return "%s," % (items[0],)
-    else:
-        return ", ".join(items)

=== removed file 'breezy/plugins/fastimport/reftracker.py'
--- breezy/plugins/fastimport/reftracker.py	2017-05-23 23:21:16 +0000
+++ breezy/plugins/fastimport/reftracker.py	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-# Copyright (C) 2009 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, see <http://www.gnu.org/licenses/>.
-
-
-"""Tracker of refs."""
-
-from __future__ import absolute_import
-
-
-class RefTracker(object):
-
-    def __init__(self):
-        # Head tracking: last ref, last id per ref & map of commit ids to ref*s*
-        self.last_ref = None
-        self.last_ids = {}
-        self.heads = {}
-
-    def dump_stats(self, note):
-        self._show_stats_for(self.last_ids, "last-ids", note=note)
-        self._show_stats_for(self.heads, "heads", note=note)
-
-    def clear(self):
-        self.last_ids.clear()
-        self.heads.clear()
-
-    def track_heads(self, cmd):
-        """Track the repository heads given a CommitCommand.
-
-        :param cmd: the CommitCommand
-        :return: the list of parents in terms of commit-ids
-        """
-        # Get the true set of parents
-        if cmd.from_ is not None:
-            parents = [cmd.from_]
-        else:
-            last_id = self.last_ids.get(cmd.ref)
-            if last_id is not None:
-                parents = [last_id]
-            else:
-                parents = []
-        parents.extend(cmd.merges)
-
-        # Track the heads
-        self.track_heads_for_ref(cmd.ref, cmd.id, parents)
-        return parents
-
-    def track_heads_for_ref(self, cmd_ref, cmd_id, parents=None):
-        if parents is not None:
-            for parent in parents:
-                if parent in self.heads:
-                    del self.heads[parent]
-        self.heads.setdefault(cmd_id, set()).add(cmd_ref)
-        self.last_ids[cmd_ref] = cmd_id
-        self.last_ref = cmd_ref
-
-

=== modified file 'breezy/plugins/fastimport/tests/test_commands.py'
--- breezy/plugins/fastimport/tests/test_commands.py	2018-02-18 15:21:06 +0000
+++ breezy/plugins/fastimport/tests/test_commands.py	2018-05-07 11:48:26 +0000
@@ -196,40 +196,6 @@
 
 """
 
-class TestFastImportInfo(ExternalBase):
-
-    _test_needs_features = [FastimportFeature]
-
-    def test_simple(self):
-        self.build_tree_contents([('simple.fi', simple_fast_import_stream)])
-        output = self.run_bzr("fast-import-info simple.fi")[0]
-        self.assertEquals(output, """Command counts:
-\t0\tblob
-\t0\tcheckpoint
-\t1\tcommit
-\t0\tfeature
-\t0\tprogress
-\t0\treset
-\t0\ttag
-File command counts:
-\t0\tfilemodify
-\t0\tfiledelete
-\t0\tfilecopy
-\t0\tfilerename
-\t0\tfiledeleteall
-Parent counts:
-\t1\tparents-0
-\t0\ttotal revisions merged
-Commit analysis:
-\tno\texecutables
-\tno\tseparate authors found
-\tno\tsymlinks
-\tno\tblobs referenced by SHA
-Head analysis:
-\t[':1']\trefs/heads/master
-Merges:
-""")
-
 
 class TestFastImport(ExternalBase):
 
@@ -256,17 +222,3 @@
         self.make_branch_and_tree("br")
         self.run_bzr_error(['brz: ERROR: 4: Parse error: line 4: Command commit is missing section committer\n'], "fast-import empty.fi br")
 
-
-class TestFastImportFilter(ExternalBase):
-
-    _test_needs_features = [FastimportFeature]
-
-    def test_empty(self):
-        self.build_tree_contents([('empty.fi', b"")])
-        self.make_branch_and_tree("br")
-        self.assertEquals("", self.run_bzr("fast-import-filter -")[0])
-
-    def test_default_stdin(self):
-        self.build_tree_contents([('empty.fi', b"")])
-        self.make_branch_and_tree("br")
-        self.assertEquals("", self.run_bzr("fast-import-filter")[0])

=== modified file 'setup.py'
--- setup.py	2018-04-01 18:03:28 +0000
+++ setup.py	2018-05-07 11:48:26 +0000
@@ -58,7 +58,7 @@
         'six>=1.9.0',
         ],
     'extras_require': {
-        'fastimport': ['fastimport'],
+        'fastimport': ['fastimport>=0.9.8'],
         },
 }