add icon field to manifest (#14)

* add icon field to manifest

* run tests only during the build

Author: dlipicar

.github/workflows/ci.yml

@@ -9,24 +9,16 @@ on:
 jobs:
   build-and-test:
     runs-on: ubuntu-latest
-    
+
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
-    
+
     - name: Install Nix
       uses: cachix/install-nix-action@v27
       with:
         extra_nix_config: |
           experimental-features = nix-command flakes
-    
-    - name: Build with Nix
+
+    - name: Build and test
       run: nix build
-    
-    - name: Run core tests
-      run: |
-        export LGX_BINARY="$(pwd)/result/bin/lgx"
-        ./result/bin/lgx_tests
-    
-    - name: Run library tests
-      run: ./result/bin/lgx_lib_tests

README.md

@@ -133,18 +133,7 @@ The C API header will be at `./result/include/lgx.h`.
 
 #### Running Tests with Nix
 
-After building with `nix build '.'` or `nix build '.#all'`, run the tests:
-
-```bash
-# Run core tests (including CLI integration tests)
-export LGX_BINARY="$(pwd)/result/bin/lgx"
-./result/bin/lgx_tests
-
-# Run library API tests
-./result/bin/lgx_lib_tests
-```
-
-**Note:** The `LGX_BINARY` environment variable tells the CLI tests where to find the `lgx` binary. Without it, the CLI integration tests will be skipped (though all other tests will still run).
+Tests run automatically during `nix build`. The build will fail if any tests do not pass.
 
 **Note:** If you haven't enabled flakes, you'll need to add the experimental features flag:
 
@@ -212,13 +201,6 @@ This will create:
 ```bash
 mkdir build
 cd build
-cmake .. -DLGX_BUILD_TESTS=ON
-make -j$(nproc)
-```
-
-To also test the library:
-
-```bash
 cmake .. -DLGX_BUILD_TESTS=ON -DLGX_BUILD_SHARED=ON
 make -j$(nproc)
 ```
@@ -229,9 +211,3 @@ make -j$(nproc)
 cd build
 ctest --output-on-failure
 ```
-
-Or run the test executable directly:
-
-```bash
-./build/lgx_tests
-```

docs/project.md

@@ -234,6 +234,8 @@ The header file `src/lgx.h` is installed to `include/` when using `make install`
 - `lgx_set_version(pkg, version) → lgx_result_t` - Set package version
 - `lgx_get_description(pkg) → const char*` - Get package description (owned by library)
 - `lgx_set_description(pkg, description)` - Set package description
+- `lgx_get_icon(pkg) → const char*` - Get package icon path (owned by library)
+- `lgx_set_icon(pkg, icon)` - Set package icon path
 - `lgx_get_manifest_json(pkg) → const char*` - Get the full manifest as a JSON string (owned by library)
 
 **Memory Management:**
@@ -594,37 +596,13 @@ This builds:
 
 **Running Tests with CMake:**
 
-Tests are built using Google Test and can be run via CMake's CTest or directly:
+Tests are built using Google Test and can be run via CMake's CTest:
 
 ```bash
 cd build
 ctest --output-on-failure
 ```
 
-Or run test executables directly:
-
-```bash
-# Core tests (including CLI integration tests)
-./build/tests/lgx_tests
-
-# Library API tests (requires shared library build)
-./build/tests/lgx_lib_tests
-```
-
-**CLI Integration Tests:**
-
-The CLI tests (`test_cli.cpp`) require the `lgx` binary to be available. They will:
-1. Check for `LGX_BINARY` environment variable first
-2. Search common locations (build directory, parent directories)
-3. Skip if binary is not found
-
-To run CLI tests explicitly:
-
-```bash
-export LGX_BINARY="$(pwd)/build/lgx"
-./build/tests/lgx_tests
-```
-
 **Installation:**
 
 To install the built binaries and libraries system-wide:

docs/spec.md

@@ -63,6 +63,7 @@ The manifest is a UTF-8 encoded JSON file with the following required fields:
   "author": "Author Name",
   "type": "library",
   "category": "crypto",
+  "icon": "icon.png",
   "dependencies": ["dep1", "dep2"],
   "main": {
     "linux-amd64": "path/to/main.so",
@@ -82,6 +83,7 @@ The manifest is a UTF-8 encoded JSON file with the following required fields:
 | `author` | string | Author/maintainer name | Human metadata |
 | `type` | string | Package type classification | Classification |
 | `category` | string | Package category | Classification |
+| `icon` | string | Relative path to icon file bundled in the package | Display/branding |
 | `dependencies` | array | List of dependency strings | Runtime needs |
 | `main` | object | Map of variant name → relative path to entry point (e.g ) `"linux-amd64": "path/to/main.so"` means `linux-amd64/path/to/main.so` | Entry point resolution |
 
@@ -156,6 +158,7 @@ lgx create <name>
    - `author`: `""`
    - `type`: `""`
    - `category`: `""`
+   - `icon`: `""`
    - `dependencies`: `[]`
    - `main`: `{}`
 4. Create empty `variants/` directory

nix/all.nix

@@ -52,20 +52,6 @@ pkgs.stdenv.mkDerivation {
     mkdir -p $out/include
     cp ${src}/src/lgx.h $out/include/
     
-    # Install test executables
-    mkdir -p $out/bin
-    cp build/tests/lgx_tests $out/bin/
-    cp build/tests/lgx_lib_tests $out/bin/
-    
-    # Fix rpath for lgx_lib_tests to find the shared library
-    if [ -f $out/bin/lgx_lib_tests ]; then
-      if [[ "$OSTYPE" == "darwin"* ]]; then
-        install_name_tool -add_rpath $out/lib $out/bin/lgx_lib_tests
-      else
-        patchelf --set-rpath $out/lib:$(patchelf --print-rpath $out/bin/lgx_lib_tests) $out/bin/lgx_lib_tests
-      fi
-    fi
-    
     runHook postInstall
   '';
 

src/core/manifest.cpp

@@ -19,6 +19,7 @@ Manifest::Manifest()
     , author("")
     , type("")
     , category("")
+    , icon("")
 {
 }
 
@@ -70,7 +71,13 @@ std::optional<Manifest> Manifest::fromJson(const std::string& jsonStr) {
             return std::nullopt;
         }
         m.category = j["category"].get<std::string>();
-        
+
+        if (!j.contains("icon") || !j["icon"].is_string()) {
+            lastError_ = "Missing or invalid 'icon' field";
+            return std::nullopt;
+        }
+        m.icon = j["icon"].get<std::string>();
+
         if (!j.contains("dependencies") || !j["dependencies"].is_array()) {
             lastError_ = "Missing or invalid 'dependencies' field";
             return std::nullopt;
@@ -115,6 +122,7 @@ std::string Manifest::toJson() const {
     j["author"] = author;
     j["type"] = type;
     j["category"] = category;
+    j["icon"] = icon;
     j["dependencies"] = dependencies;
 
     // main as object with sorted keys

src/core/manifest.h

@@ -45,6 +45,7 @@ class Manifest {
     std::string author;
     std::string type;
     std::string category;
+    std::string icon;
     std::vector<std::string> dependencies;
 
     // Main mapping: variant -> relative path to entry point

src/core/package.cpp

@@ -30,6 +30,7 @@ Package::Result Package::create(
     pkg.manifest_.author = "";
     pkg.manifest_.type = "";
     pkg.manifest_.category = "";
+    pkg.manifest_.icon = "";
     pkg.manifest_.dependencies = {};
 
     // Create skeleton with manifest and variants directory

src/lgx.h

@@ -190,6 +190,22 @@ LGX_EXPORT const char* lgx_get_description(lgx_package_t pkg);
  */
 LGX_EXPORT void lgx_set_description(lgx_package_t pkg, const char* description);
 
+/**
+ * Get the package icon path from manifest.
+ *
+ * @param pkg Package handle
+ * @return Package icon path, owned by library (valid until package is freed)
+ */
+LGX_EXPORT const char* lgx_get_icon(lgx_package_t pkg);
+
+/**
+ * Set the package icon path in manifest.
+ *
+ * @param pkg Package handle
+ * @param icon New icon path string
+ */
+LGX_EXPORT void lgx_set_icon(lgx_package_t pkg, const char* icon);
+
 /**
  * Get the full manifest as a JSON string.
  *

src/lib.cpp

@@ -68,6 +68,7 @@ struct lgx_package_opaque {
     std::string name_cache;
     std::string version_cache;
     std::string description_cache;
+    std::string icon_cache;
     std::string manifest_json_cache;
 };
 
@@ -280,6 +281,27 @@ LGX_EXPORT void lgx_set_description(lgx_package_t pkg, const char* description)
     pkg->pkg->getManifest().description = description;
 }
 
+LGX_EXPORT const char* lgx_get_icon(lgx_package_t pkg) {
+    if (!pkg) {
+        set_error("Invalid argument: pkg cannot be NULL");
+        return nullptr;
+    }
+
+    clear_error();
+    pkg->icon_cache = pkg->pkg->getManifest().icon;
+    return pkg->icon_cache.c_str();
+}
+
+LGX_EXPORT void lgx_set_icon(lgx_package_t pkg, const char* icon) {
+    if (!pkg || !icon) {
+        set_error("Invalid arguments: pkg and icon cannot be NULL");
+        return;
+    }
+
+    clear_error();
+    pkg->pkg->getManifest().icon = icon;
+}
+
 LGX_EXPORT const char* lgx_get_manifest_json(lgx_package_t pkg) {
     if (!pkg) {
         set_error("Invalid argument: pkg cannot be NULL");