Get initial wasm impl working

Author: bradcypert

CLAUDE.md

@@ -0,0 +1,56 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+HTTPSpec is a command-line tool written in Zig that extends HTTP files with assertions for integration testing. It parses `.http` or `.httpspec` files, executes HTTP requests sequentially, and validates responses against user-defined assertions.
+
+## Key Commands
+
+- **Build**: `zig build`
+- **Run**: `zig build run -- [file_or_directory]`
+- **Test**: `zig build test`
+- **Install**: `zig build install`
+
+## Architecture
+
+### Core Components
+
+- **`src/main.zig`**: Entry point with CLI parsing, file discovery, and parallel test execution using thread pools
+- **`src/httpfile/parser.zig`**: Parses `.http`/`.httpspec` files into structured HttpRequest objects with assertions
+- **`src/httpfile/http_client.zig`**: HTTP client for executing requests and capturing responses
+- **`src/httpfile/assertion_checker.zig`**: Validates responses against assertions (status codes, headers, body content)
+- **`src/reporters/test_reporter.zig`**: Test result reporting and statistics
+
+### File Format
+
+HTTPSpec extends standard `.http` files with assertion syntax:
+```
+### Request name
+GET https://example.com/api/endpoint
+Header: value
+
+//# status == 200
+//# header["content-type"] == "application/json"
+//# body contains "expected"
+```
+
+### Assertion Types
+- **Status**: `status == 200`, `status != 404`
+- **Headers**: `header["content-type"] == "application/json"`
+- **Body**: `body == "exact match"`, `body contains "substring"`
+- **Not equals**: Uses `!=` or `not_contains` operators
+
+### Configuration
+
+- **Threading**: Set `HTTP_THREAD_COUNT` environment variable to control parallel execution
+- **File Discovery**: Recursively finds `.http`/`.httpspec` files when no specific files are provided
+
+### Dependencies
+
+- **clap**: Command-line argument parsing (defined in `build.zig.zon`)
+
+## Testing Strategy
+
+The build system automatically discovers and tests all `.zig` files in the `src/` directory. Tests are run in parallel for better performance.

blog_post.md

@@ -27,6 +27,26 @@ pub fn build(b: *std.Build) void {
 
     b.installArtifact(exe);
 
+    // Add WASM build target
+    const wasm = b.addExecutable(.{
+        .name = "httpspec",
+        .root_source_file = b.path("src/wasm.zig"),
+        .target = b.resolveTargetQuery(.{
+            .cpu_arch = .wasm32,
+            .os_tag = .freestanding,
+        }),
+        .optimize = optimize,
+    });
+
+    // Configure WASM-specific build options
+    wasm.entry = .disabled;
+    wasm.rdynamic = true;
+
+    const wasm_step = b.step("wasm", "Build WebAssembly module");
+    wasm_step.dependOn(&b.addInstallArtifact(wasm, .{
+        .dest_dir = .{ .override = .{ .custom = "web" } },
+    }).step);
+
     const run_cmd = b.addRunArtifact(exe);
 
     run_cmd.step.dependOn(b.getInstallStep());

build.zig

@@ -0,0 +1,174 @@
+const std = @import("std");
+const HttpParser = @import("./httpfile/parser.zig");
+
+// Global allocator for WASM - use page allocator which works reliably in WASM
+const allocator = std.heap.page_allocator;
+
+// External JavaScript functions that we can call from WASM
+extern fn consoleLog(ptr: [*]const u8, len: usize) void;
+extern fn consoleError(ptr: [*]const u8, len: usize) void;
+
+// Buffer to store the result JSON
+var result_buffer: [65536]u8 = undefined; // 64KB for results
+var result_len: usize = 0;
+
+/// Single entry point: parses HTTPSpec content and returns structured data for JavaScript to execute
+export fn parseHttpSpecToJson(content_ptr: [*]const u8, content_len: usize) [*]const u8 {
+    const content = content_ptr[0..content_len];
+    
+    logToConsole("Parsing HTTPSpec content...");
+    
+    // Parse the HTTPSpec content
+    var items = HttpParser.parseContent(allocator, content) catch |err| {
+        const error_msg = std.fmt.allocPrint(allocator, "Parse failed: {s}", .{@errorName(err)}) catch "Parse failed";
+        defer allocator.free(error_msg);
+        logErrorToConsole(error_msg);
+        
+        const error_json = std.fmt.bufPrint(&result_buffer, 
+            \\{{"success": false, "error": "Parse failed: {s}", "requests": []}}
+        , .{@errorName(err)}) catch "{{\"success\": false, \"error\": \"JSON format error\", \"requests\": []}}";
+        
+        result_len = error_json.len;
+        return &result_buffer;
+    };
+    
+    const owned_items = items.toOwnedSlice() catch |err| {
+        const error_msg = std.fmt.allocPrint(allocator, "Failed to convert items: {s}", .{@errorName(err)}) catch "Failed to convert items";
+        defer allocator.free(error_msg);
+        logErrorToConsole(error_msg);
+        
+        const error_json = std.fmt.bufPrint(&result_buffer, 
+            \\{{"success": false, "error": "Failed to convert items: {s}", "requests": []}}
+        , .{@errorName(err)}) catch "{{\"success\": false, \"error\": \"JSON format error\", \"requests\": []}}";
+        
+        result_len = error_json.len;
+        return &result_buffer;
+    };
+    defer {
+        for (owned_items) |*item| {
+            item.deinit(allocator);
+        }
+        allocator.free(owned_items);
+    }
+    
+    const log_msg = std.fmt.allocPrint(allocator, "Parsed {d} HTTP requests", .{owned_items.len}) catch "Parsed requests";
+    defer allocator.free(log_msg);
+    logToConsole(log_msg);
+    
+    // Convert parsed requests to JSON for JavaScript to execute
+    const json = formatRequestsAsJson(owned_items) catch "{{\"success\": false, \"error\": \"JSON format error\", \"requests\": []}}";
+    result_len = json.len;
+    
+    logToConsole("HTTPSpec parsing complete");
+    
+    return &result_buffer;
+}
+
+/// Returns the length of the last result
+export fn getResultLength() usize {
+    return result_len;
+}
+
+/// Formats parsed requests as JSON string for JavaScript to execute
+/// Uses manual JSON construction because std.json.stringify has issues with complex types in WASM
+fn formatRequestsAsJson(requests: []const HttpParser.HttpRequest) ![]const u8 {
+    var json_string = std.ArrayList(u8).init(allocator);
+    defer json_string.deinit();
+    
+    var writer = json_string.writer();
+    
+    try writer.writeAll("{\"success\": true, \"requests\": [");
+    
+    for (requests, 0..) |request, i| {
+        if (i > 0) try writer.writeAll(", ");
+        
+        try writer.writeAll("{");
+        
+        // Method
+        const method_name = if (request.method) |m| @tagName(m) else "GET";
+        try writer.writeAll("\"method\": ");
+        try std.json.stringify(method_name, .{}, writer);
+        try writer.writeAll(", ");
+        
+        // URL  
+        try writer.writeAll("\"url\": ");
+        try std.json.stringify(request.url, .{}, writer);
+        try writer.writeAll(", ");
+        
+        // Headers as object
+        try writer.writeAll("\"headers\": {");
+        for (request.headers.items, 0..) |header, j| {
+            if (j > 0) try writer.writeAll(", ");
+            try std.json.stringify(header.name, .{}, writer);
+            try writer.writeAll(": ");
+            try std.json.stringify(header.value, .{}, writer);
+        }
+        try writer.writeAll("}, ");
+        
+        // Body
+        try writer.writeAll("\"body\": ");
+        if (request.body) |body| {
+            try std.json.stringify(body, .{}, writer);
+        } else {
+            try writer.writeAll("null");
+        }
+        try writer.writeAll(", ");
+        
+        // Assertions
+        try writer.writeAll("\"assertions\": [");
+        for (request.assertions.items, 0..) |assertion, k| {
+            if (k > 0) try writer.writeAll(", ");
+            try writer.writeAll("{");
+            try writer.writeAll("\"key\": ");
+            try std.json.stringify(assertion.key, .{}, writer);
+            try writer.writeAll(", \"value\": ");
+            try std.json.stringify(assertion.value, .{}, writer);
+            try writer.writeAll(", \"type\": ");
+            try std.json.stringify(@tagName(assertion.assertion_type), .{}, writer);
+            try writer.writeAll("}");
+        }
+        try writer.writeAll("]");
+        
+        try writer.writeAll("}");
+    }
+    
+    try writer.writeAll("]}");
+    
+    // Copy to result buffer
+    const json_str = json_string.items;
+    if (json_str.len >= result_buffer.len) {
+        return std.fmt.bufPrint(&result_buffer, "{{\"success\": false, \"error\": \"JSON too large ({d} bytes), buffer size {d}\", \"requests\": []}}", .{ json_str.len, result_buffer.len });
+    }
+    
+    @memcpy(result_buffer[0..json_str.len], json_str);
+    return result_buffer[0..json_str.len];
+}
+
+// escapeJsonString function removed - std.json.stringify handles escaping automatically
+
+/// Test function to verify WASM is working
+export fn testWasm() i32 {
+    consoleLog("WASM module loaded successfully!", 30);
+    return 42;
+}
+
+/// Logging helper functions for debugging
+fn logToConsole(message: []const u8) void {
+    consoleLog(message.ptr, message.len);
+}
+
+fn logErrorToConsole(message: []const u8) void {
+    consoleError(message.ptr, message.len);
+}
+
+/// Test function for basic HTTPSpec parsing
+export fn testHttpSpecParsing() [*]const u8 {
+    const test_content = 
+        \\### Test request
+        \\GET https://httpbin.org/status/200
+        \\
+        \\//# status == 200
+    ;
+    
+    return parseHttpSpecToJson(test_content.ptr, test_content.len);
+}

src/wasm.zig

@@ -0,0 +1,6 @@
+### Test JSONPlaceholder API
+GET https://jsonplaceholder.typicode.com/users/1
+Accept: application/json
+
+//# status == 200
+//# body contains "Leanne Graham"

test.httpspec

@@ -0,0 +1,83 @@
+# HTTPSpec Web Runner
+
+A web-based interface for running HTTPSpec tests directly in your browser using WebAssembly.
+
+## Quick Start
+
+1. **Build the WebAssembly module:**
+   ```bash
+   zig build wasm
+   cp zig-out/web/httpspec.wasm web/
+   ```
+
+2. **Serve the web files:**
+   Since the browser needs to load the WASM file, you need to serve the files over HTTP (not file://).
+   
+   **Option A: Using Python (recommended for local testing):**
+   ```bash
+   cd web
+   python3 -m http.server 8000
+   ```
+   
+   **Option B: Using Node.js:**
+   ```bash
+   cd web
+   npx serve .
+   ```
+   
+   **Option C: Using any other static file server**
+
+3. **Open in browser:**
+   Navigate to `http://localhost:8000` in your web browser.
+
+## Features
+
+- **HTTPSpec Syntax Support**: Full support for HTTPSpec syntax including all assertion types
+- **Real-time Parsing**: Uses WebAssembly-compiled Zig parser for accurate syntax validation  
+- **HTTP Execution**: Executes actual HTTP requests using the browser's fetch API
+- **Assertion Checking**: Validates responses against your defined assertions
+- **Example Templates**: Pre-loaded examples to get you started quickly
+
+## Supported Assertions
+
+- `status == 200` - Check response status code
+- `header["content-type"] contains "json"` - Check response headers
+- `body contains "expected text"` - Check response body content
+- `body == "exact match"` - Exact body matching
+- Support for `!=`, `not_contains`, `starts_with`, `ends_with` operators
+
+## CORS Considerations
+
+Since the web version runs in a browser, it's subject to CORS (Cross-Origin Resource Sharing) policies:
+
+- ✅ **Same-origin requests** (same domain/port) work without issues
+- ✅ **CORS-enabled APIs** that send proper headers work fine
+- ✅ **Public APIs** like JSONPlaceholder work great for testing
+- ❌ **CORS-restricted APIs** will be blocked by the browser
+
+### Workarounds for CORS:
+1. Test against CORS-enabled APIs
+2. Use browser flags to disable CORS (development only): `--disable-web-security`
+3. Set up a local proxy server
+4. Use the CLI version for unrestricted testing
+
+## File Structure
+
+```
+web/
+├── index.html           # Main web interface
+├── httpspec-runner.js   # JavaScript WASM integration
+├── httpspec.wasm       # Compiled WebAssembly module
+└── README.md           # This file
+```
+
+## Development
+
+To rebuild the WASM module after making changes to the Zig code:
+
+```bash
+zig build wasm
+cp zig-out/web/httpspec.wasm web/
+```
+
+The web interface will automatically reload the WASM module on page refresh.