update for mypy --strict, prepare de-inheritance (Loader/Dumper)0.14.0

1 files changed, 49 insertions, 28 deletions

diff --git a/resolver.py b/resolver.py
index 38546ac..eab1b41 100644
--- a/resolver.py
+++ b/resolver.py
@@ -4,11 +4,11 @@ from __future__ import absolute_import
 
 import re
 
-from typing import Any, Dict  # NOQA
+from typing import Any, Dict, List, Union  # NOQA
 
 from ruamel.yaml.error import *                               # NOQA
 from ruamel.yaml.nodes import *                               # NOQA
-from ruamel.yaml.compat import string_types
+from ruamel.yaml.compat import string_types, VersionType      # NOQA
 
 __all__ = ['BaseResolver', 'Resolver', 'VersionedResolver']
 
@@ -100,11 +100,21 @@ class BaseResolver(object):
     yaml_implicit_resolvers = {}  # type: Dict[Any, Any]
     yaml_path_resolvers = {}      # type: Dict[Any, Any]
 
-    def __init__(self):
-        # type: () -> None
-        self._loader_version = None
-        self.resolver_exact_paths = []
-        self.resolver_prefix_paths = []
+    def __init__(self, loadumper=None):
+        # type: (Any, Any) -> None
+        self.loadumper = loadumper
+        if self.loadumper is not None:
+            self.loadumper._resolver = self.loadumper
+        self._loader_version = None  # type: Any
+        self.resolver_exact_paths = []  # type: List[Any]
+        self.resolver_prefix_paths = []  # type: List[Any]
+
+    @property
+    def parser(self):
+        # type: () -> Any
+        if self.loadumper is not None:
+            return self.loadumper._parser
+        return None
 
     @classmethod
     def add_implicit_resolver_base(cls, tag, regexp, first):
@@ -138,6 +148,7 @@ class BaseResolver(object):
 
     @classmethod
     def add_path_resolver(cls, tag, path, kind=None):
+        # type: (Any, Any, Any) -> None
         # Note: `add_path_resolver` is experimental.  The API could be changed.
         # `new_path` is a pattern that is matched against the path from the
         # root to the node that is being considered.  `node_path` elements are
@@ -152,11 +163,11 @@ class BaseResolver(object):
         # against a sequence value with the index equal to `index_check`.
         if 'yaml_path_resolvers' not in cls.__dict__:
             cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()
-        new_path = []
+        new_path = []  # type: List[Any]
         for element in path:
             if isinstance(element, (list, tuple)):
                 if len(element) == 2:
-                    node_check, index_check = element
+                    node_check, index_check = element  # type: ignore
                 elif len(element) == 1:
                     node_check = element[0]
                     index_check = True
@@ -191,6 +202,7 @@ class BaseResolver(object):
         cls.yaml_path_resolvers[tuple(new_path), kind] = tag
 
     def descend_resolver(self, current_node, current_index):
+        # type: (Any, Any) -> None
         if not self.yaml_path_resolvers:
             return
         exact_paths = {}
@@ -215,6 +227,7 @@ class BaseResolver(object):
         self.resolver_prefix_paths.append(prefix_paths)
 
     def ascend_resolver(self):
+        # type: () -> None
         if not self.yaml_path_resolvers:
             return
         self.resolver_exact_paths.pop()
@@ -222,29 +235,31 @@ class BaseResolver(object):
 
     def check_resolver_prefix(self, depth, path, kind,
                               current_node, current_index):
+        # type: (int, Text, Any, Any, Any) -> bool
         node_check, index_check = path[depth-1]
         if isinstance(node_check, string_types):
             if current_node.tag != node_check:
-                return
+                return False
         elif node_check is not None:
             if not isinstance(current_node, node_check):
-                return
+                return False
         if index_check is True and current_index is not None:
-            return
+            return False
         if (index_check is False or index_check is None)    \
                 and current_index is None:
-            return
+            return False
         if isinstance(index_check, string_types):
             if not (isinstance(current_index, ScalarNode) and
                     index_check == current_index.value):
-                return
+                return False
         elif isinstance(index_check, int) and not isinstance(index_check,
                                                              bool):
             if index_check != current_index:
-                return
+                return False
         return True
 
     def resolve(self, kind, value, implicit):
+        # type: (Any, Any, Any) -> Any
         if kind is ScalarNode and implicit[0]:
             if value == u'':
                 resolvers = self.yaml_implicit_resolvers.get(u'', [])
@@ -255,7 +270,7 @@ class BaseResolver(object):
                 if regexp.match(value):
                     return tag
             implicit = implicit[1]
-        if self.yaml_path_resolvers:
+        if bool(self.yaml_path_resolvers):
             exact_paths = self.resolver_exact_paths[-1]
             if kind in exact_paths:
                 return exact_paths[kind]
@@ -270,6 +285,7 @@ class BaseResolver(object):
 
     @property
     def processing_version(self):
+        # type: () -> Any
         return None
 
 
@@ -341,16 +357,18 @@ class VersionedResolver(BaseResolver):
     """
     contrary to the "normal" resolver, the smart resolver delays loading
     the pattern matching rules. That way it can decide to load 1.1 rules
-    or the (default) 1.2 that no longer support octal without 0o, sexagesimals
+    or the (default) 1.2 rules, that no longer support octal without 0o, sexagesimals
     and Yes/No/On/Off booleans.
     """
 
-    def __init__(self, version=None):
-        BaseResolver.__init__(self)
+    def __init__(self, version=None, loader=None):
+        # type: (VersionType, Any) -> None
+        BaseResolver.__init__(self, loader)
         self._loader_version = self.get_loader_version(version)
-        self._version_implicit_resolver = {}
+        self._version_implicit_resolver = {}  # type: Dict[Any, Any]
 
     def add_version_implicit_resolver(self, version, tag, regexp, first):
+        # type: (VersionType, Any, Any, Any) -> None
         if first is None:
             first = [None]
         impl_resolver = self._version_implicit_resolver.setdefault(version, {})
@@ -358,6 +376,7 @@ class VersionedResolver(BaseResolver):
             impl_resolver.setdefault(ch, []).append((tag, regexp))
 
     def get_loader_version(self, version):
+        # type: (Union[VersionType, None]) -> Any
         if version is None or isinstance(version, tuple):
             return version
         if isinstance(version, list):
@@ -366,7 +385,8 @@ class VersionedResolver(BaseResolver):
         return tuple(map(int, version.split(u'.')))
 
     @property
-    def resolver(self):
+    def versioned_resolver(self):
+        # type: () -> Any
         """
         select the resolver based on the version we are parsing
         """
@@ -378,17 +398,18 @@ class VersionedResolver(BaseResolver):
         return self._version_implicit_resolver[version]
 
     def resolve(self, kind, value, implicit):
+        # type: (Any, Any, Any) -> Any
         if kind is ScalarNode and implicit[0]:
             if value == u'':
-                resolvers = self.resolver.get(u'', [])
+                resolvers = self.versioned_resolver.get(u'', [])
             else:
-                resolvers = self.resolver.get(value[0], [])
-            resolvers += self.resolver.get(None, [])
+                resolvers = self.versioned_resolver.get(value[0], [])
+            resolvers += self.versioned_resolver.get(None, [])
             for tag, regexp in resolvers:
                 if regexp.match(value):
                     return tag
             implicit = implicit[1]
-        if self.yaml_path_resolvers:
+        if bool(self.yaml_path_resolvers):
             exact_paths = self.resolver_exact_paths[-1]
             if kind in exact_paths:
                 return exact_paths[kind]
@@ -403,11 +424,11 @@ class VersionedResolver(BaseResolver):
 
     @property
     def processing_version(self):
+        # type: () -> Any
         try:
-            version = self.yaml_version
+            version = self.parser.yaml_version
         except AttributeError:
-            # dumping
-            version = self.use_version
+            version = self.loadumper._serializer.use_version     # dumping
         if version is None:
             version = self._loader_version
             if version is None: