add clang formater

Author: sethhorsley

.github/workflows/test.yml

@@ -20,3 +20,16 @@ jobs:
 
       - name: run tests
         run: ./run_erbx_tests
+  formatting-check:
+    name: Formatting Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install clang-format
+        run: sudo apt-get install -y clang-format
+
+      - name: Check formatting
+        run: |
+          find . -name '*.[ch]' -not -path './vendor/*' | xargs clang-format -i
+          git diff --exit-code || (echo "❌ Code formatting check failed! Run clang-format locally and commit changes." && exit 1)

bin/format

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# Format all C/C++ files in the repository
+find . \( -name '*.c' -o -name '*.h' -o -name '*.cpp' -o -name '*.hpp' \) \
+  -not -path "./build/*" \
+  -not -path "./vendor/*" \
+  -exec clang-format -i {} +
+
+echo "Formatting complete!"

ext/erbx/extension.c

@@ -1,6 +1,6 @@
-#include "ruby.h"
-#include "extconf.h"
 #include "extension.h"
+#include "extconf.h"
+#include "ruby.h"
 
 #include "../../src/include/erbx.h"
 
@@ -10,7 +10,9 @@ static const char *check_string(VALUE value) {
   }
 
   if (!RB_TYPE_P(value, T_STRING)) {
-    rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)", rb_obj_class(value));
+    rb_raise(rb_eTypeError,
+             "wrong argument type %" PRIsVALUE " (expected String)",
+             rb_obj_class(value));
   }
 
   return RSTRING_PTR(value);
@@ -19,7 +21,7 @@ static const char *check_string(VALUE value) {
 VALUE rb_erbx_lex(VALUE self, VALUE source) {
   const char *string = check_string(source);
 
-  erbx_lex((char *) string);
+  erbx_lex((char *)string);
 
   return Qnil;
 }

src/array.c

@@ -1,46 +1,45 @@
 #include "include/array.h"
 
-size_t array_sizeof(void) {
-  return sizeof(array_T);
-}
+size_t array_sizeof(void) { return sizeof(array_T); }
 
-array_T* array_init(int capacity) {
-  array_T* array = (array_T*) malloc(sizeof(array_T));
+array_T *array_init(int capacity) {
+  array_T *array = (array_T *)malloc(sizeof(array_T));
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = (void**) malloc(sizeof(void*) * capacity);
+  array->items = (void **)malloc(sizeof(void *) * capacity);
 
   return array;
 }
 
-void array_append(array_T* array, void* item) {
+void array_append(array_T *array, void *item) {
   if (array->size >= array->capacity) {
     array->capacity *= 2;
-    array->items = (void**) realloc(array->items, sizeof(void*) * array->capacity);
+    array->items =
+        (void **)realloc(array->items, sizeof(void *) * array->capacity);
   }
 
   array->items[array->size] = item;
   array->size++;
 }
 
-void* array_get(array_T* array, int index) {
+void *array_get(array_T *array, int index) {
   if (index >= array->size || index < 0) {
     return NULL;
   }
 
   return array->items[index];
 }
 
-void array_set(array_T* array, int index, void* item) {
+void array_set(array_T *array, int index, void *item) {
   if (index >= array->size || index < 0) {
     return;
   }
 
   array->items[index] = item;
 }
 
-void array_remove(array_T* array, int index) {
+void array_remove(array_T *array, int index) {
   if (index >= array->size || index < 0) {
     return;
   }
@@ -52,15 +51,11 @@ void array_remove(array_T* array, int index) {
   array->size--;
 }
 
-size_t array_size(array_T* array) {
-  return array->size;
-}
+size_t array_size(array_T *array) { return array->size; }
 
-size_t array_capacity(array_T* array) {
-  return array->capacity;
-}
+size_t array_capacity(array_T *array) { return array->capacity; }
 
-void array_free(array_T* array) {
+void array_free(array_T *array) {
   free(array->items);
   free(array);
 }

src/ast.c

@@ -2,12 +2,10 @@
 
 #include <stdlib.h>
 
-size_t ast_sizeof(void) {
-  return sizeof(struct AST_STRUCT);
-}
+size_t ast_sizeof(void) { return sizeof(struct AST_STRUCT); }
 
-AST_T* ast_init(int type) {
-  AST_T* ast = calloc(1, ast_sizeof());
+AST_T *ast_init(int type) {
+  AST_T *ast = calloc(1, ast_sizeof());
   ast->type = type;
   ast->children = array_init(ast_sizeof());
 

src/buffer.c

@@ -4,7 +4,7 @@
 
 #include "include/buffer.h"
 
-bool buffer_init(buffer_T* buffer) {
+bool buffer_init(buffer_T *buffer) {
   buffer->capacity = 1024;
   buffer->length = 0;
   buffer->value = malloc(buffer->capacity * sizeof(char));
@@ -16,28 +16,20 @@ bool buffer_init(buffer_T* buffer) {
   return buffer != NULL;
 }
 
-char* buffer_value(buffer_T* buffer) {
-  return buffer->value;
-}
+char *buffer_value(buffer_T *buffer) { return buffer->value; }
 
-size_t buffer_length(buffer_T* buffer) {
-  return buffer->length;
-}
+size_t buffer_length(buffer_T *buffer) { return buffer->length; }
 
-size_t buffer_capacity(buffer_T* buffer) {
-  return buffer->capacity;
-}
+size_t buffer_capacity(buffer_T *buffer) { return buffer->capacity; }
 
-size_t buffer_sizeof(void) {
-  return sizeof(buffer_T);
-}
+size_t buffer_sizeof(void) { return sizeof(buffer_T); }
 
-void buffer_append(buffer_T* buffer, const char* text) {
+void buffer_append(buffer_T *buffer, const char *text) {
   size_t text_length = strlen(text);
 
   if (buffer->length + text_length >= buffer->capacity) {
     size_t new_capacity = (buffer->length + text_length) * 2;
-    char* new_buffer = realloc(buffer->value, new_capacity);
+    char *new_buffer = realloc(buffer->value, new_capacity);
 
     if (new_buffer) {
       buffer->value = new_buffer;
@@ -52,8 +44,9 @@ void buffer_append(buffer_T* buffer, const char* text) {
   buffer->length += text_length;
 }
 
-void buffer_prepend(buffer_T* buffer, const char* text) {
-  if (text == NULL || text[0] == '\0') return;
+void buffer_prepend(buffer_T *buffer, const char *text) {
+  if (text == NULL || text[0] == '\0')
+    return;
 
   size_t text_length = strlen(text);
   size_t new_length = buffer->length + text_length;
@@ -71,8 +64,9 @@ void buffer_prepend(buffer_T* buffer, const char* text) {
   buffer->value[buffer->length] = '\0';
 }
 
-void buffer_concat(buffer_T* destination, buffer_T* source) {
-  if (source->length == 0) return;
+void buffer_concat(buffer_T *destination, buffer_T *source) {
+  if (source->length == 0)
+    return;
 
   size_t new_length = destination->length + source->length;
 
@@ -87,7 +81,7 @@ void buffer_concat(buffer_T* destination, buffer_T* source) {
   destination->length = new_length;
 }
 
-void buffer_free(buffer_T* buffer) {
+void buffer_free(buffer_T *buffer) {
   free(buffer->value);
   buffer->value = NULL;
   buffer->length = buffer->capacity = 0;

src/erbx.c

@@ -1,19 +1,19 @@
 #include "include/erbx.h"
+#include "include/array.h"
+#include "include/buffer.h"
 #include "include/io.h"
 #include "include/lexer.h"
-#include "include/token.h"
 #include "include/parser.h"
-#include "include/buffer.h"
-#include "include/array.h"
+#include "include/token.h"
 #include "include/version.h"
 
 #include <stdlib.h>
 
-array_T* erbx_lex(char* source) {
-  lexer_T* lexer = lexer_init(source);
-  token_T* token = 0;
+array_T *erbx_lex(char *source) {
+  lexer_T *lexer = lexer_init(source);
+  token_T *token = 0;
 
-  array_T* tokens = array_init(1);
+  array_T *tokens = array_init(1);
 
   while ((token = lexer_next_token(lexer))->type != TOKEN_EOF) {
     array_append(tokens, token);
@@ -24,20 +24,20 @@ array_T* erbx_lex(char* source) {
   return tokens;
 }
 
-array_T* erbx_lex_file(const char* path) {
-  char* source = erbx_read_file(path);
-  array_T* tokens = erbx_lex(source);
+array_T *erbx_lex_file(const char *path) {
+  char *source = erbx_read_file(path);
+  array_T *tokens = erbx_lex(source);
 
   free(source);
 
   return tokens;
 }
 
-void erbx_lex_to_buffer(char* source, buffer_T* output) {
-  array_T* tokens = erbx_lex(source);
+void erbx_lex_to_buffer(char *source, buffer_T *output) {
+  array_T *tokens = erbx_lex(source);
 
   for (int i = 0; i < array_size(tokens); i++) {
-    token_T* token = array_get(tokens, i);
+    token_T *token = array_get(tokens, i);
     buffer_append(output, token_to_string(token));
     buffer_append(output, "\n");
   }
@@ -47,6 +47,4 @@ void erbx_lex_to_buffer(char* source, buffer_T* output) {
   // printf("%zu\n", root->children->size);
 }
 
-const char* erbx_version(void) {
-  return ERBX_VERSION;
-}
+const char *erbx_version(void) { return ERBX_VERSION; }

src/include/array.h

@@ -4,22 +4,22 @@
 #include <stdlib.h>
 
 typedef struct ARRAY_STRUCT {
-  void** items;
+  void **items;
   size_t size;
   size_t capacity;
 } array_T;
 
-array_T* array_init(int capacity);
+array_T *array_init(int capacity);
 
-void* array_get(array_T* array, int index);
+void *array_get(array_T *array, int index);
 
-void array_append(array_T* array, void* item);
-void array_set(array_T* array, int index, void* item);
-void array_free(array_T* array);
-void array_remove(array_T* array, int index);
+void array_append(array_T *array, void *item);
+void array_set(array_T *array, int index, void *item);
+void array_free(array_T *array);
+void array_remove(array_T *array, int index);
 
-size_t array_capacity(array_T* array);
-size_t array_size(array_T* array);
+size_t array_capacity(array_T *array);
+size_t array_size(array_T *array);
 size_t array_sizeof(void);
 
 #endif

src/include/ast.h

@@ -19,14 +19,14 @@ typedef struct AST_STRUCT {
     AST_NOOP,
   } type;
 
-  array_T* children;
-  char* name;
-  struct AST_STRUCT* value;
+  array_T *children;
+  char *name;
+  struct AST_STRUCT *value;
   int data_type;
   int int_value;
 } AST_T;
 
-AST_T* ast_init(int type);
+AST_T *ast_init(int type);
 
 size_t ast_sizeof(void);
 

src/include/buffer.h

@@ -1,26 +1,26 @@
 #ifndef ERBX_BUFFER_H
 #define ERBX_BUFFER_H
 
-#include <stdlib.h>
 #include <stdbool.h>
+#include <stdlib.h>
 
 typedef struct BUFFER_STRUCT {
-  char* value;
+  char *value;
   size_t length;
   size_t capacity;
 } buffer_T;
 
-bool buffer_init(buffer_T* buffer);
+bool buffer_init(buffer_T *buffer);
 
-void buffer_append(buffer_T* buffer, const char* text);
-void buffer_prepend(buffer_T* buffer, const char* text);
-void buffer_concat(buffer_T* destination, buffer_T* source);
-void buffer_free(buffer_T* buffer);
+void buffer_append(buffer_T *buffer, const char *text);
+void buffer_prepend(buffer_T *buffer, const char *text);
+void buffer_concat(buffer_T *destination, buffer_T *source);
+void buffer_free(buffer_T *buffer);
 
-char* buffer_value(buffer_T* buffer);
+char *buffer_value(buffer_T *buffer);
 
-size_t buffer_length(buffer_T* buffer);
-size_t buffer_capacity(buffer_T* buffer);
+size_t buffer_length(buffer_T *buffer);
+size_t buffer_capacity(buffer_T *buffer);
 size_t buffer_sizeof(void);
 
 #endif