jaclang 0.0.5__py3-none-any.whl → 0.0.8__py3-none-any.whl

jaclang/vendor/pygls/uris.py

@@ -0,0 +1,184 @@
+############################################################################
+# Original work Copyright 2017 Palantir Technologies, Inc.                 #
+# Original work licensed under the MIT License.                            #
+# See ThirdPartyNotices.txt in the project root for license information.   #
+# All modifications Copyright (c) Open Law Library. All rights reserved.   #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+"""
+A collection of URI utilities with logic built on the VSCode URI library.
+
+https://github.com/Microsoft/vscode-uri/blob/e59cab84f5df6265aed18ae5f43552d3eef13bb9/lib/index.ts
+"""
+from typing import Optional, Tuple
+
+import re
+from urllib import parse
+
+from jaclang.vendor.pygls import IS_WIN
+
+RE_DRIVE_LETTER_PATH = re.compile(r"^\/[a-zA-Z]:")
+
+URLParts = Tuple[str, str, str, str, str, str]
+
+
+def _normalize_win_path(path: str):
+    netloc = ""
+
+    # normalize to fwd-slashes on windows,
+    # on other systems bwd-slashes are valid
+    # filename character, eg /f\oo/ba\r.txt
+    if IS_WIN:
+        path = path.replace("\\", "/")
+
+    # check for authority as used in UNC shares
+    # or use the path as given
+    if path[:2] == "//":
+        idx = path.index("/", 2)
+        if idx == -1:
+            netloc = path[2:]
+        else:
+            netloc = path[2:idx]
+            path = path[idx:]
+
+    # Ensure that path starts with a slash
+    # or that it is at least a slash
+    if not path.startswith("/"):
+        path = "/" + path
+
+    # Normalize drive paths to lower case
+    if RE_DRIVE_LETTER_PATH.match(path):
+        path = path[0] + path[1].lower() + path[2:]
+
+    return path, netloc
+
+
+def from_fs_path(path: str):
+    """Returns a URI for the given filesystem path."""
+    try:
+        scheme = "file"
+        params, query, fragment = "", "", ""
+        path, netloc = _normalize_win_path(path)
+        return urlunparse((scheme, netloc, path, params, query, fragment))
+    except (AttributeError, TypeError):
+        return None
+
+
+def to_fs_path(uri: str):
+    """
+    Returns the filesystem path of the given URI.
+
+    Will handle UNC paths and normalize windows drive letters to lower-case.
+    Also uses the platform specific path separator. Will *not* validate the
+    path for invalid characters and semantics.
+    Will *not* look at the scheme of this URI.
+    """
+    try:
+        # scheme://netloc/path;parameters?query#fragment
+        scheme, netloc, path, _, _, _ = urlparse(uri)
+
+        if netloc and path and scheme == "file":
+            # unc path: file://shares/c$/far/boo
+            value = f"//{netloc}{path}"
+
+        elif RE_DRIVE_LETTER_PATH.match(path):
+            # windows drive letter: file:///C:/far/boo
+            value = path[1].lower() + path[2:]
+
+        else:
+            # Other path
+            value = path
+
+        if IS_WIN:
+            value = value.replace("/", "\\")
+
+        return value
+    except TypeError:
+        return None
+
+
+def uri_scheme(uri: str):
+    try:
+        return urlparse(uri)[0]
+    except (TypeError, IndexError):
+        return None
+
+
+# TODO: Use `URLParts` type
+def uri_with(
+    uri: str,
+    scheme: Optional[str] = None,
+    netloc: Optional[str] = None,
+    path: Optional[str] = None,
+    params: Optional[str] = None,
+    query: Optional[str] = None,
+    fragment: Optional[str] = None,
+):
+    """
+    Return a URI with the given part(s) replaced.
+    Parts are decoded / encoded.
+    """
+    old_scheme, old_netloc, old_path, old_params, old_query, old_fragment = urlparse(
+        uri
+    )
+
+    if path is None:
+        raise Exception("`path` must not be None")
+
+    path, _ = _normalize_win_path(path)
+    return urlunparse(
+        (
+            scheme or old_scheme,
+            netloc or old_netloc,
+            path or old_path,
+            params or old_params,
+            query or old_query,
+            fragment or old_fragment,
+        )
+    )
+
+
+def urlparse(uri: str):
+    """Parse and decode the parts of a URI."""
+    scheme, netloc, path, params, query, fragment = parse.urlparse(uri)
+    return (
+        parse.unquote(scheme),
+        parse.unquote(netloc),
+        parse.unquote(path),
+        parse.unquote(params),
+        parse.unquote(query),
+        parse.unquote(fragment),
+    )
+
+
+def urlunparse(parts: URLParts) -> str:
+    """Unparse and encode parts of a URI."""
+    scheme, netloc, path, params, query, fragment = parts
+
+    # Avoid encoding the windows drive letter colon
+    if RE_DRIVE_LETTER_PATH.match(path):
+        quoted_path = path[:3] + parse.quote(path[3:])
+    else:
+        quoted_path = parse.quote(path)
+
+    return parse.urlunparse(
+        (
+            parse.quote(scheme),
+            parse.quote(netloc),
+            quoted_path,
+            parse.quote(params),
+            parse.quote(query),
+            parse.quote(fragment),
+        )
+    )

jaclang/vendor/pygls/workspace/__init__.py

@@ -0,0 +1,81 @@
+from typing import List
+import warnings
+
+from jaclang.vendor.pygls.lsprotocol import types
+
+from .workspace import Workspace
+from .text_document import TextDocument
+from .position import Position
+
+Workspace = Workspace
+TextDocument = TextDocument
+Position = Position
+
+# For backwards compatibility
+Document = TextDocument
+
+
+def utf16_unit_offset(chars: str):
+    warnings.warn(
+        "'utf16_unit_offset' has been deprecated, use "
+        "'Position.utf16_unit_offset' instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _position = Position()
+    return _position.utf16_unit_offset(chars)
+
+
+def utf16_num_units(chars: str):
+    warnings.warn(
+        "'utf16_num_units' has been deprecated, use "
+        "'Position.client_num_units' instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _position = Position()
+    return _position.client_num_units(chars)
+
+
+def position_from_utf16(lines: List[str], position: types.Position):
+    warnings.warn(
+        "'position_from_utf16' has been deprecated, use "
+        "'Position.position_from_client_units' instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _position = Position()
+    return _position.position_from_client_units(lines, position)
+
+
+def position_to_utf16(lines: List[str], position: types.Position):
+    warnings.warn(
+        "'position_to_utf16' has been deprecated, use "
+        "'Position.position_to_client_units' instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _position = Position()
+    return _position.position_to_client_units(lines, position)
+
+
+def range_from_utf16(lines: List[str], range: types.Range):
+    warnings.warn(
+        "'range_from_utf16' has been deprecated, use "
+        "'Position.range_from_client_units' instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _position = Position()
+    return _position.range_from_client_units(lines, range)
+
+
+def range_to_utf16(lines: List[str], range: types.Range):
+    warnings.warn(
+        "'range_to_utf16' has been deprecated, use "
+        "'Position.range_to_client_units' instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _position = Position()
+    return _position.range_to_client_units(lines, range)

jaclang/vendor/pygls/workspace/position.py

@@ -0,0 +1,204 @@
+############################################################################
+# Original work Copyright 2017 Palantir Technologies, Inc.                 #
+# Original work licensed under the MIT License.                            #
+# See ThirdPartyNotices.txt in the project root for license information.   #
+# All modifications Copyright (c) Open Law Library. All rights reserved.   #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+import logging
+from typing import List, Optional, Union
+
+from jaclang.vendor.pygls.lsprotocol import types
+
+
+log = logging.getLogger(__name__)
+
+
+class Position:
+    def __init__(
+        self,
+        encoding: Optional[
+            Union[types.PositionEncodingKind, str]
+        ] = types.PositionEncodingKind.Utf16,
+    ):
+        self.encoding = encoding
+
+    @classmethod
+    def is_char_beyond_multilingual_plane(cls, char: str) -> bool:
+        return ord(char) > 0xFFFF
+
+    def utf16_unit_offset(self, chars: str):
+        """
+        Calculate the number of characters which need two utf-16 code units.
+
+        Arguments:
+            chars (str): The string to count occurrences of utf-16 code units for.
+        """
+        return sum(self.is_char_beyond_multilingual_plane(ch) for ch in chars)
+
+    def client_num_units(self, chars: str):
+        """
+        Calculate the length of `str` in utf-16 code units.
+
+        Arguments:
+            chars (str): The string to return the length in utf-16 code units for.
+        """
+        utf32_units = len(chars)
+        if self.encoding == types.PositionEncodingKind.Utf32:
+            return utf32_units
+
+        if self.encoding == types.PositionEncodingKind.Utf8:
+            return utf32_units + (self.utf16_unit_offset(chars) * 2)
+
+        return utf32_units + self.utf16_unit_offset(chars)
+
+    def position_from_client_units(
+        self, lines: List[str], position: types.Position
+    ) -> types.Position:
+        """
+        Convert the position.character from UTF-[32|16|8] code units to UTF-32.
+
+        A python application can't use the character member of `Position`
+        directly. As per specification it is represented as a zero-based line and
+        character offset based on posible a UTF-[32|16|8] string representation.
+
+        All characters whose code point exceeds the Basic Multilingual Plane are
+        represented by 2 UTF-16 or 4 UTF-8 code units.
+
+        The offset of the closing quotation mark in x="😋" is
+        - 7 in UTF-8 representation
+        - 5 in UTF-16 representation
+        - 4 in UTF-32 representation
+
+        see: https://github.com/microsoft/language-server-protocol/issues/376
+
+        Arguments:
+            lines (list):
+                The content of the document which the position refers to.
+            position (Position):
+                The line and character offset in UTF-[32|16|8] code units.
+
+        Returns:
+            The position with `character` being converted to UTF-32 code units.
+        """
+        if len(lines) == 0:
+            return types.Position(0, 0)
+        if position.line >= len(lines):
+            return types.Position(len(lines) - 1, self.client_num_units(lines[-1]))
+
+        _line = lines[position.line]
+        _line = _line.replace("\r\n", "\n")  # TODO: it's a bit of a hack
+        _client_len = self.client_num_units(_line)
+        _utf32_len = len(_line)
+
+        if _client_len == 0:
+            return types.Position(position.line, 0)
+
+        _client_end_of_line = self.client_num_units(_line)
+        if position.character > _client_end_of_line:
+            position.character = _client_end_of_line - 1
+
+        _client_index = 0
+        utf32_index = 0
+        while True:
+            _is_searching_queried_position = _client_index < position.character
+            _is_before_end_of_line = utf32_index < _utf32_len
+            _is_searching_for_position = (
+                _is_searching_queried_position and _is_before_end_of_line
+            )
+            if not _is_searching_for_position:
+                break
+
+            _current_char = _line[utf32_index]
+            _is_double_width = Position.is_char_beyond_multilingual_plane(_current_char)
+            if _is_double_width:
+                if self.encoding == types.PositionEncodingKind.Utf32:
+                    _client_index += 1
+                if self.encoding == types.PositionEncodingKind.Utf8:
+                    _client_index += 4
+                _client_index += 2
+            else:
+                _client_index += 1
+            utf32_index += 1
+
+        position = types.Position(line=position.line, character=utf32_index)
+        return position
+
+    def position_to_client_units(
+        self, lines: List[str], position: types.Position
+    ) -> types.Position:
+        """
+        Convert the position.character from its internal UTF-32 representation
+        to client-supported UTF-[32|16|8] code units.
+
+        Arguments:
+            lines (list):
+                The content of the document which the position refers to.
+            position (Position):
+                The line and character offset in UTF-32 code units.
+
+        Returns:
+            The position with `character` being converted to UTF-[32|16|8] code units.
+        """
+        try:
+            character = self.client_num_units(
+                lines[position.line][: position.character]
+            )
+            return types.Position(
+                line=position.line,
+                character=character,
+            )
+        except IndexError:
+            return types.Position(line=len(lines), character=0)
+
+    def range_from_client_units(
+        self, lines: List[str], range: types.Range
+    ) -> types.Range:
+        """
+        Convert range.[start|end].character from UTF-[32|16|8] code units to UTF-32.
+
+        Arguments:
+            lines (list):
+                The content of the document which the range refers to.
+            range (Range):
+                The line and character offset in UTF-[32|16|8] code units.
+
+        Returns:
+            The range with `character` offsets being converted to UTF-32 code units.
+        """
+        range_new = types.Range(
+            start=self.position_from_client_units(lines, range.start),
+            end=self.position_from_client_units(lines, range.end),
+        )
+        return range_new
+
+    def range_to_client_units(
+        self, lines: List[str], range: types.Range
+    ) -> types.Range:
+        """
+        Convert range.[start|end].character from UTF-32 to UTF-[32|16|8] code units.
+
+        Arguments:
+            lines (list):
+                The content of the document which the range refers to.
+            range (Range):
+                The line and character offset in  code units.
+
+        Returns:
+            The range with `character` offsets being converted to UTF-[32|16|8] code units.
+        """
+        return types.Range(
+            start=self.position_to_client_units(lines, range.start),
+            end=self.position_to_client_units(lines, range.end),
+        )

jaclang/vendor/pygls/workspace/text_document.py

@@ -0,0 +1,234 @@
+############################################################################
+# Original work Copyright 2017 Palantir Technologies, Inc.                 #
+# Original work licensed under the MIT License.                            #
+# See ThirdPartyNotices.txt in the project root for license information.   #
+# All modifications Copyright (c) Open Law Library. All rights reserved.   #
+#                                                                          #
+# Licensed under the Apache License, Version 2.0 (the "License")           #
+# you may not use this file except in compliance with the License.         #
+# You may obtain a copy of the License at                                  #
+#                                                                          #
+#     http: // www.apache.org/licenses/LICENSE-2.0                         #
+#                                                                          #
+# Unless required by applicable law or agreed to in writing, software      #
+# distributed under the License is distributed on an "AS IS" BASIS,        #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and      #
+# limitations under the License.                                           #
+############################################################################
+import io
+import logging
+import os
+import re
+from typing import List, Optional, Pattern, Union
+
+from jaclang.vendor.pygls.lsprotocol import types
+
+from jaclang.vendor.pygls.uris import to_fs_path
+from .position import Position
+
+# TODO: this is not the best e.g. we capture numbers
+RE_END_WORD = re.compile("^[A-Za-z_0-9]*")
+RE_START_WORD = re.compile("[A-Za-z_0-9]*$")
+
+logger = logging.getLogger(__name__)
+
+
+class TextDocument(object):
+    def __init__(
+        self,
+        uri: str,
+        source: Optional[str] = None,
+        version: Optional[int] = None,
+        language_id: Optional[str] = None,
+        local: bool = True,
+        sync_kind: types.TextDocumentSyncKind = types.TextDocumentSyncKind.Incremental,
+        position_encoding: Optional[
+            Union[types.PositionEncodingKind, str]
+        ] = types.PositionEncodingKind.Utf16,
+    ):
+        self.uri = uri
+        self.version = version
+        path = to_fs_path(uri)
+        if path is None:
+            raise Exception("`path` cannot be None")
+        self.path = path
+        self.language_id = language_id
+        self.filename: Optional[str] = os.path.basename(self.path)
+
+        self._local = local
+        self._source = source
+
+        self._is_sync_kind_full = sync_kind == types.TextDocumentSyncKind.Full
+        self._is_sync_kind_incremental = (
+            sync_kind == types.TextDocumentSyncKind.Incremental
+        )
+        self._is_sync_kind_none = sync_kind == types.TextDocumentSyncKind.None_
+
+        self.position = Position(encoding=position_encoding)
+
+    def __str__(self):
+        return str(self.uri)
+
+    def _apply_incremental_change(
+        self, change: types.TextDocumentContentChangeEvent_Type1
+    ) -> None:
+        """Apply an ``Incremental`` text change to the document"""
+        lines = self.lines
+        text = change.text
+        change_range = change.range
+
+        range = self.position.range_from_client_units(lines, change_range)
+        start_line = range.start.line
+        start_col = range.start.character
+        end_line = range.end.line
+        end_col = range.end.character
+
+        # Check for an edit occurring at the very end of the file
+        if start_line == len(lines):
+            self._source = self.source + text
+            return
+
+        new = io.StringIO()
+
+        # Iterate over the existing document until we hit the edit range,
+        # at which point we write the new text, then loop until we hit
+        # the end of the range and continue writing.
+        for i, line in enumerate(lines):
+            if i < start_line:
+                new.write(line)
+                continue
+
+            if i > end_line:
+                new.write(line)
+                continue
+
+            if i == start_line:
+                new.write(line[:start_col])
+                new.write(text)
+
+            if i == end_line:
+                new.write(line[end_col:])
+
+        self._source = new.getvalue()
+
+    def _apply_full_change(self, change: types.TextDocumentContentChangeEvent) -> None:
+        """Apply a ``Full`` text change to the document."""
+        self._source = change.text
+
+    def _apply_none_change(self, _: types.TextDocumentContentChangeEvent) -> None:
+        """Apply a ``None`` text change to the document
+
+        Currently does nothing, provided for consistency.
+        """
+        pass
+
+    def apply_change(self, change: types.TextDocumentContentChangeEvent) -> None:
+        """Apply a text change to a document, considering TextDocumentSyncKind
+
+        Performs either
+        :attr:`~lsprotocol.types.TextDocumentSyncKind.Incremental`,
+        :attr:`~lsprotocol.types.TextDocumentSyncKind.Full`, or no synchronization
+        based on both the client request and server capabilities.
+
+        .. admonition:: ``Incremental`` versus ``Full`` synchronization
+
+           Even if a server accepts ``Incremantal`` SyncKinds, clients may request
+           a ``Full`` SyncKind. In LSP 3.x, clients make this request by omitting
+           both Range and RangeLength from their request. Consequently, the
+           attributes "range" and "rangeLength" will be missing from ``Full``
+           content update client requests in the pygls Python library.
+
+        """
+        if isinstance(change, types.TextDocumentContentChangeEvent_Type1):
+            if self._is_sync_kind_incremental:
+                self._apply_incremental_change(change)
+                return
+            # Log an error, but still perform full update to preserve existing
+            # assumptions in test_document/test_document_full_edit. Test breaks
+            # otherwise, and fixing the tests would require a broader fix to
+            # protocol.py.
+            logger.error(
+                "Unsupported client-provided TextDocumentContentChangeEvent. "
+                "Please update / submit a Pull Request to your LSP client."
+            )
+
+        if self._is_sync_kind_none:
+            self._apply_none_change(change)
+        else:
+            self._apply_full_change(change)
+
+    @property
+    def lines(self) -> List[str]:
+        return self.source.splitlines(True)
+
+    def offset_at_position(self, client_position: types.Position) -> int:
+        """Return the character offset pointed at by the given client_position."""
+        lines = self.lines
+        server_position = self.position.position_from_client_units(
+            lines, client_position
+        )
+        row, col = server_position.line, server_position.character
+        return col + sum(self.position.client_num_units(line) for line in lines[:row])
+
+    @property
+    def source(self) -> str:
+        if self._source is None:
+            with io.open(self.path, "r", encoding="utf-8") as f:
+                return f.read()
+        return self._source
+
+    def word_at_position(
+        self,
+        client_position: types.Position,
+        re_start_word: Pattern[str] = RE_START_WORD,
+        re_end_word: Pattern[str] = RE_END_WORD,
+    ) -> str:
+        """Return the word at position.
+
+        The word is constructed in two halves, the first half is found by taking
+        the first match of ``re_start_word`` on the line up until
+        ``position.character``.
+
+        The second half is found by taking ``position.character`` up until the
+        last match of ``re_end_word`` on the line.
+
+        :func:`python:re.findall` is used to find the matches.
+
+        Parameters
+        ----------
+        position
+           The line and character offset.
+
+        re_start_word
+           The regular expression for extracting the word backward from
+           position. The default pattern is ``[A-Za-z_0-9]*$``.
+
+        re_end_word
+           The regular expression for extracting the word forward from
+           position. The default pattern is ``^[A-Za-z_0-9]*``.
+
+        Returns
+        -------
+        str
+           The word (obtained by concatenating the two matches) at position.
+        """
+        lines = self.lines
+        if client_position.line >= len(lines):
+            return ""
+
+        server_position = self.position.position_from_client_units(
+            lines, client_position
+        )
+        row, col = server_position.line, server_position.character
+        line = lines[row]
+        # Split word in two
+        start = line[:col]
+        end = line[col:]
+
+        # Take end of start and start of end to find word
+        # These are guaranteed to match, even if they match the empty string
+        m_start = re_start_word.findall(start)
+        m_end = re_end_word.findall(end)
+
+        return m_start[0] + m_end[-1]