refkit 0.0.7__tar.gz → 0.1.0__tar.gz

{refkit-0.0.7 → refkit-0.1.0}/Cargo.lock

@@ -455,7 +455,7 @@ dependencies = [
 
 [[package]]
 name = "refkit-core"
-version = "0.0.7"
+version = "0.1.0"
 dependencies = [
  "biblatex",
  "hayagriva",
@@ -468,7 +468,7 @@ dependencies = [
 
 [[package]]
 name = "refkit-native"
-version = "0.0.7"
+version = "0.1.0"
 dependencies = [
  "pyo3",
  "refkit-core",

{refkit-0.0.7 → refkit-0.1.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/refkit-core", "packages/refkit/rust"]
 resolver = "3"
 
 [workspace.package]
-version = "0.0.7"
+version = "0.1.0"
 edition = "2024"
 rust-version = "1.88"
 license = "Apache-2.0"
@@ -11,7 +11,7 @@ repository = "https://github.com/peter-gy/refkit"
 
 [workspace.dependencies]
 pyo3 = "0.29.0"
-refkit-core = { version = "0.0.7", path = "crates/refkit-core" }
+refkit-core = { version = "0.1.0", path = "crates/refkit-core" }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.150"
 

{refkit-0.0.7 → refkit-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refkit
-Version: 0.0.7
+Version: 0.1.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/document.rs

@@ -97,12 +97,12 @@ impl Document {
         )?;
         let citations = rendered
             .citations
-            .iter()
-            .zip(&requests)
+            .into_iter()
+            .zip(requests)
             .map(|(citation, request)| {
                 rendered_record_from_citation(
                     citation,
-                    request.items.iter().map(|item| item.key.clone()).collect(),
+                    request.items.into_iter().map(|item| item.key).collect(),
                 )
             })
             .collect::<Result<Vec<_>, _>>()

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/library/guard.rs

@@ -165,23 +165,22 @@ pub(crate) fn validate_raw(raw: &RawBibliography<'_>) -> Result<(), Diagnostic>
         .iter()
         .map(|pair| (pair.key.v, &pair.value.v))
         .collect();
-    let entry_index: HashMap<_, _> = raw
+    let has_references = raw
         .entries
         .iter()
-        .enumerate()
-        .map(|(index, entry)| (entry.v.key.v, index))
-        .collect();
-    let mut graph = vec![Vec::new(); raw.entries.len()];
+        .any(|entry| entry.v.fields.iter().any(|field| is_reference(field.key.v)));
     let mut weights = vec![1usize; raw.entries.len()];
     let mut bytes = 0usize;
     let mut expansion_steps = 0usize;
+    let mut value = String::new();
+    let mut ancestors = Vec::new();
     for (index, entry) in raw.entries.iter().enumerate() {
         for field in &entry.v.fields {
-            let mut value = String::new();
+            value.clear();
             expand(
                 &field.value.v,
                 &abbreviations,
-                &mut Vec::new(),
+                &mut ancestors,
                 &mut expansion_steps,
                 &mut value,
             )
@@ -200,15 +199,16 @@ pub(crate) fn validate_raw(raw: &RawBibliography<'_>) -> Result<(), Diagnostic>
             weights[index] = weights[index].saturating_add(value.len());
         }
     }
-    if raw.entries.iter().all(|entry| {
-        entry
-            .v
-            .fields
-            .iter()
-            .all(|field| !is_reference(field.key.v))
-    }) {
+    if !has_references {
         return Ok(());
     }
+    let entry_index: HashMap<_, _> = raw
+        .entries
+        .iter()
+        .enumerate()
+        .map(|(index, entry)| (entry.v.key.v, index))
+        .collect();
+    let mut graph = vec![Vec::new(); raw.entries.len()];
     let mut detached = raw.clone();
     for entry in &mut detached.entries {
         entry.v.fields.retain(|field| {

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/raw/parse.rs

@@ -346,6 +346,11 @@ fn parse_entry_key(body: &str) -> Result<(String, usize), String> {
 
 fn find_at_block_end(source: &str, start: usize) -> Result<usize, (usize, String)> {
     let escape_aware = find_at_block_end_with_escape_mode(source, start, true);
+    if let Ok(end) = escape_aware
+        && !source[start..end].contains('\\')
+    {
+        return Ok(end);
+    }
     let permissive = find_at_block_end_with_escape_mode(source, start, false);
     match (escape_aware, permissive) {
         (Ok(escaped_end), Ok(permissive_end))
@@ -381,7 +386,6 @@ fn find_at_block_end_with_escape_mode(
     start: usize,
     escape_aware: bool,
 ) -> Result<usize, (usize, String)> {
-    let next_block = find_recovery_block_start(source, start);
     if is_line_style_comment(source, start) {
         return Err((
             take_line(source, start),
@@ -390,14 +394,12 @@ fn find_at_block_end_with_escape_mode(
     }
     let Some(open_rel) = source[start..].find(['{', '(']) else {
         return Err((
-            next_block.unwrap_or_else(|| take_line(source, start)),
+            find_recovery_block_start(source, start).unwrap_or_else(|| take_line(source, start)),
             "entry opener is missing".to_string(),
         ));
     };
     let open = start + open_rel;
-    if let Some(next) = next_block
-        && next < open
-    {
+    if let Some(next) = find_recovery_block_start(&source[..open], start) {
         return Err((next, "entry opener is missing".to_string()));
     }
     let opener = source[open..].chars().next().unwrap();
@@ -464,7 +466,7 @@ fn find_at_block_end_with_escape_mode(
     }
 
     Err((
-        next_block.unwrap_or(source.len()),
+        find_recovery_block_start(source, start).unwrap_or(source.len()),
         "entry ended before closing delimiter".to_string(),
     ))
 }
@@ -539,17 +541,17 @@ fn is_parseable_at_start(source: &str, start: usize) -> bool {
 }
 
 fn is_line_style_comment(source: &str, start: usize) -> bool {
+    if !source[start..]
+        .get(.."@comment".len())
+        .is_some_and(|prefix| prefix.eq_ignore_ascii_case("@comment"))
+    {
+        return false;
+    }
     let line_start = source[..start].rfind('\n').map_or(0, |index| index + 1);
     if !source[line_start..start].chars().all(char::is_whitespace) {
         return false;
     }
     let line = &source[start..take_line(source, start)];
-    let Some(prefix) = line.get(.."@comment".len()) else {
-        return false;
-    };
-    if !prefix.eq_ignore_ascii_case("@comment") {
-        return false;
-    }
     let rest = line.get("@comment".len()..).unwrap_or_default();
     if !rest
         .chars()
@@ -568,12 +570,12 @@ pub(super) fn parse_value(
 ) -> Result<ParsedValue, String> {
     let first = parse_value_atom(body, start, body_offset)?;
     let mut cursor = first.1;
-    let mut atoms = first.4.clone();
     let mut expression_cursor = cursor;
     skip_field_space(body, &mut expression_cursor);
     if !body[expression_cursor..].starts_with('#') {
         return Ok(first);
     }
+    let mut atoms = first.4;
 
     while expression_cursor < body.len() && body[expression_cursor..].starts_with('#') {
         expression_cursor += 1;

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/raw/tests.rs

@@ -556,3 +556,12 @@ fn raw_document_rejects_unsafe_field_edits() {
         "jcs # \" Extra\""
     );
 }
+
+#[test]
+fn adjacent_entries_preserve_unicode_values_and_source_writeback() {
+    let source = "@book{a,title={Été}}@book{b,title={研究}}@book{c,title={🙂}}";
+    let document = RawDocument::parse(source);
+    assert_eq!(document.entry_keys(), ["a", "b", "c"]);
+    assert_eq!(raw_field_value(&document, "b", "title"), "研究");
+    assert_eq!(document.render().unwrap(), source);
+}

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/raw.rs

@@ -435,13 +435,18 @@ impl RawDocument {
         self.data.blocks.iter().map(raw_block_info).collect()
     }
 
-    pub(crate) fn syntax(&self) -> RawSyntaxDocument {
+    #[cfg(test)]
+    fn syntax(&self) -> RawSyntaxDocument {
+        self.clone().into_syntax()
+    }
+
+    pub(crate) fn into_syntax(self) -> RawSyntaxDocument {
         RawSyntaxDocument {
-            blocks: self.data.blocks.iter().map(raw_syntax_block).collect(),
+            blocks: self.data.blocks.into_iter().map(raw_syntax_block).collect(),
             entries: self
                 .data
                 .entry_blocks
-                .iter()
+                .into_iter()
                 .enumerate()
                 .map(|(entry_id, entry)| raw_syntax_entry(RawEntryId(entry_id), entry))
                 .collect(),
@@ -541,70 +546,53 @@ fn raw_block_info(block: &RawBlock) -> RawBlockInfo {
     }
 }
 
-fn raw_syntax_block(block: &RawBlock) -> RawSyntaxBlock {
+fn raw_syntax_block(block: RawBlock) -> RawSyntaxBlock {
     match block {
-        RawBlock::Whitespace { raw, span } => RawSyntaxBlock::Whitespace {
-            raw: raw.clone(),
-            span: span.clone(),
-        },
-        RawBlock::Comment { raw, span } => RawSyntaxBlock::Comment {
-            raw: raw.clone(),
-            span: span.clone(),
-        },
-        RawBlock::Preamble { raw, value, span } => RawSyntaxBlock::Preamble {
-            raw: raw.clone(),
-            value: value.clone(),
-            span: span.clone(),
-        },
+        RawBlock::Whitespace { raw, span } => RawSyntaxBlock::Whitespace { raw, span },
+        RawBlock::Comment { raw, span } => RawSyntaxBlock::Comment { raw, span },
+        RawBlock::Preamble { raw, value, span } => RawSyntaxBlock::Preamble { raw, value, span },
         RawBlock::StringDef {
             raw,
             key,
             value,
             span,
         } => RawSyntaxBlock::StringDef {
-            raw: raw.clone(),
-            key: key.clone(),
-            value: value.clone(),
-            span: span.clone(),
+            raw,
+            key,
+            value,
+            span,
         },
         RawBlock::Entry { id, key, span } => RawSyntaxBlock::Entry {
-            id: RawEntryId(*id),
-            key: key.clone(),
-            span: span.clone(),
-        },
-        RawBlock::Failed { raw, error, span } => RawSyntaxBlock::Failed {
-            raw: raw.clone(),
-            error: error.clone(),
-            span: span.clone(),
-        },
-        RawBlock::Other { raw, span } => RawSyntaxBlock::Other {
-            raw: raw.clone(),
-            span: span.clone(),
+            id: RawEntryId(id),
+            key,
+            span,
         },
+        RawBlock::Failed { raw, error, span } => RawSyntaxBlock::Failed { raw, error, span },
+        RawBlock::Other { raw, span } => RawSyntaxBlock::Other { raw, span },
     }
 }
 
-fn raw_syntax_entry(id: RawEntryId, entry: &RawEntryData) -> RawSyntaxEntry {
+fn raw_syntax_entry(id: RawEntryId, entry: RawEntryData) -> RawSyntaxEntry {
     RawSyntaxEntry {
         id,
-        key: entry.key.clone(),
-        kind: entry.kind.clone(),
+        key: entry.key,
+        kind: entry.kind,
         fields: entry
             .field_blocks
-            .iter()
+            .into_iter()
             .enumerate()
             .map(|(field_id, field)| RawSyntaxField {
                 id: RawFieldId(field_id),
-                name: field.name.clone(),
-                value: field.value.clone(),
+                name: field.name,
+                value: field.value,
                 value_mode: field.value_mode,
-                value_atoms: field.value_atoms.clone(),
-                span: field.span.clone(),
-                patch_span: field.patch_span.clone(),
+                value_atoms: field.value_atoms,
+                span: field.span,
+                patch_span: field.patch_span,
             })
             .collect(),
-        span: entry.span.clone(),
-        raw: entry.raw.clone(),
+        span: entry.span,
+        raw: entry.raw,
     }
 }
 

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/render/bibliography.rs

@@ -3,7 +3,6 @@ use std::fmt::{self, Write as _};
 use hayagriva::{BibliographyItem, BufWriteFormat, RenderedBibliography};
 
 use super::html::{render_child_html, render_children_html, write_html_escaped};
-use super::text::elem_children_to_string;
 
 pub(crate) fn bibliography_to_text_html(
     bibliography: &RenderedBibliography,
@@ -57,11 +56,17 @@ fn write_bibliography_item_text(
             .map_err(|err| err.to_string())?;
     }
 
-    let content = elem_children_to_string(&item.content, BufWriteFormat::Plain)?;
-    if output.len() > item_start && !content.is_empty() {
+    let label_end = output.len();
+    if label_end > item_start {
         output.push(' ');
     }
-    output.push_str(&content);
+    let content_start = output.len();
+    item.content
+        .write_buf(output, BufWriteFormat::Plain)
+        .map_err(|err| err.to_string())?;
+    if output.len() == content_start {
+        output.truncate(label_end);
+    }
     Ok(())
 }
 

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/render/html.rs

@@ -141,14 +141,19 @@ fn push_html_wrapper(output: &mut String, suffix: &mut String, start: &str, end:
 }
 
 pub(crate) fn write_html_escaped(output: &mut String, value: &str) {
-    for ch in value.chars() {
-        match ch {
-            '&' => output.push_str("&"),
-            '<' => output.push_str("&lt;"),
-            '>' => output.push_str("&gt;"),
-            '"' => output.push_str("&quot;"),
-            '\'' => output.push_str("&#39;"),
-            _ => output.push(ch),
-        }
+    let mut start = 0;
+    for (index, byte) in value.bytes().enumerate() {
+        let escaped = match byte {
+            b'&' => "&amp;",
+            b'<' => "&lt;",
+            b'>' => "&gt;",
+            b'"' => "&quot;",
+            b'\'' => "&#39;",
+            _ => continue,
+        };
+        output.push_str(&value[start..index]);
+        output.push_str(escaped);
+        start = index + 1;
     }
+    output.push_str(&value[start..]);
 }

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/render/mod.rs

@@ -25,7 +25,14 @@ pub struct RenderedOutput {
 
 pub(crate) fn bundled_locales() -> &'static [CslLocale] {
     static LOCALES: OnceLock<Vec<CslLocale>> = OnceLock::new();
-    LOCALES.get_or_init(archive::locales).as_slice()
+    LOCALES
+        .get_or_init(|| {
+            let mut locales = archive::locales();
+            // The engine searches these resources for every term, including its en-US fallback.
+            locales.sort_by_key(|locale| locale.lang.as_ref().is_none_or(|lang| lang.0 != "en-US"));
+            locales
+        })
+        .as_slice()
 }
 
 pub fn is_bundled_locale(code: &str) -> bool {

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/render_tree.rs

@@ -61,7 +61,7 @@ impl RenderedRecord {
 }
 
 pub(crate) fn rendered_record_from_citation(
-    citation: &RenderedCitation,
+    citation: RenderedCitation,
     keys: Vec<String>,
 ) -> Result<RenderedRecord, String> {
     Ok(RenderedRecord::new(
@@ -69,7 +69,7 @@ pub(crate) fn rendered_record_from_citation(
         elem_children_to_html(&citation.citation)?,
         None,
         RenderedTree::Citation {
-            children: citation.citation.clone(),
+            children: citation.citation,
             keys,
         },
     ))

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/tidy/keys.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 
 use indexmap::IndexMap;
@@ -40,7 +41,7 @@ pub(crate) fn generated_keys<'a>(
     let mut groups: IndexMap<String, Vec<&RawSyntaxEntry>> = IndexMap::new();
     let mut reserved = HashSet::new();
     for entry in entries {
-        if let Some(key) = generate_key(&entry_values(entry), &template, None)? {
+        if let Some(key) = generate_key(entry, &template, None)? {
             groups.entry(key).or_default().push(entry);
         } else {
             reserved.insert(entry.key.clone());
@@ -54,11 +55,10 @@ pub(crate) fn generated_keys<'a>(
         let duplicate = entries.len() > 1 || retained.contains(&base);
         let mut suffix = 1;
         for entry in entries {
-            let values = entry_values(entry);
             let candidate = if duplicate {
                 let mut attempted = HashSet::new();
                 loop {
-                    let mut candidate = generate_key(&values, &template, Some(suffix))?
+                    let mut candidate = generate_key(entry, &template, Some(suffix))?
                         .unwrap_or_else(|| base.clone());
                     if !attempted.insert(candidate.clone()) {
                         candidate = format!("{base}{}", num_to_letter(suffix));
@@ -136,7 +136,7 @@ fn marker_parameter(marker: &str) -> (String, Option<usize>) {
 }
 
 fn generate_key(
-    values: &HashMap<String, String>,
+    values: &RawSyntaxEntry,
     template: &[TemplateToken],
     duplicate: Option<usize>,
 ) -> Result<Option<String>, String> {
@@ -171,13 +171,13 @@ fn generate_key(
 }
 
 fn marker_words(
-    values: &HashMap<String, String>,
+    values: &RawSyntaxEntry,
     marker: &str,
     parameter: Option<usize>,
     duplicate: Option<usize>,
 ) -> Result<Vec<String>, String> {
     match marker {
-        "auth" => Ok(parse_name_list(value(values, "author"))
+        "auth" => Ok(parse_name_list(&value(values, "author"))
             .into_iter()
             .filter(|name| !name.last.is_empty())
             .collect::<Vec<_>>()
@@ -185,7 +185,7 @@ fn marker_words(
             .map(|name| vec![name.last.clone()])
             .unwrap_or_default()),
         "authEtAl" => {
-            let authors = parse_name_list(value(values, "author"))
+            let authors = parse_name_list(&value(values, "author"))
                 .into_iter()
                 .filter(|name| !name.last.is_empty())
                 .collect::<Vec<_>>();
@@ -199,14 +199,14 @@ fn marker_words(
             }
             Ok(words)
         }
-        "authors" => Ok(parse_name_list(value(values, "author"))
+        "authors" => Ok(parse_name_list(&value(values, "author"))
             .into_iter()
             .filter(|name| !name.last.is_empty())
             .map(|name| name.last)
             .collect()),
         "authorsN" => {
             let limit = parameter.unwrap_or(0);
-            let authors = parse_name_list(value(values, "author"))
+            let authors = parse_name_list(&value(values, "author"))
                 .into_iter()
                 .filter(|name| !name.last.is_empty())
                 .collect::<Vec<_>>();
@@ -248,7 +248,7 @@ fn marker_words(
             duplicate.map(|value| value.to_string()).unwrap_or_default(),
         ]),
         marker if marker == marker.to_uppercase() => {
-            Ok(words(value(values, &marker.to_lowercase())))
+            Ok(words(&value(values, &marker.to_lowercase())))
         }
         _ => Err(format!("Invalid citation key token {marker}")),
     }
@@ -270,21 +270,13 @@ fn apply_modifier(words: Vec<String>, modifier: &str) -> Result<Vec<String>, Str
     }
 }
 
-fn entry_values(entry: &RawSyntaxEntry) -> HashMap<String, String> {
-    entry
-        .fields
-        .iter()
-        .map(|field| (field.name.to_lowercase(), rendered_field_value(field)))
-        .collect()
-}
-
-fn rendered_field_value(field: &RawSyntaxField) -> String {
+fn rendered_field_value(field: &RawSyntaxField) -> Cow<'_, str> {
     match field.value_mode {
-        RawValueMode::Expression => expression_text(&field.value_atoms),
+        RawValueMode::Expression => Cow::Owned(expression_text(&field.value_atoms)),
         RawValueMode::Bare
         | RawValueMode::Braced
         | RawValueMode::Missing
-        | RawValueMode::Quoted => field.value.clone(),
+        | RawValueMode::Quoted => Cow::Borrowed(&field.value),
     }
 }
 
@@ -371,7 +363,7 @@ fn is_prefix_token(token: &str) -> bool {
         .is_some_and(|ch| ch.is_ascii_lowercase())
 }
 
-fn title(values: &HashMap<String, String>) -> String {
+fn title(values: &RawSyntaxEntry) -> String {
     let title = value(values, "title");
     if title.is_empty() {
         value(values, "booktitle").to_string()
@@ -380,8 +372,14 @@ fn title(values: &HashMap<String, String>) -> String {
     }
 }
 
-fn value<'a>(values: &'a HashMap<String, String>, key: &str) -> &'a str {
-    values.get(key).map(String::as_str).unwrap_or("")
+fn value<'a>(entry: &'a RawSyntaxEntry, key: &str) -> Cow<'a, str> {
+    entry
+        .fields
+        .iter()
+        .rev()
+        .find(|field| field.name.to_lowercase() == key)
+        .map(rendered_field_value)
+        .unwrap_or(Cow::Borrowed(""))
 }
 
 fn non_function_words(value: &str) -> Vec<String> {

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/tidy/latex.rs

@@ -61,8 +61,8 @@ fn read_command(chars: &[char], index: &mut usize) -> String {
     let mut output = String::from("\\");
     *index += 1;
     let symbol = chars.get(*index).copied().filter(|character| {
-        !character.is_alphabetic()
-            && !(*character == '\\'
+        !(character.is_alphabetic()
+            || *character == '\\'
                 && chars
                     .get(*index + 1)
                     .is_some_and(|next| next.is_alphabetic()))

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/tidy/mod.rs

@@ -6,6 +6,7 @@ mod references;
 mod render;
 mod unicode;
 
+use std::borrow::Cow;
 use std::fmt;
 
 use crate::raw::{RawDocument, RawEntryId, RawSyntaxBlock};
@@ -103,7 +104,7 @@ pub fn tidy_bibtex(input: &str, options: TidyOptions) -> Result<TidyResult, Tidy
     })?;
     let input = normalize_newlines(input);
     let doc = RawDocument::parse(&input);
-    let mut syntax = doc.syntax();
+    let mut syntax = doc.into_syntax();
 
     if let Some((raw, error, byte)) = syntax.blocks.iter().find_map(first_failed_block) {
         return Err(syntax_error(&input, raw, error, byte));
@@ -222,8 +223,12 @@ fn line_column(input: &str, byte: usize) -> (usize, usize) {
     (line, column)
 }
 
-fn normalize_newlines(input: &str) -> String {
-    input.replace("\r\n", "\n").replace('\r', "\n")
+fn normalize_newlines(input: &str) -> Cow<'_, str> {
+    if input.contains('\r') {
+        Cow::Owned(input.replace("\r\n", "\n").replace('\r', "\n"))
+    } else {
+        Cow::Borrowed(input)
+    }
 }
 
 #[cfg(test)]

{refkit-0.0.7 → refkit-0.1.0}/crates/refkit-core/src/tidy/render/value.rs

@@ -192,6 +192,9 @@ fn unwrap_text(value: &str) -> String {
 }
 
 fn wrap_braced_value(field: &RawSyntaxField, value: &str, options: &TidyOptions) -> String {
+    if options.wrap.is_none() && !value.contains("\n\n") {
+        return value.to_string();
+    }
     let indent = if options.tab {
         "\t".to_string()
     } else {

{refkit-0.0.7 → refkit-0.1.0}/packages/refkit/rust/src/conversion.rs

@@ -92,10 +92,10 @@ pub(crate) fn parse_projection_keys(
     Ok(Some(parsed))
 }
 
-pub(crate) fn project_rows_to_py(
+pub(crate) fn project_rows_to_py<'a>(
     py: Python<'_>,
     fields: &[ProjectionField],
-    records: &[EntryRecord],
+    records: impl IntoIterator<Item = &'a EntryRecord>,
 ) -> PyResult<Py<PyAny>> {
     let rows = PyList::empty(py);
     for record in records {

{refkit-0.0.7 → refkit-0.1.0}/packages/refkit/rust/src/entry.rs

@@ -23,23 +23,23 @@ impl Entry {
 #[pymethods]
 impl Entry {
     #[getter]
-    fn key(&self) -> String {
-        self.data.key.clone()
+    fn key(&self) -> &str {
+        &self.data.key
     }
 
     #[getter]
-    fn entry_type(&self) -> String {
-        self.data.entry_type.clone()
+    fn entry_type(&self) -> &str {
+        &self.data.entry_type
     }
 
     #[getter]
-    fn title(&self) -> Option<String> {
-        self.data.title.clone()
+    fn title(&self) -> Option<&str> {
+        self.data.title.as_deref()
     }
 
     #[getter]
-    fn date(&self) -> Option<String> {
-        self.data.date.clone()
+    fn date(&self) -> Option<&str> {
+        self.data.date.as_deref()
     }
 
     #[getter]
@@ -53,13 +53,13 @@ impl Entry {
     }
 
     #[getter]
-    fn volume(&self) -> Option<String> {
-        self.data.volume.clone()
+    fn volume(&self) -> Option<&str> {
+        self.data.volume.as_deref()
     }
 
     #[getter]
-    fn doi(&self) -> Option<String> {
-        self.data.doi.clone()
+    fn doi(&self) -> Option<&str> {
+        self.data.doi.as_deref()
     }
 
     fn __repr__(&self) -> String {

{refkit-0.0.7 → refkit-0.1.0}/packages/refkit/rust/src/library.rs

@@ -147,14 +147,14 @@ impl Library {
     ) -> PyResult<Py<PyAny>> {
         let fields = parse_project_fields_arg(fields)?;
         let keys = parse_projection_keys(self.inner.as_ref(), keys)?;
-        let records = match keys {
-            Some(keys) => keys
-                .iter()
-                .filter_map(|key| self.inner.get_record(key).cloned())
-                .collect(),
-            None => self.inner.records().to_vec(),
-        };
-        project_rows_to_py(py, &fields, &records)
+        match keys {
+            Some(keys) => project_rows_to_py(
+                py,
+                &fields,
+                keys.iter().filter_map(|key| self.inner.get_record(key)),
+            ),
+            None => project_rows_to_py(py, &fields, self.inner.records()),
+        }
     }
 
     fn __len__(&self) -> usize {

{refkit-0.0.7 → refkit-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refkit"
-version = "0.0.7"
+version = "0.1.0"
 description = "Fast Python citation parsing, rendering, and BibTeX editing backed by Rust"
 readme = "README.md"
 license = "Apache-2.0"