clean up comments

Author: saviorand

lightbug_http/strings.mojo

@@ -33,7 +33,6 @@ struct BytesConstant:
     alias DOUBLE_CRLF = bytes(lineBreak + lineBreak)
 
 
-# RFC 9112 Section 2.2-2: US-ASCII character bounds
 alias US_ASCII_MAX = 0x7F
 alias ISO_8859_1_MAX = 0xFF
 
@@ -79,20 +78,15 @@ fn validate_http_message_octets[origin: Origin](data: Span[UInt8, origin]) raise
         Error: If the data contains invalid multi-byte sequences that could
                create security vulnerabilities.
     """
-    # Check each byte to ensure it's in a safe encoding superset of US-ASCII
     for i in range(len(data)):
         var b = data[i]
 
-        # Allow US-ASCII range (most common case)
         if is_us_ascii_octet(b):
             continue
 
-        # Allow ISO-8859-1 extended range (superset of US-ASCII)
         if is_iso_8859_1_octet(b):
             continue
 
-        # If we get here, we have a byte outside ISO-8859-1 range
-        # This could be part of a multi-byte UTF-8 sequence which is unsafe
         raise Error(
             "RFC 9112 violation: Invalid octet 0x" + hex(Int(b)) + 
             " at position " + String(i) + 
@@ -118,11 +112,8 @@ fn safe_to_string_rfc9112[origin: Origin](b: Span[UInt8, origin]) raises -> Stri
     Raises:
         Error: If the bytes contain invalid sequences for HTTP parsing.
     """
-    # Validate the octets first
     var validated_span = validate_http_message_octets(b)
 
-    # Create string treating bytes as ISO-8859-1 (safe superset of US-ASCII)
-    # Note: We use unsafe_from_utf8 here but we've validated the input is safe
     return String(StringSlice(unsafe_from_utf8=validated_span))
 
 
@@ -143,11 +134,9 @@ fn percent_encode_invalid_octets[origin: Origin](data: Span[UInt8, origin]) -> S
     for i in range(len(data)):
         var b = data[i]
 
-        # Safe US-ASCII characters can be added directly
         if is_us_ascii_octet(b) and b >= 0x20 and b != 0x25:  # Printable ASCII except %
             result += chr(Int(b))
         else:
-            # Percent-encode unsafe or non-printable octets
             result += "%" + hex(Int(b)).upper().rjust(2, "0")
 
     return result

tests/rfc/test_rfc9112_simple.mojo

@@ -6,59 +6,44 @@ def test_rfc9112_parse_as_octets():
     """RFC 9112 Section 2.2-2: MUST parse HTTP message as sequence of octets."""
     print("Testing: Parse HTTP message as sequence of octets...")
 
-    # Test that we parse HTTP messages as individual octets, not Unicode characters
     var http_message = "GET /path HTTP/1.1\r\nHost: example.com\r\n\r\n"
     var octets = http_message.as_bytes()
 
-    # Verify we access individual octets (bytes), not Unicode code points
-    testing.assert_equal(octets[0], ord('G'))  # First octet is 'G'
-    testing.assert_equal(octets[4], ord('/'))  # Fifth octet is '/'
+    testing.assert_equal(octets[0], ord('G'))
+    testing.assert_equal(octets[4], ord('/'))
 
-    # Find the first CR and LF octets in the message
     var found_cr = False
     var found_lf = False
     for i in range(len(octets)):
-        if octets[i] == 0x0D and not found_cr:  # First CR
+        if octets[i] == 0x0D and not found_cr:
             found_cr = True
-        if octets[i] == 0x0A and not found_lf:  # First LF  
+        if octets[i] == 0x0A and not found_lf:
             found_lf = True
         if found_cr and found_lf:
             break
 
-    testing.assert_true(found_cr)  # CR found as octet
-    testing.assert_true(found_lf)  # LF found as octet
-    
-    print("✓ HTTP message parsed as sequence of octets")
+    testing.assert_true(found_cr)
+    testing.assert_true(found_lf)
 
 
 def test_rfc9112_us_ascii_superset_encoding():
     """RFC 9112 Section 2.2-2: MUST use encoding that is superset of US-ASCII."""
     print("Testing: Encoding is superset of US-ASCII...")
 
-    # US-ASCII range is 0x00-0x7F
-    # ISO-8859-1 (0x00-0xFF) is a valid superset
-    
-    # Test US-ASCII characters are valid
     testing.assert_true(ord('G') <= 0x7F)      # US-ASCII
     testing.assert_true(ord(' ') <= 0x7F)      # US-ASCII
     testing.assert_true(0x0A <= 0x7F)          # LF in US-ASCII
     testing.assert_true(0x0D <= 0x7F)          # CR in US-ASCII
-    
-    # Test that superset (ISO-8859-1) includes extended range
     testing.assert_true(0x80 <= 0xFF)          # Extended range valid
     testing.assert_true(0xFF <= 0xFF)          # Maximum byte valid
-    
-    print("✓ Encoding is superset of US-ASCII (ISO-8859-1)")
 
 
 def test_rfc9112_lf_security_vulnerability():
     """RFC 9112 Section 2.2-2: Prevent LF (%x0A) security vulnerabilities."""
     print("Testing: LF (%x0A) security vulnerability prevention...")
 
-    # The critical security issue: LF (%x0A) in multibyte sequences
     var lf_octet: UInt8 = 0x0A
 
-    # When parsed as octets (safe), LF is clearly identifiable
     var test_data = "GET /\r\nHost: test\r\n\r\n"
     var data_octets = test_data.as_bytes()
 
@@ -67,22 +52,16 @@ def test_rfc9112_lf_security_vulnerability():
         if data_octets[i] == lf_octet:
             lf_positions.append(i)
 
-    # Should find LF octets at specific positions
     testing.assert_true(len(lf_positions) > 0)
-    print("✓ LF (%x0A) handled safely as octet")
-    print("  - Found " + String(len(lf_positions)) + " LF octets in message")
-    print("  - No multibyte character sequence confusion")
 
 
 def test_rfc9112_string_parser_safety():
     """RFC 9112 Section 2.2-2: String parsers only used after protocol element extraction."""
     print("Testing: String parsers used only after safe extraction...")
 
-    # Demonstrate the RFC requirement: protocol elements extracted as octets first
     var http_request = "GET /api/data HTTP/1.1\r\nHost: server.com\r\n\r\n"
     var request_octets = http_request.as_bytes()
 
-    # Step 1: Extract protocol elements as octets (safe)
     var method_end = -1
     for i in range(len(request_octets)):
         if request_octets[i] == ord(' '):
@@ -91,15 +70,10 @@ def test_rfc9112_string_parser_safety():
 
     testing.assert_true(method_end > 0)
 
-    # Step 2: Verify the extracted octets match expected method
-    testing.assert_equal(request_octets[0], ord('G'))  # First octet
-    testing.assert_equal(request_octets[1], ord('E'))  # Second octet  
-    testing.assert_equal(request_octets[2], ord('T'))  # Third octet
-    testing.assert_equal(method_end, 3)                # Method is 3 octets
-    
-    print("✓ String parsing only after protocol element extraction")
-    print("  - Protocol elements extracted as octets first")
-    print("  - String conversion only after safe extraction")
+    testing.assert_equal(request_octets[0], ord('G'))
+    testing.assert_equal(request_octets[1], ord('E'))
+    testing.assert_equal(request_octets[2], ord('T'))
+    testing.assert_equal(method_end, 3)
 
 
 def main():