narrow: remove custom filelog type

This functionality is now handled by core as of the previous commit.

I wanted this to be a standalone commit because the deleted code
makes a reference to remotefilelog's file type missing a node() method
and this may have implications to narrow+remotefilelog usage. The code
in core doesn't perform this check and therefore behavior may be subtly
different and buggy.

But I /think/ the check is merely a performance optimization and
nothing more. So I'm optimistic this will continue to "just work."

Differential Revision: https://phab.mercurial-scm.org/D4644

hgext/narrow/narrowrepo.py

@@ -1,36 +1,30 b''
 # narrowrepo.py - repository which supports narrow revlogs, lazy loading
 #
 # Copyright 2017 Google, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from . import (
     narrowdirstate,
-    narrowrevlog,
     narrowwirepeer,
 )
 
 def wraprepo(repo):
     """Enables narrow clone functionality on a single local repository."""
 
     class narrowrepository(repo.__class__):
 
-        def file(self, f):
-            fl = super(narrowrepository, self).file(f)
-            narrowrevlog.makenarrowfilelog(fl, self.narrowmatch())
-            return fl
-
         def _makedirstate(self):
             dirstate = super(narrowrepository, self)._makedirstate()
             return narrowdirstate.wrapdirstate(self, dirstate)
 
         def peer(self):
             peer = super(narrowrepository, self).peer()
             peer._caps.add(narrowwirepeer.NARROWCAP)
             peer._caps.add(narrowwirepeer.ELLIPSESCAP)
             return peer
 
     repo.__class__ = narrowrepository

hgext/narrow/narrowrevlog.py

@@ -1,80 +1,29 b''
 # narrowrevlog.py - revlog storing irrelevant nodes as "ellipsis" nodes
 #
 # Copyright 2017 Google, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from mercurial import (
    revlog,
-   util,
 )
 
 def readtransform(self, text):
     return text, False
 
 def writetransform(self, text):
     return text, False
 
 def rawtransform(self, text):
     return False
 
 revlog.addflagprocessor(revlog.REVIDX_ELLIPSIS,
                         (readtransform, writetransform, rawtransform))
 
 def setup():
     # We just wanted to add the flag processor, which is done at module
     # load time.
     pass
-
-def makenarrowfilelog(fl, narrowmatch):
-    class narrowfilelog(fl.__class__):
-        def renamed(self, node):
-            # Renames that come from outside the narrowspec are
-            # problematic at least for git-diffs, because we lack the
-            # base text for the rename. This logic was introduced in
-            # 3cd72b1 of narrowhg (authored by martinvonz, reviewed by
-            # adgar), but that revision doesn't have any additional
-            # commentary on what problems we can encounter.
-            m = super(narrowfilelog, self).renamed(node)
-            if m and not narrowmatch(m[0]):
-                return None
-            return m
-
-        def size(self, rev):
-            # We take advantage of the fact that remotefilelog
-            # lacks a node() method to just skip the
-            # rename-checking logic when on remotefilelog. This
-            # might be incorrect on other non-revlog-based storage
-            # engines, but for now this seems to be fine.
-            #
-            # TODO: when remotefilelog is in core, improve this to
-            # explicitly look for remotefilelog instead of cheating
-            # with a hasattr check.
-            if util.safehasattr(self, 'node'):
-                node = self.node(rev)
-                # Because renamed() is overridden above to
-                # sometimes return None even if there is metadata
-                # in the revlog, size can be incorrect for
-                # copies/renames, so we need to make sure we call
-                # the super class's implementation of renamed()
-                # for the purpose of size calculation.
-                if super(narrowfilelog, self).renamed(node):
-                    return len(self.read(node))
-            return super(narrowfilelog, self).size(rev)
-
-        def cmp(self, node, text):
-            different = super(narrowfilelog, self).cmp(node, text)
-            if different:
-                # Similar to size() above, if the file was copied from
-                # a file outside the narrowspec, the super class's
-                # would have returned True because we tricked it into
-                # thinking that the file was not renamed.
-                if super(narrowfilelog, self).renamed(node):
-                    t2 = self.read(node)
-                    return t2 != text
-            return different
-
-    fl.__class__ = narrowfilelog