Fix multiple roast items: autolinker, validator, C++ bindings, conformance.

- char_at_utf16_offset returns Option<char> instead of panicking
- Add title attribute to URL entities with expanded_url
- Implement JSON entity autolink conformance tests (was TODO)
- Add Validator::with_config_and_parser_backend constructor
- C++ configurationFromPath/Json return unique_ptr instead of raw pointer

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: sayrer

rust/conformance/tests/autolink.rs

@@ -4,6 +4,7 @@
 
 use serde_derive::{Deserialize, Serialize};
 use twitter_text::autolinker::Autolinker;
+use twitter_text::entity::{Entity, Type};
 use twitter_text::ParserBackend;
 
 /// Returns all ParserBackend variants for testing both backends.
@@ -30,7 +31,6 @@ pub struct JsonAssertion {
     pub expected: String,
 }
 
-// TODO: json
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct Tests {
     pub usernames: Vec<Assertion>,
@@ -90,4 +90,80 @@ fn autolink() {
             assert_eq!(text, assertion.expected, "{}", assertion.description);
         }
     } // end for parser_backend
+
+    // JSON entity tests: entities are provided as pre-parsed JSON (Twitter API format)
+    let manifest: Manifest = serde_yaml_ng::from_str(MANIFEST_YML).expect("Error parsing yaml");
+    for assertion in manifest.tests.json {
+        let entities_json: JsonEntities =
+            serde_json::from_str(&assertion.json).expect("Error parsing entity JSON");
+        let mut entities = Vec::new();
+        for m in &entities_json.user_mentions {
+            entities.push(Entity {
+                t: Type::MENTION,
+                start: m.indices[0],
+                end: m.indices[1],
+                value: &m.screen_name,
+                list_slug: "",
+                display_url: "",
+                expanded_url: "",
+            });
+        }
+        for h in &entities_json.hashtags {
+            entities.push(Entity {
+                t: Type::HASHTAG,
+                start: h.indices[0],
+                end: h.indices[1],
+                value: &h.text,
+                list_slug: "",
+                display_url: "",
+                expanded_url: "",
+            });
+        }
+        for u in &entities_json.urls {
+            entities.push(Entity {
+                t: Type::URL,
+                start: u.indices[0],
+                end: u.indices[1],
+                value: &u.url,
+                list_slug: "",
+                display_url: u.display_url.as_deref().unwrap_or(""),
+                expanded_url: u.expanded_url.as_deref().unwrap_or(""),
+            });
+        }
+        entities.sort_by_key(|e| e.start);
+
+        let autolinker = Autolinker::new(false);
+        let result = autolinker.autolink_entities(&assertion.text, &entities);
+        assert_eq!(result, assertion.expected, "{}", assertion.description);
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct JsonEntities {
+    #[serde(default)]
+    hashtags: Vec<JsonHashtag>,
+    #[serde(default)]
+    urls: Vec<JsonUrl>,
+    #[serde(default)]
+    user_mentions: Vec<JsonMention>,
+}
+
+#[derive(Debug, Deserialize)]
+struct JsonHashtag {
+    text: String,
+    indices: Vec<i32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct JsonUrl {
+    url: String,
+    expanded_url: Option<String>,
+    display_url: Option<String>,
+    indices: Vec<i32>,
+}
+
+#[derive(Debug, Deserialize)]
+struct JsonMention {
+    screen_name: String,
+    indices: Vec<i32>,
 }

rust/cpp-bindings/config_test.cpp

@@ -27,7 +27,6 @@ TEST(TwitterTextConfigurationTest, Path) {
   ASSERT_EQ(wr.range.start, 0);
   ASSERT_EQ(wr.range.end, 4351);
   ASSERT_EQ(wr.weight, 200);
-  delete config;
 }
 
 TEST(TwitterTextConfigurationTest, Json) {
@@ -47,7 +46,6 @@ TEST(TwitterTextConfigurationTest, Json) {
   ASSERT_EQ(wr.range.start, 0);
   ASSERT_EQ(wr.range.end, 4351);
   ASSERT_EQ(wr.weight, 200);
-  delete config;
 }
 
 TEST(TwitterTextConfigurationTest, Version) {

rust/cpp-bindings/twitter.h

@@ -12,13 +12,12 @@ class TwitterTextConfiguration {
     config(config)
   {}
 
-  // TODO: these are fallible, so the return type should change
-  static TwitterTextConfiguration* configurationFromPath(std::string path) {
-    return new TwitterTextConfiguration(configuration_from_path(path));
+  static std::unique_ptr<TwitterTextConfiguration> configurationFromPath(std::string path) {
+    return std::make_unique<TwitterTextConfiguration>(configuration_from_path(path));
   }
 
-  static TwitterTextConfiguration* configurationFromJson(std::string json) {
-    return new TwitterTextConfiguration(configuration_from_json(json));
+  static std::unique_ptr<TwitterTextConfiguration> configurationFromJson(std::string json) {
+    return std::make_unique<TwitterTextConfiguration>(configuration_from_json(json));
   }
 
   int32_t getVersion() {

rust/twitter-text/src/autolinker.rs

@@ -8,21 +8,15 @@ use crate::extractor::{Extract, Extractor, ParserBackend};
 use std::borrow::Cow;
 
 /// Get the character at a given UTF-16 offset in a string.
-/// Panics if the offset is out of bounds or doesn't align with a character boundary.
-fn char_at_utf16_offset(text: &str, utf16_offset: i32) -> char {
+fn char_at_utf16_offset(text: &str, utf16_offset: i32) -> Option<char> {
     let mut current_utf16 = 0i32;
     for c in text.chars() {
         if current_utf16 == utf16_offset {
-            return c;
+            return Some(c);
         }
         current_utf16 += c.len_utf16() as i32;
     }
-    panic!(
-        "UTF-16 offset {} not found in text of length {} (UTF-16 length {})",
-        utf16_offset,
-        text.len(),
-        current_utf16
-    );
+    None
 }
 
 type Attributes = Vec<(String, String)>;
@@ -270,7 +264,7 @@ impl<'a> Autolinker<'a> {
     }
 
     fn link_to_hashtag(&self, entity: &Entity, text: &str, buf: &mut String) {
-        let hash_char = char_at_utf16_offset(text, entity.get_start());
+        let hash_char = char_at_utf16_offset(text, entity.get_start()).unwrap_or('#');
         let hashtag = entity.get_value();
         let mut attrs: Attributes = Vec::new();
         attrs.push((HREF.to_string(), self.hashtag_url_base.to_owned() + hashtag));
@@ -297,7 +291,7 @@ impl<'a> Autolinker<'a> {
 
     fn link_to_mention_and_list(&self, entity: &Entity, text: &str, buf: &mut String) {
         let mut mention = String::from(entity.get_value());
-        let at_char = char_at_utf16_offset(text, entity.get_start());
+        let at_char = char_at_utf16_offset(text, entity.get_start()).unwrap_or('@');
         let mut attrs: Attributes = Vec::new();
 
         if entity.get_type() == entity::Type::MENTION && !entity.get_list_slug().is_empty() {
@@ -416,6 +410,9 @@ impl<'a> Autolinker<'a> {
 
         let mut attrs: Attributes = Vec::new();
         attrs.push((HREF.to_string(), String::from(url)));
+        if !entity.get_expanded_url().is_empty() {
+            attrs.push((TITLE.to_string(), String::from(entity.get_expanded_url())));
+        }
         if !self.url_class.is_empty() {
             attrs.push((CLASS.to_string(), String::from(self.url_class)));
         }
@@ -830,22 +827,23 @@ mod tests {
     #[test]
     fn test_char_at_utf16_offset() {
         // ASCII text - UTF-16 offset equals char index
-        assert_eq!(char_at_utf16_offset("hello", 0), 'h');
-        assert_eq!(char_at_utf16_offset("hello", 4), 'o');
+        assert_eq!(char_at_utf16_offset("hello", 0), Some('h'));
+        assert_eq!(char_at_utf16_offset("hello", 4), Some('o'));
+        assert_eq!(char_at_utf16_offset("hello", 99), None);
 
         // Emoji at start (🔥 is U+1F525, takes 2 UTF-16 code units)
         let text = "🔥hello";
-        assert_eq!(char_at_utf16_offset(text, 0), '🔥');
-        assert_eq!(char_at_utf16_offset(text, 2), 'h'); // After emoji (2 UTF-16 units)
-        assert_eq!(char_at_utf16_offset(text, 3), 'e');
+        assert_eq!(char_at_utf16_offset(text, 0), Some('🔥'));
+        assert_eq!(char_at_utf16_offset(text, 2), Some('h')); // After emoji (2 UTF-16 units)
+        assert_eq!(char_at_utf16_offset(text, 3), Some('e'));
 
         // Multiple emoji
         let text = "🔥🔥🔥 @test";
-        assert_eq!(char_at_utf16_offset(text, 0), '🔥');
-        assert_eq!(char_at_utf16_offset(text, 2), '🔥');
-        assert_eq!(char_at_utf16_offset(text, 4), '🔥');
-        assert_eq!(char_at_utf16_offset(text, 6), ' ');
-        assert_eq!(char_at_utf16_offset(text, 7), '@');
+        assert_eq!(char_at_utf16_offset(text, 0), Some('🔥'));
+        assert_eq!(char_at_utf16_offset(text, 2), Some('🔥'));
+        assert_eq!(char_at_utf16_offset(text, 4), Some('🔥'));
+        assert_eq!(char_at_utf16_offset(text, 6), Some(' '));
+        assert_eq!(char_at_utf16_offset(text, 7), Some('@'));
     }
 
     #[test]

rust/twitter-text/src/validator.rs

@@ -53,6 +53,19 @@ impl Validator {
         }
     }
 
+    pub fn with_config_and_parser_backend(
+        config: twitter_text_config::Configuration,
+        parser_backend: ParserBackend,
+    ) -> Validator {
+        Validator {
+            short_url_length: 23,
+            short_url_length_https: 23,
+            config,
+            extractor: Extractor::new(),
+            parser_backend,
+        }
+    }
+
     pub fn is_valid_tweet(&self, s: &str) -> bool {
         parse_with_parser_backend(s, &self.config, false, self.parser_backend).is_valid
     }