First

Author: renatillas

.claude/settings.local.json

@@ -0,0 +1,28 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gleam test:*)",
+      "Bash(gleam run:*)",
+      "Bash(gleam check:*)",
+      "Bash(grep:*)",
+      "Bash(sed:*)",
+      "Bash(gleam build:*)",
+      "Bash(cat:*)",
+      "Read(//usr/**)",
+      "Bash(find:*)",
+      "Bash(chmod:*)",
+      "Bash(./test/cleanup.sh:*)",
+      "Bash(./scripts/setup_tests.sh:*)",
+      "Bash(./gloto:*)",
+      "Bash(./scripts/clean_test_files.sh:*)",
+      "Bash(./scripts/setup_test_files.sh:*)",
+      "Bash(mkdir:*)",
+      "Bash(bash:*)",
+      "WebFetch(domain:hexdocs.pm)",
+      "Bash(rm:*)",
+      "Bash(rg:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

.githooks/pre-commit

@@ -0,0 +1,23 @@
+#!/bin/bash
+# Pre-commit hook to prevent committing generated test files
+
+# Check if any files in build/test/ are staged
+if git diff --cached --name-only | grep -q "^build/test/"; then
+    echo "Error: Attempting to commit generated test files from build/test/"
+    echo "These files should not be committed to the repository."
+    echo "Run 'git reset HEAD build/test/' to unstage them."
+    exit 1
+fi
+
+# Check if any _pb.gleam files in src/ are staged (except example_pb.gleam and test_optional_pb.gleam)
+if git diff --cached --name-only | grep -E "^src/.*_pb\.gleam$" | grep -v "example_pb.gleam" | grep -v "test_optional_pb.gleam"; then
+    echo "Warning: You are committing generated _pb.gleam files in src/"
+    echo "Consider moving test-generated files to build/test/ instead."
+    read -p "Continue anyway? (y/n) " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        exit 1
+    fi
+fi
+
+exit 0

.github/workflows/test.yml

@@ -0,0 +1,23 @@
+name: test
+
+on:
+  push:
+    branches:
+      - master
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: erlef/setup-beam@v1
+        with:
+          otp-version: "28"
+          gleam-version: "1.12.0-nightly-20250818"
+          rebar3-version: "3"
+          # elixir-version: "1"
+      - run: gleam deps download
+      - run: gleam test
+      - run: gleam format --check src test

.gitignore

@@ -0,0 +1,10 @@
+*.beam
+*.ez
+/build
+erl_crash.dump
+
+# Test-generated files - kept in test/ dir to avoid cluttering src/
+test/*_pb.gleam
+test/.generated/
+build/test_gen/
+dev/

Makefile

@@ -0,0 +1,56 @@
+.PHONY: test clean build all setup-test
+
+# Default target
+all: build
+
+# Build the project
+build:
+	gleam build
+
+# Setup test environment by generating test proto files
+setup-test:
+	@echo "Setting up test environment..."
+	@./scripts/setup_tests.sh
+
+# Run tests with proper setup and cleanup
+test: setup-test
+	@echo "Running tests..."
+	gleam test
+	@echo "Cleaning up test files..."
+	@rm -rf build/test_gen
+
+# Clean all build artifacts and generated test files
+clean:
+	@echo "Cleaning build artifacts..."
+	@rm -rf build/
+	@rm -rf _build/
+	@echo "Clean complete"
+
+# Generate a proto file (usage: make generate INPUT=file.proto OUTPUT=file_pb.gleam)
+generate:
+	@if [ -z "$(INPUT)" ] || [ -z "$(OUTPUT)" ]; then \
+		echo "Usage: make generate INPUT=file.proto OUTPUT=file_pb.gleam"; \
+		exit 1; \
+	fi
+	gleam run -m gloto -- generate $(INPUT) $(OUTPUT)
+
+# Check code formatting and linting
+check:
+	gleam check
+	gleam format --check src test
+
+# Format code
+format:
+	gleam format src test
+
+# Show help
+help:
+	@echo "Available targets:"
+	@echo "  all        - Build the project (default)"
+	@echo "  build      - Build the project"
+	@echo "  test       - Run tests with automatic setup/cleanup"
+	@echo "  clean      - Remove all build artifacts"
+	@echo "  generate   - Generate Gleam code from proto file"
+	@echo "  check      - Run code checks and formatting verification"
+	@echo "  format     - Format the code"
+	@echo "  help       - Show this help message"

README.md

@@ -0,0 +1,141 @@
+# gloto
+
+A Protocol Buffers library for Gleam, providing encoding and decoding of protobuf messages.
+
+[![Package Version](https://img.shields.io/hexpm/v/gloto)](https://hex.pm/packages/gloto)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/gloto/)
+
+## Installation
+
+```sh
+gleam add gloto@1
+```
+
+## Usage
+
+### Encoding Messages
+
+```gleam
+import gloto
+import gleam/int
+import gleam/io
+
+pub fn encode_example() {
+  // Create a protobuf message with multiple fields
+  let message = gloto.build_message([
+    gloto.encode_int32(1, 42),           // Field 1: int32
+    gloto.encode_string(2, "Hello"),     // Field 2: string
+    gloto.encode_bool(3, True),          // Field 3: bool
+  ])
+  
+  // message is now a BitArray containing the encoded protobuf
+  message
+}
+```
+
+### Decoding Messages
+
+```gleam
+import gloto
+import gleam/int
+import gleam/io
+
+pub fn decode_example(data: BitArray) {
+  case gloto.decode(data) {
+    Ok(fields) -> {
+      // Find specific fields by number
+      case gloto.find_field(fields, 1) {
+        Ok(field) -> {
+          case gloto.decode_varint_value(field) {
+            Ok(value) -> io.println("Field 1: " <> int.to_string(value))
+            Error(_) -> io.println("Failed to decode field 1")
+          }
+        }
+        Error(_) -> io.println("Field 1 not found")
+      }
+    }
+    Error(_) -> io.println("Failed to decode message")
+  }
+}
+```
+
+### Nested Messages
+
+```gleam
+import gloto
+
+pub fn nested_message_example() {
+  // Create an inner message
+  let inner = gloto.build_message([
+    gloto.encode_string(1, "inner value"),
+    gloto.encode_int32(2, 100),
+  ])
+  
+  // Embed it in an outer message
+  let outer = gloto.build_message([
+    gloto.encode_int32(1, 999),
+    gloto.encode_message_field(2, inner),  // Nested message in field 2
+  ])
+  
+  outer
+}
+```
+
+### Repeated Fields
+
+Protocol Buffers supports repeated fields. Simply encode multiple values with the same field number:
+
+```gleam
+import gloto
+
+pub fn repeated_fields_example() {
+  let message = gloto.build_message([
+    gloto.encode_int32(1, 10),
+    gloto.encode_int32(1, 20),  // Same field number
+    gloto.encode_int32(1, 30),  // Creates a repeated field
+    gloto.encode_string(2, "other field"),
+  ])
+  
+  // When decoding, use find_all_fields to get all values
+  case gloto.decode(message) {
+    Ok(fields) -> {
+      let repeated = gloto.find_all_fields(fields, 1)
+      // repeated will contain all three int32 values
+      repeated
+    }
+    Error(_) -> panic
+  }
+}
+```
+
+## Supported Types
+
+- **Varint**: int32, int64, bool
+- **Fixed32**: 32-bit values with fixed size
+- **Fixed64**: 64-bit values with fixed size
+- **Length-delimited**: strings, bytes, nested messages
+
+## Architecture
+
+The library is structured into three main modules:
+
+- `gloto/wire` - Wire format types and tag encoding/decoding
+- `gloto/encoder` - Functions for encoding various protobuf types
+- `gloto/decoder` - Functions for decoding protobuf messages
+- `gloto` - High-level API for working with protobuf messages
+
+## Future Plans
+
+- Code generation from .proto files
+- gRPC support
+- Schema validation
+- More comprehensive type support
+
+## Development
+
+```sh
+gleam run   # Run the project
+gleam test  # Run the tests
+```
+
+Further documentation can be found at <https://hexdocs.pm/gloto>.

birdie_snapshots/generate_all_field_types.accepted

@@ -0,0 +1,52 @@
+---
+version: 1.4.0
+title: Generate all field types
+file: ./test/codegen_test.gleam
+test_name: field_types_test
+---
+import gloto/wire
+import gloto/decode
+import gloto/encode
+
+
+
+pub type AllTypes {
+  AllTypes(
+  d: Float,
+  f: Float,
+  i32: Int,
+  i64: Int,
+  b: Bool,
+  s: String,
+  by: BitArray
+  )
+}
+
+pub fn encode_alltypes(alltypes: AllTypes) -> BitArray {
+  encode.message([
+    encode.double_field(1, alltypes.d),
+    encode.float_field(2, alltypes.f),
+    encode.int32_field(3, alltypes.i32),
+    encode.int64_field(4, alltypes.i64),
+    encode.bool_field(5, alltypes.b),
+    encode.string_field(6, alltypes.s),
+    encode.field(7, wire.LengthDelimited, encode.length_delimited(alltypes.by))
+  ])
+}
+
+pub fn alltypes_decoder() -> decode.Decoder(AllTypes) {
+  use d <- decode.subrecord(decode.double(1))
+  use f <- decode.subrecord(decode.float(2))
+  use i32 <- decode.subrecord(decode.int32_with_default(3, 0))
+  use i64 <- decode.subrecord(decode.int64_with_default(4, 0))
+  use b <- decode.subrecord(decode.bool_with_default(5, False))
+  use s <- decode.subrecord(decode.string_with_default(6, ""))
+  use by <- decode.subrecord(decode.bytes(7))
+  decode.success(AllTypes(d: d, f: f, i32: i32, i64: i64, b: b, s: s, by: by))
+}
+
+pub fn decode_alltypes(data: BitArray) -> Result(AllTypes, decode.DecodeError) {
+  decode.decode(data, alltypes_decoder())
+}
+
+