Patchwork [6,of,9] flagutil: introduce a flagprocessorsmixin class

login
register
mail settings
Submitter Pierre-Yves David
Date Aug. 8, 2019, 1:47 a.m.
Message ID <466943d2fed3602e08ac.1565228842@nodosa.octopoid.net>
Download mbox | patch
Permalink /patch/41220/
State Accepted
Headers show

Comments

Pierre-Yves David - Aug. 8, 2019, 1:47 a.m.
# HG changeset patch
# User Pierre-Yves David <pierre-yves.david@octobus.net>
# Date 1565219568 -7200
#      Thu Aug 08 01:12:48 2019 +0200
# Node ID 466943d2fed3602e08ac9117afef1c727bcb98a5
# Parent  82e7f9d4d0bac574e4aa1b8f81e81ac1df3f6ddc
# EXP-Topic flag-processors
# Available At https://bitbucket.org/octobus/mercurial-devel/
#              hg pull https://bitbucket.org/octobus/mercurial-devel/ -r 466943d2fed3
flagutil: introduce a flagprocessorsmixin class

To avoid code duplication, we will provide a simple "ready to use" mixin that
carry the appropriate logic. First we use it in standard revlog, we'll remove
code duplication in later changesets.
Gregory Szorc - Aug. 10, 2019, 11:35 p.m.
On Wed, Aug 7, 2019 at 7:18 PM Pierre-Yves David <
pierre-yves.david@ens-lyon.org> wrote:

> # HG changeset patch
> # User Pierre-Yves David <pierre-yves.david@octobus.net>
> # Date 1565219568 -7200
> #      Thu Aug 08 01:12:48 2019 +0200
> # Node ID 466943d2fed3602e08ac9117afef1c727bcb98a5
> # Parent  82e7f9d4d0bac574e4aa1b8f81e81ac1df3f6ddc
> # EXP-Topic flag-processors
> # Available At https://bitbucket.org/octobus/mercurial-devel/
> #              hg pull https://bitbucket.org/octobus/mercurial-devel/ -r
> 466943d2fed3
> flagutil: introduce a flagprocessorsmixin class
>
> To avoid code duplication, we will provide a simple "ready to use" mixin
> that
> carry the appropriate logic. First we use it in standard revlog, we'll
> remove
> code duplication in later changesets.
>
> diff --git a/mercurial/revlog.py b/mercurial/revlog.py
> --- a/mercurial/revlog.py
> +++ b/mercurial/revlog.py
> @@ -259,7 +259,7 @@ class revlogio(object):
>              p = versionformat_pack(version) + p[4:]
>          return p
>
> -class revlog(object):
> +class revlog(flagutil.flagprocessorsmixin):
>      """
>      the underlying revision storage object
>
> @@ -1682,69 +1682,6 @@ class revlog(object):
>          """
>          return storageutil.hashrevisionsha1(text, p1, p2)
>
> -    def _processflags(self, text, flags, operation, raw=False):
> -        """Inspect revision data flags and applies transforms defined by
> -        registered flag processors.
> -
> -        ``text`` - the revision data to process
> -        ``flags`` - the revision flags
> -        ``operation`` - the operation being performed (read or write)
> -        ``raw`` - an optional argument describing if the raw transform
> should be
> -        applied.
> -
> -        This method processes the flags in the order (or reverse order if
> -        ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying
> the
> -        flag processors registered for present flags. The order of flags
> defined
> -        in REVIDX_FLAGS_ORDER needs to be stable to allow
> non-commutativity.
> -
> -        Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is
> the
> -        processed text and ``validatehash`` is a bool indicating whether
> the
> -        returned text should be checked for hash integrity.
> -
> -        Note: If the ``raw`` argument is set, it has precedence over the
> -        operation and will only update the value of ``validatehash``.
> -        """
> -        # fast path: no flag processors will run
> -        if flags == 0:
> -            return text, True
> -        if not operation in ('read', 'write'):
> -            raise error.ProgrammingError(_("invalid '%s' operation") %
> -                                         operation)
> -        # Check all flags are known.
> -        if flags & ~flagutil.REVIDX_KNOWN_FLAGS:
> -            raise error.RevlogError(_("incompatible revision flag '%#x'")
> %
> -                                    (flags &
> ~flagutil.REVIDX_KNOWN_FLAGS))
> -        validatehash = True
> -        # Depending on the operation (read or write), the order might be
> -        # reversed due to non-commutative transforms.
> -        orderedflags = REVIDX_FLAGS_ORDER
> -        if operation == 'write':
> -            orderedflags = reversed(orderedflags)
> -
> -        for flag in orderedflags:
> -            # If a flagprocessor has been registered for a known flag,
> apply the
> -            # related operation transform and update result tuple.
> -            if flag & flags:
> -                vhash = True
> -
> -                if flag not in self._flagprocessors:
> -                    message = _("missing processor for flag '%#x'") %
> (flag)
> -                    raise error.RevlogError(message)
> -
> -                processor = self._flagprocessors[flag]
> -                if processor is not None:
> -                    readtransform, writetransform, rawtransform =
> processor
> -
> -                    if raw:
> -                        vhash = rawtransform(self, text)
> -                    elif operation == 'read':
> -                        text, vhash = readtransform(self, text)
> -                    else: # write operation
> -                        text, vhash = writetransform(self, text)
> -                validatehash = validatehash and vhash
> -
> -        return text, validatehash
> -
>      def checkhash(self, text, node, p1=None, p2=None, rev=None):
>          """Check node hash integrity.
>
> diff --git a/mercurial/revlogutils/flagutil.py
> b/mercurial/revlogutils/flagutil.py
> --- a/mercurial/revlogutils/flagutil.py
> +++ b/mercurial/revlogutils/flagutil.py
> @@ -78,3 +78,90 @@ def insertflagprocessor(flag, processor,
>          msg = _("cannot register multiple processors on flag '%#x'.") %
> (flag)
>          raise error.Abort(msg)
>      flagprocessors[flag] = processor
> +
> +# Flag processors for REVIDX_ELLIPSIS.
> +def ellipsisreadprocessor(rl, text):
> +    return text, False
> +
> +def ellipsiswriteprocessor(rl, text):
> +    return text, False
> +
> +def ellipsisrawprocessor(rl, text):
> +    return False
> +
> +ellipsisprocessor = (
> +    ellipsisreadprocessor,
> +    ellipsiswriteprocessor,
> +    ellipsisrawprocessor,
> +)
>

Is the addition of the ellipsis flag processor intentional for this commit?


> +
> +class flagprocessorsmixin(object):
> +    """basic mixin to support revlog flag processing
> +
> +    Make sure the `_flagprocessors` attribute is set at ``__init__`` time.
> +
> +    See the documentation of the ``_processflags`` method for details.
> +    """
> +
> +    def _processflags(self, text, flags, operation, raw=False):
> +        """Inspect revision data flags and applies transforms defined by
> +        registered flag processors.
> +
> +        ``text`` - the revision data to process
> +        ``flags`` - the revision flags
> +        ``operation`` - the operation being performed (read or write)
> +        ``raw`` - an optional argument describing if the raw transform
> should be
> +        applied.
> +
> +        This method processes the flags in the order (or reverse order if
> +        ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying
> the
> +        flag processors registered for present flags. The order of flags
> defined
> +        in REVIDX_FLAGS_ORDER needs to be stable to allow
> non-commutativity.
> +
> +        Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is
> the
> +        processed text and ``validatehash`` is a bool indicating whether
> the
> +        returned text should be checked for hash integrity.
> +
> +        Note: If the ``raw`` argument is set, it has precedence over the
> +        operation and will only update the value of ``validatehash``.
> +        """
> +        # fast path: no flag processors will run
> +        if flags == 0:
> +            return text, True
> +        if not operation in ('read', 'write'):
> +            raise error.ProgrammingError(_("invalid '%s' operation") %
> +                                         operation)
> +        # Check all flags are known.
> +        if flags & ~REVIDX_KNOWN_FLAGS:
> +            raise error.RevlogError(_("incompatible revision flag '%#x'")
> %
> +                                    (flags & ~REVIDX_KNOWN_FLAGS))
> +        validatehash = True
> +        # Depending on the operation (read or write), the order might be
> +        # reversed due to non-commutative transforms.
> +        orderedflags = REVIDX_FLAGS_ORDER
> +        if operation == 'write':
> +            orderedflags = reversed(orderedflags)
> +
> +        for flag in orderedflags:
> +            # If a flagprocessor has been registered for a known flag,
> apply the
> +            # related operation transform and update result tuple.
> +            if flag & flags:
> +                vhash = True
> +
> +                if flag not in self._flagprocessors:
> +                    message = _("missing processor for flag '%#x'") %
> (flag)
> +                    raise error.RevlogError(message)
> +
> +                processor = self._flagprocessors[flag]
> +                if processor is not None:
> +                    readtransform, writetransform, rawtransform =
> processor
> +
> +                    if raw:
> +                        vhash = rawtransform(self, text)
> +                    elif operation == 'read':
> +                        text, vhash = readtransform(self, text)
> +                    else: # write operation
> +                        text, vhash = writetransform(self, text)
> +                validatehash = validatehash and vhash
> +
> +        return text, validatehash
> _______________________________________________
> Mercurial-devel mailing list
> Mercurial-devel@mercurial-scm.org
> https://www.mercurial-scm.org/mailman/listinfo/mercurial-devel
>
Pierre-Yves David - Aug. 11, 2019, 9:58 a.m.
On 8/11/19 1:35 AM, Gregory Szorc wrote:
> On Wed, Aug 7, 2019 at 7:18 PM Pierre-Yves David 
> <pierre-yves.david@ens-lyon.org <mailto:pierre-yves.david@ens-lyon.org>> 
> wrote:
> 
>     # HG changeset patch
>     # User Pierre-Yves David <pierre-yves.david@octobus.net
>     <mailto:pierre-yves.david@octobus.net>>
>     # Date 1565219568 -7200
>     #      Thu Aug 08 01:12:48 2019 +0200
>     # Node ID 466943d2fed3602e08ac9117afef1c727bcb98a5
>     # Parent  82e7f9d4d0bac574e4aa1b8f81e81ac1df3f6ddc
>     # EXP-Topic flag-processors
>     # Available At https://bitbucket.org/octobus/mercurial-devel/
>     #              hg pull
>     https://bitbucket.org/octobus/mercurial-devel/ -r 466943d2fed3
>     flagutil: introduce a flagprocessorsmixin class
> 
>     To avoid code duplication, we will provide a simple "ready to use"
>     mixin that
>     carry the appropriate logic. First we use it in standard revlog,
>     we'll remove
>     code duplication in later changesets.
> 
>     diff --git a/mercurial/revlog.py b/mercurial/revlog.py
>     --- a/mercurial/revlog.py
>     +++ b/mercurial/revlog.py
>     @@ -259,7 +259,7 @@ class revlogio(object):
>                   p = versionformat_pack(version) + p[4:]
>               return p
> 
>     -class revlog(object):
>     +class revlog(flagutil.flagprocessorsmixin):
>           """
>           the underlying revision storage object
> 
>     @@ -1682,69 +1682,6 @@ class revlog(object):
>               """
>               return storageutil.hashrevisionsha1(text, p1, p2)
> 
>     -    def _processflags(self, text, flags, operation, raw=False):
>     -        """Inspect revision data flags and applies transforms
>     defined by
>     -        registered flag processors.
>     -
>     -        ``text`` - the revision data to process
>     -        ``flags`` - the revision flags
>     -        ``operation`` - the operation being performed (read or write)
>     -        ``raw`` - an optional argument describing if the raw
>     transform should be
>     -        applied.
>     -
>     -        This method processes the flags in the order (or reverse
>     order if
>     -        ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER,
>     applying the
>     -        flag processors registered for present flags. The order of
>     flags defined
>     -        in REVIDX_FLAGS_ORDER needs to be stable to allow
>     non-commutativity.
>     -
>     -        Returns a 2-tuple of ``(text, validatehash)`` where
>     ``text`` is the
>     -        processed text and ``validatehash`` is a bool indicating
>     whether the
>     -        returned text should be checked for hash integrity.
>     -
>     -        Note: If the ``raw`` argument is set, it has precedence
>     over the
>     -        operation and will only update the value of ``validatehash``.
>     -        """
>     -        # fast path: no flag processors will run
>     -        if flags == 0:
>     -            return text, True
>     -        if not operation in ('read', 'write'):
>     -            raise error.ProgrammingError(_("invalid '%s' operation") %
>     -                                         operation)
>     -        # Check all flags are known.
>     -        if flags & ~flagutil.REVIDX_KNOWN_FLAGS:
>     -            raise error.RevlogError(_("incompatible revision flag
>     '%#x'") %
>     -                                    (flags &
>     ~flagutil.REVIDX_KNOWN_FLAGS))
>     -        validatehash = True
>     -        # Depending on the operation (read or write), the order
>     might be
>     -        # reversed due to non-commutative transforms.
>     -        orderedflags = REVIDX_FLAGS_ORDER
>     -        if operation == 'write':
>     -            orderedflags = reversed(orderedflags)
>     -
>     -        for flag in orderedflags:
>     -            # If a flagprocessor has been registered for a known
>     flag, apply the
>     -            # related operation transform and update result tuple.
>     -            if flag & flags:
>     -                vhash = True
>     -
>     -                if flag not in self._flagprocessors:
>     -                    message = _("missing processor for flag '%#x'")
>     % (flag)
>     -                    raise error.RevlogError(message)
>     -
>     -                processor = self._flagprocessors[flag]
>     -                if processor is not None:
>     -                    readtransform, writetransform, rawtransform =
>     processor
>     -
>     -                    if raw:
>     -                        vhash = rawtransform(self, text)
>     -                    elif operation == 'read':
>     -                        text, vhash = readtransform(self, text)
>     -                    else: # write operation
>     -                        text, vhash = writetransform(self, text)
>     -                validatehash = validatehash and vhash
>     -
>     -        return text, validatehash
>     -
>           def checkhash(self, text, node, p1=None, p2=None, rev=None):
>               """Check node hash integrity.
> 
>     diff --git a/mercurial/revlogutils/flagutil.py
>     b/mercurial/revlogutils/flagutil.py
>     --- a/mercurial/revlogutils/flagutil.py
>     +++ b/mercurial/revlogutils/flagutil.py
>     @@ -78,3 +78,90 @@ def insertflagprocessor(flag, processor,
>               msg = _("cannot register multiple processors on flag
>     '%#x'.") % (flag)
>               raise error.Abort(msg)
>           flagprocessors[flag] = processor
>     +
>     +# Flag processors for REVIDX_ELLIPSIS.
>     +def ellipsisreadprocessor(rl, text):
>     +    return text, False
>     +
>     +def ellipsiswriteprocessor(rl, text):
>     +    return text, False
>     +
>     +def ellipsisrawprocessor(rl, text):
>     +    return False
>     +
>     +ellipsisprocessor = (
>     +    ellipsisreadprocessor,
>     +    ellipsiswriteprocessor,
>     +    ellipsisrawprocessor,
>     +)
> 
> 
> Is the addition of the ellipsis flag processor intentional for this commit?

It is not, I'll clean that up and send a V2.

Patch

diff --git a/mercurial/revlog.py b/mercurial/revlog.py
--- a/mercurial/revlog.py
+++ b/mercurial/revlog.py
@@ -259,7 +259,7 @@  class revlogio(object):
             p = versionformat_pack(version) + p[4:]
         return p
 
-class revlog(object):
+class revlog(flagutil.flagprocessorsmixin):
     """
     the underlying revision storage object
 
@@ -1682,69 +1682,6 @@  class revlog(object):
         """
         return storageutil.hashrevisionsha1(text, p1, p2)
 
-    def _processflags(self, text, flags, operation, raw=False):
-        """Inspect revision data flags and applies transforms defined by
-        registered flag processors.
-
-        ``text`` - the revision data to process
-        ``flags`` - the revision flags
-        ``operation`` - the operation being performed (read or write)
-        ``raw`` - an optional argument describing if the raw transform should be
-        applied.
-
-        This method processes the flags in the order (or reverse order if
-        ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
-        flag processors registered for present flags. The order of flags defined
-        in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.
-
-        Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
-        processed text and ``validatehash`` is a bool indicating whether the
-        returned text should be checked for hash integrity.
-
-        Note: If the ``raw`` argument is set, it has precedence over the
-        operation and will only update the value of ``validatehash``.
-        """
-        # fast path: no flag processors will run
-        if flags == 0:
-            return text, True
-        if not operation in ('read', 'write'):
-            raise error.ProgrammingError(_("invalid '%s' operation") %
-                                         operation)
-        # Check all flags are known.
-        if flags & ~flagutil.REVIDX_KNOWN_FLAGS:
-            raise error.RevlogError(_("incompatible revision flag '%#x'") %
-                                    (flags & ~flagutil.REVIDX_KNOWN_FLAGS))
-        validatehash = True
-        # Depending on the operation (read or write), the order might be
-        # reversed due to non-commutative transforms.
-        orderedflags = REVIDX_FLAGS_ORDER
-        if operation == 'write':
-            orderedflags = reversed(orderedflags)
-
-        for flag in orderedflags:
-            # If a flagprocessor has been registered for a known flag, apply the
-            # related operation transform and update result tuple.
-            if flag & flags:
-                vhash = True
-
-                if flag not in self._flagprocessors:
-                    message = _("missing processor for flag '%#x'") % (flag)
-                    raise error.RevlogError(message)
-
-                processor = self._flagprocessors[flag]
-                if processor is not None:
-                    readtransform, writetransform, rawtransform = processor
-
-                    if raw:
-                        vhash = rawtransform(self, text)
-                    elif operation == 'read':
-                        text, vhash = readtransform(self, text)
-                    else: # write operation
-                        text, vhash = writetransform(self, text)
-                validatehash = validatehash and vhash
-
-        return text, validatehash
-
     def checkhash(self, text, node, p1=None, p2=None, rev=None):
         """Check node hash integrity.
 
diff --git a/mercurial/revlogutils/flagutil.py b/mercurial/revlogutils/flagutil.py
--- a/mercurial/revlogutils/flagutil.py
+++ b/mercurial/revlogutils/flagutil.py
@@ -78,3 +78,90 @@  def insertflagprocessor(flag, processor,
         msg = _("cannot register multiple processors on flag '%#x'.") % (flag)
         raise error.Abort(msg)
     flagprocessors[flag] = processor
+
+# Flag processors for REVIDX_ELLIPSIS.
+def ellipsisreadprocessor(rl, text):
+    return text, False
+
+def ellipsiswriteprocessor(rl, text):
+    return text, False
+
+def ellipsisrawprocessor(rl, text):
+    return False
+
+ellipsisprocessor = (
+    ellipsisreadprocessor,
+    ellipsiswriteprocessor,
+    ellipsisrawprocessor,
+)
+
+class flagprocessorsmixin(object):
+    """basic mixin to support revlog flag processing
+
+    Make sure the `_flagprocessors` attribute is set at ``__init__`` time.
+
+    See the documentation of the ``_processflags`` method for details.
+    """
+
+    def _processflags(self, text, flags, operation, raw=False):
+        """Inspect revision data flags and applies transforms defined by
+        registered flag processors.
+
+        ``text`` - the revision data to process
+        ``flags`` - the revision flags
+        ``operation`` - the operation being performed (read or write)
+        ``raw`` - an optional argument describing if the raw transform should be
+        applied.
+
+        This method processes the flags in the order (or reverse order if
+        ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
+        flag processors registered for present flags. The order of flags defined
+        in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.
+
+        Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
+        processed text and ``validatehash`` is a bool indicating whether the
+        returned text should be checked for hash integrity.
+
+        Note: If the ``raw`` argument is set, it has precedence over the
+        operation and will only update the value of ``validatehash``.
+        """
+        # fast path: no flag processors will run
+        if flags == 0:
+            return text, True
+        if not operation in ('read', 'write'):
+            raise error.ProgrammingError(_("invalid '%s' operation") %
+                                         operation)
+        # Check all flags are known.
+        if flags & ~REVIDX_KNOWN_FLAGS:
+            raise error.RevlogError(_("incompatible revision flag '%#x'") %
+                                    (flags & ~REVIDX_KNOWN_FLAGS))
+        validatehash = True
+        # Depending on the operation (read or write), the order might be
+        # reversed due to non-commutative transforms.
+        orderedflags = REVIDX_FLAGS_ORDER
+        if operation == 'write':
+            orderedflags = reversed(orderedflags)
+
+        for flag in orderedflags:
+            # If a flagprocessor has been registered for a known flag, apply the
+            # related operation transform and update result tuple.
+            if flag & flags:
+                vhash = True
+
+                if flag not in self._flagprocessors:
+                    message = _("missing processor for flag '%#x'") % (flag)
+                    raise error.RevlogError(message)
+
+                processor = self._flagprocessors[flag]
+                if processor is not None:
+                    readtransform, writetransform, rawtransform = processor
+
+                    if raw:
+                        vhash = rawtransform(self, text)
+                    elif operation == 'read':
+                        text, vhash = readtransform(self, text)
+                    else: # write operation
+                        text, vhash = writetransform(self, text)
+                validatehash = validatehash and vhash
+
+        return text, validatehash