Wuff 0.0.2__tar.gz → 0.0.4__tar.gz

Wuff-0.0.4/MANIFEST.in

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

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: Wuff
-Version: 0.0.2
+Version: 0.0.4
 Summary: Analyzer tools for WooWoo projects
 Author: Michal Janecek
 Author-email: michal.janecek@gmail.com
-Requires-Python: >=3.9
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Provides-Extra: test
 Requires-Dist: pytest>=6.0; extra == "test"

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: Wuff
-Version: 0.0.2
+Version: 0.0.4
 Summary: Analyzer tools for WooWoo projects
 Author: Michal Janecek
 Author-email: michal.janecek@gmail.com
-Requires-Python: >=3.9
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Provides-Extra: test
 Requires-Dist: pytest>=6.0; extra == "test"

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

@@ -0,0 +1,71 @@
+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/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/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.4}/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.4",
     author="Michal Janecek",
     author_email="michal.janecek@gmail.com",
     description="Analyzer tools for WooWoo projects",
@@ -142,6 +142,6 @@ setup(
     cmdclass={"build_ext": CMakeBuild},
     zip_safe=False,
     extras_require={"test": ["pytest>=6.0"]},
-    python_requires=">=3.9", 
+    python_requires=">=3.7",
 )
 

Wuff-0.0.4/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.4/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.4/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.4/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)); }
+
+// - - - - - - - - - - - - - - - - -

Wuff-0.0.4/wuff/WooWooAnalyzer.h

@@ -0,0 +1,81 @@
+//
+// Created by Michal Janecek on 27.01.2024.
+//
+
+#ifndef WUFF_WOOWOOANALYZER_H
+#define WUFF_WOOWOOANALYZER_H
+
+
+#include <filesystem>
+#include <string>
+#include <unordered_map>
+#include <pybind11/pytypes.h>
+#include "document/DialectedWooWooDocument.h"
+#include "parser/Parser.h"
+#include "dialect/DialectManager.h"
+#include "lsp/LSPTypes.h"
+
+class Hoverer;
+class Highlighter;
+class Navigator;
+class Completer;
+class Linter;
+class Folder;
+
+
+namespace fs = std::filesystem;
+namespace py = pybind11;
+
+class WooWooAnalyzer {
+private:
+    std::unordered_map<std::string, std::unordered_map<std::string, DialectedWooWooDocument*>> projects;
+    std::unordered_map<std::string, std::string> docToProject;
+    Parser* parser;
+    Hoverer* hoverer;
+    Highlighter* highlighter;
+    Navigator * navigator;
+    Completer * completer;
+    Linter * linter;
+    Folder * folder;
+
+public:
+    WooWooAnalyzer();
+    ~WooWooAnalyzer(); 
+    void setDialect(const std::string& dialectPath);
+    bool loadWorkspace(const std::string& workspaceUri);
+    DialectedWooWooDocument * getDocumentByUri(const std::string & docUri);
+    DialectedWooWooDocument * getDocument(const std::string& pathToDoc);
+    DialectManager* dialectManager;
+    
+    std::vector<DialectedWooWooDocument *> getDocumentsFromTheSameProject(WooWooDocument * document);
+    
+    // LSP-like functionalities
+    std::string hover(const std::string& docUri, int line, int character);
+    std::vector<int> semanticTokens(const std::string& docUri);
+    Location goToDefinition(const DefinitionParams& params);
+    std::vector<CompletionItem> complete(const CompletionParams & params);
+    std::vector<Diagnostic> diagnose(const TextDocumentIdentifier & tdi); 
+    std::vector<FoldingRange> foldingRanges(const TextDocumentIdentifier & tdi);
+    
+    // LSP support functions
+
+    void setTokenTypes(std::vector<std::string> tokenTypes);
+    void setTokenModifiers (std::vector<std::string> tokenModifiers);
+    void documentDidChange(const TextDocumentIdentifier & tdi, std::string &source);
+    void renameDocument(const std::string & oldUri, const std::string & newUri);
+    void openDocument(const TextDocumentIdentifier & tdi);
+    
+private:
+
+    static std::vector<fs::path> findProjectFolders(const fs::path& rootPath);
+    static std::optional<fs::path> findProjectFolder(const std::string& uri);
+    
+    void loadDocument(const fs::path& projectPath, const fs::path& documentPath);
+    void handleDocumentChange(const TextDocumentIdentifier & tdi, std::string & source);
+    static bool endsWith(const std::string &str, const std::string &suffix) ;
+    static std::vector<fs::path> findAllWooFiles(const fs::path  & rootPath);
+};
+
+
+
+#endif //WUFF_WOOWOOANALYZER_H