526caaa1-66b8-4cc2-904f-4910c5de2373

Committed 25 Sep 2025 04:52PM UTC coverage: 90.509% (+0.9%) from 89.659%

Build # 526caaa1-66b8-4cc2-904f-4910c5de2373

Build Type

circleci

Committed by Ryan Laddusaw

Commit Message

Update config load json

Pull Request Pull Request #2941: Update solr for CI and local deveopment to solr 9.9

Run Details

7801 of 8619 relevant lines covered (90.51%)

393.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/lib/bibdata_rs/src/marc.rs

use itertools::Itertools;
use magnus::exception;
use marctk::Record;

mod string_normalize;

pub mod control_field;
pub mod fixed_field;
pub mod genre;
pub mod identifier;
pub mod language;
pub mod note;
pub mod publication;
pub mod record_facet_mapping;
pub mod scsb;
pub mod variable_length_field;

pub use string_normalize::trim_punctuation;

pub fn holding_id(
    field_string: String,
    full_record: String,
) -> Result<Option<String>, magnus::Error> {
    let field = field_852(&field_string)?;
    let record = get_record(&full_record)?;
    let subfield_code_8 = field.first_subfield("8");
    let subfield_code_0 = field.first_subfield("0");
    match (subfield_code_8, subfield_code_0) {
        (Some(subfield), _) if alma_code_start_22(subfield.content().to_owned()) => {
            Ok(Some(subfield.content().to_owned()))
        }
        (_, Some(subfield)) if scsb::is_scsb(&record) => Ok(Some(subfield.content().to_owned())),
        _ => Ok(None),
    }
}

pub fn alma_code_start_22(code: String) -> bool {
    code.starts_with("22") && code.ends_with("06421")
}
pub fn genres(record_string: String) -> Result<Vec<String>, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(genre::genres(&record))
}

pub fn original_languages_of_translation(
    record_string: String,
) -> Result<Vec<String>, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(language::original_languages_of_translation(&record)
        .iter()
        .map(|language| language.english_name.to_owned())
        .collect())
}

pub fn access_notes(record_string: String) -> Result<Option<Vec<String>>, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(note::access_notes(&record))
}

pub fn recap_partner_notes(record_string: String) -> Result<Vec<String>, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(scsb::recap_partner::recap_partner_notes(&record))
}

pub fn is_scsb(record_string: String) -> Result<bool, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(scsb::is_scsb(&record))
}

// Build the permanent location code from 852$b and 852$c
// Do not append the 852c if it is a SCSB - we save the SCSB locations as scsbnypl and scsbcul
pub fn permanent_location_code(field_string: String) -> Result<Option<String>, magnus::Error> {
    let field = field_852(&field_string)?;
    Ok(match field.first_subfield("8") {
        Some(alma_code) if alma_code_start_22(alma_code.content().to_string()) => {
            let b = field
                .first_subfield("b")
                .map(|subfield| subfield.content())
                .unwrap_or_default();
            let c = field
                .first_subfield("c")
                .map(|subfield| subfield.content())
                .unwrap_or_default();
            Some(format!("{b}${c}"))
        }
        _ => field
            .first_subfield("b")
            .map(|subfield| subfield.content().to_string()),
    })
}

fn field_852(field_string: &String) -> Result<marctk::Field, magnus::Error> {
    let record = get_record(field_string)?;
    let field_852 = record.get_fields("852").into_iter().next();
    let field_852 = field_852.ok_or_else(|| {
        magnus::Error::new(
            exception::runtime_error(),
            format!("No 852 field found in record {}", field_string),
        )
    })?;
    Ok(field_852.clone())
}

pub fn current_location_code(field_string: String) -> Result<Option<String>, magnus::Error> {
    let record = get_record(&field_string)?;
    let field_876 = record.get_fields("876").into_iter().next();
    Ok(field_876.and_then(
        |field| match (field.first_subfield("y"), field.first_subfield("z")) {
            (Some(y), Some(z)) => Some(format!("{}${}", y.content(), z.content())),
            _ => None,
        },
    ))
}
pub fn build_call_number(field_string: String) -> Result<Option<String>, magnus::Error> {
    // call_number = [field_852['h'], field_852['i'], field_852['k'], field_852['j']].reject(&:blank?)
    let record = get_record(&field_string)?;
    let field_852 = record.get_fields("852").into_iter().next();
    let call_number = field_852.map(|field| {
        field
            .subfields()
            .iter()
            .filter(|subfield| ["h", "i", "k", "j"].contains(&subfield.code()))
            .map(|subfield| subfield.content().to_string())
            .filter(|s| !s.is_empty())
            //.collect::<Vec<String>>()
            .join(" ")
    });
    Ok(call_number.filter(|s| !s.is_empty()))
}

pub fn format_facets(record_string: String) -> Result<Vec<String>, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(record_facet_mapping::format_facets(&record)
        .iter()
        .map(|facet| format!("{facet}"))
        .collect())
}
pub fn private_items(record_string: String, holding_id: String) -> Result<bool, magnus::Error> {
    let record = get_record(&record_string)?;
    let fields_876 = record.get_fields("876");
    let mut items = fields_876.iter().filter(|field| {
        field.first_subfield("0").map(|subfield| subfield.content()) == Some(&holding_id)
    });
    Ok(items.any(|item| {
        item.first_subfield("x")
            .map_or(true, |subfield| subfield.content() == "Private")
    }))
}

pub fn normalize_oclc_number(string: String) -> String {
    identifier::normalize_oclc_number(&string)
}

pub fn is_oclc_number(string: String) -> bool {
    identifier::is_oclc_number(&string)
}

pub fn identifiers_of_all_versions(record_string: String) -> Result<Vec<String>, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(identifier::identifiers_of_all_versions(&record))
}

pub fn publication_statements(record_string: String) -> Result<Vec<String>, magnus::Error> {
    let record = get_record(&record_string)?;
    Ok(publication::publication_statements(&record).collect())
}

pub fn strip_non_numeric(string: String) -> String {
    string_normalize::strip_non_numeric(&string)
}

fn get_record(breaker: &str) -> Result<Record, magnus::Error> {
    Record::from_breaker(breaker).map_err(|err| {
        magnus::Error::new(
            exception::runtime_error(),
            format!("Found error {} while parsing breaker {}", err, breaker),
        )
    })
}

1	use itertools::Itertools;
2	use magnus::exception;
3	use marctk::Record;
4
5	mod string_normalize;
6
7	pub mod control_field;
8	pub mod fixed_field;
9	pub mod genre;
10	pub mod identifier;
11	pub mod language;
12	pub mod note;
13	pub mod publication;
14	pub mod record_facet_mapping;
15	pub mod scsb;
16	pub mod variable_length_field;
17
18	pub use string_normalize::trim_punctuation;
19
20	pub fn holding_id(	×
21	field_string: String,	×
22	full_record: String,	×
23	) -> Result<Option<String>, magnus::Error> {	×
24	let field = field_852(&field_string)?;	×
25	let record = get_record(&full_record)?;	×
26	let subfield_code_8 = field.first_subfield("8");	×
27	let subfield_code_0 = field.first_subfield("0");	×
28	match (subfield_code_8, subfield_code_0) {	×
29	(Some(subfield), _) if alma_code_start_22(subfield.content().to_owned()) => {	×
30	Ok(Some(subfield.content().to_owned()))	×
31	}
32	(_, Some(subfield)) if scsb::is_scsb(&record) => Ok(Some(subfield.content().to_owned())),	×
33	_ => Ok(None),	×
34	}
35	}	×
36
37	pub fn alma_code_start_22(code: String) -> bool {	×
38	code.starts_with("22") && code.ends_with("06421")	×
39	}	×
40	pub fn genres(record_string: String) -> Result<Vec<String>, magnus::Error> {	×
41	let record = get_record(&record_string)?;	×
42	Ok(genre::genres(&record))	×
43	}	×
44
45	pub fn original_languages_of_translation(	×
46	record_string: String,	×
47	) -> Result<Vec<String>, magnus::Error> {	×
48	let record = get_record(&record_string)?;	×
49	Ok(language::original_languages_of_translation(&record)	×
50	.iter()	×
51	.map(\|language\| language.english_name.to_owned())	×
52	.collect())	×
53	}	×
54
55	pub fn access_notes(record_string: String) -> Result<Option<Vec<String>>, magnus::Error> {	×
56	let record = get_record(&record_string)?;	×
57	Ok(note::access_notes(&record))	×
58	}	×
59
60	pub fn recap_partner_notes(record_string: String) -> Result<Vec<String>, magnus::Error> {	×
61	let record = get_record(&record_string)?;	×
62	Ok(scsb::recap_partner::recap_partner_notes(&record))	×
63	}	×
64
65	pub fn is_scsb(record_string: String) -> Result<bool, magnus::Error> {	×
66	let record = get_record(&record_string)?;	×
67	Ok(scsb::is_scsb(&record))	×
68	}	×
69
70	// Build the permanent location code from 852$b and 852$c
71	// Do not append the 852c if it is a SCSB - we save the SCSB locations as scsbnypl and scsbcul
72	pub fn permanent_location_code(field_string: String) -> Result<Option<String>, magnus::Error> {	×
73	let field = field_852(&field_string)?;	×
74	Ok(match field.first_subfield("8") {	×
75	Some(alma_code) if alma_code_start_22(alma_code.content().to_string()) => {	×
76	let b = field	×
77	.first_subfield("b")	×
78	.map(\|subfield\| subfield.content())	×
79	.unwrap_or_default();	×
80	let c = field	×
81	.first_subfield("c")	×
82	.map(\|subfield\| subfield.content())	×
83	.unwrap_or_default();	×
84	Some(format!("{b}${c}"))	×
85	}
86	_ => field	×
87	.first_subfield("b")	×
88	.map(\|subfield\| subfield.content().to_string()),	×
89	})
90	}	×
91
92	fn field_852(field_string: &String) -> Result<marctk::Field, magnus::Error> {	×
93	let record = get_record(field_string)?;	×
94	let field_852 = record.get_fields("852").into_iter().next();	×
95	let field_852 = field_852.ok_or_else(\|\| {	×
96	magnus::Error::new(	×
97	exception::runtime_error(),	×
98	format!("No 852 field found in record {}", field_string),	×
99	)
100	})?;	×
101	Ok(field_852.clone())	×
102	}	×
103
104	pub fn current_location_code(field_string: String) -> Result<Option<String>, magnus::Error> {	×
105	let record = get_record(&field_string)?;	×
106	let field_876 = record.get_fields("876").into_iter().next();	×
107	Ok(field_876.and_then(	×
108	\|field\| match (field.first_subfield("y"), field.first_subfield("z")) {	×
109	(Some(y), Some(z)) => Some(format!("{}${}", y.content(), z.content())),	×
110	_ => None,	×
111	},	×
112	))
113	}	×
114	pub fn build_call_number(field_string: String) -> Result<Option<String>, magnus::Error> {	×
115	// call_number = [field_852['h'], field_852['i'], field_852['k'], field_852['j']].reject(&:blank?)
116	let record = get_record(&field_string)?;	×
117	let field_852 = record.get_fields("852").into_iter().next();	×
118	let call_number = field_852.map(\|field\| {	×
119	field	×
120	.subfields()	×
121	.iter()	×
122	.filter(\|subfield\| ["h", "i", "k", "j"].contains(&subfield.code()))	×
123	.map(\|subfield\| subfield.content().to_string())	×
124	.filter(\|s\| !s.is_empty())	×
125	//.collect::<Vec<String>>()
126	.join(" ")	×
127	});	×
128	Ok(call_number.filter(\|s\| !s.is_empty()))	×
129	}	×
130
131	pub fn format_facets(record_string: String) -> Result<Vec<String>, magnus::Error> {	×
132	let record = get_record(&record_string)?;	×
133	Ok(record_facet_mapping::format_facets(&record)	×
134	.iter()	×
135	.map(\|facet\| format!("{facet}"))	×
136	.collect())	×
137	}	×
138	pub fn private_items(record_string: String, holding_id: String) -> Result<bool, magnus::Error> {	×
139	let record = get_record(&record_string)?;	×
140	let fields_876 = record.get_fields("876");	×
141	let mut items = fields_876.iter().filter(\|field\| {	×
142	field.first_subfield("0").map(\|subfield\| subfield.content()) == Some(&holding_id)	×
143	});	×
144	Ok(items.any(\|item\| {	×
145	item.first_subfield("x")	×
146	.map_or(true, \|subfield\| subfield.content() == "Private")	×
147	}))	×
148	}	×
149
150	pub fn normalize_oclc_number(string: String) -> String {	×
151	identifier::normalize_oclc_number(&string)	×
152	}	×
153
154	pub fn is_oclc_number(string: String) -> bool {	×
155	identifier::is_oclc_number(&string)	×
156	}	×
157
158	pub fn identifiers_of_all_versions(record_string: String) -> Result<Vec<String>, magnus::Error> {	×
159	let record = get_record(&record_string)?;	×
160	Ok(identifier::identifiers_of_all_versions(&record))	×
161	}	×
162
163	pub fn publication_statements(record_string: String) -> Result<Vec<String>, magnus::Error> {	×
164	let record = get_record(&record_string)?;	×
165	Ok(publication::publication_statements(&record).collect())	×
166	}	×
167
168	pub fn strip_non_numeric(string: String) -> String {	×
169	string_normalize::strip_non_numeric(&string)	×
170	}	×
171
172	fn get_record(breaker: &str) -> Result<Record, magnus::Error> {	×
173	Record::from_breaker(breaker).map_err(\|err\| {	×
174	magnus::Error::new(	×
175	exception::runtime_error(),	×
176	format!("Found error {} while parsing breaker {}", err, breaker),	×
177	)
178	})	×
179	}	×

pulibrary / bibdata / 526caaa1-66b8-4cc2-904f-4910c5de2373

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous