clang-format run incl. workflow for feature branch format check

Author: BlueAndi

.github/workflows/featureBranches.yml

@@ -146,6 +146,43 @@ jobs:
     - name: Run tests on native environment
       run: platformio test --environment test -vvv
 
+  # Perform clang-format check
+  check_format:
+    # The type of runner that the job will run on.
+    runs-on: ubuntu-latest
+    needs: intro
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v6
+
+    - name: Cache pip
+      uses: actions/cache@v5
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Cache PlatformIO
+      uses: actions/cache@v5
+      with:
+        path: ~/.platformio
+        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: '3.9'
+    
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio
+
+    - name: Run clang-format check
+      run: find lib -iname '*.h' -iname '*.hpp' -o -iname '*.cpp' | xargs clang-format -i --dry-run -Werror
+
   # Build documentation
   doc:
     # The type of runner that the job will run on.

lib/ArduinoNative/src/FS.cpp

@@ -63,9 +63,9 @@ FS NativeFS;
 
 size_t File::size() const
 {
-    size_t  fileSize    = 0U;
-    size_t  currPos     = ftell(m_fd);
-    
+    size_t fileSize = 0U;
+    size_t currPos  = ftell(m_fd);
+
     if (0 == fseek(m_fd, 0, SEEK_END))
     {
         long pos = ftell(m_fd);

lib/ArduinoNative/src/Print.cpp

@@ -61,30 +61,32 @@
  * Public Methods
  *****************************************************************************/
 
-size_t Print::write(const uint8_t *buffer, size_t size)
+size_t Print::write(const uint8_t* buffer, size_t size)
 {
     size_t n = 0;
-    while(size--) {
+    while (size--)
+    {
         n += write(*buffer++);
     }
     return n;
 }
 
-size_t Print::write(const char *str)
+size_t Print::write(const char* str)
 {
-    if(str == nullptr) {
+    if (str == nullptr)
+    {
         return 0;
     }
 
-    return write(reinterpret_cast<const uint8_t *>(str), strlen(str));
+    return write(reinterpret_cast<const uint8_t*>(str), strlen(str));
 }
 
-size_t Print::write(const char *buffer, size_t size)
+size_t Print::write(const char* buffer, size_t size)
 {
-    return write(reinterpret_cast<const uint8_t *>(buffer), size);
+    return write(reinterpret_cast<const uint8_t*>(buffer), size);
 }
 
-size_t Print::print(const String &s)
+size_t Print::print(const String& s)
 {
     return write(s.c_str(), s.length());
 }
@@ -101,16 +103,22 @@ size_t Print::print(char c)
 
 size_t Print::print(long n, int base)
 {
-    if(base == 0) {
+    if (base == 0)
+    {
         return write(n);
-    } else if(base == 10) {
-        if(n < 0) {
+    }
+    else if (base == 10)
+    {
+        if (n < 0)
+        {
             int t = print('-');
-            n = -n;
+            n     = -n;
             return printNumber(n, 10) + t;
         }
         return printNumber(n, 10);
-    } else {
+    }
+    else
+    {
         return printNumber(n, base);
     }
 }
@@ -120,10 +128,10 @@ size_t Print::println()
     return print("\r\n");
 }
 
-size_t Print::println(const String &s)
+size_t Print::println(const String& s)
 {
-    size_t n = print(s);
-    n += println();
+    size_t n  = print(s);
+    n        += println();
     return n;
 }
 
@@ -137,22 +145,25 @@ size_t Print::println(const String &s)
 
 size_t Print::printNumber(unsigned long n, uint8_t base)
 {
-    char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
-    char *str = &buf[sizeof(buf) - 1];
+    char  buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
+    char* str = &buf[sizeof(buf) - 1];
 
-    *str = '\0';
+    *str      = '\0';
 
     // prevent crash if called with base == 1
-    if(base < 2) {
+    if (base < 2)
+    {
         base = 10;
     }
 
-    do {
-        unsigned long m = n;
-        n /= base;
-        char c = m - base * n;
-        *--str = c < 10 ? c + '0' : c + 'A' - 10;
-    } while(n);
+    do
+    {
+        unsigned long m  = n;
+        n               /= base;
+        char c           = m - base * n;
+        *--str           = c < 10 ? c + '0' : c + 'A' - 10;
+    }
+    while (n);
 
     return write(str);
 }

lib/AsyncHttpClient/src/AsyncHttpClient.cpp

@@ -1314,7 +1314,7 @@ bool AsyncHttpClient::parseChunkedResponseChunkData(const uint8_t* data, size_t
 
         /* Abort by set EOF. */
         m_chunkIndex = 0U;
-        isDataEOF = true;
+        isDataEOF    = true;
     }
     else
     {

lib/AsyncHttpClient/src/HttpHeader.cpp

@@ -63,7 +63,7 @@ HttpHeader& HttpHeader::operator=(const HttpHeader& hdr)
 {
     if (this != &hdr)
     {
-        m_name = hdr.m_name;
+        m_name  = hdr.m_name;
         m_value = hdr.m_value;
     }
 
@@ -76,11 +76,11 @@ void HttpHeader::parse(const String& line)
 
     if (0 <= idx)
     {
-        m_name = line.substring(0, idx);
+        m_name  = line.substring(0, idx);
         m_value = line.substring(idx + 2);
 
         /* There may be CRLF at the end, which must be removed. */
-        idx = m_value.indexOf("\r\n");
+        idx     = m_value.indexOf("\r\n");
 
         if (0 <= idx)
         {

lib/AudioService/src/AudioService.cpp

@@ -65,8 +65,8 @@
 
 bool AudioService::start()
 {
-    bool        isSuccessful    = true;
-    AudioDrv&   audioDrv        = AudioDrv::getInstance();
+    bool      isSuccessful = true;
+    AudioDrv& audioDrv     = AudioDrv::getInstance();
 
     if ((IoPin::NC == CONFIG_PIN_I2S_WS) ||
         (IoPin::NC == CONFIG_PIN_I2S_SC) ||
@@ -92,8 +92,8 @@ bool AudioService::start()
         else
         {
             uint8_t idx = 0U;
-            
-            while(MAX_TONE_DETECTORS > idx)
+
+            while (MAX_TONE_DETECTORS > idx)
             {
                 if (false == audioDrv.registerObserver(m_audioToneDetector[idx]))
                 {
@@ -120,12 +120,12 @@ bool AudioService::start()
 
 void AudioService::stop()
 {
-    AudioDrv&   audioDrv    = AudioDrv::getInstance();
-    uint8_t     idx         = 0U;
+    AudioDrv& audioDrv = AudioDrv::getInstance();
+    uint8_t   idx      = 0U;
 
     audioDrv.unregisterObserver(m_spectrumAnalyzer);
 
-    while(MAX_TONE_DETECTORS > idx)
+    while (MAX_TONE_DETECTORS > idx)
     {
         audioDrv.unregisterObserver(m_audioToneDetector[idx]);
 

lib/AudioService/src/AudioToneDetector.cpp

@@ -67,34 +67,34 @@ void AudioToneDetector::notify(int32_t* data, size_t size)
     if (((EPSILON < m_targetFreq) || (-EPSILON > m_targetFreq)) &&
         (nullptr != data))
     {
-        size_t  index           = 0U;
-        float   q0              = 0.0F;
-        float   q1              = 0.0F;
-        float   q2              = 0.0F;
-        float   realValue       = 0.0F;
-        float   imagValue       = 0.0F;
-        float   magnitude       = 0.0F;
-        float   scalingFactor   = static_cast<float>(size) / 2.0F;
-
-        while(size > index)
+        size_t index         = 0U;
+        float  q0            = 0.0F;
+        float  q1            = 0.0F;
+        float  q2            = 0.0F;
+        float  realValue     = 0.0F;
+        float  imagValue     = 0.0F;
+        float  magnitude     = 0.0F;
+        float  scalingFactor = static_cast<float>(size) / 2.0F;
+
+        while (size > index)
         {
             float fData = static_cast<float>(data[index]);
 
-            q0  = m_coeff * q1 - q2 + applyHanningWindow(fData, index, AudioDrv::SAMPLES);
-            q2  = q1;
-            q1  = q0;
+            q0          = m_coeff * q1 - q2 + applyHanningWindow(fData, index, AudioDrv::SAMPLES);
+            q2          = q1;
+            q1          = q0;
 
             ++index;
         }
 
-        realValue = q1 - q2 * m_cosValue;
+        realValue  = q1 - q2 * m_cosValue;
         realValue /= scalingFactor;
 
-        imagValue = q2 * m_sinValue;
+        imagValue  = q2 * m_sinValue;
         imagValue /= scalingFactor;
 
-        magnitude = sqrtf(realValue * realValue + imagValue * imagValue);
-        magnitude = applyHanningMagnitudeCorrection(magnitude);
+        magnitude  = sqrtf(realValue * realValue + imagValue * imagValue);
+        magnitude  = applyHanningMagnitudeCorrection(magnitude);
 
         if (m_threshold < magnitude)
         {
@@ -137,23 +137,23 @@ void AudioToneDetector::notify(int32_t* data, size_t size)
 
 void AudioToneDetector::preCompute()
 {
-    float       fIndex  = 0.5F + ((AudioDrv::SAMPLES * m_targetFreq) / AudioDrv::SAMPLE_RATE);
-    uint32_t    index   = static_cast<uint32_t>(fIndex);
+    float    fIndex  = 0.5F + ((AudioDrv::SAMPLES * m_targetFreq) / AudioDrv::SAMPLE_RATE);
+    uint32_t index   = static_cast<uint32_t>(fIndex);
 
-    m_omega = (2.0F * M_PI) / AudioDrv::SAMPLES;
-    m_omega *= index;
+    m_omega          = (2.0F * M_PI) / AudioDrv::SAMPLES;
+    m_omega         *= index;
 
-    m_cosValue = cos(m_omega);
-    m_sinValue = sin(m_omega);
+    m_cosValue       = cos(m_omega);
+    m_sinValue       = sin(m_omega);
 
-    m_coeff = 2.0F * m_cosValue;
+    m_coeff          = 2.0F * m_cosValue;
 }
 
 float AudioToneDetector::applyHanningWindow(float data, uint32_t sampleIndex, uint32_t samples)
 {
     float fSamples = static_cast<float>(samples);
 
-    return data * (0.54F - 0.46F * cos( 2.0F * M_PI * sampleIndex / fSamples));
+    return data * (0.54F - 0.46F * cos(2.0F * M_PI * sampleIndex / fSamples));
 }
 
 float AudioToneDetector::applyHanningMagnitudeCorrection(float data)