Normalise to jats when input is plain text

Author: ja573

thoth-api/src/graphql/tests.rs

@@ -2546,6 +2546,73 @@ query LinkedRelations($reviewId: Uuid!, $endorsementId: Uuid!) {
     assert!(data["endorsement"]["authorInstitution"].is_null());
 }
 
+#[test]
+fn graphql_markup_mutations_accept_plain_text_when_markup_is_jats_xml() {
+    let (_guard, pool) = test_db::setup_test_db();
+    let schema = create_schema();
+    let superuser = test_db::test_superuser("user-jats-xml-mutations");
+    let context = test_db::test_context_with_user(pool.clone(), superuser);
+    let seed = seed_data(&schema, &context);
+
+    let title = Title::from_id(pool.as_ref(), &seed.title_id).unwrap();
+    update_with_data_and_markup(
+        &schema,
+        &context,
+        "updateTitle",
+        "PatchTitle",
+        "titleId",
+        PatchTitle {
+            title_id: title.title_id,
+            work_id: title.work_id,
+            locale_code: title.locale_code,
+            full_title: "Foundations for Moral <italic>Relativism</italic> Second Expanded Edition"
+                .to_string(),
+            title: "Foundations for Moral <italic>Relativism</italic>".to_string(),
+            subtitle: Some("Second Expanded Edition".to_string()),
+            canonical: title.canonical,
+        },
+        MarkupFormat::JatsXml,
+    );
+
+    let stored_title = Title::from_id(pool.as_ref(), &seed.title_id).unwrap();
+    assert_eq!(
+        stored_title.full_title,
+        "Foundations for Moral <italic>Relativism</italic> Second Expanded Edition"
+    );
+    assert_eq!(
+        stored_title.title,
+        "Foundations for Moral <italic>Relativism</italic>"
+    );
+    assert_eq!(
+        stored_title.subtitle.as_deref(),
+        Some("Second Expanded Edition")
+    );
+
+    let abstract_item = Abstract::from_id(pool.as_ref(), &seed.abstract_short_id).unwrap();
+    update_with_data_and_markup(
+        &schema,
+        &context,
+        "updateAbstract",
+        "PatchAbstract",
+        "abstractId",
+        PatchAbstract {
+            abstract_id: abstract_item.abstract_id,
+            work_id: abstract_item.work_id,
+            content: "Plain abstract content updated".to_string(),
+            locale_code: abstract_item.locale_code,
+            abstract_type: abstract_item.abstract_type,
+            canonical: abstract_item.canonical,
+        },
+        MarkupFormat::JatsXml,
+    );
+
+    let stored_abstract = Abstract::from_id(pool.as_ref(), &seed.abstract_short_id).unwrap();
+    assert_eq!(
+        stored_abstract.content,
+        "<p>Plain abstract content updated</p>"
+    );
+}
+
 #[test]
 fn graphql_mutations_cover_all() {
     let (_guard, pool) = test_db::setup_test_db();

thoth-api/src/markup/mod.rs

@@ -74,8 +74,32 @@ pub fn convert_to_jats(
     format: MarkupFormat,
     conversion_limit: ConversionLimit,
 ) -> ThothResult<String> {
+    if format == MarkupFormat::JatsXml {
+        let content_looks_like_jats = content.contains('<') && content.contains("</");
+        let ast = if content_looks_like_jats {
+            jats_to_ast(&content)
+        } else {
+            plain_text_to_ast(&content)
+        };
+
+        let processed_ast = if conversion_limit == ConversionLimit::Title {
+            strip_structural_elements_from_ast_for_conversion(&ast)
+        } else {
+            ast
+        };
+
+        validate_ast_content(&processed_ast, conversion_limit)?;
+
+        return Ok(
+            if content_looks_like_jats || conversion_limit == ConversionLimit::Title {
+                ast_to_jats(&processed_ast)
+            } else {
+                plain_text_ast_to_jats(&processed_ast)
+            },
+        );
+    }
+
     validate_format(&content, &format)?;
-    let mut output = content.clone();
 
     match format {
         MarkupFormat::Html => {
@@ -90,7 +114,7 @@ pub fn convert_to_jats(
             };
 
             validate_ast_content(&processed_ast, conversion_limit)?;
-            output = ast_to_jats(&processed_ast);
+            Ok(ast_to_jats(&processed_ast))
         }
 
         MarkupFormat::Markdown => {
@@ -105,7 +129,7 @@ pub fn convert_to_jats(
             };
 
             validate_ast_content(&processed_ast, conversion_limit)?;
-            output = ast_to_jats(&processed_ast);
+            Ok(ast_to_jats(&processed_ast))
         }
 
         MarkupFormat::PlainText => {
@@ -120,18 +144,16 @@ pub fn convert_to_jats(
             };
 
             validate_ast_content(&processed_ast, conversion_limit)?;
-            output = if conversion_limit == ConversionLimit::Title {
+            Ok(if conversion_limit == ConversionLimit::Title {
                 // Title JATS should remain inline (no paragraph wrapper)
                 ast_to_jats(&processed_ast)
             } else {
                 plain_text_ast_to_jats(&processed_ast)
-            };
+            })
         }
 
-        MarkupFormat::JatsXml => {}
+        MarkupFormat::JatsXml => unreachable!("handled above"),
     }
-
-    Ok(output)
 }
 
 /// Convert from JATS XML to specified format using a specific tag name
@@ -347,6 +369,30 @@ mod tests {
         .unwrap();
         assert_eq!(output, "Just plain text.");
     }
+
+    #[test]
+    fn test_jatsxml_plain_text_title_is_accepted() {
+        let input = "Second Expanded Edition";
+        let output = convert_to_jats(
+            input.to_string(),
+            MarkupFormat::JatsXml,
+            ConversionLimit::Title,
+        )
+        .unwrap();
+        assert_eq!(output, input);
+    }
+
+    #[test]
+    fn test_jatsxml_plain_text_abstract_is_wrapped() {
+        let input = "Plain abstract content.";
+        let output = convert_to_jats(
+            input.to_string(),
+            MarkupFormat::JatsXml,
+            ConversionLimit::Abstract,
+        )
+        .unwrap();
+        assert_eq!(output, "<p>Plain abstract content.</p>");
+    }
     // --- convert_to_jats tests end   ---
 
     // --- convert_from_jats tests start   ---

thoth-api/src/model/title/tests.rs

@@ -27,9 +27,9 @@ mod conversions {
     #[test]
     fn convert_title_to_jats_updates_fields() {
         let mut title = Title {
-            title: "<title>My Title</title>".to_string(),
-            subtitle: Some("<subtitle>Sub</subtitle>".to_string()),
-            full_title: "<title>My Title: Sub</title>".to_string(),
+            title: "My <italic>Title</italic>".to_string(),
+            subtitle: Some("Sub".to_string()),
+            full_title: "My <italic>Title</italic>: Sub".to_string(),
             locale_code: LocaleCode::En,
             canonical: false,
             ..Default::default()
@@ -38,12 +38,9 @@ mod conversions {
         convert_title_to_jats(&mut title, MarkupFormat::JatsXml)
             .expect("Failed to convert title to JATS");
 
-        assert_eq!(title.title(), "<title>My Title</title>");
-        assert_eq!(
-            TitleProperties::subtitle(&title),
-            Some("<subtitle>Sub</subtitle>")
-        );
-        assert_eq!(title.full_title(), "<title>My Title: Sub</title>");
+        assert_eq!(title.title(), "My <italic>Title</italic>");
+        assert_eq!(TitleProperties::subtitle(&title), Some("Sub"));
+        assert_eq!(title.full_title(), "My <italic>Title</italic>: Sub");
     }
 }