Cleanup C fraglets

I wanted a single POC for different fraglet "modes" as it would make
sense for a single container to have multiple injection points for
various reasons. Doing that example in C makes less sense than in Java
-- where that example can be demonstrated with Wordle/word puzzle fun.

Author: frison

the-c-programming-language/files/hello-world.c

@@ -1,14 +1,6 @@
+// BEGIN_FRAGLET
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <math.h>
-#include <time.h>
-#include <ctype.h>
-#include <errno.h>
 
-// BEGIN_FRAGLET
 int main() {
     printf("Hello World!\n");
     return 0;

the-c-programming-language/files/hello-world.sh

@@ -4,4 +4,4 @@ set -e
 
 cd /hello-world
 gcc -Wall -Wextra -o hello hello-world.c || exit 1
-./hello
+./hello "$@"

the-c-programming-language/fraglet/fraglet-main.yml

@@ -4,7 +4,8 @@ fragletTempPath: /FRAGLET
 
 injection:
   codePath: /hello-world/hello-world.c
-  match: Hello World
+  match_start: "// BEGIN_FRAGLET"
+  match_end: "// END_FRAGLET"
 
 guide: /guide.md
 

the-c-programming-language/fraglet/fraglet.yml

@@ -15,10 +15,10 @@ C (GCC compiler, musl libc)
 - Uses musl libc (Alpine's C library)
 
 ## Fragment Authoring
-Write valid C statements or expressions. Your fragment becomes the `main()` function body. Your fragment will be compiled and executed.
+Write valid C code. Your fragment becomes the complete C program. You must include the `main()` function. Your fragment will be compiled and executed.
 
 ## Available Headers
-The template includes these standard headers:
+Standard headers are available:
 - `stdio.h` - Input/output (printf, scanf, FILE operations)
 - `stdlib.h` - Memory allocation (malloc, free), utilities (atoi, exit)
 - `string.h` - String operations (strlen, strcpy, strcmp)
@@ -32,39 +32,81 @@ The template includes these standard headers:
 ## Common Patterns
 - Print: `printf("message\n");`
 - Variables: `int x = 10;`
-- Functions: `int add(int a, int b) { return a + b; }`
 - Arrays: `int arr[10];`
 - Pointers: `int *ptr = &x;`
 - Loops: `for (int i = 0; i < 10; i++) { ... }`
+- Conditionals: `if (condition) { ... } else { ... }`
+- Memory: `int *arr = malloc(10 * sizeof(int)); free(arr);`
+- Strings: `char str[] = "hello"; int len = strlen(str);`
 
 ## Examples
 ```c
 // Simple output
-printf("Hello from fragment!\n");
+#include <stdio.h>
+int main() {
+    printf("Hello from fragment!\n");
+    return 0;
+}
 
 // Variables and calculations
-int a = 5;
-int b = 10;
-printf("Sum: %d\n", a + b);
+#include <stdio.h>
+int main() {
+    int a = 5;
+    int b = 10;
+    printf("Sum: %d\n", a + b);
+    return 0;
+}
+
+// Loops and arrays
+#include <stdio.h>
+int main() {
+    int numbers[] = {1, 2, 3, 4, 5};
+    int sum = 0;
+    for (int i = 0; i < 5; i++) {
+        sum += numbers[i];
+    }
+    printf("Array sum: %d\n", sum);
+    return 0;
+}
 
-// Loops
-for (int i = 1; i <= 5; i++) {
-    printf("Count: %d\n", i);
+// String manipulation
+#include <stdio.h>
+#include <string.h>
+int main() {
+    char message[] = "Hello, World!";
+    int len = strlen(message);
+    printf("Length: %d\n", len);
+    return 0;
 }
 
-// Arrays
-int numbers[] = {1, 2, 3, 4, 5};
-int sum = 0;
-for (int i = 0; i < 5; i++) {
-    sum += numbers[i];
+// Dynamic memory
+#include <stdio.h>
+#include <stdlib.h>
+int main() {
+    int *arr = malloc(5 * sizeof(int));
+    for (int i = 0; i < 5; i++) {
+        arr[i] = i * 2;
+    }
+    free(arr);
+    return 0;
+}
+
+// Math functions
+#include <stdio.h>
+#include <math.h>
+int main() {
+    double result = sqrt(16.0);
+    printf("Square root: %.2f\n", result);
+    return 0;
 }
-printf("Array sum: %d\n", sum);
 ```
 
 ## Caveats
 - Fragments must be valid C code that compiles
 - Remember to include `\n` in printf for newlines
-- Variables are scoped to the main function
-- The code is compiled fresh each time, so compilation errors will fail execution
+- You must include the `main()` function in your fragment
+- Include necessary headers (stdio.h, stdlib.h, etc.) for the functions you use
+- Dynamic memory must be freed to avoid leaks
 - musl libc may have some differences from glibc in edge cases
+- The code is compiled fresh each time, so compilation errors will fail execution
 

the-c-programming-language/fraglet/guide-main.md

@@ -0,0 +1,100 @@
+#!/bin/bash
+set -euo pipefail
+
+IMAGE="${1:-100hellos/the-c-programming-language:local}"
+
+# Helper: verify fraglet compiles and runs, output contains expected string
+verify_fraglet() {
+    local expected="$1"
+    fragletc --image "$IMAGE" - 2>&1 | grep -q "$expected"
+}
+
+echo "Testing default execution..."
+docker run --rm "$IMAGE" | grep -q "Hello World!"
+
+echo "Testing fraglet examples from guide.md..."
+
+# Example 1: Simple output
+verify_fraglet "Hello from fragment!" <<'EOF'
+#include <stdio.h>
+int main() {
+    printf("Hello from fragment!\n");
+    return 0;
+}
+EOF
+
+# Example 2: Variables and calculations
+verify_fraglet "Sum: 15" <<'EOF'
+#include <stdio.h>
+int main() {
+    int a = 5;
+    int b = 10;
+    printf("Sum: %d\n", a + b);
+    return 0;
+}
+EOF
+
+# Example 3: Loops and arrays
+verify_fraglet "Array sum: 15" <<'EOF'
+#include <stdio.h>
+int main() {
+    int numbers[] = {1, 2, 3, 4, 5};
+    int sum = 0;
+    for (int i = 0; i < 5; i++) {
+        sum += numbers[i];
+    }
+    printf("Array sum: %d\n", sum);
+    return 0;
+}
+EOF
+
+# Example 4: String manipulation
+verify_fraglet "Length: 13" <<'EOF'
+#include <stdio.h>
+#include <string.h>
+int main() {
+    char message[] = "Hello, World!";
+    int len = strlen(message);
+    printf("Length: %d\n", len);
+    return 0;
+}
+EOF
+
+# Example 5: Dynamic memory
+verify_fraglet "Freed" <<'EOF'
+#include <stdio.h>
+#include <stdlib.h>
+int main() {
+    int *arr = malloc(5 * sizeof(int));
+    for (int i = 0; i < 5; i++) {
+        arr[i] = i * 2;
+    }
+    free(arr);
+    printf("Freed\n");
+    return 0;
+}
+EOF
+
+# Example 6: Math functions
+verify_fraglet "Square root: 4.00" <<'EOF'
+#include <stdio.h>
+#include <math.h>
+int main() {
+    double result = sqrt(16.0);
+    printf("Square root: %.2f\n", result);
+    return 0;
+}
+EOF
+
+# Example 7: Argument passing
+echo "Testing argument passing..."
+fragletc --image "$IMAGE" - arg1 arg2 <<'EOF' 2>&1 | grep -q "First: arg1"
+#include <stdio.h>
+int main(int argc, char *argv[]) {
+    if (argc > 1) printf("First: %s\n", argv[1]);
+    if (argc > 2) printf("Second: %s\n", argv[2]);
+    return 0;
+}
+EOF
+
+echo "✓ All tests passed"