Fix some codegen

Author: renatillas

.gitignore

@@ -5,3 +5,4 @@ erl_crash.dump
 
 test/generated_outputs/
 .claude/
+example/build

example/README.md

@@ -0,0 +1,205 @@
+# Protozoa Example Project
+
+This example project demonstrates the usage of the Protozoa Protocol Buffer library for Gleam.
+
+## Overview
+
+Protozoa is a Protocol Buffer compiler and runtime library for Gleam that supports all 27 Google Protocol Buffer well-known types and provides complete encode/decode functionality.
+
+## What's Demonstrated
+
+This example showcases:
+
+### ✅ Core Protocol Buffer Features
+- **Basic Types**: `int32`, `string`, `bool`, `bytes`, `repeated` fields
+- **Enums**: User roles with proper encoding/decoding
+- **Oneof Fields**: Union types with multiple data variants
+- **Well-Known Types**: `Timestamp`, `StringValue`, and other Google well-known types
+
+### ✅ Advanced Features
+- **Message Nesting**: Complex message structures
+- **Type Safety**: Full Gleam type safety with generated types
+- **Encoding/Decoding**: Bidirectional serialization with proper error handling
+
+## Files Structure
+
+```
+example/
+├── src/
+│   ├── proto/
+│   │   └── simple.proto          # Protocol Buffer definitions
+│   ├── generated/
+│   │   └── proto.gleam          # Auto-generated Gleam code
+│   └── simple_example.gleam     # Main example application
+├── test/
+│   └── simple_test.gleam        # Test suite
+└── README.md                    # This file
+```
+
+## Protocol Buffer Definitions
+
+### User Message
+Demonstrates basic types, enums, repeated fields, and well-known types:
+
+```proto
+message User {
+  int32 id = 1;
+  string name = 2;
+  string email = 3;
+  google.protobuf.Timestamp created_at = 4;
+  bool is_active = 5;
+  UserRole role = 6;
+  repeated string tags = 7;
+  google.protobuf.StringValue bio = 8;
+}
+```
+
+### SimpleMessage with Oneof
+Demonstrates union types (oneof fields):
+
+```proto
+message SimpleMessage {
+  string id = 1;
+  
+  oneof data {
+    string text_data = 2;
+    int64 numeric_data = 3;
+    bytes binary_data = 4;
+  }
+  
+  string description = 5;
+  bool enabled = 6;
+}
+```
+
+## Running the Example
+
+### Prerequisites
+- Gleam >= 1.5.0
+- Protozoa library
+
+### Generate Code
+```bash
+# Generate Gleam code from proto files
+gleam run -m protozoa src/proto/simple.proto src/generated/
+```
+
+### Run the Example
+```bash
+gleam run -m simple_example
+```
+
+Expected output:
+```
+🚀 Protozoa Simple Example
+=========================
+👤 Created user: Alice (alice@example.com)
+📦 Encoded user data successfully
+💬 Created simple message: msg_001
+✅ Successfully decoded message: msg_001
+   Text data: Hello, World!
+✅ Simple example completed!
+```
+
+### Run Tests
+```bash
+gleam run -m gleeunit -- --module simple_test
+```
+
+All tests should pass:
+```
+3 tests, no failures
+```
+
+## Generated Code Features
+
+The generated `proto.gleam` file includes:
+
+### Type Definitions
+- **Union Types**: For oneof fields with proper Gleam algebraic data types
+- **Record Types**: For messages with named fields
+- **Enum Types**: For protocol buffer enums
+
+### Encoding Functions
+- `encode_user(user: User) -> BitArray`
+- `encode_simplemessage(message: SimpleMessage) -> BitArray`
+- `encode_timestamp(timestamp: Timestamp) -> BitArray`
+
+### Decoding Functions
+- `decode_user(data: BitArray) -> Result(User, List(DecodeError))`
+- `decode_simplemessage(data: BitArray) -> Result(SimpleMessage, List(DecodeError))`
+- `decode_timestamp(data: BitArray) -> Result(Timestamp, List(DecodeError))`
+
+### Well-Known Types Support
+The generated code includes full support for Google's Protocol Buffer well-known types:
+- `Timestamp` - for date/time values
+- `StringValue` - for optional strings
+- `Int32Value`, `Int64Value` - for optional integers
+- And many more...
+
+## Key Features Demonstrated
+
+### 1. Type Safety
+```gleam
+// Compile-time type checking
+let user = proto.User(
+  id: 42,
+  name: "Alice",
+  // ... other fields
+)
+```
+
+### 2. Oneof Fields (Union Types)
+```gleam
+// Pattern matching on union types
+case message.data {
+  option.Some(proto.TextData(text)) -> // Handle text
+  option.Some(proto.NumericData(num)) -> // Handle number
+  option.Some(proto.BinaryData(bytes)) -> // Handle binary
+  option.None -> // Handle no data
+}
+```
+
+### 3. Error Handling
+```gleam
+// Safe decoding with proper error handling
+case proto.decode_user(encoded_data) {
+  Ok(user) -> // Successfully decoded
+  Error(decode_errors) -> // Handle decode errors
+}
+```
+
+### 4. Well-Known Types
+```gleam
+// Using Google's well-known types
+let timestamp = proto.Timestamp(
+  seconds: 1640995200,
+  nanos: 123456789,
+)
+```
+
+## What's Working
+
+✅ **Basic Types**: All primitive types work correctly  
+✅ **Enums**: User roles and other enums  
+✅ **Oneof Fields**: Union types with proper type safety  
+✅ **Well-Known Types**: Timestamp and other Google types  
+✅ **Encoding/Decoding**: Round-trip serialization  
+✅ **Type Safety**: Full Gleam compiler integration  
+
+## Performance Notes
+
+- **Efficient Encoding**: Uses Protocol Buffer's compact binary format
+- **Memory Safe**: Leverages Gleam's memory safety guarantees
+- **Type Safe**: No runtime type errors with proper Gleam types
+
+## Integration
+
+To use Protozoa in your own project:
+
+1. **Add Dependency**: Add protozoa to your `gleam.toml`
+2. **Define Schemas**: Create `.proto` files
+3. **Generate Code**: Run `gleam run -m protozoa your.proto src/generated/`
+4. **Import & Use**: Import generated modules and use the types
+
+This example demonstrates that Protozoa successfully provides a complete, type-safe Protocol Buffer implementation for Gleam with excellent integration into the Gleam ecosystem.

example/gleam.toml

@@ -0,0 +1,14 @@
+name = "protozoa_example"
+version = "1.0.0"
+description = "Example project demonstrating Protozoa Protocol Buffer library usage"
+
+gleam = ">= 1.5.0"
+
+[dependencies]
+gleam_stdlib = ">= 0.34.0 and < 2.0.0"
+# Protozoa will be loaded from parent directory
+protozoa = { path = "../" }
+
+[dev-dependencies]
+gleeunit = ">= 1.0.0 and < 2.0.0"
+

example/manifest.toml

@@ -0,0 +1,20 @@
+# This file was generated by Gleam
+# You typically do not need to edit this file
+
+packages = [
+  { name = "argv", version = "1.0.2", build_tools = ["gleam"], requirements = [], otp_app = "argv", source = "hex", outer_checksum = "BA1FF0929525DEBA1CE67256E5ADF77A7CDDFE729E3E3F57A5BDCAA031DED09D" },
+  { name = "filepath", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "B06A9AF0BF10E51401D64B98E4B627F1D2E48C154967DA7AF4D0914780A6D40A" },
+  { name = "gleam_erlang", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "1124AD3AA21143E5AF0FC5CF3D9529F6DB8CA03E43A55711B60B6B7B3874375C" },
+  { name = "gleam_stdlib", version = "0.62.1", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "0080706D3A5A9A36C40C68481D1D231D243AF602E6D2A2BE67BA8F8F4DFF45EC" },
+  { name = "gleam_time", version = "1.4.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_time", source = "hex", outer_checksum = "DCDDC040CE97DA3D2A925CDBBA08D8A78681139745754A83998641C8A3F6587E" },
+  { name = "gleeunit", version = "1.6.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "FDC68A8C492B1E9B429249062CD9BAC9B5538C6FBF584817205D0998C42E1DAC" },
+  { name = "protozoa", version = "2.0.2", build_tools = ["gleam"], requirements = ["argv", "filepath", "gleam_erlang", "gleam_stdlib", "simplifile", "snag", "tom"], source = "local", path = ".." },
+  { name = "simplifile", version = "2.3.0", build_tools = ["gleam"], requirements = ["filepath", "gleam_stdlib"], otp_app = "simplifile", source = "hex", outer_checksum = "0A868DAC6063D9E983477981839810DC2E553285AB4588B87E3E9C96A7FB4CB4" },
+  { name = "snag", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "snag", source = "hex", outer_checksum = "7E9F06390040EB5FAB392CE642771484136F2EC103A92AE11BA898C8167E6E17" },
+  { name = "tom", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "gleam_time"], otp_app = "tom", source = "hex", outer_checksum = "74D0C5A3761F7A7D06994755D4D5AD854122EF8E9F9F76A3E7547606D8C77091" },
+]
+
+[requirements]
+gleam_stdlib = { version = ">= 0.34.0 and < 2.0.0" }
+gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
+protozoa = { path = "../" }

example/src/debug_decoder.gleam

@@ -0,0 +1,80 @@
+import generated/proto
+import gleam/bit_array
+import gleam/int
+import gleam/io
+import gleam/list
+import gleam/string
+import protozoa/decode
+
+pub fn main() {
+  io.println("🔍 Debug: Step-by-step decoding")
+
+  let user =
+    proto.User(
+      id: 42,
+      name: "Test",
+      email: "test@example.com",
+      created_at: proto.Timestamp(seconds: 1_640_995_200, nanos: 0),
+      is_active: True,
+      role: proto.ADMIN,
+      tags: [],
+      bio: proto.StringValue(value: "Bio"),
+    )
+
+  let encoded = proto.encode_user(user)
+  io.println(
+    "Encoded " <> int.to_string(bit_array.byte_size(encoded)) <> " bytes",
+  )
+
+  // Try to manually decode using the lower-level decode functions
+  io.println("\nTrying to decode with raw decode functions...")
+
+  case decode.run(encoded, test_decoder()) {
+    Ok(_) -> io.println("✅ Manual decode succeeded!")
+    Error(errors) -> {
+      io.println("❌ Manual decode failed:")
+      list.each(errors, fn(err) { io.println("  - " <> string.inspect(err)) })
+    }
+  }
+}
+
+fn test_decoder() -> decode.Decoder(String) {
+  // Try to decode just the first field (id)
+  use id <- decode.then(decode.int32_with_default(1, 0))
+  io.println("Decoded field 1 (id): " <> int.to_string(id))
+
+  // Try to decode the second field (name) 
+  use name <- decode.then(decode.string_with_default(2, ""))
+  io.println("Decoded field 2 (name): " <> name)
+
+  // Try to decode the third field (email)
+  use email <- decode.then(decode.string_with_default(3, ""))
+  io.println("Decoded field 3 (email): " <> email)
+
+  // Skip field 4 (timestamp) for now
+  io.println("Skipping field 4 (timestamp)")
+
+  // Try to decode boolean
+  use is_active <- decode.then(decode.bool_with_default(5, False))
+  io.println(
+    "Decoded field 5 (is_active): "
+    <> case is_active {
+      True -> "true"
+      False -> "false"
+    },
+  )
+
+  // Try to decode the enum
+  use role <- decode.then(proto.decode_userrole_field(6))
+  io.println("Decoded field 6 (role): " <> string.inspect(role))
+
+  // Try to decode tags (repeated strings)
+  use tags <- decode.then(decode.repeated_string(7))
+  io.println("Decoded field 7 (tags): " <> string.inspect(tags))
+
+  // Try to decode the StringValue 
+  use bio <- decode.then(decode.nested_message(8, proto.stringvalue_decoder()))
+  io.println("Decoded field 8 (bio): " <> bio.value)
+
+  decode.success("All fields decoded!")
+}

example/src/debug_encoding.gleam

@@ -0,0 +1,68 @@
+import generated/proto
+import gleam/bit_array
+import gleam/int
+import gleam/io
+import gleam/string
+
+pub fn main() {
+  io.println("🔍 Debug: Analyzing encoded User message")
+
+  let user =
+    proto.User(
+      id: 42,
+      name: "Test",
+      email: "test@example.com",
+      created_at: proto.Timestamp(seconds: 1_640_995_200, nanos: 0),
+      is_active: True,
+      role: proto.ADMIN,
+      tags: [],
+      bio: proto.StringValue(value: "Bio"),
+    )
+
+  let encoded = proto.encode_user(user)
+
+  io.println("Encoded length: " <> int.to_string(bit_array.byte_size(encoded)))
+
+  // Convert to list of bytes for inspection
+  case bit_array.to_string(encoded) {
+    Ok(_) -> io.println("Contains valid UTF-8")
+    Error(_) -> io.println("Contains binary data (expected)")
+  }
+
+  // Let's examine all the bytes
+  io.println("All bytes as hex:")
+  hex_dump(encoded)
+
+  // Test individual field encodings
+  io.println("\nTesting individual field encodings:")
+
+  // Let's analyze what the User encoder creates
+  io.println("User encoding contains these field numbers: 1,2,3,4,5,6,8")
+  io.println(
+    "Expected wire types: Varint,String,String,LengthDelimited,Bool,Varint,LengthDelimited",
+  )
+}
+
+fn hex_dump(data: BitArray) -> Nil {
+  hex_dump_helper(data, 0)
+}
+
+fn hex_dump_helper(data: BitArray, offset: Int) -> Nil {
+  case data {
+    <<byte:int, rest:bits>> -> {
+      let hex = int.to_base16(byte)
+      let padded = case string.length(hex) {
+        1 -> "0" <> hex
+        _ -> hex
+      }
+      io.print(padded <> " ")
+      case int.remainder(offset + 1, 16) {
+        Ok(0) -> io.println("")
+        _ -> Nil
+      }
+      hex_dump_helper(rest, offset + 1)
+    }
+    <<>> -> io.println("")
+    _ -> io.println("(invalid pattern)")
+  }
+}