Change: Separate path functions from utils and main function from luaumb

- Renamed from .h -> .hpp
- Moved path functions from utils to path.hpp
- Moved main function out of luaumb (this commit only moves the code), future plans include handling errors/results via return functions and making luaumb usable through the header.
- Added version submodule to display in --help
- Updated readme

Author: noonomyen

CMakeLists.txt

@@ -8,7 +8,16 @@ add_subdirectory(submodules/luau)
 
 include_directories(submodules/base64/include)
 
-add_executable(luaumb src/luaumb.cpp src/localizer.cpp src/bundle.cpp src/utils.cpp)
+add_executable(
+    luaumb
+
+    src/main.cpp
+    src/path.cpp
+    src/luaumb.cpp
+    src/localizer.cpp
+    src/bundle.cpp
+    src/utils.cpp
+)
 
 if (MSVC)
     target_compile_options(luaumb PRIVATE /W4)

README.md

@@ -14,7 +14,7 @@ cmake .. && cmake --build . -j $(nproc)
 ## Usage
 
 ```txt
-Luau module bundle - v0.1
+Luau module bundle - 0.1-dev luau:0.658-release base64:387b32f-checkout
   luaumb [main.luau] [out.luau]
 ```
 
@@ -24,7 +24,6 @@ Luau module bundle - v0.1
 mkdir -p tmp
 ./luaumb ./example/main.luau ./tmp/out.luau
 
-Modules and dependencies
 Modules and dependencies
   /lib/count.luau
   /lib/print.luau

src/bundle.cpp

@@ -1,4 +1,4 @@
-#include "bundle.h"
+#include "bundle.hpp"
 
 #include <sstream>
 #include <queue>

src/bundle.h renamed to src/bundle.hpp

@@ -6,8 +6,9 @@
 #include <map>
 #include <filesystem>
 
-#include "localizer.h"
-#include "utils.h"
+#include "path.hpp"
+#include "localizer.hpp"
+#include "utils.hpp"
 
 struct ModuleFile {
     std::string name;

src/localizer.cpp

@@ -1,4 +1,4 @@
-#include "localizer.h"
+#include "localizer.hpp"
 
 #include <string>
 #include <sstream>
@@ -25,12 +25,6 @@ Location::operator std::string() const {
     return ss.str();
 }
 
-void luau_fvalue_init() {
-    for (Luau::FValue<bool>* flag = Luau::FValue<bool>::list; flag; flag = flag->next) {
-        if (strncmp(flag->name, "Luau", 4) == 0) flag->value = true;
-    }
-}
-
 struct FindRequireConstantString : public Luau::AstVisitor {
     std::vector<ExprCallRequire> list;
 

src/localizer.h renamed to src/localizer.hpp

@@ -7,7 +7,7 @@
 #include "Luau/Location.h"
 #include "Luau/ParseResult.h"
 
-#include "utils.h"
+#include "utils.hpp"
 
 struct Location {
     unsigned int begin_line, begin_column, end_line, end_column;
@@ -27,7 +27,6 @@ struct RequireFunctionLocalizerResult {
     std::vector<ExprCallRequire> list;
 };
 
-void luau_fvalue_init();
 RequireFunctionLocalizerResult require_function_localizer(const std::string& source);
 
 #endif /* LUAUMB_LOCALIZER_H */

src/luaumb.cpp

@@ -8,33 +8,34 @@
 #include <optional>
 #include <fstream>
 
-#include "Luau/ToString.h"
 #include "Luau/FileUtils.h"
 #include "Luau/Config.h"
 
-#include "localizer.h"
-#include "bundle.h"
-#include "utils.h"
+#include "luaumb.hpp"
+#include "path.hpp"
+#include "localizer.hpp"
+#include "bundle.hpp"
+#include "utils.hpp"
 
-#ifndef LUAUMB_VERSION
-#define LUAUMB_VERSION "0.1"
-#endif
+bool fvalue_inited = false;
 
-int main(int argc, char** argv) {
-    luau_fvalue_init();
-
-    if ((argc < 3) || (argc >= 3 && strcmp(argv[1], "--help") == 0)) {
-        std::cout << "Luau module bundle - v" << LUAUMB_VERSION << std::endl;
-        std::cout << "  luaumb [main.luau] [out.luau]" << std::endl;
-        return 0;
+void luau_fvalue_init() {
+    for (Luau::FValue<bool>* flag = Luau::FValue<bool>::list; flag; flag = flag->next) {
+        if (strncmp(flag->name, "Luau", 4) == 0) flag->value = true;
     }
+}
 
-    const char* in_name = argv[1];
-    const char* out_name = argv[2];
+// TODO: handle error/result by returning it instead of outputting it to stdout.
+
+void luaumb::bundle(const std::string& main_file, const std::string& out_file) {
+    if (!fvalue_inited) {
+        luau_fvalue_init();
+        fvalue_inited = true;
+    }
 
     std::map<const std::string, std::vector<Luau::ParseError>> parse_errors;
     std::map<std::string, Luau::Config> configs;
-    RelativePathModule main_path(in_name);
+    RelativePathModule main_path(main_file);
     LuauModuleBundle lmb(main_path);
     std::queue<RelativePathModule> q;
     q.push(main_path);
@@ -49,7 +50,7 @@ int main(int argc, char** argv) {
 
         if (!file) {
             std::cout << "Couldn't read source " << module_path.path << std::endl;
-            return 1;
+            return; // TODO: Return error
         }
 
         std::filesystem::path relative_path = module_path.relative.parent_path();
@@ -134,13 +135,11 @@ int main(int argc, char** argv) {
     }
 
     const std::string out = lmb.build();
-    std::ofstream out_file(out_name);
-    if (!out_file) {
-        std::cout << "Couldn't open output file " << out_name << std::endl;
-        return 1;
+    std::ofstream out_fs(out_file);
+    if (!out_fs) {
+        std::cout << "Couldn't open output file " << out_file << std::endl;
+        return; // TODO: Return error
     }
-    out_file << out;
-    out_file.close();
-
-    return parse_errors.size() > 0 ? 1 : 0;
+    out_fs << out;
+    out_fs.close();
 }

src/luaumb.hpp

@@ -0,0 +1,28 @@
+#ifndef LUAUMB_H
+#define LUAUMB_H
+
+#include <string>
+
+#ifndef LUAUMB_VERSION
+#define LUAUMB_VERSION "0.1-dev"
+#endif
+
+#ifndef LUAUMB_LUAU_VERSION
+#define LUAUMB_LUAU_VERSION "0.658-release"
+#endif
+
+#ifndef LUAUMB_LIB_BASE64_VERSION
+#define LUAUMB_LIB_BASE64_VERSION "387b32f-checkout"
+#endif
+
+namespace luaumb {
+    const struct {
+        const std::string luaumb = LUAUMB_VERSION;
+        const std::string luau = LUAUMB_LUAU_VERSION;
+        const std::string base64 = LUAUMB_LIB_BASE64_VERSION;
+    } version;
+
+    void bundle(const std::string& main_file, const std::string& out_file);
+}
+
+#endif /* LUAUMB_H */

src/main.cpp

@@ -0,0 +1,21 @@
+#include <iostream>
+#include <string>
+#include <cstring>
+
+#include "luaumb.hpp"
+
+int main(int argc, char** argv) {
+    if ((argc < 3) || (argc >= 3 && strcmp(argv[1], "--help") == 0)) {
+        std::cout << "Luau module bundle - " << luaumb::version.luaumb << " luau:" << luaumb::version.luau << " base64:" << luaumb::version.base64 << std::endl;
+        std::cout << "  luaumb [main.luau] [out.luau]" << std::endl;
+
+        return 0;
+    }
+
+    const std::string in_file = argv[1];
+    const std::string out_file = argv[2];
+
+    luaumb::bundle(in_file, out_file);
+
+    return 0;
+}

src/path.cpp

@@ -0,0 +1,53 @@
+#include "path.hpp"
+
+#include <array>
+
+using namespace std;
+
+namespace fs = filesystem;
+
+const std::array<const string, 4> module_suffixes = {".luau", ".lua", "/init.luau", "/init.lua"};
+
+RelativePathModule::RelativePathModule(const fs::path& root, const fs::path& relative, const fs::path& path) {
+    this->root = root;
+    this->relative = relative.is_absolute() ? relative : fs::path("/") / relative;
+    this->path = path;
+}
+
+RelativePathModule::RelativePathModule(const fs::path& main_path) {
+    this->path = main_path.lexically_normal();
+    fs::path root_relative("/");
+    root_relative += main_path.filename();
+    this->relative = root_relative;
+    this->root = main_path.parent_path();
+
+    if (!fs::exists(this->path)) {
+        throw runtime_error("Error main file not found\n  File: " + this->path.string());
+    }
+}
+
+RelativePathModule::operator string() const {
+    stringstream ss;
+    ss << "[ROOT:\"" << this->root.string() << "\" PATH:\"" << this->path.string() << "\" RELATIVE:\"" << this->relative.string() << "\"]";
+
+    return ss.str();
+}
+
+RelativePathModule relative_path_module(const RelativePathModule& parent_path, const fs::path& module_path) {
+    fs::path path = (parent_path.path.parent_path() / module_path).lexically_normal();
+
+    bool found = false;
+    for (string ext : module_suffixes) {
+        fs::path _path = path;
+        _path += ext;
+        if (fs::exists(_path)) {
+            found = true;
+            path = _path;
+            break;
+        }
+    }
+
+    if (!found) throw runtime_error("Error module file not found\n  Parent: " + string(parent_path) + "\n  File: " + path.string());
+
+    return RelativePathModule(parent_path.root, path.lexically_proximate(parent_path.root), path);
+}