resovler / models refator (sqm)

Author: Nementon

openapi_python_client/resolver/pointer.py

@@ -0,0 +1,48 @@
+import urllib.parse
+from typing import List, Union
+
+
+class Pointer:
+    """ https://tools.ietf.org/html/rfc6901 """
+
+    def __init__(self, pointer: str) -> None:
+        if pointer is None or pointer != "" and not pointer.startswith("/"):
+            raise ValueError(f'Invalid pointer value {pointer}, it must match: *( "/" reference-token )')
+
+        self._pointer = pointer
+
+    @property
+    def value(self) -> str:
+        return self._pointer
+
+    @property
+    def parent(self) -> Union["Pointer", None]:
+        tokens = self.tokens(False)
+
+        if len(tokens) > 1:
+            tokens.pop()
+            return Pointer("/".join(tokens))
+        else:
+            assert tokens[-1] == ""
+            return None
+
+    def tokens(self, unescape: bool = True) -> List[str]:
+        tokens = []
+
+        if unescape:
+            for token in self._pointer.split("/"):
+                tokens.append(self._unescape(token))
+        else:
+            tokens = self._pointer.split("/")
+
+        return tokens
+
+    @property
+    def unescapated_value(self) -> str:
+        return self._unescape(self._pointer)
+
+    def _unescape(self, data: str) -> str:
+        data = urllib.parse.unquote(data)
+        data = data.replace("~1", "/")
+        data = data.replace("~0", "~")
+        return data

openapi_python_client/resolver/reference.py

@@ -1,59 +1,51 @@
-# import urllib
-from pathlib import PosixPath
-from typing import Union
+import urllib.parse
+
+from .pointer import Pointer
 
 
 class Reference:
+    """ https://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03 """
+
     def __init__(self, reference: str):
         self._ref = reference
-
-    @property
-    def remote_path(self) -> Union[str, None]:
-        if self.is_remote():
-            return self._ref.split("#")[0]
-        return None
-
-    @property
-    def path_parent(self) -> str:
-        path = PosixPath(self.path)
-        return str(path.parent)
+        self._parsed_ref = urllib.parse.urlparse(reference)
 
     @property
     def path(self) -> str:
-        path = "/"
+        return urllib.parse.urldefrag(self._parsed_ref.geturl()).url
 
-        if not self.is_full_document():
-            parts = self._ref.split("#")
-            path = parts[-1]
-            if not path.startswith("/") and not path.startswith("."):
-                path = f"/{path}"
-
-        return path
-        # d = urllib.parse.unquote(d)
-        # d = d.replace("~1", "/")
-        # return d
+    @property
+    def pointer(self) -> Pointer:
+        frag = self._parsed_ref.fragment
+        if self.is_url() and frag != "" and not frag.startswith("/"):
+            frag = f"/{frag}"
 
-    def is_full_document(self) -> bool:
-        return "#" not in self._ref
+        return Pointer(frag)
 
     def is_relative(self) -> bool:
+        """ return True if reference path is a relative path """
         return not self.is_absolute()
 
     def is_absolute(self) -> bool:
-        remote_path = self.remote_path
-        if remote_path:
-            return not remote_path.startswith("..") and (remote_path.startswith("/") or remote_path.startswith("http"))
-        return True
+        """ return True is reference path is an absolute path """
+        return self._parsed_ref.netloc != ""
 
     @property
     def value(self) -> str:
         return self._ref
 
     def is_url(self) -> bool:
-        return self.is_remote() and (self._ref.startswith("//", 0) or self._ref.startswith("http", 0))
+        """ return True if the reference path is pointing to an external url location """
+        return self.is_remote() and self._parsed_ref.netloc != ""
 
     def is_remote(self) -> bool:
+        """ return True if the reference pointer is pointing to a remote document """
         return not self.is_local()
 
     def is_local(self) -> bool:
-        return self._ref.startswith("#", 0)
+        """ return True if the reference pointer is pointing to the current document """
+        return self._parsed_ref.path == ""
+
+    def is_full_document(self) -> bool:
+        """ return True if the reference pointer is pointing to the whole document content """
+        return self.pointer.parent is None

openapi_python_client/resolver/resolved_schema.py

@@ -37,7 +37,7 @@ def _process_remote_paths(self) -> None:
             if ref.is_local():
                 continue
 
-            remote_path = ref.remote_path
+            remote_path = ref.pointer.value
             path = ref.path
 
             if remote_path not in self._refs:
@@ -67,7 +67,7 @@ def _process_remote_components(
                 if depth > 0:
                     self._transform_to_local_components(owner, ref)
             else:
-                remote_path = ref.remote_path
+                remote_path = ref.pointer.value
                 if remote_path not in self._refs:
                     self._errors.append("Failed to resolve remote reference > {0}".format(remote_path))
                 else:
@@ -80,8 +80,11 @@ def _transform_to_local_components(self, owner: SchemaData, ref: Reference) -> N
 
         # print('Processing remote component > {0}'.format(ref.value))
         remote_component = self._lookup_dict(owner, ref.path)
-        root_components_dir = self._lookup_dict(self._resolved_remotes_components, ref.path_parent)
-        component_name = ref.path.split("/")[-1]
+        pointer_parent = ref.pointer.parent
+
+        if pointer_parent is not None:
+            root_components_dir = self._lookup_dict(self._resolved_remotes_components, pointer_parent.value)
+            component_name = ref.path.split("/")[-1]
 
         if component_name == "SorTransparentContainer" or component_name == "sorTransparentContainer":
             print(ref.value)
@@ -118,7 +121,10 @@ def _transform_to_local_components(self, owner: SchemaData, ref: Reference) -> N
 
     def _ensure_components_dir_exists(self, ref: Reference) -> None:
         cursor = self._resolved_remotes_components
-        for key in ref.path_parent.split("/"):
+        pointer_dir = ref.pointer.parent
+        assert pointer_dir is not None
+
+        for key in pointer_dir.value.split("/"):  # noqa
             if key == "":
                 continue