Move title_sort to Rust

Also some automated cargo clippy fixes

Author: sandbergja

lib/bibdata_rs/src/marc/extract_values.rs

@@ -5,6 +5,11 @@ pub trait ExtractValues<'a> {
     where
         C: Fn(&'a Field) -> bool,
         E: Fn(&'a Field) -> Option<T>;
+
+    fn first_matching_field_value<C, E, T>(self, criteria: C, extractor: E) -> Option<T>
+    where
+        C: Fn(&'a Field) -> bool,
+        E: Fn(&'a Field) -> Option<T>;
 }
 
 impl<'a> ExtractValues<'a> for &'a Record {
@@ -21,4 +26,12 @@ impl<'a> ExtractValues<'a> for &'a Record {
             }
         })
     }
+
+    fn first_matching_field_value<C, E, T>(self, criteria: C, extractor: E) -> Option<T>
+    where
+        C: Fn(&'a Field) -> bool,
+        E: Fn(&'a Field) -> Option<T>,
+    {
+        self.extract_field_values_by(criteria, extractor).next()
+    }
 }

lib/bibdata_rs/src/marc/identifier.rs

@@ -41,10 +41,10 @@ fn linked_record_control_numbers(record: &Record) -> impl Iterator<Item = String
         .extract_values("776w:787w")
         .into_iter()
         .filter_map(|value| {
-            if is_oclc_number(&value) {
-                Some(normalize_oclc_number(&value))
+            if is_oclc_number(value) {
+                Some(normalize_oclc_number(value))
             } else if value.contains('(') {
-                Some(format!("BIB{}", strip_non_numeric(&value)))
+                Some(format!("BIB{}", strip_non_numeric(value)))
             } else {
                 None
             }

lib/bibdata_rs/src/marc/ruby_bindings.rs

@@ -104,7 +104,7 @@ fn solr_fields(ruby: &Ruby, record: magnus::RObject) -> Result<RHash, magnus::Er
         .ok()
         .and_then(|date| date.maybe_to_string());
 
-    let hash = ruby.hash_new_capa(36);
+    let hash = ruby.hash_new_capa(37);
     hash.aset("aat_s", ruby.ary_from_iter(genre::aat_s(&record)))?;
     hash.aset("action_notes_1display", action_notes_1display)?;
     hash.aset("access_restrictions_note_display", access_notes(&record))?;
@@ -188,6 +188,7 @@ fn solr_fields(ruby: &Ruby, record: magnus::RObject) -> Result<RHash, magnus::Er
         "standard_no_index",
         standard_numbers_for_ruby(ruby, &record),
     )?;
+    hash.aset("title_sort", title::title_sort(&record))?;
     hash.aset("title_t", title_t)?;
 
     Ok(hash)

lib/bibdata_rs/src/marc/ruby_bindings/marc_gem.rs

@@ -1,6 +1,5 @@
 /// This module is responsible for converting Marc data from Ruby's Marc gem to
 /// Rust's marctk
-
 use magnus::{
     Object, RArray, RClass, RObject, RString, Ruby,
     value::{InnerRef, Lazy, LazyId, ReprValue},

lib/bibdata_rs/src/marc/title.rs

@@ -1,8 +1,13 @@
+use std::borrow::Cow;
+
 use crate::marc::{
     extract_values::ExtractValues,
     string_normalize::maybe_not_empty,
     trim_punctuation,
-    variable_length_field::{SubfieldIterator, latin_or_non_latin_tag_included_in},
+    variable_length_field::{
+        SubfieldIterator, join_subfields_by_code, latin_or_non_latin_tag_included_in,
+        latin_tag_included_in,
+    },
 };
 use itertools::Itertools;
 use marctk::Record;
@@ -20,7 +25,7 @@ pub fn contains_titles_index(record: &Record) -> impl Iterator<Item = String> {
 
 pub fn latin_script_title(record: &Record) -> Option<String> {
     record
-        .extract_field_values_by(
+        .first_matching_field_value(
             |field| field.tag() == "245",
             |field| {
                 Some(
@@ -33,7 +38,33 @@ pub fn latin_script_title(record: &Record) -> Option<String> {
                 )
             },
         )
-        .next()
+}
+
+pub fn title_sort(record: &Record) -> Option<String> {
+    record.first_matching_field_value(latin_tag_included_in(&["245"]), |field| {
+        let joined =
+            join_subfields_by_code(field, &["a", "b", "c", "f", "g", "h", "k", "n", "p", "s"]);
+        let non_filing_characters = field.ind2().parse::<u8>();
+        let trimmed = match non_filing_characters {
+            Ok(non_filing_characters) => {
+                without_non_filing_characters(&joined, non_filing_characters).to_string()
+            }
+            Err(_) => joined,
+        };
+        maybe_not_empty(trimmed)
+    })
+}
+
+fn without_non_filing_characters<'a>(title: &'a str, non_filing_characters: u8) -> Cow<'a, str> {
+    if non_filing_characters == 0 {
+        Cow::Borrowed(title)
+    } else {
+        if title.len() > non_filing_characters.into() {
+            Cow::Owned(title.chars().skip(non_filing_characters.into()).collect())
+        } else {
+            Cow::Borrowed(Default::default())
+        }
+    }
 }
 
 #[cfg(test)]
@@ -49,4 +80,18 @@ mod tests {
         assert_eq!(contains_titles.next(), Some(String::from("زوراء")));
         assert_eq!(contains_titles.next(), None);
     }
+
+    #[test]
+    fn it_can_find_title_sort() {
+        let record = Record::from_breaker(r"=245 \4 $aThe octopus").unwrap();
+        let title_sort = title_sort(&record).unwrap();
+        assert_eq!(title_sort, "octopus");
+    }
+
+    #[test]
+    fn it_returns_title_sort_none_if_245_empty() {
+        let record = Record::from_breaker(r"=245 \4 $a  ").unwrap();
+        let title_sort = title_sort(&record);
+        assert_eq!(title_sort, None);
+    }
 }

lib/bibdata_rs/src/marc/title/uniform_title.rs

@@ -31,6 +31,10 @@ where
     }
 }
 
+pub fn latin_tag_included_in(tags: &[&str]) -> impl Fn(&Field) -> bool {
+    |field| tags.contains(&field.tag())
+}
+
 pub fn latin_or_non_latin_tag_included_in(tags: &[&str]) -> impl Fn(&Field) -> bool {
     |field| tags.contains(&field.tag()) || non_latin_tag_included_in(tags)(field)
 }
@@ -53,13 +57,23 @@ pub fn join_all_subfields(field: &Field) -> String {
     join_subfields(field.subfields().iter())
 }
 
+pub fn join_subfields_by_code(field: &Field, include: &[&str]) -> String {
+    join_subfields(filter_subfields(field, |subfield| {
+        include.contains(&subfield.code())
+    }))
+}
+
 pub fn join_subfields_except(field: &Field, exclude: &[&str]) -> String {
-    join_subfields(
-        field
-            .subfields()
-            .iter()
-            .filter(|subfield| !exclude.contains(&subfield.code())),
-    )
+    join_subfields(filter_subfields(field, |subfield| {
+        !exclude.contains(&subfield.code())
+    }))
+}
+
+fn filter_subfields(
+    field: &Field,
+    filter: impl Fn(&&Subfield) -> bool,
+) -> impl Iterator<Item = &Subfield> {
+    field.subfields().iter().filter(filter)
 }
 
 pub fn join_subfields<'a>(subfields: impl Iterator<Item = &'a Subfield>) -> String {

lib/bibdata_rs/src/marc/variable_length_field.rs

@@ -175,12 +175,8 @@
 to_field 'title_vern_display', extract_marc('245abcfghknps', alternate_script: :only, first: true)
 
 # to_field 'title_sort', marc_sortable_title
-to_field 'title_sort' do |record, accumulator|
-  MarcExtractor.cached('245abcfghknps', alternate_script: false).collect_matching_lines(record) do |field, spec, extractor|
-    str = extractor.collect_subfields(field, spec).first
-    str = str.slice(field.indicator2.to_i, str.length) if str
-    accumulator << str if accumulator[0].nil?
-  end
+to_field 'title_sort' do |_record, accumulator, context|
+  accumulator << context.clipboard[:solr_fields]['title_sort'] if context.clipboard[:solr_fields]['title_sort']
 end
 
 to_field 'title_vern_sort' do |record, accumulator|