Update CLAUDE.md to reflect Rust 2024 edition and test improvements

Author: anonrig

CLAUDE.md

@@ -0,0 +1,100 @@
+# Claude Development Notes
+
+## Project Overview
+
+This is a Rust implementation of IDNA (Internationalized Domain Names in Applications) based on the C++ implementation from [ada-url/ada](https://github.com/ada-url/ada). The project aims to provide a zero-dependency, high-performance IDNA library for Rust.
+
+## Implementation Details
+
+### Core Components
+
+- **`src/domain.rs`** - Main IDNA conversion functions (`to_ascii`, `to_unicode`)
+- **`src/punycode.rs`** - RFC 3492 Punycode encoding/decoding (1:1 match with C++ implementation)
+- **`src/mapping.rs`** - Character mapping and case folding
+- **`src/normalization.rs`** - Unicode NFC normalization with composition tables
+- **`src/validation.rs`** - Character and domain validation
+- **`src/unicode.rs`** - UTF-8 ↔ UTF-32 conversion utilities
+- **`src/unicode_tables.rs`** - Unicode lookup tables extracted from C++ implementation
+
+### Key Implementation Notes
+
+1. **Zero Dependencies**: No external crates are used. All Unicode processing is implemented manually.
+
+2. **Punycode Implementation**: Exact 1:1 match with C++ [ada_idna.cpp](https://raw.githubusercontent.com/ada-url/ada/refs/heads/main/src/ada_idna.cpp) implementation:
+   - Uses same constants (BASE=36, TMIN=1, TMAX=26, SKEW=38, DAMP=700, INITIAL_BIAS=72, INITIAL_N=128)
+   - Identical algorithm flow and bias adaptation
+
+3. **Unicode Tables**: Extracted from C++ implementation ([ada_idna.cpp](https://raw.githubusercontent.com/ada-url/ada/refs/heads/main/src/ada_idna.cpp)) with proper dimensions:
+   - `DECOMPOSITION_BLOCK`: 67×257 elements
+   - `CANONICAL_COMBINING_CLASS_BLOCK`: 67×257 elements  
+   - `COMPOSITION_BLOCK`: 67×257 elements (17,219 total)
+
+4. **Unicode Normalization**: Complete NFC implementation matching C++ behavior:
+   - Canonical decomposition
+   - Canonical combining class ordering
+   - Canonical composition using two-level lookup tables
+
+## Test Coverage
+
+Comprehensive test suite covering:
+- Basic IDNA conversion (`to_ascii_tests.rs`, `to_unicode_tests.rs`)
+- Unicode identifier validation (`identifier_tests.rs`)
+- Punycode encoding/decoding (`punycode_tests.rs`)
+- Mapping and normalization (`mapping_tests.rs`, `normalization_tests.rs`)
+- Web Platform Tests compatibility (`wpt_tests.rs`)
+
+## Development Commands
+
+**⚠️ IMPORTANT: Always run tests, formatter, and clippy before committing changes ⚠️**
+
+```bash
+# Build
+cargo build
+
+# Run tests (ALWAYS run before committing)
+cargo test
+
+# Lint (ALWAYS run before committing)
+cargo clippy
+
+# Format (ALWAYS run before committing)
+cargo fmt
+```
+
+### Pre-commit Checklist
+1. `cargo test` - All tests must pass
+2. `cargo clippy` - No clippy warnings allowed
+3. `cargo fmt` - Code must be properly formatted
+
+## Current Status
+
+**⚠️ INCOMPLETE IMPLEMENTATION ⚠️**
+
+Known limitations:
+- Some test cases may fail due to expected value discrepancies
+- Unicode table data may need refinement
+- Error handling needs improvement
+- API subject to change
+
+## Source References
+
+- Original C++ header: https://raw.githubusercontent.com/ada-url/ada/refs/heads/main/include/ada/ada_idna.h
+- Original C++ implementation: https://raw.githubusercontent.com/ada-url/ada/refs/heads/main/src/ada_idna.cpp
+- Test cases adapted from: https://github.com/ada-url/idna/tree/main/tests
+
+## Architecture Decisions
+
+1. **Static vs Const Arrays**: Large Unicode tables use `static` instead of `const` to avoid stack overflow during compilation.
+
+2. **UTF-32 Processing**: All Unicode processing is done in UTF-32 code points for simplicity and correctness.
+
+3. **Error Handling**: Custom `IdnaError` enum for specific IDNA-related errors.
+
+4. **Performance**: Optimized for common ASCII cases while maintaining full Unicode support.
+
+## Build Configuration
+
+- **Target**: Rust 2024 edition
+- **Dependencies**: None (zero-dependency implementation)
+- **Features**: No optional features
+- **Minimum Rust Version**: 1.85+ (for Rust 2024 edition)

tests/mapping_tests.rs

@@ -55,10 +55,9 @@ fn test_map_unicode_normalization() {
         ("ø", "ø"),
     ];
 
-    for (input, _expected) in test_cases {
+    for (input, expected) in test_cases {
         let result = mapping::map(input);
-        println!("Unicode mapping: '{}' -> '{}'", input, result);
-        // Note: Exact expected values may need adjustment based on normalization rules
+        assert_eq!(result, expected, "Unicode mapping mismatch for '{}'", input);
     }
 }
 
@@ -78,10 +77,9 @@ fn test_map_case_folding() {
         ("Ελληνικά", "ελληνικά"),
     ];
 
-    for (input, _expected) in test_cases {
+    for (input, expected) in test_cases {
         let result = mapping::map(input);
-        println!("Case folding: '{}' -> '{}'", input, result);
-        // Note: Some Unicode case folding rules are complex
+        assert_eq!(result, expected, "Case folding mismatch for '{}'", input);
     }
 }
 
@@ -103,10 +101,13 @@ fn test_map_special_characters() {
         ), // Multiple handling
     ];
 
-    for (input, _expected) in test_cases {
+    for (input, expected) in test_cases {
         let result = mapping::map(input);
-        println!("Special chars: '{}' -> '{}'", input, result);
-        // Note: Expected behavior may vary based on IDNA mapping rules
+        assert_eq!(
+            result, expected,
+            "Special chars mapping mismatch for '{}'",
+            input
+        );
     }
 }
 
@@ -168,10 +169,13 @@ fn test_map_international_scripts() {
         ("ไทย", "ไทย"),
     ];
 
-    for (input, _expected) in test_cases {
+    for (input, expected) in test_cases {
         let result = mapping::map(input);
-        println!("International script: '{}' -> '{}'", input, result);
-        // Note: Scripts without case distinctions should remain unchanged
+        assert_eq!(
+            result, expected,
+            "International script mapping mismatch for '{}'",
+            input
+        );
     }
 }
 
@@ -189,9 +193,12 @@ fn test_map_bidirectional_characters() {
         ("test\u{202c}example", "testexample"),
     ];
 
-    for (input, _expected) in test_cases {
+    for (input, expected) in test_cases {
         let result = mapping::map(input);
-        println!("Bidirectional: '{}' -> '{}'", input, result);
-        // Note: Expected behavior depends on IDNA mapping rules for bidi chars
+        assert_eq!(
+            result, expected,
+            "Bidirectional mapping mismatch for '{}'",
+            input
+        );
     }
 }

tests/to_ascii_tests.rs

@@ -13,7 +13,7 @@ fn test_to_ascii_basic() {
         ("bücher.example", "xn--bcher-kva.example"),
     ];
 
-    for (input, _expected) in test_cases {
+    for (input, expected) in test_cases {
         let result = to_ascii(input);
         assert!(
             result.is_ok(),
@@ -82,7 +82,7 @@ fn test_to_ascii_edge_cases() {
         ("simple.café.com", "simple.xn--caf-dma.com"),
     ];
 
-    for (input, _expected) in test_cases {
+    for (input, expected) in test_cases {
         let result = to_ascii(input);
         assert!(
             result.is_ok(),