Adds command line option --config

The option allows for arbtrary name/location of the config file.
In addition, it exposes the rest of the commad line interface to
the configuration options file under the same names

TODO: update README config arguments

Author: gnikit

README.md

@@ -5,12 +5,12 @@
 [![image](https://img.shields.io/github/license/gnikit/fortran-language-server.svg)](https://github.com/gnikit/fortran-language-server/blob/master/LICENSE)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
-`fortls`: A Fortran implementation of the [Language Server Protocol](https://github.com/Microsoft/language-server-protocol)
-(LSP) using Python (3.6+).
+`fortls` is an implementation of the [Language Server Protocol](https://github.com/Microsoft/language-server-protocol)
+(LSP) for Fortran using Python (3.6+).
 
 Editor extensions that can integrate with `fortls` to provide autocomplete and
 other IDE-like functionality are available for
-[Visual Studio Code](https://github.com/krvajal/vscode-fortran-support)
+[Visual Studio Code](https://github.com/krvajal/vscode-fortran-support),
 [Atom](https://atom.io/packages/ide-fortran),
 [Visual Studio](https://github.com/michaelkonecny/vs-fortran-ls-client),
 [(Neo)vim](https://github.com/hansec/fortran-language-server/wiki/Using-forts-with-vim),
@@ -71,6 +71,7 @@ pip install fortls
 The following global settings can be used when launching the language
 server.
 
+- `--config` Configuration options file (default: `.fortls`)
 - `--nthreads` Number of threads to use during workspace
   initialization (default: 4)
 - `--notify_init` Send notification message when workspace
@@ -139,8 +140,11 @@ fortls
 
 ## Configuration
 
-Project specific settings can be specified by placing a JSON file named
-`.fortls` (example below) in the `root_dir` directory.
+Project specific settings can be specified by creating a **options** JSON file.
+You can specify the location and name of the file with the `--config` option.
+By default the options file is assumed to be `root_dir` with the name `.fortls`.
+
+All command line options are also available through the **options** file as well.
 
 - `lowercase_intrinsics` Use lowercase for intrinsics and keywords in
   autocomplete requests (default: false)
@@ -164,7 +168,7 @@ the project.
 ### Excluding folders and file extensions
 
 Directories and files can be excluded from the project by specifying
-their paths in the `excl_paths` variable in the`.fortls` file.
+their paths in the `excl_paths` variable in the options file.
 Paths can be absolute or relative to `root_dir`.
 
 Excluded directories **will not** exclude all sub-directories.
@@ -178,11 +182,10 @@ Source files with a common suffix may also be excluded using the
 
 By default all source directories under `root_dir` are recursively included.
 Source file directories can also be specified manually by specifying
-their paths in the `source_dirs` variable in `.fortls`.
+their paths in the `source_dirs` variable in the configuration options file.
 Paths can be absolute or relative to `root_dir`.
-the `.fortls` file.
 
-When defining `source_dirs` in `.fortls` the default behaviour (i.e. including
+When defining `source_dirs` in the configuration options filethe default behaviour (i.e. including
 all files in all subdirectories under `root_dir`) is overriden. To include them
 back again one can do
 
@@ -207,25 +210,25 @@ preprocessing (ie. tracking definitions). Fortran objects defined in
 these files will not be processed.
 
 File suffixes for preprocessing can be controlled with the variable
-`pp_suffixes` in a workspace's `.fortls` file. When this variable is
+`pp_suffixes` in a workspace's configuration options file. When this variable is
 used _only_ those files with the specified suffixes will be
 preprocessed. If an empty array is specified then _no_ preprocessing
 will be performed on any files. By default, or if the variable is
 omitted or `null`, only files with upper case suffixes are preprocessed.
 
 Preprocessor definitions can be set for each project, to improve support
 for Fortran files using conditional compilation, using the `pp_defs`
-variable in the `.fortls` file. Preprocessing is performed _only_ for
+variable in the configuration options file. Preprocessing is performed _only_ for
 files where the file extension is all caps (ie. ".F90", ".F", etc.).
 Currently, support for preprocessing is limited to variables declared in
-the project's `.fortls` file or in the source file of interest as
+the project's configuration options file or in the source file of interest as
 `#include` files and inheritance through `USE` statements are yet not
 supported. Variable substitution is also performed within files, but is
 currently limited to non-recursive cases. For example, `#define PP_VAR1 PP_VAR2` will cause `PP_VAR1` to be replaced with the text `PP_VAR2`
 throughout the file, not that value of `PP_VAR2`.
 
 Include directories can be specified using the variable `include_dirs`
-in a workspace's `.fortls` file. These directories are _only_ used to
+in a workspace's configuration options file. These directories are _only_ used to
 search for preprocessor `#include`'d files. The directory containing the
 file where an `#include` statement is encountered is always searched.
 File search is performed starting with the containing directory followed

fortls/__init__.py

@@ -59,18 +59,21 @@ def main():
 
 
 def parse_args():
-    """Parses the command line aguments to the Language Server
+    """Parses the command line arguments to the Language Server
 
     Returns
     -------
     Namespace
         command line arguments
     """
     parser = argparse.ArgumentParser()
-    parser.description = "FORTRAN Language Server ({0})".format(__version__)
+    parser.description = "fortls ({0})".format(__version__)
     parser.add_argument(
         "--version", action="store_true", help="Print server version number and exit"
     )
+    parser.add_argument(
+        "--config", type=str, default=".fortls", help="Configuration options file"
+    )
     parser.add_argument(
         "--nthreads",
         type=int,
@@ -272,6 +275,7 @@ def set_settings(args):
         settings for the Language Server
     """
     settings = {
+        "config": args.config,
         "nthreads": args.nthreads,
         "notify_init": args.notify_init,
         "symbol_include_mem": (not args.symbol_skip_mem),
@@ -288,6 +292,7 @@ def set_settings(args):
         "max_line_length": args.max_line_length,
         "max_comment_line_length": args.max_comment_line_length,
         "disable_diagnostics": args.disable_diagnostics,
+
     }
     if args.hover_language is not None:
         settings["hover_language"] = args.hover_language
@@ -702,7 +707,7 @@ def debug_server_parser(args):
     pp_defs = {}
     include_dirs = []
     if args.debug_rootpath:
-        config_path = os.path.join(args.debug_rootpath, ".fortls")
+        config_path = os.path.join(args.debug_rootpath, args.config)
         config_exists = os.path.isfile(config_path)
         if config_exists:
             try:
@@ -719,7 +724,7 @@ def debug_server_parser(args):
                     if isinstance(pp_defs, list):
                         pp_defs = {key: "" for key in pp_defs}
             except:
-                print("Error while parsing '.fortls' settings file")
+                print(f"Error while parsing '{args.config}' settings file")
     #
     print("\nTesting parser")
     print('  File = "{0}"'.format(args.debug_filepath))

fortls/langserver.py

@@ -141,7 +141,7 @@ def only_dirs(paths: list[str], err_msg: list = []) -> list[str]:
             continue
         else:
             msg: str = (
-                f"Directory '{p}' specified in '.fortls' settings file does not exist"
+                f"Directory '{p}' specified in Configuration settings file does not exist"
             )
             if err_msg:
                 err_msg.append([2, msg])
@@ -177,6 +177,7 @@ def __init__(self, conn, debug_log=False, settings={}):
             self.intrinsic_mods,
         ) = load_intrinsics()
         # Get launch settings
+        self.config = settings.get("config", ".fortls")
         self.nthreads = settings.get("nthreads", 4)
         self.notify_init = settings.get("notify_init", False)
         self.symbol_include_mem = settings.get("symbol_include_mem", True)
@@ -1475,8 +1476,7 @@ def __load_config_file(self) -> None:
         """Loads the configuration file for the Language Server"""
 
         # Check for config file
-        config_fname = ".fortls"
-        config_path = os.path.join(self.root_path, config_fname)
+        config_path = os.path.join(self.root_path, self.config)
         if not os.path.isfile(config_path):
             return None
 
@@ -1489,63 +1489,81 @@ def __load_config_file(self) -> None:
                 # config_dict = json.loads(jsondata)
                 config_dict = json.load(jsonfile)
 
-                # Exclude paths (directories & files)
-                # with glob resolution
-                for path in config_dict.get("excl_paths", []):
-                    self.excl_paths.update(set(resolve_globs(path, self.root_path)))
-
-                # Source directory paths (directories)
-                # with glob resolution
-                source_dirs = config_dict.get("source_dirs", [])
-                for path in source_dirs:
-                    self.source_dirs.update(
-                        set(
-                            only_dirs(
-                                resolve_globs(path, self.root_path),
-                                self.post_messages,
-                            )
-                        )
-                    )
-                # Keep all directories present in source_dirs but not excl_paths
-                self.source_dirs = {
-                    i for i in self.source_dirs if i not in self.excl_paths
-                }
+                # Include and Exclude directories
+                self.__load_config_file_dirs(config_dict)
 
-                self.excl_suffixes = config_dict.get("excl_suffixes", [])
-                self.lowercase_intrinsics = config_dict.get(
-                    "lowercase_intrinsics", self.lowercase_intrinsics
-                )
+                # General options
+                self.__load_config_file_general(config_dict)
+
+                # Preprocessor options
+                self.__load_config_file_preproc(config_dict)
+
+                # Debug options
                 self.debug_log = config_dict.get("debug_log", self.debug_log)
-                self.disable_diagnostics = config_dict.get(
-                    "disable_diagnostics", self.disable_diagnostics
-                )
-                self.pp_suffixes = config_dict.get("pp_suffixes", None)
-                self.pp_defs = config_dict.get("pp_defs", {})
-                for path in config_dict.get("include_dirs", []):
-                    self.include_dirs.extend(
-                        only_dirs(
-                            resolve_globs(path, self.root_path), self.post_messages
-                        )
-                    )
-                self.max_line_length = config_dict.get(
-                    "max_line_length", self.max_line_length
-                )
-                self.max_comment_line_length = config_dict.get(
-                    "max_comment_line_length", self.max_comment_line_length
-                )
-                if isinstance(self.pp_defs, list):
-                    self.pp_defs = {key: "" for key in self.pp_defs}
 
         except FileNotFoundError:
-            msg = f"Error settings file '{config_fname}' not found"
+            msg = f"Error settings file '{self.config}' not found"
             self.post_messages.append([1, msg])
             log.error(msg)
 
         except ValueError:
-            msg = f"Error while parsing '{config_fname}' settings file"
+            msg = f"Error while parsing '{self.config}' settings file"
             self.post_messages.append([1, msg])
             log.error(msg)
 
+    def __load_config_file_dirs(self, config_dict) -> None:
+        # Exclude paths (directories & files)
+        # with glob resolution
+        for path in config_dict.get("excl_paths", []):
+            self.excl_paths.update(set(resolve_globs(path, self.root_path)))
+
+        # Source directory paths (directories)
+        # with glob resolution
+        source_dirs = config_dict.get("source_dirs", [])
+        for path in source_dirs:
+            self.source_dirs.update(
+                set(
+                    only_dirs(
+                        resolve_globs(path, self.root_path),
+                        self.post_messages,
+                    )
+                )
+            )
+        # Keep all directories present in source_dirs but not excl_paths
+        self.source_dirs = {i for i in self.source_dirs if i not in self.excl_paths}
+
+    def __load_config_file_general(self, config_dict) -> None:
+        self.excl_suffixes = config_dict.get("excl_suffixes", [])
+        self.lowercase_intrinsics = config_dict.get(
+            "lowercase_intrinsics", self.lowercase_intrinsics
+        )
+        self.use_signature_help = config_dict.get(
+            "use_signature_help", self.use_signature_help
+        )
+        self.variable_hover = config_dict.get("variable_hover", self.variable_hover)
+        self.hover_signature = config_dict.get("hover_signature", self.hover_signature)
+        self.enable_code_actions = config_dict.get(
+            "enable_code_actions", self.enable_code_actions
+        )
+        self.disable_diagnostics = config_dict.get(
+            "disable_diagnostics", self.disable_diagnostics
+        )
+        self.max_line_length = config_dict.get("max_line_length", self.max_line_length)
+        self.max_comment_line_length = config_dict.get(
+            "max_comment_line_length", self.max_comment_line_length
+        )
+
+    def __load_config_file_preproc(self, config_dict) -> None:
+        self.pp_suffixes = config_dict.get("pp_suffixes", None)
+        self.pp_defs = config_dict.get("pp_defs", {})
+        if isinstance(self.pp_defs, list):
+            self.pp_defs = {key: "" for key in self.pp_defs}
+
+        for path in config_dict.get("include_dirs", []):
+            self.include_dirs.extend(
+                only_dirs(resolve_globs(path, self.root_path), self.post_messages)
+            )
+
     def __add_source_dirs(self) -> None:
         """Will recursively add all subdirectories that contain Fortran
         source files only if the option `source_dirs` has not been specified

setup.py

@@ -22,7 +22,7 @@
     url="https://github.com/gnikit/fortran-language-server",
     author="Giannis Nikiteas",
     author_email="[email protected]",
-    description="FORTRAN Language Server - dev version",
+    description="fortls - Fortran Language Server",
     long_description=README,
     long_description_content_type="text/markdown",
     license="MIT",
@@ -47,10 +47,7 @@
     # simple. Or you can use find_packages().
     packages=find_packages(exclude=["contrib", "docs", "test"]),
     package_data={"fortls": ["*.json"]},
-    # List run-time dependencies here.  These will be installed by pip when
-    # your project is installed. For an analysis of "install_requires" vs pip's
-    # requirements files see:
-    # https://packaging.python.org/en/latest/requirements.html
+    # https://packaging.python.org/en/latest/discussions/install-requires-vs-requirements/
     install_requires=[
         'future; python_version < "3"',
         'argparse; python_version < "2.7" or python_version in "3.0, 3.1"',