Moves functions to helper_functions

Author: gnikit

fortls/constants.py

@@ -2,6 +2,9 @@
 
 PY3K = sys.version_info >= (3, 0)
 
+# Global variables
+sort_keywords = True
+
 # Keyword identifiers
 KEYWORD_LIST = [
     "pointer",

fortls/helper_functions.py

@@ -1,3 +1,8 @@
+import logging
+import os
+from pathlib import Path
+
+from fortls.constants import KEYWORD_ID_DICT, KEYWORD_LIST, sort_keywords
 from fortls.regex_patterns import (
     DQ_STRING_REGEX,
     FIXED_COMMENT_LINE_MATCH,
@@ -6,10 +11,13 @@
     LOGICAL_REGEX,
     NAT_VAR_REGEX,
     NUMBER_REGEX,
+    OBJBREAK_REGEX,
     SQ_STRING_REGEX,
     WORD_REGEX,
 )
 
+log = logging.getLogger(__name__)
+
 
 def expand_name(line, char_poss):
     """Get full word containing given cursor position"""
@@ -124,3 +132,211 @@ def find_paren_match(test_str):
         if paren_count == 0:
             return i
     return ind
+
+
+def get_line_prefix(pre_lines: list, curr_line: str, col: int, qs: bool = True) -> str:
+    """Get code line prefix from current line and preceding continuation lines
+
+    Parameters
+    ----------
+    pre_lines : list
+        for multiline cases get all the previous, relevant lines
+    curr_line : str
+        the current line
+    col : int
+        column index of the current line
+    qs : bool, optional
+        strip quotes i.e. string literals from `curr_line` and `pre_lines`.
+        Need this disable when hovering over string literals, by default True
+
+    Returns
+    -------
+    str
+        part of the line including any relevant line continuations before `col`
+    """
+    if (curr_line is None) or (col > len(curr_line)) or (curr_line.startswith("#")):
+        return None
+    prepend_string = "".join(pre_lines)
+    curr_line = prepend_string + curr_line
+    col += len(prepend_string)
+    line_prefix = curr_line[:col].lower()
+    # Ignore string literals
+    if qs:
+        if (line_prefix.find("'") > -1) or (line_prefix.find('"') > -1):
+            sq_count = 0
+            dq_count = 0
+            for char in line_prefix:
+                if (char == "'") and (dq_count % 2 == 0):
+                    sq_count += 1
+                elif (char == '"') and (sq_count % 2 == 0):
+                    dq_count += 1
+            if (dq_count % 2 == 1) or (sq_count % 2 == 1):
+                return None
+    return line_prefix
+
+
+def resolve_globs(glob_path: str, root_path: str = None) -> list[str]:
+    """Resolve glob patterns
+
+    Parameters
+    ----------
+    glob_path : str
+        Path containing the glob pattern follows
+        `fnmatch` glob pattern, can include relative paths, etc.
+        see fnmatch: https://docs.python.org/3/library/fnmatch.html#module-fnmatch
+
+    root_path : str, optional
+        root path to start glob search. If left empty the root_path will be
+        extracted from the glob_path, by default None
+
+    Returns
+    -------
+    list[str]
+        Expanded glob patterns with absolute paths.
+        Absolute paths are used to resolve any potential ambiguity
+    """
+    # Path.glob returns a generator, we then cast the Path obj to a str
+    # alternatively use p.as_posix()
+    if root_path:
+        return [str(p) for p in Path(root_path).resolve().glob(glob_path)]
+    # Attempt to extract the root and glob pattern from the glob_path
+    # This is substantially less robust that then above
+    else:
+        p = Path(glob_path).expanduser()
+        parts = p.parts[p.is_absolute() :]
+        return [str(i) for i in Path(p.root).resolve().glob(str(Path(*parts)))]
+
+
+def only_dirs(paths: list[str], err_msg: list = []) -> list[str]:
+    dirs: list[str] = []
+    for p in paths:
+        if os.path.isdir(p):
+            dirs.append(p)
+        elif os.path.isfile(p):
+            continue
+        else:
+            msg: str = (
+                f"Directory '{p}' specified in Configuration settings file does not"
+                " exist"
+            )
+            if err_msg:
+                err_msg.append([2, msg])
+            else:
+                log.warning(msg)
+    return dirs
+
+
+def set_keyword_ordering(sorted):
+    global sort_keywords
+    sort_keywords = sorted
+
+
+def map_keywords(keywords):
+    mapped_keywords = []
+    keyword_info = {}
+    for keyword in keywords:
+        keyword_prefix = keyword.split("(")[0].lower()
+        keyword_ind = KEYWORD_ID_DICT.get(keyword_prefix)
+        if keyword_ind is not None:
+            mapped_keywords.append(keyword_ind)
+            if keyword_prefix in ("intent", "dimension", "pass"):
+                keyword_substring = get_paren_substring(keyword)
+                if keyword_substring is not None:
+                    keyword_info[keyword_prefix] = keyword_substring
+    if sort_keywords:
+        mapped_keywords.sort()
+    return mapped_keywords, keyword_info
+
+
+def get_keywords(keywords, keyword_info={}):
+    keyword_strings = []
+    for keyword_id in keywords:
+        string_rep = KEYWORD_LIST[keyword_id]
+        addl_info = keyword_info.get(string_rep)
+        string_rep = string_rep.upper()
+        if addl_info is not None:
+            string_rep += "({0})".format(addl_info)
+        keyword_strings.append(string_rep)
+    return keyword_strings
+
+
+def get_paren_substring(test_str):
+    i1 = test_str.find("(")
+    i2 = test_str.rfind(")")
+    if i1 > -1 and i2 > i1:
+        return test_str[i1 + 1 : i2]
+    else:
+        return None
+
+
+def get_paren_level(line):
+    """Get sub-string corresponding to a single parenthesis level,
+    via backward search up through the line.
+
+    Examples:
+      "CALL sub1(arg1,arg2" -> ("arg1,arg2", [[10, 19]])
+      "CALL sub1(arg1(i),arg2" -> ("arg1,arg2", [[10, 14], [17, 22]])
+    """
+    if line == "":
+        return "", [[0, 0]]
+    level = 0
+    in_string = False
+    string_char = ""
+    i1 = len(line)
+    sections = []
+    for i in range(len(line) - 1, -1, -1):
+        char = line[i]
+        if in_string:
+            if char == string_char:
+                in_string = False
+            continue
+        if (char == "(") or (char == "["):
+            level -= 1
+            if level == 0:
+                i1 = i
+            elif level < 0:
+                sections.append([i + 1, i1])
+                break
+        elif (char == ")") or (char == "]"):
+            level += 1
+            if level == 1:
+                sections.append([i + 1, i1])
+        elif (char == "'") or (char == '"'):
+            in_string = True
+            string_char = char
+    if level == 0:
+        sections.append([i, i1])
+    sections.reverse()
+    out_string = ""
+    for section in sections:
+        out_string += line[section[0] : section[1]]
+    return out_string, sections
+
+
+def get_var_stack(line):
+    """Get user-defined type field sequence terminating the given line
+
+    Examples:
+      "myvar%foo%bar" -> ["myvar", "foo", "bar"]
+      "myarray(i)%foo%bar" -> ["myarray", "foo", "bar"]
+      "CALL self%method(this%foo" -> ["this", "foo"]
+    """
+    if len(line) == 0:
+        return [""]
+    final_var, sections = get_paren_level(line)
+    if final_var == "":
+        return [""]
+    # Continuation of variable after paren requires '%' character
+    iLast = 0
+    for (i, section) in enumerate(sections):
+        if not line[section[0] : section[1]].startswith("%"):
+            iLast = i
+    final_var = ""
+    for section in sections[iLast:]:
+        final_var += line[section[0] : section[1]]
+    #
+    if final_var is not None:
+        final_op_split = OBJBREAK_REGEX.split(final_var)
+        return final_op_split[-1].split("%")
+    else:
+        return None

fortls/intrinsics.py

@@ -1,6 +1,7 @@
 import json
 import os
 
+from fortls.helper_functions import map_keywords
 from fortls.objects import (
     fortran_ast,
     fortran_function,
@@ -9,7 +10,6 @@
     fortran_subroutine,
     fortran_type,
     fortran_var,
-    map_keywords,
 )
 
 none_ast = fortran_ast()

fortls/langserver.py

@@ -23,7 +23,15 @@
     SUBROUTINE_TYPE_ID,
     VAR_TYPE_ID,
 )
-from fortls.helper_functions import expand_name
+from fortls.helper_functions import (
+    expand_name,
+    get_line_prefix,
+    get_paren_level,
+    get_var_stack,
+    only_dirs,
+    resolve_globs,
+    set_keyword_ordering,
+)
 from fortls.intrinsics import (
     get_intrinsic_keywords,
     load_intrinsics,
@@ -36,10 +44,7 @@
     find_in_workspace,
     fortran_ast,
     fortran_var,
-    get_paren_level,
     get_use_tree,
-    get_var_stack,
-    set_keyword_ordering,
 )
 from fortls.parse_fortran import fortran_file, get_line_context, process_file
 from fortls.regex_patterns import (
@@ -81,98 +86,6 @@ def init_file(filepath, pp_defs, pp_suffixes, include_dirs):
     return file_obj, None
 
 
-def get_line_prefix(pre_lines: list, curr_line: str, col: int, qs: bool = True) -> str:
-    """Get code line prefix from current line and preceding continuation lines
-
-    Parameters
-    ----------
-    pre_lines : list
-        for multiline cases get all the previous, relevant lines
-    curr_line : str
-        the current line
-    col : int
-        column index of the current line
-    qs : bool, optional
-        strip quotes i.e. string literals from `curr_line` and `pre_lines`.
-        Need this disable when hovering over string literals, by default True
-
-    Returns
-    -------
-    str
-        part of the line including any relevant line continuations before `col`
-    """
-    if (curr_line is None) or (col > len(curr_line)) or (curr_line.startswith("#")):
-        return None
-    prepend_string = "".join(pre_lines)
-    curr_line = prepend_string + curr_line
-    col += len(prepend_string)
-    line_prefix = curr_line[:col].lower()
-    # Ignore string literals
-    if qs:
-        if (line_prefix.find("'") > -1) or (line_prefix.find('"') > -1):
-            sq_count = 0
-            dq_count = 0
-            for char in line_prefix:
-                if (char == "'") and (dq_count % 2 == 0):
-                    sq_count += 1
-                elif (char == '"') and (sq_count % 2 == 0):
-                    dq_count += 1
-            if (dq_count % 2 == 1) or (sq_count % 2 == 1):
-                return None
-    return line_prefix
-
-
-def resolve_globs(glob_path: str, root_path: str = None) -> list[str]:
-    """Resolve glob patterns
-
-    Parameters
-    ----------
-    glob_path : str
-        Path containing the glob pattern follows
-        `fnmatch` glob pattern, can include relative paths, etc.
-        see fnmatch: https://docs.python.org/3/library/fnmatch.html#module-fnmatch
-
-    root_path : str, optional
-        root path to start glob search. If left empty the root_path will be
-        extracted from the glob_path, by default None
-
-    Returns
-    -------
-    list[str]
-        Expanded glob patterns with absolute paths.
-        Absolute paths are used to resolve any potential ambiguity
-    """
-    # Path.glob returns a generator, we then cast the Path obj to a str
-    # alternatively use p.as_posix()
-    if root_path:
-        return [str(p) for p in Path(root_path).resolve().glob(glob_path)]
-    # Attempt to extract the root and glob pattern from the glob_path
-    # This is substantially less robust that then above
-    else:
-        p = Path(glob_path).expanduser()
-        parts = p.parts[p.is_absolute() :]
-        return [str(i) for i in Path(p.root).resolve().glob(str(Path(*parts)))]
-
-
-def only_dirs(paths: list[str], err_msg: list = []) -> list[str]:
-    dirs: list[str] = []
-    for p in paths:
-        if os.path.isdir(p):
-            dirs.append(p)
-        elif os.path.isfile(p):
-            continue
-        else:
-            msg: str = (
-                f"Directory '{p}' specified in Configuration settings file does not"
-                " exist"
-            )
-            if err_msg:
-                err_msg.append([2, msg])
-            else:
-                log.warning(msg)
-    return dirs
-
-
 class LangServer:
     def __init__(self, conn, debug_log=False, settings={}):
         self.conn = conn