def _do_create_libspec_on_get(self, libname, current_doc_uri): from robocode_ls_core import uris additional_path = None abspath = None cwd = None if current_doc_uri is not None: cwd = os.path.dirname(uris.to_fs_path(current_doc_uri)) if not cwd or not os.path.isdir(cwd): cwd = None if os.path.isabs(libname): abspath = libname elif current_doc_uri is not None: # relative path: let's make it absolute fs_path = os.path.dirname(uris.to_fs_path(current_doc_uri)) abspath = os.path.abspath(os.path.join(fs_path, libname)) if abspath: additional_path = os.path.dirname(abspath) libname = os.path.basename(libname) if libname.lower().endswith((".py", ".class", ".java")): libname = os.path.splitext(libname)[0] if self._create_libspec(libname, additional_path=additional_path, cwd=cwd): self.synchronize_internal_libspec_folders() return True return False
def __init__(self, root_uri, init_opts, process_id, capabilities): self._root_path = uris.to_fs_path(root_uri) self._root_uri = root_uri self._init_opts = init_opts self._process_id = process_id self._capabilities = capabilities self._settings = {} self._config_sources = {}
def __init__(self, uri, source=None, version=None): self.uri = uri self.version = version self.path = uris.to_fs_path(uri) # Note: may be None. self._source = source self.__line_start_offsets = None # Only set when the source is read from disk. self._source_mtime = -1
def __init__(self, root_uri, workspace_folders=None) -> None: from robocode_ls_core.lsp import WorkspaceFolder self._root_uri = root_uri self._root_uri_scheme = uri_scheme(self._root_uri) self._root_path = to_fs_path(self._root_uri) self._folders: Dict[str, WorkspaceFolder] = {} # Contains the docs with files considered open. self._docs: Dict[str, IDocument] = {} # Contains the docs pointing to the filesystem. self._filesystem_docs: Dict[str, IDocument] = {} if workspace_folders is not None: for folder in workspace_folders: self.add_folder(folder) if root_uri and root_uri not in self.folders: as_fs_path = uris.to_fs_path(root_uri) name = os.path.basename(as_fs_path) self.add_folder(WorkspaceFolder(root_uri, name))
def __init__(self, resource_doc): """ :param RobotDocument resource_doc: """ from robocode_ls_core import uris self.keyword_name = "" self.resource_doc = resource_doc self.source = uris.to_fs_path(resource_doc.uri) self.lineno = 1 self.end_lineno = 1 self.col_offset = 1 self.end_col_offset = 1
def add_workspace_folder(self, folder_uri): from robocode_ls_core import uris if folder_uri not in self._workspace_folder_uri_to_folder_info: log.debug("Added workspace folder: %s", folder_uri) cp = self._workspace_folder_uri_to_folder_info.copy() folder_info = cp[folder_uri] = _FolderInfo( uris.to_fs_path(folder_uri), recursive=True) self._workspace_folder_uri_to_folder_info = cp folder_info.start_watch(self._observer, self._spec_changes_notifier) folder_info.synchronize() else: log.debug("Workspace folder already added: %s", folder_uri)
def get_interpreter_info_for_doc_uri(self, doc_uri) -> Optional[IInterpreterInfo]: try: pm = self._pm() if pm is None: log.critical("Did not expect PluginManager to be None at this point.") return None from robotframework_ls.ep_providers import ( EPConfigurationProvider, EPEndPointProvider, ) # Check that our requirements are there. pm[EPConfigurationProvider] pm[EPEndPointProvider] fs_path = Path(uris.to_fs_path(doc_uri)) for path in fs_path.parents: package_yaml: Path = path / "package.yaml" if package_yaml.exists(): break else: # i.e.: Could not find any package.yaml in the structure. log.debug("Could not find package yaml for: %s", fs_path) return None # Ok, we have the package_yaml, so, we should be able to run RCC with it. package_yaml_file_info = _CacheInfo.get_file_info(package_yaml) yaml_contents = package_yaml_file_info.yaml_contents if not isinstance(yaml_contents, dict): raise AssertionError(f"Expected dict as root in: {package_yaml}") conda_config = yaml_contents.get("condaConfig") conda_config_file_info = None if conda_config: parent: Path = package_yaml.parent conda_config_path = parent.joinpath(conda_config) if conda_config_path.exists(): conda_config_file_info = _CacheInfo.get_file_info(conda_config_path) return _CacheInfo.get_interpreter_info( package_yaml_file_info, conda_config_file_info, pm ) except: log.exception(f"Error getting interpreter info for: {doc_uri}") return None
def _add_completions_from_dir( completion_context, directory, matcher, ret, sel, token, qualifier, extensions, skip_current, ): from robocode_ls_core import uris def normfile(path): return os.path.normpath(os.path.normcase(path)) curr_file = normfile(uris.to_fs_path(completion_context.doc.uri)) try: # This is ok if the directory doesn't exist. contents = sorted(os.listdir(directory)) except: return for filename in contents: use_path = None if filename.endswith(extensions): # If that'd be a match for the current .robot file, don't show it. if skip_current and curr_file == normfile( os.path.join(directory, filename)): continue use_path = filename elif filename not in (u"__pycache__", u".git") and os.path.isdir( os.path.join(directory, filename)): use_path = filename + u"/" else: continue if matcher.accepts(use_path): ret.append( _create_completion_item(use_path, sel, token, start_col_offset=sel.col - len(qualifier)))
def get_interpreter_info_for_doc_uri(self, doc_uri) -> Optional[IInterpreterInfo]: as_path = Path(uris.to_fs_path(doc_uri)) environ = dict(os.environ) if as_path.parent.name == "env1": return DefaultInterpreterInfo( "env1", sys.executable, environ, [str(as_path.parent / "lib1")] ) elif as_path.parent.name == "env2": return DefaultInterpreterInfo( "env2", sys.executable, environ, [str(as_path.parent / "lib2")] ) return None
def test_keyword_completions_user_library(data_regression, workspace, tmpdir, cases, libspec_manager, library_import): import os.path from robotframework_ls.impl import keyword_completions from robotframework_ls.impl.completion_context import CompletionContext from robotframework_ls_tests.fixtures import LIBSPEC_1 from robocode_ls_core import uris workspace_dir = str(tmpdir.join("workspace")) cases.copy_to("case1", workspace_dir) workspace.set_root(workspace_dir, libspec_manager=libspec_manager) doc = workspace.get_doc("case1.robot") if library_import == "__FULL_PATH__": case1_robot_path = uris.to_fs_path(doc.uri) case1_py_path = os.path.join(os.path.dirname(case1_robot_path), "case1_library.py") library_import = case1_py_path doc.source = doc.source.replace("case1_library", library_import) doc.source = doc.source + "\n verify" completions = keyword_completions.complete( CompletionContext(doc, workspace=workspace.ws)) data_regression.check(completions, basename="keyword_completions_1") # Now, let's put a .libspec file in the workspace and check whether # it has priority over the auto-generated spec file. with open(os.path.join(workspace_dir, "new_spec.libspec"), "w") as stream: stream.write(LIBSPEC_1) libspec_manager.synchronize_workspace_folders() completions = keyword_completions.complete( CompletionContext(doc, workspace=workspace.ws)) data_regression.check(completions, basename="keyword_completions_2_new")
def test_win_to_fs_path(uri, path): assert uris.to_fs_path(uri) == path
def source(self): from robocode_ls_core import uris return uris.to_fs_path(self.completion_context.doc.uri)
def get_folder_paths(self) -> List[str]: folders = self._folders return [uris.to_fs_path(ws_folder.uri) for ws_folder in folders.values()]
def resource_name(self): from robocode_ls_core import uris uri = self.completion_context.doc.uri return os.path.splitext(os.path.basename(uris.to_fs_path(uri)))[0]
def _get_completions(completion_context, token, match_libs, extensions, skip_current): from robotframework_ls.impl.string_matcher import RobotStringMatcher from robocode_ls_core import uris from robotframework_ls.impl.robot_constants import BUILTIN_LIB ret = [] sel = completion_context.sel value_to_cursor = token.value if token.end_col_offset > sel.col: value_to_cursor = value_to_cursor[:-(token.end_col_offset - sel.col)] if u"{" in value_to_cursor: value_to_cursor = completion_context.token_value_resolving_variables( value_to_cursor) value_to_cursor_split = os.path.split(value_to_cursor) if os.path.isabs(value_to_cursor): _add_completions_from_dir( completion_context, value_to_cursor_split[0], RobotStringMatcher(value_to_cursor_split[1]), ret, sel, token, value_to_cursor_split[1], extensions, skip_current=skip_current, ) else: if match_libs: matcher = RobotStringMatcher(value_to_cursor) libspec_manager = completion_context.workspace.libspec_manager library_names = set(libspec_manager.get_library_names()) library_names.discard(BUILTIN_LIB) for library_name in library_names: if matcher.accepts(library_name): ret.append( _create_completion_item(library_name, sel, token)) # After checking the existing library names in memory (because we # loaded them at least once), check libraries in the filesystem. uri = completion_context.doc.uri path = uris.to_fs_path(uri) dirname = os.path.dirname(path) matcher = RobotStringMatcher(value_to_cursor_split[1]) directory = os.path.join(dirname, value_to_cursor_split[0]) _add_completions_from_dir( completion_context, directory, matcher, ret, sel, token, value_to_cursor_split[1], extensions, skip_current=skip_current, ) return ret
def find_parents(self, path, names): root_path = uris.to_fs_path(self._root_uri) return basic.find_parents(root_path, path, names)