Skip to content

Cross-platform CI/CD pipeline#6

Merged
mannie-exe merged 21 commits into
mainfrom
dev
Feb 24, 2026
Merged

Cross-platform CI/CD pipeline#6
mannie-exe merged 21 commits into
mainfrom
dev

Conversation

@mannie-exe
Copy link
Copy Markdown
Contributor

@mannie-exe mannie-exe commented Feb 24, 2026

Summary

Cross-platform CI/CD pipeline with full local development parity via mise tasks.

CI workflows (5):

  • ci.yml — 4-platform build matrix (Linux/Windows AMD64, Linux ARM64, macOS ARM64)
  • lint.yml — clang-format 21 + clang-tidy + cppcheck
  • sanitizers.yml — ASan+UBSan on PR, TSan nightly
  • coverage.yml — llvm-cov + Codecov upload
  • dependency-scan.yml — OSV-Scanner weekly

Local mise tasks (17):
build, build:release, clean, test, test:e2e, test:all, test:filter, format, format:fix, lint, lint:changed, lint:fix, cppcheck, sanitize, sanitize:tsan, coverage, codeql

Cross-platform fixes:

  • Linux: SDL3 build deps, GNU extensions for Quill, X11 macro pollution guards
  • Windows: near/far macro rename, SDL_main.h WinMain trampoline, DXBC/DXIL shader handling, FreeType FetchContent fallback
  • macOS: ObjC++ compilation for bgfx Vulkan/WebGPU renderers

Build system:

  • CMakePresets.json as single source of truth (local + CI)
  • LLVM 21 toolchain scoped per-project via mise [env]
  • ccache (Linux/macOS) + sccache (Windows) compiler caching
  • BGFX_AMALGAMATED, shallow FetchContent clones

Config: .clang-format (C++20), .clang-tidy, renovate.json

Dependency updates: Flecs 4.0.5→4.1.4, RmlUi 6.0→6.2, FreeType 2.13.3→2.14.1

6 GitHub Actions workflows:
- ci.yml: 5-platform matrix (Linux/Windows AMD64+ARM64, macOS ARM64)
- lint.yml: clang-format + clang-tidy + cppcheck
- sanitizers.yml: ASan+UBSan on PR, TSan nightly
- codeql.yml: CodeQL security-extended analysis
- coverage.yml: llvm-cov + Codecov upload
- dependency-scan.yml: OSV-Scanner weekly

Config files: .clang-format (C++20), .clang-tidy, renovate.json
CMake: FABRIC_USE_MIMALLOC option, sanitizer/coverage presets
@greptile-apps
Copy link
Copy Markdown

greptile-apps Bot commented Feb 24, 2026

Greptile Summary

Added comprehensive CI/CD infrastructure with 6 GitHub Actions workflows covering build matrix (5 platforms), code quality (lint, sanitizers, coverage), security (CodeQL, OSV-Scanner), and automated dependency updates (Renovate). Key change: FABRIC_USE_MIMALLOC option gates mimalloc to prevent conflicts with sanitizers.

  • Build Matrix: Linux/Windows/macOS on AMD64/ARM64 with sccache and FetchContent caching
  • Code Quality: clang-format, clang-tidy (advisory mode), cppcheck static analysis
  • Sanitizers: ASan+UBSan on PRs, TSan nightly with mimalloc disabled
  • Coverage: llvm-cov instrumentation with Codecov integration
  • Security: CodeQL security-extended queries, OSV-Scanner for dependency vulnerabilities
  • Config: .clang-format (C++20, 120 char), .clang-tidy (Fabric naming conventions), renovate.json (custom regex for CMake FetchContent)

Confidence Score: 5/5

  • This PR is safe to merge with minimal risk
  • Infrastructure-only changes adding CI/CD pipelines, linting config, and build presets. No logic changes to core codebase. The FABRIC_USE_MIMALLOC gating is properly implemented to prevent sanitizer conflicts. All workflows use established actions with pinned versions and appropriate permissions scopes.
  • No files require special attention

Important Files Changed

Filename Overview
.github/workflows/ci.yml Added comprehensive cross-platform build matrix (Linux/Windows/macOS, AMD64/ARM64) with caching and sccache
.github/workflows/lint.yml Added clang-format, clang-tidy, and cppcheck linting jobs with appropriate checks and suppressions
.github/workflows/sanitizers.yml Added ASan+UBSan on PRs and TSan nightly schedule with proper mimalloc gating
.github/workflows/coverage.yml Added llvm-cov based coverage reporting with Codecov integration, filtering out build artifacts and tests
CMakeLists.txt Added FABRIC_USE_MIMALLOC option to conditionally disable mimalloc for sanitizer/coverage builds
CMakePresets.json Added ci-sanitize, ci-tsan, ci-coverage presets with appropriate compiler flags and environment variables

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[Push/PR to main] --> B{Which workflow?}
    B -->|Code changes| C[CI: Build Matrix]
    B -->|Code changes| D[Lint: Format/Tidy/Cppcheck]
    B -->|Code changes| E[Sanitizers: ASan+UBSan]
    B -->|Code changes| F[Coverage: llvm-cov]
    B -->|Code/Schedule| G[CodeQL Security]
    B -->|CMake/Schedule| H[Dependency Scan]
    
    C --> C1[Linux AMD64/ARM64]
    C --> C2[Windows AMD64/ARM64]
    C --> C3[macOS ARM64]
    C1 --> C4[sccache + FetchContent cache]
    C2 --> C4
    C3 --> C4
    C4 --> C5[Build + Test]
    
    E --> E1{Event type?}
    E1 -->|PR| E2[ASan+UBSan]
    E1 -->|Nightly| E3[TSan]
    E2 --> E4[FABRIC_USE_MIMALLOC=OFF]
    E3 --> E4
    
    F --> F1[clang instrumentation]
    F1 --> F2[llvm-profdata merge]
    F2 --> F3[Codecov upload]
    
    H --> H1[Configure to populate _deps]
    H1 --> H2[OSV-Scanner]
Loading

Last reviewed commit: 44c0518

Linux: add full SDL3 build dependencies (libxss-dev, libasound2-dev,
libwayland-dev, etc.) to all workflow apt-get steps.

Windows: add FetchContent fallback for Freetype in FabricRmlUi.cmake
so RmlUi builds without system Freetype.

macOS: enable OBJCXX language and force ObjC++ compilation for bgfx
renderer_vk.cpp and renderer_webgpu.cpp (Xcode 26 SDK compatibility).
CI fixes:
- Enable GNU extensions (CMAKE_CXX_EXTENSIONS ON) for Quill's
  ##__VA_ARGS__ comma-eating on GCC
- Suppress DXBC/DXIL shader symbols on non-Windows platforms
  (bgfx embedded_shader.h enables them on Linux)
- Fix Windows shader ext naming: dx11 -> dxbc to match bgfx convention
- Strip sanitizer/coverage flags from bgfx subtree build to prevent
  glsl-optimizer UBSan crashes in shaderc
- Replace M_PI with std::numbers::pi_v<T> for MSVC compatibility

CI performance:
- Migrate Linux/macOS from sccache to ccache (avoids GHA 200
  uploads/min rate limit that caused ~81% cache write failures)
- Keep sccache for Windows (ccache doesn't support MSVC well)
- Enable BGFX_AMALGAMATED (reduces ~50 TUs to 1)
- Add GIT_SHALLOW TRUE to SDL3 and webview FetchContent
- Add FetchContent cache to CodeQL and dependency-scan workflows
- Add ccache to lint and CodeQL workflows

Dependency updates:
- Flecs v4.0.5 -> v4.1.4 (migrate get<T>() -> try_get<T>() for
  nullable access; use reference get<T>() for known-present)
- RmlUi 6.0 -> 6.2
- FreeType VER-2-13-3 -> VER-2-14-1
Linux: X11/X.h defines bare-word macros (Always, None, Never, Bool,
Status, Success, True, False) that replace Quill enum member names when
WebKitGTK headers are included before Log.hh. Add #undef guards before
Quill includes.

Windows: <windows.h> defines min/max macros that break
std::numeric_limits<T>::max() in Quill's Codec.h and RdtscClock.h.
Add NOMINMAX and WIN32_LEAN_AND_MEAN compile definitions.
- Reformat all src/ and include/ files to match .clang-format config
  (4-space indent, 120 column limit, Attach braces)
- Fix cppcheck stlFindInsert: use insert().second instead of
  find()+insert() in CoordinatedGraph.hh (3 locations)
- Fix cppcheck stlIfStrFind: use starts_with() instead of
  find() == 0 in SyntaxTree.cc (3 locations)
The previous fix in Log.hh only protected Quill includes, but any TU
that includes WebView.hh (which transitively brings in X11/X.h via
WebKitGTK) still had X11 macros polluting all subsequent headers.

Move the undef block to WebView.hh immediately after the webview.h
include so GoogleTest's struct None, Quill enums, and any other
downstream code get a clean namespace.
- ECSTest.cc: add #include <algorithm> for std::find (implicit on
  macOS via transitive includes, explicit required on Linux Clang)
- ThreadPoolExecutor.hh: reformat with clang-format 18 to match CI
  (v21 and v18 disagree on trailing return type line breaks)
embedded_shader.h expects vs_rmlui_dxil/fs_rmlui_dxil symbols when
BGFX_PLATFORM_SUPPORTS_DXIL is set (default on Windows), but we only
compile DXBC (SM 5.0) shaders. Suppress DXIL globally since we don't
compile SM 6.x shaders on any platform.
ctest needs LLVM_PROFILE_FILE to write profraw files with the expected
fabric-*.profraw pattern. Without it, Clang writes to default.profraw
in the working directory, and the merge step can't find the files.
MSVC defines `near` and `far` as empty macros (legacy x86 segmented
memory model), which silently deletes parameter names and produces
syntax errors. Use zNear/zFar following GLM/OpenGL convention.
WIN32_EXECUTABLE TRUE requires WinMain, but Fabric.cc defines main().
SDL3's SDL_main.h provides the WinMain→SDL_main trampoline, which is
the recommended approach for SDL3 GUI applications.
- Add explicit uint8_t base types to 11 small enums (performance-enum-size)
- NOLINT reinterpret_cast in Codec.hh (necessary for byte-level ops)
- NOLINTBEGIN/END for CMake-generated constants in Constants.g.hh
- Update .clang-tidy: add NamespaceIgnoredRegexp for Space/Utils/Test,
  ConstexprVariableCase UPPER_CASE, VariableIgnoredRegexp for ALL_CAPS

The 79 readability-identifier-naming warnings (private member suffix)
require a coordinated project-wide refactor and are deferred.
CodeQL analyze step needs actions:read to query workflow run metadata.
GitHub Advanced Security must be enabled for code scanning uploads on
private repositories. Since the repo is private and GHAS is not
available, the workflow wastes CI minutes without producing results.
Re-add when the repo goes public.
- Remove Windows ARM64 from CI matrix (slow, no Blacksmith runner)
- Re-add CodeQL workflow (repo is now public, GHAS available)
- Add mise tasks: format, format:fix, cppcheck, sanitize, sanitize:tsan, coverage
- Full local-CI parity: all CI checks reproducible locally via mise
- Fix clang-format violation in ThreadPoolExecutor.hh
- Return errorMsg by const ref in ArgumentParser.hh (cppcheck perf)
- Add lint:changed task for fast iteration on dirty files
- Scope lint:fix to changed files only (limits auto-fix blast radius)
- Suppress clang-tidy "N warnings generated" noise in output
Move CC/CXX/CPPFLAGS/LDFLAGS from global ~/.bash_env to project-scoped
mise.toml [env] section. Homebrew manages the LLVM install (macOS ABI
compatibility), mise scopes the environment per-project.

The GitHub-released LLVM binary has ABI incompatibilities with macOS
SDK's libc++, so Homebrew LLVM remains the correct choice on macOS.
Consistently exceeds 18+ minutes. Run locally if needed.
@github-advanced-security
Copy link
Copy Markdown

This pull request sets up GitHub code scanning for this repository. Once the scans have completed and the checks have passed, the analysis results for this pull request branch will appear on this overview. Once you merge this pull request, the 'Security' tab will show more code scanning analysis results (for example, for the default branch). Depending on your configuration and choice of analysis tool, future pull requests will be annotated with code scanning analysis results. For more information about GitHub code scanning, check out the documentation.

CodeQL CLI managed by mise (github:github/codeql-cli-binaries).
Task script creates database by observing build, runs cpp-code-scanning
suite, outputs SARIF with jq-powered summary.
CI was using clang-format 18 while local uses Homebrew LLVM 21.
Trailing return type formatting differs between versions, causing
false failures on ThreadPoolExecutor.hh.
- build.sh now uses CMakePresets instead of manual cmake flags,
  so preset changes propagate to local dev builds automatically
- Default build dir is build/dev-debug (matches preset binaryDir),
  fixing the split between build/ and build/<preset>/
- test.sh, lint.sh updated to match new default build dir
- coverage.yml: profdata and lcov now write to build/ci-coverage/
  (matching local coverage.sh paths)
- lint.yml: document clang-tidy config discovery behavior
@github-actions
Copy link
Copy Markdown

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy (v18.1.3) reports: 123 concern(s)
  • include/fabric/codec/Codec.hh:190:21: warning: [cppcoreguidelines-pro-type-reinterpret-cast]

    do not use reinterpret_cast

      190 |                     reinterpret_cast<const uint8_t*>(s.data() +
          |                     ^
  • include/fabric/core/Async.hh:41:19: warning: [readability-identifier-naming]

    invalid case style for global variable 'use_nothrow'

       41 | inline const auto use_nothrow = asio::as_tuple(asio::use_awaitable);
          |                   ^~~~~~~~~~~
          |                   g_use_nothrow
  • include/fabric/core/ChunkedGrid.hh:13:22: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kChunkSize'

       13 | inline constexpr int kChunkSize = 32;
          |                      ^~~~~~~~~~
          |                      K_CHUNK_SIZE
       14 | inline constexpr int kChunkShift = 5;
       15 | inline constexpr int kChunkMask = kChunkSize - 1;
          |                                   ~~~~~~~~~~
          |                                   K_CHUNK_SIZE
       16 | inline constexpr int kChunkVolume = kChunkSize * kChunkSize * kChunkSize;
          |                                     ~~~~~~~~~~   ~~~~~~~~~~   ~~~~~~~~~~
          |                                     K_CHUNK_SIZE K_CHUNK_SIZE K_CHUNK_SIZE
  • include/fabric/core/ChunkedGrid.hh:14:22: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kChunkShift'

       14 | inline constexpr int kChunkShift = 5;
          |                      ^~~~~~~~~~~
          |                      K_CHUNK_SHIFT
       15 | inline constexpr int kChunkMask = kChunkSize - 1;
       16 | inline constexpr int kChunkVolume = kChunkSize * kChunkSize * kChunkSize;
       17 | 
       18 | template <typename T> class ChunkedGrid {
       19 |   public:
       20 |     // C++20 arithmetic right shift gives floor division for power-of-2
       21 |     static void worldToChunk(int wx, int wy, int wz, int& cx, int& cy, int& cz, int& lx, int& ly, int& lz) {
       22 |         cx = wx >> kChunkShift;
          |                    ~~~~~~~~~~~
          |                    K_CHUNK_SHIFT
       23 |         cy = wy >> kChunkShift;
          |                    ~~~~~~~~~~~
          |                    K_CHUNK_SHIFT
       24 |         cz = wz >> kChunkShift;
          |                    ~~~~~~~~~~~
          |                    K_CHUNK_SHIFT
  • include/fabric/core/ChunkedGrid.hh:15:22: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kChunkMask'

       15 | inline constexpr int kChunkMask = kChunkSize - 1;
          |                      ^~~~~~~~~~
          |                      K_CHUNK_MASK
       16 | inline constexpr int kChunkVolume = kChunkSize * kChunkSize * kChunkSize;
       17 | 
       18 | template <typename T> class ChunkedGrid {
       19 |   public:
       20 |     // C++20 arithmetic right shift gives floor division for power-of-2
       21 |     static void worldToChunk(int wx, int wy, int wz, int& cx, int& cy, int& cz, int& lx, int& ly, int& lz) {
       22 |         cx = wx >> kChunkShift;
       23 |         cy = wy >> kChunkShift;
       24 |         cz = wz >> kChunkShift;
       25 |         lx = wx & kChunkMask;
          |                   ~~~~~~~~~~
          |                   K_CHUNK_MASK
       26 |         ly = wy & kChunkMask;
          |                   ~~~~~~~~~~
          |                   K_CHUNK_MASK
       27 |         lz = wz & kChunkMask;
          |                   ~~~~~~~~~~
          |                   K_CHUNK_MASK
  • include/fabric/core/ChunkedGrid.hh:16:22: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kChunkVolume'

       16 | inline constexpr int kChunkVolume = kChunkSize * kChunkSize * kChunkSize;
          |                      ^~~~~~~~~~~~
          |                      K_CHUNK_VOLUME
  • include/fabric/core/Command.hh:109:27: warning: [performance-unnecessary-value-param]

    parameter 'descFunc' is passed by value and only copied once; consider moving it to avoid unnecessary copies

        8 |           descriptionFunc(descFunc),
          |                           ^       
          |                           std::move( )
  • include/fabric/core/Command.hh:148:17: warning: [readability-identifier-naming]

    invalid case style for private member 'executeFunc'

       90 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionFunc, reversible);
          |                                                                 ~~~~~~~~~~~
          |                                                                 executeFunc_
       91 |         } else {
       92 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionText, reversible);
          |                                                                 ~~~~~~~~~~~
          |                                                                 executeFunc_
       93 |         }
       94 |     }
       95 | 
       96 |   private:
       97 |     ExecuteFunc executeFunc;
          |                 ^~~~~~~~~~~
          |                 executeFunc_
  • include/fabric/core/Command.hh:149:15: warning: [readability-identifier-naming]

    invalid case style for private member 'beforeState'

       91 |     StateType beforeState;
          |               ^~~~~~~~~~~
          |               beforeState_
  • include/fabric/core/Command.hh:150:15: warning: [readability-identifier-naming]

    invalid case style for private member 'afterState'

       92 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionFunc, reversible);
          |                                                                              ~~~~~~~~~~
          |                                                                              afterState_
       93 |         } else {
       94 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionText, reversible);
          |                                                                              ~~~~~~~~~~
          |                                                                              afterState_
       95 |         }
       96 |     }
       97 | 
       98 |   private:
       99 |     ExecuteFunc executeFunc;
      100 |     StateType beforeState;
      101 |     StateType afterState;
          |               ^~~~~~~~~~
          |               afterState_
  • include/fabric/core/Command.hh:151:17: warning: [readability-identifier-naming]

    invalid case style for private member 'descriptionText'

       93 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionText, reversible);
          |                                                                                          ~~~~~~~~~~~~~~~
          |                                                                                          descriptionText_
       94 |         }
       95 |     }
       96 | 
       97 |   private:
       98 |     ExecuteFunc executeFunc;
       99 |     StateType beforeState;
      100 |     StateType afterState;
      101 |     std::string descriptionText;
          |                 ^~~~~~~~~~~~~~~
          |                 descriptionText_
  • include/fabric/core/Command.hh:152:21: warning: [readability-identifier-naming]

    invalid case style for private member 'descriptionFunc'

      109 |         if (descriptionFunc) {
          |             ~~~~~~~~~~~~~~~
          |             descriptionFunc_
      110 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionFunc, reversible);
          |                                                                                          ~~~~~~~~~~~~~~~
          |                                                                                          descriptionFunc_
      111 |         } else {
      112 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionText, reversible);
      113 |         }
      114 |     }
      115 | 
      116 |   private:
      117 |     ExecuteFunc executeFunc;
      118 |     StateType beforeState;
      119 |     StateType afterState;
      120 |     std::string descriptionText;
      121 |     DescriptionFunc descriptionFunc;
          |                     ^~~~~~~~~~~~~~~
          |                     descriptionFunc_
  • include/fabric/core/Command.hh:153:10: warning: [readability-identifier-naming]

    invalid case style for private member 'reversible'

       94 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionFunc, reversible);
          |                                                                                                           ~~~~~~~~~~
          |                                                                                                           reversible_
       95 |         } else {
       96 |             return std::make_unique<FunctionCommand<StateType>>(executeFunc, afterState, descriptionText, reversible);
          |                                                                                                           ~~~~~~~~~~
          |                                                                                                           reversible_
       97 |         }
       98 |     }
       99 | 
      100 |   private:
      101 |     ExecuteFunc executeFunc;
      102 |     StateType beforeState;
      103 |     StateType afterState;
      104 |     std::string descriptionText;
      105 |     DescriptionFunc descriptionFunc;
      106 |     bool reversible;
          |          ^~~~~~~~~~
          |          reversible_
  • include/fabric/core/Command.hh:226:43: warning: [readability-identifier-naming]

    invalid case style for private member 'commands'

      177 |         for (const auto& command : commands) {
          |                                    ~~~~~~~~
          |                                    commands_
      178 |             copy->addCommand(command->clone());
      179 |         }
      180 |         return copy;
      181 |     }
      182 | 
      183 |   private:
      184 |     std::vector<std::unique_ptr<Command>> commands;
          |                                           ^~~~~~~~
          |                                           commands_
  • include/fabric/core/Command.hh:227:17: warning: [readability-identifier-naming]

    invalid case style for private member 'descriptionText'

      170 |         auto copy = std::make_unique<CompositeCommand>(descriptionText);
          |                                                        ~~~~~~~~~~~~~~~
          |                                                        descriptionText_
      171 |         for (const auto& command : commands) {
      172 |             copy->addCommand(command->clone());
      173 |         }
      174 |         return copy;
      175 |     }
      176 | 
      177 |   private:
      178 |     std::vector<std::unique_ptr<Command>> commands;
      179 |     std::string descriptionText;
          |                 ^~~~~~~~~~~~~~~
          |                 descriptionText_
  • include/fabric/core/Command.hh:448:37: warning: [bugprone-narrowing-conversions]

    narrowing conversion from 'size_type' (aka 'unsigned long') to signed type 'int' is implementation-defined

      448 |                         commandId = undoStack.size() + 1;
          |                                     ^
  • include/fabric/core/Command.hh:467:42: warning: [readability-identifier-naming]

    invalid case style for private member 'undoStack'

      257 |     std::stack<std::unique_ptr<Command>> undoStack;
          |                                          ^~~~~~~~~
          |                                          undoStack_
  • include/fabric/core/Command.hh:468:42: warning: [readability-identifier-naming]

    invalid case style for private member 'redoStack'

      254 |                 redoStack.push(std::make_unique<FunctionCommand<int>>(
          |                 ~~~~~~~~~
          |                 redoStack_
      255 |                     [](int& state) {
      256 |                         // Empty implementation - the test will handle execution recording
      257 |                     },
      258 |                     commandId, description));
      259 |             }
      260 |         }
      261 | 
      262 |         // Successfully loaded if we found at least one command
      263 |         return !commandStrs.empty();
      264 |     }
      265 | 
      266 |   private:
      267 |     std::stack<std::unique_ptr<Command>> undoStack;
      268 |     std::stack<std::unique_ptr<Command>> redoStack;
          |                                          ^~~~~~~~~
          |                                          redoStack_
  • include/fabric/core/Component.hh:111:17: warning: [readability-identifier-naming]

    invalid case style for private member 'id'

      111 |     std::string id;
          |                 ^~
          |                 id_
  • include/fabric/core/Component.hh:112:24: warning: [readability-identifier-naming]

    invalid case style for private member 'propertiesMutex'

      112 |     mutable std::mutex propertiesMutex; // Mutex for thread-safe property access
          |                        ^~~~~~~~~~~~~~~
          |                        propertiesMutex_
  • include/fabric/core/Component.hh:113:52: warning: [readability-identifier-naming]

    invalid case style for private member 'properties'

      113 |     std::unordered_map<std::string, PropertyValue> properties;
          |                                                    ^~~~~~~~~~
          |                                                    properties_
  • include/fabric/core/Component.hh:115:24: warning: [readability-identifier-naming]

    invalid case style for private member 'childrenMutex'

      115 |     mutable std::mutex childrenMutex; // Mutex for thread-safe children access
          |                        ^~~~~~~~~~~~~
          |                        childrenMutex_
  • include/fabric/core/Component.hh:116:45: warning: [readability-identifier-naming]

    invalid case style for private member 'children'

      116 |     std::vector<std::shared_ptr<Component>> children;
          |                                             ^~~~~~~~
          |                                             children_
  • include/fabric/core/Event.hh:61:17: warning: [readability-identifier-naming]

    invalid case style for private member 'type'

       61 |     std::string type;
          |                 ^~~~
          |                 type_
  • include/fabric/core/Event.hh:62:17: warning: [readability-identifier-naming]

    invalid case style for private member 'source'

       62 |     std::string source;
          |                 ^~~~~~
          |                 source_
  • include/fabric/core/Event.hh:63:24: warning: [readability-identifier-naming]

    invalid case style for private member 'dataMutex'

       34 |     mutable std::mutex dataMutex;
          |                        ^~~~~~~~~
          |                        dataMutex_
  • include/fabric/core/Event.hh:64:48: warning: [readability-identifier-naming]

    invalid case style for private member 'data'

       64 |     std::unordered_map<std::string, DataValue> data;
          |                                                ^~~~
          |                                                data_
  • include/fabric/core/Event.hh:65:47: warning: [readability-identifier-naming]

    invalid case style for private member 'anyData'

       35 |     std::unordered_map<std::string, std::any> anyData;
          |                                               ^~~~~~~
          |                                               anyData_
  • include/fabric/core/Event.hh:66:23: warning: [readability-identifier-naming]

    invalid case style for private member 'handled'

       66 |     std::atomic<bool> handled{false};
          |                       ^~~~~~~
          |                       handled_
  • include/fabric/core/Event.hh:67:23: warning: [readability-identifier-naming]

    invalid case style for private member 'cancelled'

       67 |     std::atomic<bool> cancelled{false};
          |                       ^~~~~~~~~
          |                       cancelled_
  • include/fabric/core/Event.hh:90:24: warning: [readability-identifier-naming]

    invalid case style for private member 'listenersMutex'

       90 |     mutable std::mutex listenersMutex;
          |                        ^~~~~~~~~~~~~~
          |                        listenersMutex_
  • include/fabric/core/Event.hh:91:64: warning: [readability-identifier-naming]

    invalid case style for private member 'listeners'

       91 |     std::unordered_map<std::string, std::vector<HandlerEntry>> listeners;
          |                                                                ^~~~~~~~~
          |                                                                listeners_
  • include/fabric/core/JsonTypes.hh:13:47: warning: [readability-identifier-naming]

    invalid case style for function 'to_json'

       13 | template <typename T, typename SpaceTag> void to_json(nlohmann::json& j, const Vector2<T, SpaceTag>& v) {
          |                                               ^~~~~~~
          |                                               toJson
  • include/fabric/core/JsonTypes.hh:17:47: warning: [readability-identifier-naming]

    invalid case style for function 'from_json'

       17 | template <typename T, typename SpaceTag> void from_json(const nlohmann::json& j, Vector2<T, SpaceTag>& v) {
          |                                               ^~~~~~~~~
          |                                               fromJson
  • include/fabric/core/JsonTypes.hh:24:47: warning: [readability-identifier-naming]

    invalid case style for function 'to_json'

       24 | template <typename T, typename SpaceTag> void to_json(nlohmann::json& j, const Vector3<T, SpaceTag>& v) {
          |                                               ^~~~~~~
          |                                               toJson
  • include/fabric/core/JsonTypes.hh:28:47: warning: [readability-identifier-naming]

    invalid case style for function 'from_json'

       28 | template <typename T, typename SpaceTag> void from_json(const nlohmann::json& j, Vector3<T, SpaceTag>& v) {
          |                                               ^~~~~~~~~
          |                                               fromJson
  • include/fabric/core/JsonTypes.hh:36:47: warning: [readability-identifier-naming]

    invalid case style for function 'to_json'

       36 | template <typename T, typename SpaceTag> void to_json(nlohmann::json& j, const Vector4<T, SpaceTag>& v) {
          |                                               ^~~~~~~
          |                                               toJson
  • include/fabric/core/JsonTypes.hh:40:47: warning: [readability-identifier-naming]

    invalid case style for function 'from_json'

       40 | template <typename T, typename SpaceTag> void from_json(const nlohmann::json& j, Vector4<T, SpaceTag>& v) {
          |                                               ^~~~~~~~~
          |                                               fromJson
  • include/fabric/core/JsonTypes.hh:49:28: warning: [readability-identifier-naming]

    invalid case style for function 'to_json'

       49 | template <typename T> void to_json(nlohmann::json& j, const Quaternion<T>& q) {
          |                            ^~~~~~~
          |                            toJson
  • include/fabric/core/JsonTypes.hh:53:28: warning: [readability-identifier-naming]

    invalid case style for function 'from_json'

       53 | template <typename T> void from_json(const nlohmann::json& j, Quaternion<T>& q) {
          |                            ^~~~~~~~~
          |                            fromJson
  • include/fabric/core/Log.hh:53:23: warning: [readability-identifier-naming]

    invalid case style for parameter 'log_file_path'

       53 | void init(const char* log_file_path);
          |                       ^~~~~~~~~~~~~
          |                       logFilePath
  • include/fabric/core/Plugin.hh:151:24: warning: [readability-identifier-naming]

    invalid case style for private member 'pluginMutex'

      151 |     mutable std::mutex pluginMutex;
          |                        ^~~~~~~~~~~
          |                        pluginMutex_
  • include/fabric/core/Plugin.hh:152:52: warning: [readability-identifier-naming]

    invalid case style for private member 'pluginFactories'

      152 |     std::unordered_map<std::string, PluginFactory> pluginFactories;
          |                                                    ^~~~~~~~~~~~~~~
          |                                                    pluginFactories_
  • include/fabric/core/Plugin.hh:153:62: warning: [readability-identifier-naming]

    invalid case style for private member 'loadedPlugins'

      153 |     std::unordered_map<std::string, std::shared_ptr<Plugin>> loadedPlugins;
          |                                                              ^~~~~~~~~~~~~
          |                                                              loadedPlugins_
  • include/fabric/core/Resource.hh:214:23: warning: [readability-identifier-naming]

    invalid case style for global variable 'mutex_'

      190 |     static std::mutex mutex_;
          |                       ^~~~~~
          |                       g_mutex
  • include/fabric/core/Resource.hh:215:106: warning: [readability-identifier-naming]

    invalid case style for global variable 'factories_'

      191 |     static std::unordered_map<std::string, std::function<std::shared_ptr<Resource>(const std::string&)>> factories_;
          |                                                                                                          ^~~~~~~~~~
          |                                                                                                          g_factories
  • include/fabric/core/ResourceHub.hh:81:23: warning: [bugprone-empty-catch]

    empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether

       81 |                     } catch (...) {
          |                       ^
  • include/fabric/core/ResourceHub.hh:98:27: warning: [bugprone-empty-catch]

    empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether

       98 |                         } catch (...) {
          |                           ^
  • include/fabric/core/ResourceHub.hh:102:19: warning: [bugprone-empty-catch]

    empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether

      102 |                 } catch (...) {
          |                   ^
  • include/fabric/core/ResourceHub.hh:135:35: warning: [bugprone-empty-catch]

    empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether

      135 |                                 } catch (...) {
          |                                   ^
  • include/fabric/core/ResourceHub.hh:187:47: warning: [performance-unnecessary-copy-initialization]

    local copy 'resourceCopy' of the variable 'resource' is never modified; consider avoiding the copy

      187 |                     std::shared_ptr<Resource> resourceCopy = resource;
          |                                               ^
          |                     const                    &
  • include/fabric/core/ResourceHub.hh:195:31: warning: [bugprone-empty-catch]

    empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether

      195 |                             } catch (...) {
          |                               ^
  • include/fabric/core/ResourceHub.hh:229:27: warning: [bugprone-empty-catch]

    empty catch statements hide issues; to handle exceptions appropriately, consider re-throwing, handling, or avoiding catch altogether

      229 |                         } catch (...) {
          |                           ^
  • include/fabric/core/ResourceHub.hh:509:49: warning: [readability-identifier-naming]

    invalid case style for member 'resourceGraph_'

       80 |     CoordinatedGraph<std::shared_ptr<Resource>> resourceGraph_;
          |                                                 ^~~~~~~~~~~~~~
          |                                                 resourceGraph
  • include/fabric/core/Spatial.hh:350:11: warning: [readability-identifier-naming]

    invalid case style for variable 'sinr_cosp'

      350 |         T sinr_cosp = 2 * (w * x + y * z);
          |           ^~~~~~~~~
          |           sinrCosp
      351 |         T cosr_cosp = 1 - 2 * (x * x + y * y);
      352 |         angles.x = std::atan2(sinr_cosp, cosr_cosp);
          |                               ~~~~~~~~~
          |                               sinrCosp
  • include/fabric/core/Spatial.hh:351:11: warning: [readability-identifier-naming]

    invalid case style for variable 'cosr_cosp'

      351 |         T cosr_cosp = 1 - 2 * (x * x + y * y);
          |           ^~~~~~~~~
          |           cosrCosp
      352 |         angles.x = std::atan2(sinr_cosp, cosr_cosp);
          |                                          ~~~~~~~~~
          |                                          cosrCosp
  • include/fabric/core/Spatial.hh:362:11: warning: [readability-identifier-naming]

    invalid case style for variable 'siny_cosp'

      362 |         T siny_cosp = 2 * (w * z + x * y);
          |           ^~~~~~~~~
          |           sinyCosp
      363 |         T cosy_cosp = 1 - 2 * (y * y + z * z);
      364 |         angles.z = std::atan2(siny_cosp, cosy_cosp);
          |                               ~~~~~~~~~
          |                               sinyCosp
  • include/fabric/core/Spatial.hh:363:11: warning: [readability-identifier-naming]

    invalid case style for variable 'cosy_cosp'

      363 |         T cosy_cosp = 1 - 2 * (y * y + z * z);
          |           ^~~~~~~~~
          |           cosyCosp
      364 |         angles.z = std::atan2(siny_cosp, cosy_cosp);
          |                                          ~~~~~~~~~
          |                                          cosyCosp
  • include/fabric/core/Temporal.hh:225:27: warning: [performance-unnecessary-value-param]

    parameter 'updateFunc' is passed by value and only copied once; consider moving it to avoid unnecessary copies

       13 |             : updateFunc_(updateFunc), getStateFunc_(getStateFunc), setStateFunc_(setStateFunc) {}
          |                           ^         
          |                           std::move()
  • include/fabric/parser/ArgumentParser.hh:32:14: warning: [readability-identifier-naming]

    invalid case style for private member 'arguments'

       32 |     TokenMap arguments;
          |              ^~~~~~~~~
          |              arguments_
  • include/fabric/parser/ArgumentParser.hh:33:25: warning: [readability-identifier-naming]

    invalid case style for private member 'availableArgs'

       33 |     TokenTypeOptionsMap availableArgs;
          |                         ^~~~~~~~~~~~~
          |                         availableArgs_
  • include/fabric/parser/ArgumentParser.hh:34:21: warning: [readability-identifier-naming]

    invalid case style for private member 'argumentDescriptions'

       34 |     StringStringMap argumentDescriptions;
          |                     ^~~~~~~~~~~~~~~~~~~~
          |                     argumentDescriptions_
  • include/fabric/parser/ArgumentParser.hh:36:17: warning: [readability-identifier-naming]

    invalid case style for private member 'errorMsg'

       14 |     std::string errorMsg;
          |                 ^~~~~~~~
          |                 errorMsg_
  • include/fabric/parser/ArgumentParser.hh:37:10: warning: [readability-identifier-naming]

    invalid case style for private member 'valid'

       15 |     bool valid = true;
          |          ^~~~~
          |          valid_
  • include/fabric/parser/ArgumentParser.hh:54:25: warning: [readability-identifier-naming]

    invalid case style for private member 'options'

       48 |     const TokenTypeOptionsMap& getOptions() const { return options; }
          |                                                            ~~~~~~~
          |                                                            options_
       49 | 
       50 |     ArgumentParserBuilder& addOption(const std::string& name, TokenType type, bool optional = false);
       51 |     ArgumentParser build() const;
       52 | 
       53 |   private:
       54 |     TokenTypeOptionsMap options;
          |                         ^~~~~~~
          |                         options_
  • include/fabric/parser/SyntaxTree.hh:21:11: warning: [readability-identifier-naming]

    invalid case style for private member 'token'

       21 |     Token token;
          |           ^~~~~
          |           token_
  • include/fabric/parser/SyntaxTree.hh:22:43: warning: [readability-identifier-naming]

    invalid case style for private member 'children'

       22 |     std::vector<std::shared_ptr<ASTNode>> children;
          |                                           ^~~~~~~~
          |                                           children_
  • include/fabric/parser/Token.hh:8:12: warning: [performance-enum-size]

    enum 'TokenType' uses a larger base type ('int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size

        8 | enum class TokenType {
          |            ^
  • include/fabric/parser/Token.hh:226:72: warning: [performance-unnecessary-value-param]

    parameter 'value' is passed by value and only copied once; consider moving it to avoid unnecessary copies

        3 |     Token(TokenType type, Variant value = nullptr) : type(type), value(value) {}
          |                                                                        ^    
          |                                                                        std::move( )
  • include/fabric/ui/BgfxRenderInterface.hh:62:35: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kDefaultViewId'

       62 |     static constexpr bgfx::ViewId kDefaultViewId = 255;
          |                                   ^~~~~~~~~~~~~~
          |                                   K_DEFAULT_VIEW_ID
       63 | 
       64 |     bgfx::ViewId viewId_ = kDefaultViewId;
          |                            ~~~~~~~~~~~~~~
          |                            K_DEFAULT_VIEW_ID
  • include/fabric/utils/ErrorHandling.hh:21:17: warning: [readability-identifier-naming]

    invalid case style for private member 'message'

       21 |     std::string message;
          |                 ^~~~~~~
          |                 message_
  • include/fabric/utils/ImmutableDAG.hh:67:56: warning: [performance-unnecessary-value-param]

    the parameter 'visitor' is copied for each invocation but only used as a const reference; consider making it a const reference

       67 |     void bfs(NodeId start, std::function<bool(NodeId)> visitor) const {
          |                                                        ^
          |                            const                      &
  • include/fabric/utils/ImmutableDAG.hh:88:56: warning: [performance-unnecessary-value-param]

    the parameter 'visitor' is copied for each invocation but only used as a const reference; consider making it a const reference

       88 |     void dfs(NodeId start, std::function<bool(NodeId)> visitor) const {
          |                                                        ^
          |                            const                      &
  • include/fabric/utils/Testing.hh:18:11: warning: [readability-identifier-naming]

    invalid case style for namespace 'Testing'

       18 | namespace Testing {
          |           ^~~~~~~
          |           testing
  • include/fabric/utils/Testing.hh:42:10: warning: [readability-identifier-naming]

    invalid case style for method 'initialize_impl'

       27 |     void initialize() override { initialize_impl(); }
          |                                  ~~~~~~~~~~~~~~~
          |                                  initializeImpl
       28 |     std::string render() override {
       29 |         render_impl();
       30 |         return "<mock-component id=\"" + getId() + "\"></mock-component>";
       31 |     }
       32 |     void update(float deltaTime) override { update_impl(deltaTime); }
       33 |     void cleanup() override { cleanup_impl(); }
       34 | 
       35 |     // Test helpers
       36 |     int initializeCallCount = 0;
       37 |     int renderCallCount = 0;
       38 |     int updateCallCount = 0;
       39 |     int cleanupCallCount = 0;
       40 | 
       41 |     // Override these methods for testing
       42 |     void initialize_impl() { initializeCallCount++; }
          |          ^~~~~~~~~~~~~~~
          |          initializeImpl
  • include/fabric/utils/Testing.hh:43:17: warning: [readability-identifier-naming]

    invalid case style for method 'render_impl'

       29 |         render_impl();
          |         ~~~~~~~~~~~
          |         renderImpl
       30 |         return "<mock-component id=\"" + getId() + "\"></mock-component>";
       31 |     }
       32 |     void update(float deltaTime) override { update_impl(deltaTime); }
       33 |     void cleanup() override { cleanup_impl(); }
       34 | 
       35 |     // Test helpers
       36 |     int initializeCallCount = 0;
       37 |     int renderCallCount = 0;
       38 |     int updateCallCount = 0;
       39 |     int cleanupCallCount = 0;
       40 | 
       41 |     // Override these methods for testing
       42 |     void initialize_impl() { initializeCallCount++; }
       43 |     std::string render_impl() {
          |                 ^~~~~~~~~~~
          |                 renderImpl
  • include/fabric/utils/Testing.hh:47:10: warning: [readability-identifier-naming]

    invalid case style for method 'update_impl'

       32 |     void update(float deltaTime) override { update_impl(deltaTime); }
          |                                             ~~~~~~~~~~~
          |                                             updateImpl
       33 |     void cleanup() override { cleanup_impl(); }
       34 | 
       35 |     // Test helpers
       36 |     int initializeCallCount = 0;
       37 |     int renderCallCount = 0;
       38 |     int updateCallCount = 0;
       39 |     int cleanupCallCount = 0;
       40 | 
       41 |     // Override these methods for testing
       42 |     void initialize_impl() { initializeCallCount++; }
       43 |     std::string render_impl() {
       44 |         renderCallCount++;
       45 |         return "";
       46 |     }
       47 |     void update_impl(float deltaTime) { updateCallCount++; }
          |          ^~~~~~~~~~~
          |          updateImpl
  • include/fabric/utils/Testing.hh:48:10: warning: [readability-identifier-naming]

    invalid case style for method 'cleanup_impl'

       33 |     void cleanup() override { cleanup_impl(); }
          |                               ~~~~~~~~~~~~
          |                               cleanupImpl
       34 | 
       35 |     // Test helpers
       36 |     int initializeCallCount = 0;
       37 |     int renderCallCount = 0;
       38 |     int updateCallCount = 0;
       39 |     int cleanupCallCount = 0;
       40 | 
       41 |     // Override these methods for testing
       42 |     void initialize_impl() { initializeCallCount++; }
       43 |     std::string render_impl() {
       44 |         renderCallCount++;
       45 |         return "";
       46 |     }
       47 |     void update_impl(float deltaTime) { updateCallCount++; }
       48 |     void cleanup_impl() { cleanupCallCount++; }
          |          ^~~~~~~~~~~~
          |          cleanupImpl
  • include/fabric/utils/Testing.hh:161:31: warning: [readability-identifier-naming]

    invalid case style for function 'RunWithTimeout'

      161 | template <typename Func> bool RunWithTimeout(Func&& func, std::chrono::milliseconds timeout) {
          |                               ^~~~~~~~~~~~~~
          |                               runWithTimeout
  • include/fabric/utils/Testing.hh:192:13: warning: [readability-identifier-naming]

    invalid case style for function 'RunConcurrent'

      192 | inline void RunConcurrent(size_t threadCount, size_t iterationsPerThread,
          |             ^~~~~~~~~~~~~
          |             runConcurrent
  • include/fabric/utils/Testing.hh:193:82: warning: [performance-unnecessary-value-param]

    the parameter 'func' is copied for each invocation but only used as a const reference; consider making it a const reference

      193 |                           std::function<void(size_t threadId, size_t iteration)> func) {
          |                                                                                  ^
          |                           const                                                 &
  • include/fabric/utils/Testing.hh:217:20: warning: [readability-identifier-naming]

    invalid case style for function 'RandomString'

      217 | inline std::string RandomString(size_t length) {
          |                    ^~~~~~~~~~~~
          |                    randomString
  • include/fabric/utils/Testing.hh:243:12: warning: [readability-identifier-naming]

    invalid case style for function 'RandomInt'

      243 | inline int RandomInt(int min, int max) {
          |            ^~~~~~~~~
          |            randomInt
  • include/fabric/utils/ThreadPoolExecutor.hh:108:79: warning: [performance-avoid-endl]

    do not use 'std::endl' with streams; use '\n' instead

      108 |                 std::cerr << "Exception in thread pool task: " << e.what() << std::endl;
          |                                                                               ^~~~~~~~~
          |                                                                               '\n'
  • include/fabric/utils/ThreadPoolExecutor.hh:110:73: warning: [performance-avoid-endl]

    do not use 'std::endl' with streams; use '\n' instead

      110 |                 std::cerr << "Unknown exception in thread pool task" << std::endl;
          |                                                                         ^~~~~~~~~
          |                                                                         '\n'
  • src/core/Async.cc:8:25: warning: [readability-identifier-naming]

    invalid case style for global variable 'io_ctx'

        8 | static asio::io_context io_ctx;
          |                         ^~~~~~
          |                         g_io_ctx
        9 | static std::optional<asio::executor_work_guard<asio::io_context::executor_type>> work_guard;
       10 | 
       11 | asio::io_context& context() {
       12 |     return io_ctx;
          |            ~~~~~~
          |            g_io_ctx
       13 | }
       14 | 
       15 | void init() {
       16 |     work_guard.emplace(asio::make_work_guard(io_ctx));
          |                                              ~~~~~~
          |                                              g_io_ctx
       17 |     FABRIC_LOG_INFO("Async: subsystem initialized");
       18 | }
       19 | 
       20 | void shutdown() {
       21 |     FABRIC_LOG_INFO("Async: subsystem shutting down");
       22 |     work_guard.reset();
       23 |     io_ctx.run();
          |     ~~~~~~
          |     g_io_ctx
  • src/core/Async.cc:9:82: warning: [readability-identifier-naming]

    invalid case style for global variable 'work_guard'

        9 | static std::optional<asio::executor_work_guard<asio::io_context::executor_type>> work_guard;
          |                                                                                  ^~~~~~~~~~
          |                                                                                  g_work_guard
       10 | 
       11 | asio::io_context& context() {
       12 |     return io_ctx;
       13 | }
       14 | 
       15 | void init() {
       16 |     work_guard.emplace(asio::make_work_guard(io_ctx));
          |     ~~~~~~~~~~
          |     g_work_guard
       17 |     FABRIC_LOG_INFO("Async: subsystem initialized");
       18 | }
       19 | 
       20 | void shutdown() {
       21 |     FABRIC_LOG_INFO("Async: subsystem shutting down");
       22 |     work_guard.reset();
          |     ~~~~~~~~~~
          |     g_work_guard
  • src/core/Component.cc:28:53: warning: [performance-unnecessary-value-param]

    the parameter 'child' is copied for each invocation but only used as a const reference; consider making it a const reference

       28 | void Component::addChild(std::shared_ptr<Component> child) {
          |                                                     ^
          |                          const                     &
  • src/core/Fabric.cc:48:18: warning: [cppcoreguidelines-pro-type-reinterpret-cast]

    do not use reinterpret_cast

       48 |         pd.nwh = reinterpret_cast<void*>(
          |                  ^
  • src/core/Fabric.cc:48:18: warning: [performance-no-int-to-ptr]

    integer to pointer cast pessimizes optimization opportunities

  • src/core/Fabric.cc:58:5: warning: [bugprone-exception-escape]

    an exception may be thrown in function 'main' which should not throw exceptions

       58 | int main(int argc, char* argv[]) {
          |     ^
  • src/core/Fabric.cc:68:80: warning: [performance-avoid-endl]

    do not use 'std::endl' with streams; use '\n' instead

       68 |         std::cout << fabric::APP_NAME << " version " << fabric::APP_VERSION << std::endl;
          |                                                                                ^~~~~~~~~
          |                                                                                '\n'
  • src/core/Fabric.cc:74:82: warning: [performance-avoid-endl]

    do not use 'std::endl' with streams; use '\n' instead

       74 |         std::cout << "Usage: " << fabric::APP_EXECUTABLE_NAME << " [options]" << std::endl;
          |                                                                                  ^~~~~~~~~
          |                                                                                  '\n'
  • src/core/Fabric.cc:75:36: warning: [performance-avoid-endl]

    do not use 'std::endl' with streams; use '\n' instead

       75 |         std::cout << "Options:" << std::endl;
          |                                    ^~~~~~~~~
          |                                    '\n'
  • src/core/Fabric.cc:76:70: warning: [performance-avoid-endl]

    do not use 'std::endl' with streams; use '\n' instead

       76 |         std::cout << "  --version    Display version information" << std::endl;
          |                                                                      ^~~~~~~~~
          |                                                                      '\n'
  • src/core/Fabric.cc:77:68: warning: [performance-avoid-endl]

    do not use 'std::endl' with streams; use '\n' instead

       77 |         std::cout << "  --help       Display this help message" << std::endl;
          |                                                                    ^~~~~~~~~
          |                                                                    '\n'
  • src/core/Fabric.cc:89:23: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kWindowWidth'

       89 |         constexpr int kWindowWidth = 1280;
          |                       ^~~~~~~~~~~~
          |                       K_WINDOW_WIDTH
       90 |         constexpr int kWindowHeight = 720;
       91 | 
       92 |         SDL_Window* window = SDL_CreateWindow(fabric::APP_NAME, kWindowWidth, kWindowHeight,
          |                                                                 ~~~~~~~~~~~~
          |                                                                 K_WINDOW_WIDTH
  • src/core/Fabric.cc:90:23: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kWindowHeight'

       90 |         constexpr int kWindowHeight = 720;
          |                       ^~~~~~~~~~~~~
          |                       K_WINDOW_HEIGHT
       91 | 
       92 |         SDL_Window* window = SDL_CreateWindow(fabric::APP_NAME, kWindowWidth, kWindowHeight,
          |                                                                               ~~~~~~~~~~~~~
          |                                                                               K_WINDOW_HEIGHT
  • src/core/Fabric.cc:213:25: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kMoveSpeed'

      213 |         constexpr float kMoveSpeed = 5.0f;
          |                         ^~~~~~~~~~
          |                         K_MOVE_SPEED
  • src/core/Fabric.cc:214:25: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kMouseSensitivity'

      214 |         constexpr float kMouseSensitivity = 0.002f;
          |                         ^~~~~~~~~~~~~~~~~
          |                         K_MOUSE_SENSITIVITY
  • src/core/Fabric.cc:221:26: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kFixedDt'

      221 |         constexpr double kFixedDt = 1.0 / 60.0;
          |                          ^~~~~~~~
          |                          K_FIXED_DT
  • src/core/Fabric.cc:261:29: warning: [readability-identifier-naming]

    invalid case style for constexpr variable 'kMaxPitch'

      261 |             constexpr float kMaxPitch = 1.5f; // ~86 degrees
          |                             ^~~~~~~~~
          |                             K_MAX_PITCH
      262 |             if (cameraPitch > kMaxPitch)
          |                               ~~~~~~~~~
          |                               K_MAX_PITCH
      263 |                 cameraPitch = kMaxPitch;
          |                               ~~~~~~~~~
          |                               K_MAX_PITCH
      264 |             if (cameraPitch < -kMaxPitch)
          |                                ~~~~~~~~~
          |                                K_MAX_PITCH
      265 |                 cameraPitch = -kMaxPitch;
          |                                ~~~~~~~~~
          |                                K_MAX_PITCH
  • src/core/Log.cc:16:27: warning: [readability-identifier-naming]

    invalid case style for variable 'backend_opts'

       16 |     quill::BackendOptions backend_opts;
          |                           ^~~~~~~~~~~~
          |                           backendOpts
       17 |     backend_opts.thread_name = "FabricLog";
          |     ~~~~~~~~~~~~
          |     backendOpts
       18 |     backend_opts.wait_for_queues_to_empty_before_exit = true;
          |     ~~~~~~~~~~~~
          |     backendOpts
       19 | 
       20 |     quill::Backend::start(backend_opts);
          |                           ~~~~~~~~~~~~
          |                           backendOpts
  • src/core/Log.cc:22:10: warning: [readability-identifier-naming]

    invalid case style for variable 'console_sink'

       22 |     auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("console");
          |          ^~~~~~~~~~~~
          |          consoleSink
       23 | 
       24 |     quill::PatternFormatterOptions pattern;
       25 |     pattern.format_pattern = "%(time) [%(thread_id)] %(short_source_location:<28) "
       26 |                              "%(log_level:<9) %(message)";
       27 |     pattern.timestamp_pattern = "%H:%M:%S.%Qms";
       28 | 
       29 |     g_logger = quill::Frontend::create_or_get_logger("fabric", std::move(console_sink), pattern);
          |                                                                          ~~~~~~~~~~~~
          |                                                                          consoleSink
  • src/core/Log.cc:33:23: warning: [readability-identifier-naming]

    invalid case style for parameter 'log_file_path'

       33 | void init(const char* log_file_path) {
          |                       ^~~~~~~~~~~~~
          |                       logFilePath
       34 |     quill::BackendOptions backend_opts;
       35 |     backend_opts.thread_name = "FabricLog";
       36 |     backend_opts.wait_for_queues_to_empty_before_exit = true;
       37 | 
       38 |     quill::Backend::start(backend_opts);
       39 | 
       40 |     auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("console");
       41 | 
       42 |     auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(log_file_path, []() {
          |                                                                           ~~~~~~~~~~~~~
          |                                                                           logFilePath
  • src/core/Log.cc:34:27: warning: [readability-identifier-naming]

    invalid case style for variable 'backend_opts'

       34 |     quill::BackendOptions backend_opts;
          |                           ^~~~~~~~~~~~
          |                           backendOpts
       35 |     backend_opts.thread_name = "FabricLog";
          |     ~~~~~~~~~~~~
          |     backendOpts
       36 |     backend_opts.wait_for_queues_to_empty_before_exit = true;
          |     ~~~~~~~~~~~~
          |     backendOpts
       37 | 
       38 |     quill::Backend::start(backend_opts);
          |                           ~~~~~~~~~~~~
          |                           backendOpts
  • src/core/Log.cc:40:10: warning: [readability-identifier-naming]

    invalid case style for variable 'console_sink'

       40 |     auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("console");
          |          ^~~~~~~~~~~~
          |          consoleSink
       41 | 
       42 |     auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(log_file_path, []() {
       43 |         quill::FileSinkConfig cfg;
       44 |         cfg.set_open_mode('w');
       45 |         cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
       46 |         return cfg;
       47 |     }());
       48 | 
       49 |     quill::PatternFormatterOptions pattern;
       50 |     pattern.format_pattern = "%(time) [%(thread_id)] %(short_source_location:<28) "
       51 |                              "%(log_level:<9) %(message)";
       52 |     pattern.timestamp_pattern = "%H:%M:%S.%Qms";
       53 | 
       54 |     g_logger = quill::Frontend::create_or_get_logger("fabric", {console_sink, file_sink}, pattern);
          |                                                                 ~~~~~~~~~~~~
          |                                                                 consoleSink
  • src/core/Log.cc:42:10: warning: [readability-identifier-naming]

    invalid case style for variable 'file_sink'

       42 |     auto file_sink = quill::Frontend::create_or_get_sink<quill::FileSink>(log_file_path, []() {
          |          ^~~~~~~~~
          |          fileSink
       43 |         quill::FileSinkConfig cfg;
       44 |         cfg.set_open_mode('w');
       45 |         cfg.set_filename_append_option(quill::FilenameAppendOption::StartDateTime);
       46 |         return cfg;
       47 |     }());
       48 | 
       49 |     quill::PatternFormatterOptions pattern;
       50 |     pattern.format_pattern = "%(time) [%(thread_id)] %(short_source_location:<28) "
       51 |                              "%(log_level:<9) %(message)";
       52 |     pattern.timestamp_pattern = "%H:%M:%S.%Qms";
       53 | 
       54 |     g_logger = quill::Frontend::create_or_get_logger("fabric", {console_sink, file_sink}, pattern);
          |                                                                               ~~~~~~~~~
          |                                                                               fileSink
  • src/core/ResourceHub.cc:26:14: warning: [bugprone-exception-escape]

    an exception may be thrown in function '~ResourceHub' which should not throw exceptions

       26 | ResourceHub::~ResourceHub() {
          |              ^
  • src/core/ResourceHub.cc:1104:21: warning: [bugprone-implicit-widening-of-multiplication-result]

    performing an implicit widening conversion to type '__integral_type' (aka 'unsigned long') of a multiplication performed in type 'int'

     1104 |     : memoryBudget_(1024 * 1024 * 1024), // 1 GB default
          |                     ^
    /home/runner/_work/Fabric/Fabric/src/core/ResourceHub.cc:1104:21: note: make conversion explicit to silence this warning
        6 |     : memoryBudget_(1024 * 1024 * 1024), // 1 GB default
          |                     ^~~~~~~~~~~~~~~~~~
          |                     static_cast<__integral_type>( )
    /home/runner/_work/Fabric/Fabric/src/core/ResourceHub.cc:1104:21: note: perform multiplication in a wider type
     1104 |     : memoryBudget_(1024 * 1024 * 1024), // 1 GB default
          |                     ^~~~~~~~~~~
          |                     static_cast<long>( )

Have any feedback or feature suggestions? Share it here.

@mannie-exe mannie-exe merged commit cd4124f into main Feb 24, 2026
11 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants