Wuff 0.0.2__tar.gz → 0.0.3__tar.gz

Wuff-0.0.3/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include wuff *
+prune wuff/cmake_*
+prune wuff/.idea

{Wuff-0.0.2 → Wuff-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Wuff
-Version: 0.0.2
+Version: 0.0.3
 Summary: Analyzer tools for WooWoo projects
 Author: Michal Janecek
 Author-email: michal.janecek@gmail.com

{Wuff-0.0.2 → Wuff-0.0.3}/Wuff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Wuff
-Version: 0.0.2
+Version: 0.0.3
 Summary: Analyzer tools for WooWoo projects
 Author: Michal Janecek
 Author-email: michal.janecek@gmail.com

Wuff-0.0.3/Wuff.egg-info/SOURCES.txt

@@ -0,0 +1,74 @@
+MANIFEST.in
+README.md
+setup.py
+Wuff.egg-info/PKG-INFO
+Wuff.egg-info/SOURCES.txt
+Wuff.egg-info/dependency_links.txt
+Wuff.egg-info/not-zip-safe
+Wuff.egg-info/requires.txt
+Wuff.egg-info/top_level.txt
+wuff/Bindings.cpp
+wuff/CMakeLists.txt
+wuff/LICENSE
+wuff/README.md
+wuff/WooWooAnalyzer.cpp
+wuff/WooWooAnalyzer.h
+wuff/components/Completer.cpp
+wuff/components/Completer.h
+wuff/components/Component.cpp
+wuff/components/Component.h
+wuff/components/Folder.cpp
+wuff/components/Folder.h
+wuff/components/Highlighter.cpp
+wuff/components/Highlighter.h
+wuff/components/Hoverer.cpp
+wuff/components/Hoverer.h
+wuff/components/Linter.cpp
+wuff/components/Linter.h
+wuff/components/Navigator.cpp
+wuff/components/Navigator.h
+wuff/components/queries/highlights.scm
+wuff/components/queries/yaml-highlights.scm
+wuff/dialect/Dialect.cpp
+wuff/dialect/Dialect.h
+wuff/dialect/DialectManager.cpp
+wuff/dialect/DialectManager.h
+wuff/dialect/DocumentPart.cpp
+wuff/dialect/DocumentPart.h
+wuff/dialect/Field.cpp
+wuff/dialect/Field.h
+wuff/dialect/IDescribable.h
+wuff/dialect/InnerEnvironment.cpp
+wuff/dialect/InnerEnvironment.h
+wuff/dialect/MetaBlock.cpp
+wuff/dialect/MetaBlock.h
+wuff/dialect/OuterEnvironment.cpp
+wuff/dialect/OuterEnvironment.h
+wuff/dialect/Reference.cpp
+wuff/dialect/Reference.h
+wuff/dialect/Shorthand.cpp
+wuff/dialect/Shorthand.h
+wuff/dialect/Wobject.cpp
+wuff/dialect/Wobject.h
+wuff/document/CommentLine.cpp
+wuff/document/CommentLine.h
+wuff/document/DialectedWooWooDocument.cpp
+wuff/document/DialectedWooWooDocument.h
+wuff/document/MetaContext.cpp
+wuff/document/MetaContext.h
+wuff/document/UTF8toUTF16Mapping.cpp
+wuff/document/UTF8toUTF16Mapping.h
+wuff/document/WooWooDocument.cpp
+wuff/document/WooWooDocument.h
+wuff/lsp/LSPTypes.h
+wuff/parser/Parser.cpp
+wuff/parser/Parser.h
+wuff/tree-sitter/woowoo/parser.c
+wuff/tree-sitter/woowoo/scanner.cc
+wuff/tree-sitter/woowoo/tree_sitter/parser.h
+wuff/tree-sitter/yaml/parser.c
+wuff/tree-sitter/yaml/scanner.cc
+wuff/tree-sitter/yaml/schema.generated.cc
+wuff/tree-sitter/yaml/tree_sitter/parser.h
+wuff/utils/utils.cpp
+wuff/utils/utils.h

{Wuff-0.0.2 → Wuff-0.0.3}/setup.py

@@ -132,7 +132,7 @@ with open(path.join(this_directory, 'wuff/README.md'), encoding='utf-8') as f:
 # logic and declaration, and simpler if you include description/version in a file.
 setup(
     name="Wuff",
-    version="0.0.2",
+    version="0.0.3",
     author="Michal Janecek",
     author_email="michal.janecek@gmail.com",
     description="Analyzer tools for WooWoo projects",

Wuff-0.0.3/wuff/Bindings.cpp

@@ -0,0 +1,121 @@
+//
+// Created by Michal Janecek on 27.01.2024.
+//
+
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "WooWooAnalyzer.h"
+#include "lsp/LSPTypes.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(Wuff, m) {
+    py::class_<WooWooAnalyzer>(m, "WooWooAnalyzer")
+            .def(py::init<>())
+            .def("set_dialect", &WooWooAnalyzer::setDialect)
+            .def("load_workspace", &WooWooAnalyzer::loadWorkspace)
+            .def("hover", &WooWooAnalyzer::hover)
+            .def("semantic_tokens", &WooWooAnalyzer::semanticTokens)
+            .def("go_to_definition", &WooWooAnalyzer::goToDefinition)
+            .def("complete", &WooWooAnalyzer::complete)
+            .def("folding_ranges", &WooWooAnalyzer::foldingRanges)
+            .def("document_did_change", &WooWooAnalyzer::documentDidChange)
+            .def("open_document", &WooWooAnalyzer::openDocument)
+            .def("rename_document", &WooWooAnalyzer::renameDocument)
+            .def("diagnose", &WooWooAnalyzer::diagnose)
+            .def("set_token_types", &WooWooAnalyzer::setTokenTypes)
+            .def("set_token_modifiers", &WooWooAnalyzer::setTokenModifiers);
+
+
+    py::class_<Position>(m, "Position")
+            .def(py::init<uint32_t, uint32_t>())
+            .def_readwrite("line", &Position::line)
+            .def_readwrite("character", &Position::character);
+
+    py::class_<Range>(m, "Range")
+            .def(py::init<Position, Position>())
+            .def_readwrite("start", &Range::start)
+            .def_readwrite("end", &Range::end);
+
+    py::class_<Location>(m, "Location")
+            .def(py::init<std::string, Range>())
+            .def_readwrite("uri", &Location::uri)
+            .def_readwrite("range", &Location::range);
+
+    py::enum_<CompletionTriggerKind>(m, "CompletionTriggerKind")
+            .value("Invoked", CompletionTriggerKind::Invoked)
+            .value("TriggerCharacter", CompletionTriggerKind::TriggerCharacter)
+            .value("TriggerForIncompleteCompletions", CompletionTriggerKind::TriggerForIncompleteCompletions)
+            .export_values();
+    
+
+    py::class_<TextDocumentIdentifier>(m, "TextDocumentIdentifier")
+            .def(py::init<const std::string&>())
+            .def_readwrite("uri", &TextDocumentIdentifier::uri);
+
+
+    py::class_<TextDocumentPositionParams>(m, "TextDocumentPositionParams")
+            .def(py::init<TextDocumentIdentifier, Position>())
+            .def_readwrite("text_document", &TextDocumentPositionParams::textDocument)
+            .def_readwrite("position", &TextDocumentPositionParams::position);
+
+    // just for clarity - internally, it is the same as TextDocumentPositionParams
+    py::class_<DefinitionParams, TextDocumentPositionParams>(m, "DefinitionParams")
+            .def(py::init<TextDocumentIdentifier, Position>());
+
+   
+
+    py::class_<CompletionContext>(m, "CompletionContext")
+            .def(py::init<CompletionTriggerKind, std::optional<std::string>>())
+            .def_readwrite("trigger_kind", &CompletionContext::triggerKind)
+            .def_readwrite("trigger_character", &CompletionContext::triggerCharacter);
+
+    py::class_<CompletionParams, TextDocumentPositionParams>(m, "CompletionParams")
+            .def(py::init<const TextDocumentIdentifier&, const Position&, std::optional<CompletionContext>>())
+            .def_readwrite("context", &CompletionParams::context);
+
+    py::enum_<CompletionItemKind>(m, "CompletionItemKind")
+            .value("Text", CompletionItemKind::Text)
+            .value("Snippet", CompletionItemKind::Snippet)
+                    // TODO: other possible values
+            .export_values();
+
+    py::enum_<InsertTextFormat>(m, "InsertTextFormat")
+            .value("PlainText", InsertTextFormat::PlainText)
+            .value("Snippet", InsertTextFormat::Snippet)
+            .export_values();
+
+    py::class_<CompletionItem>(m, "CompletionItem")
+            .def(py::init<std::string, std::optional<CompletionItemKind>,
+                         std::optional<InsertTextFormat>, std::optional<std::string>>(),
+                 py::arg("label"), py::arg("kind") = std::nullopt,
+                 py::arg("insertTextFormat") = std::nullopt, py::arg("insertText") = std::nullopt)
+            .def_readwrite("label", &CompletionItem::label)
+            .def_readwrite("kind", &CompletionItem::kind)
+            .def_readwrite("insertTextFormat", &CompletionItem::insertTextFormat)
+            .def_readwrite("insertText", &CompletionItem::insertText);
+
+    py::enum_<DiagnosticSeverity>(m, "DiagnosticSeverity")
+            .value("Error", DiagnosticSeverity::Error)
+            .value("Warning", DiagnosticSeverity::Warning)
+            .value("Information", DiagnosticSeverity::Information)
+            .value("Hint", DiagnosticSeverity::Hint)
+            .export_values();
+
+    py::class_<Diagnostic>(m, "Diagnostic")
+            .def(py::init<Range, std::string, std::string, DiagnosticSeverity>())
+            .def_readwrite("range", &Diagnostic::range)
+            .def_readwrite("message", &Diagnostic::message)
+            .def_readwrite("source", &Diagnostic::source)
+            .def_readwrite("severity", &Diagnostic::severity);
+    
+    py::class_<FoldingRange>(m, "FoldingRange")
+            .def_readwrite("start_line", &FoldingRange::startLine)
+            .def_readwrite("start_character", &FoldingRange::startCharacter)
+            .def_readwrite("end_line", &FoldingRange::endLine)
+            .def_readwrite("end_character", &FoldingRange::endCharacter)
+            .def_readwrite("kind", &FoldingRange::foldingRangeKind);
+
+}
+

Wuff-0.0.3/wuff/CMakeLists.txt

@@ -0,0 +1,133 @@
+cmake_minimum_required(VERSION 3.10)
+project(Wuff)
+
+set(CMAKE_CXX_STANDARD 20)
+
+# - - - YAML-CPP
+include(FetchContent)
+
+FetchContent_Declare(
+        yaml-cpp
+        GIT_REPOSITORY https://github.com/jbeder/yaml-cpp.git
+        GIT_TAG master # Can be a tag (yaml-cpp-x.x.x), a commit hash, or a branch name (master)
+)
+FetchContent_GetProperties(yaml-cpp)
+
+if (NOT yaml-cpp_POPULATED)
+    message(STATUS "Fetching yaml-cpp...")
+    FetchContent_Populate(yaml-cpp)
+    add_subdirectory(${yaml-cpp_SOURCE_DIR} ${yaml-cpp_BINARY_DIR})
+endif ()
+
+# - - - Tree-sitter
+FetchContent_Declare(
+        tree_sitter
+        GIT_REPOSITORY https://github.com/tree-sitter/tree-sitter.git
+        GIT_TAG master
+)
+FetchContent_GetProperties(tree_sitter)
+
+if (NOT tree_sitter_POPULATED)
+    message(STATUS "Fetching tree-sitter...")
+    FetchContent_Populate(tree_sitter)
+    # Since Tree-sitter does not use CMake, we manually add its source and include directories
+    set(TREE_SITTER_SRC ${tree_sitter_SOURCE_DIR}/lib/src/lib.c)
+    set(TREE_SITTER_INCLUDE_DIRS ${tree_sitter_SOURCE_DIR}/lib/include ${tree_sitter_SOURCE_DIR}/lib/src ${tree_sitter_SOURCE_DIR}/lib/src/unicode)
+    message(STATUS "Include directories: ${TREE_SITTER_INCLUDE_DIRS}")
+endif ()
+
+# Tree-Sitter WooWoo
+set(WOOWOO_PARSER_SRC ${CMAKE_CURRENT_SOURCE_DIR}/tree-sitter/woowoo/parser.c)
+set(WOOWOO_SCANNER_SRC ${CMAKE_CURRENT_SOURCE_DIR}/tree-sitter/woowoo/scanner.cc)
+
+# Tree-Sitter YAML
+set(YAML_PARSER_SRC ${CMAKE_CURRENT_SOURCE_DIR}/tree-sitter/yaml/parser.c)
+set(YAML_SCANNER_SRC ${CMAKE_CURRENT_SOURCE_DIR}/tree-sitter/yaml/scanner.cc)
+
+# - - - - -
+
+FetchContent_Declare(
+        pybind11
+        GIT_REPOSITORY https://github.com/pybind/pybind11.git
+        GIT_TAG v2.11.1
+)
+
+# Make pybind11 available for use
+FetchContent_MakeAvailable(pybind11)
+set(PYBIND11_PYTHON_VERSION "3.9")
+pybind11_add_module(${PROJECT_NAME}
+        ${TREE_SITTER_SRC} # Add Tree-sitter lib.c source
+        ${WOOWOO_PARSER_SRC}
+        ${WOOWOO_SCANNER_SRC}
+        ${YAML_PARSER_SRC}
+        ${YAML_SCANNER_SRC}
+        Bindings.cpp
+        WooWooAnalyzer.cpp
+        document/WooWooDocument.cpp
+        document/DialectedWooWooDocument.cpp
+        document/MetaContext.cpp
+        document/CommentLine.cpp
+        document/UTF8toUTF16Mapping.cpp
+        dialect/DialectManager.cpp
+        dialect/DocumentPart.cpp
+        dialect/Dialect.cpp
+        dialect/MetaBlock.cpp
+        dialect/Field.cpp
+        dialect/Shorthand.cpp
+        dialect/Reference.cpp
+        dialect/InnerEnvironment.cpp
+        dialect/OuterEnvironment.cpp
+        dialect/Wobject.cpp
+        components/Component.cpp
+        components/Hoverer.cpp
+        components/Highlighter.cpp
+        components/Navigator.cpp
+        components/Completer.cpp
+        components/Linter.cpp
+        components/Folder.cpp
+        parser/Parser.cpp
+        utils/utils.cpp
+)
+target_include_directories(${PROJECT_NAME} SYSTEM PRIVATE ${TREE_SITTER_INCLUDE_DIRS})
+target_link_libraries(${PROJECT_NAME} PUBLIC yaml-cpp::yaml-cpp)
+
+target_compile_definitions(${PROJECT_NAME} PRIVATE VERSION_INFO=${EXAMPLE_VERSION_INFO})
+
+# - - - WooWooTest
+if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp")
+    add_executable(WooWooTest
+            ${TREE_SITTER_SRC}
+            ${WOOWOO_PARSER_SRC}
+            ${WOOWOO_SCANNER_SRC}
+            ${YAML_PARSER_SRC}
+            ${YAML_SCANNER_SRC}
+            main.cpp
+            WooWooAnalyzer.cpp
+            document/WooWooDocument.cpp
+            document/DialectedWooWooDocument.cpp
+            document/MetaContext.cpp
+            document/CommentLine.cpp
+            document/UTF8toUTF16Mapping.cpp
+            dialect/DialectManager.cpp
+            dialect/DocumentPart.cpp
+            dialect/Dialect.cpp
+            dialect/MetaBlock.cpp
+            dialect/Field.cpp
+            dialect/Shorthand.cpp
+            dialect/Reference.cpp
+            dialect/InnerEnvironment.cpp
+            dialect/OuterEnvironment.cpp
+            dialect/Wobject.cpp
+            components/Component.cpp
+            components/Hoverer.cpp
+            components/Highlighter.cpp
+            components/Navigator.cpp
+            components/Completer.cpp
+            components/Linter.cpp
+            components/Folder.cpp
+            parser/Parser.cpp
+            utils/utils.cpp
+    )
+    target_include_directories(WooWooTest SYSTEM PRIVATE ${TREE_SITTER_INCLUDE_DIRS})
+    target_link_libraries(WooWooTest PUBLIC yaml-cpp::yaml-cpp pybind11::embed)
+endif ()

Wuff-0.0.3/wuff/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Martín D. Maas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Wuff-0.0.3/wuff/README.md

@@ -0,0 +1,3 @@
+# Wuff
+
+This is the analyzer for WooWoo projects. It can be used for example within a Language Server to provide analysis.

Wuff-0.0.3/wuff/WooWooAnalyzer.cpp

@@ -0,0 +1,225 @@
+//
+// Created by Michal Janecek on 27.01.2024.
+//
+
+//#include <pybind11/pybind11.h>
+#include <filesystem>
+#include <string>
+#include <utility>
+
+#include "WooWooAnalyzer.h"
+#include "dialect/DialectManager.h"
+#include "document/DialectedWooWooDocument.h"
+
+#include "components/Hoverer.h"
+#include "components/Highlighter.h"
+#include "components/Navigator.h"
+#include "components/Completer.h"
+#include "components/Linter.h"
+#include "components/Folder.h"
+
+#include "utils/utils.h"
+
+WooWooAnalyzer::WooWooAnalyzer() : dialectManager(nullptr) {
+    parser = new Parser();
+    highlighter = new Highlighter(this);
+    hoverer = new Hoverer(this);
+    navigator = new Navigator(this);
+    completer = new Completer(this);
+    linter = new Linter(this);
+    folder = new Folder(this);
+}
+
+WooWooAnalyzer::~WooWooAnalyzer() {
+    delete parser;
+    delete hoverer;
+
+    for (auto &project: projects) {
+        for (auto &docPair: project.second) {
+            delete docPair.second;
+        }
+    }
+}
+
+void WooWooAnalyzer::setDialect(const std::string &dialectPath) {
+    dialectManager = new DialectManager(dialectPath);
+}
+
+bool WooWooAnalyzer::loadWorkspace(const std::string &workspaceUri) {
+    fs::path rootPath = utils::uriToPathString(workspaceUri);
+    auto projectFolders = findProjectFolders(rootPath);
+
+    for (const fs::path &projectFolderPath: projectFolders) {
+        for (const auto &entry: fs::recursive_directory_iterator(projectFolderPath)) {
+            if (entry.is_regular_file() && entry.path().extension() == ".woo") {
+                loadDocument(projectFolderPath, entry.path());
+            }
+        }
+    }
+
+    // now find and load all .woo files without a project
+    auto wooFiles = findAllWooFiles(rootPath);
+
+    for (auto &wooFile: wooFiles) {
+        if (!docToProject.contains(wooFile.string())) {
+            loadDocument("", wooFile);
+        }
+    }
+
+    return true;
+}
+
+std::vector<fs::path> WooWooAnalyzer::findAllWooFiles(const fs::path &rootPath) {
+    std::vector<fs::path> wooFiles;
+
+    if (fs::exists(rootPath) && fs::is_directory(rootPath)) {
+        for (const auto &entry: fs::recursive_directory_iterator(rootPath)) {
+            if (entry.is_regular_file() && entry.path().extension() == ".woo") {
+                wooFiles.push_back(entry.path());
+            }
+        }
+    }
+
+    return wooFiles;
+}
+
+std::vector<fs::path> WooWooAnalyzer::findProjectFolders(const fs::path &rootPath) {
+
+    std::vector<fs::path> projectFolders;
+    for (const auto &entry: fs::recursive_directory_iterator(rootPath)) {
+        if (entry.is_regular_file() && entry.path().filename() == "Woofile") {
+            projectFolders.push_back(entry.path().parent_path());
+        }
+    }
+    return projectFolders;
+}
+
+std::optional<fs::path> WooWooAnalyzer::findProjectFolder(const std::string &uri) {
+    fs::path path = utils::uriToPathString(uri);
+    // Start from the given URI and move up the directory hierarchy
+    for (fs::path parent = path.parent_path(); parent!=parent.parent_path(); parent = parent.parent_path()) {
+        fs::path woofilePath = parent / "Woofile";
+
+        // Check if "Woofile" exists in this directory
+        if (fs::exists(woofilePath)) {
+            return parent; // Return the first parent directory containing "Woofile"
+        }
+        
+    }
+
+    return std::nullopt; // Return an empty optional if no project folder is found
+}
+
+void WooWooAnalyzer::loadDocument(const fs::path &projectPath, const fs::path &documentPath) {
+    projects[projectPath.generic_string()][documentPath.generic_string()] = new DialectedWooWooDocument(documentPath, parser, dialectManager);
+    docToProject[documentPath.generic_string()] = projectPath.generic_string();
+}
+
+DialectedWooWooDocument *WooWooAnalyzer::getDocumentByUri(const std::string &docUri) {
+    auto path = utils::uriToPathString(docUri);
+    return getDocument(path);
+}
+
+DialectedWooWooDocument *WooWooAnalyzer::getDocument(const std::string &pathToDoc) {
+    return projects[docToProject[pathToDoc]][pathToDoc];
+}
+
+std::vector<DialectedWooWooDocument *> WooWooAnalyzer::getDocumentsFromTheSameProject(WooWooDocument *document) {
+    std::vector<DialectedWooWooDocument *> documents;
+    auto project = docToProject[document->documentPath.generic_string()];
+    if (projects.find(project) != projects.end()) {
+        std::unordered_map<std::string, DialectedWooWooDocument *> &pathDocMap = projects[project];
+
+        for (const auto &pair: pathDocMap) {
+            documents.emplace_back(pair.second);
+        }
+    } else {
+        std::cerr << "Project with path '" << project << "' not found in projects map." << std::endl;
+    }
+    return documents;
+}
+
+void WooWooAnalyzer::handleDocumentChange(const TextDocumentIdentifier &tdi, std::string &source) {
+    auto docPath = utils::uriToPathString(tdi.uri);
+    auto document = getDocument(docPath);
+    document->updateSource(source);
+}
+
+void WooWooAnalyzer::renameDocument(const std::string &oldUri, const std::string &newUri) {
+
+    auto oldPath = utils::uriToPathString(oldUri);
+    auto newPath = utils::uriToPathString(newUri);
+
+    if (endsWith(newUri, ".woo")) {
+        std::optional<fs::path> newProjectFolder = findProjectFolder(newUri);
+        std::string oldProjectFolder = docToProject[oldPath];
+        std::string newProjectFolderPathString = newProjectFolder.has_value() ? newProjectFolder.value().generic_string() : "";
+        
+        docToProject[newPath] = newProjectFolderPathString;
+        docToProject.erase(oldPath);
+        projects[newProjectFolderPathString][newPath] = projects[oldProjectFolder][oldPath];
+        projects[oldProjectFolder].erase(oldPath);
+        projects[newProjectFolderPathString][newPath]->documentPath = fs::path(newPath);
+
+    } else {
+        // the file is no longer a WooWoo document
+        // TODO: Delete it.
+    }
+
+}
+
+
+
+bool WooWooAnalyzer::endsWith(const std::string &str, const std::string &suffix) {
+    if (str.length() >= suffix.length()) {
+        return (str.rfind(suffix) == (str.length() - suffix.length()));
+    } else {
+        return false;
+    }
+}
+
+// - LSP-like public interface - - -
+
+std::string WooWooAnalyzer::hover(const std::string &docUri, int line, int character) {
+    return hoverer->hover(docUri, line, character);
+}
+
+std::vector<int> WooWooAnalyzer::semanticTokens(const std::string &docUri) {
+    return highlighter->semanticTokens(docUri);
+}
+
+Location WooWooAnalyzer::goToDefinition(const DefinitionParams& params) {
+    return navigator->goToDefinition(params);
+}
+
+std::vector<CompletionItem> WooWooAnalyzer::complete(const CompletionParams &params) {
+    return completer->complete(params);
+}
+
+std::vector<FoldingRange> WooWooAnalyzer::foldingRanges(const TextDocumentIdentifier &tdi) {
+    return folder->foldingRanges(tdi);
+}
+
+void WooWooAnalyzer::documentDidChange(const TextDocumentIdentifier &tdi, std::string &source) {
+    handleDocumentChange(tdi, source);
+}
+
+std::vector<Diagnostic> WooWooAnalyzer::diagnose(const TextDocumentIdentifier &tdi) {
+    return linter->diagnose(tdi);
+}
+
+void WooWooAnalyzer::openDocument(const TextDocumentIdentifier &tdi) {
+    auto docPath = utils::uriToPathString(tdi.uri);
+    if (!docToProject.contains(docPath)) {
+        // unknown document opened
+        std::optional<fs::path> projectFolder = findProjectFolder(tdi.uri);
+        std::string projectFolderPathString = projectFolder.has_value() ? projectFolder.value().generic_string() : "";
+        loadDocument(projectFolderPathString, docPath);
+    }
+}
+
+
+void WooWooAnalyzer::setTokenTypes(std::vector<std::string> tokenTypes) { return highlighter->setTokenTypes(std::move(tokenTypes)); }
+void WooWooAnalyzer::setTokenModifiers (std::vector<std::string> tokenModifiers) { return highlighter->setTokenModifiers(std::move(tokenModifiers)); }
+
+// - - - - - - - - - - - - - - - - -