Merge pull request #7 from code0-tech/#6-support-html

added html support

Author: raphael-goetz

crates/lupus/src/engine.rs

@@ -5,7 +5,9 @@ use crate::codec::Codec;
 use crate::data::Data;
 use crate::error::ConvertError;
 use crate::format::Format;
-use crate::formats::{CsvCodec, HttpFormCodec, JsonCodec, ProtobufCodec, TextCodec, XmlCodec};
+use crate::formats::{
+    CsvCodec, HtmlCodec, HttpFormCodec, JsonCodec, ProtobufCodec, TextCodec, XmlCodec,
+};
 use crate::schema::{DecodeContext, EncodeContext, JsonSchema};
 use crate::transform::{data_into_markup, data_to_text, markup_into_data, markup_to_text};
 use crate::validation::validate_json_schema;
@@ -24,6 +26,7 @@ impl Engine {
         let mut engine = Self::new();
         engine.register(JsonCodec);
         engine.register(XmlCodec);
+        engine.register(HtmlCodec);
         engine.register(TextCodec);
         engine.register(CsvCodec);
         engine.register(HttpFormCodec);
@@ -180,6 +183,21 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn json_converts_to_html_markup() -> Result<(), Box<dyn std::error::Error>> {
+        let engine = Engine::with_default_codecs();
+        let html = engine.convert(
+            br#"{"article":{"h1":"Hello","p":"World"}}"#,
+            Format::Json,
+            Format::Html,
+            &DecodeContext,
+            &EncodeContext::default(),
+        )?;
+
+        assert_eq!(html, b"<article><h1>Hello</h1><p>World</p></article>");
+        Ok(())
+    }
+
     #[test]
     fn codecs_pretty_print_structured_output_when_requested()
     -> Result<(), Box<dyn std::error::Error>> {

crates/lupus/src/format.rs

@@ -4,6 +4,7 @@ pub const TEXT: &str = "text";
 pub const PROTOBUF: &str = "protobuf";
 pub const CSV: &str = "csv";
 pub const HTTP_FORM: &str = "http-form";
+pub const HTML: &str = "html";
 pub const XML: &str = "xml";
 pub const JSON: &str = "json";
 
@@ -13,14 +14,16 @@ pub enum Format {
     Protobuf,
     Csv,
     HttpForm,
+    Html,
     Xml,
     Json,
 }
 
 impl Format {
-    pub const ALL: [Self; 6] = [
+    pub const ALL: [Self; 7] = [
         Self::Json,
         Self::Xml,
+        Self::Html,
         Self::Text,
         Self::Csv,
         Self::HttpForm,
@@ -33,6 +36,7 @@ impl Format {
             Format::Protobuf => PROTOBUF,
             Format::Csv => CSV,
             Format::HttpForm => HTTP_FORM,
+            Format::Html => HTML,
             Format::Xml => XML,
             Format::Json => JSON,
         }
@@ -42,6 +46,7 @@ impl Format {
         match self {
             Format::Json => "JSON",
             Format::Xml => "XML",
+            Format::Html => "HTML",
             Format::Text => "Text",
             Format::Csv => "CSV",
             Format::HttpForm => "HTTP Form",

crates/lupus/src/formats/html.rs

@@ -0,0 +1,54 @@
+use crate::artifact::{Artifact, ArtifactKind};
+use crate::codec::Codec;
+use crate::error::ConvertError;
+use crate::format::Format;
+use crate::formats::xml::{parse_xml, write_xml};
+use crate::schema::{DecodeContext, EncodeContext};
+
+pub struct HtmlCodec;
+
+impl Codec for HtmlCodec {
+    fn format(&self) -> Format {
+        Format::Html
+    }
+
+    fn artifact_kind(&self) -> ArtifactKind {
+        ArtifactKind::Markup
+    }
+
+    fn decode(&self, input: &[u8], _ctx: &DecodeContext) -> Result<Artifact, ConvertError> {
+        let input = std::str::from_utf8(input)
+            .map_err(|err| ConvertError::Decoding(format!("html is not valid UTF-8: {err}")))?;
+        Ok(Artifact::Markup(parse_xml(input)?))
+    }
+
+    fn encode(&self, artifact: &Artifact, ctx: &EncodeContext) -> Result<Vec<u8>, ConvertError> {
+        let Artifact::Markup(markup) = artifact else {
+            return Err(ConvertError::WrongArtifact {
+                expected: ArtifactKind::Markup,
+                found: artifact.kind(),
+            });
+        };
+
+        Ok(write_xml(markup, ctx.pretty).into_bytes())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::codec::Codec;
+    use crate::formats::HtmlCodec;
+    use crate::schema::{DecodeContext, EncodeContext};
+
+    #[test]
+    fn html_codec_decodes_and_encodes_markup() -> Result<(), Box<dyn std::error::Error>> {
+        let codec = HtmlCodec;
+        let artifact = codec.decode(b"<article><h1>Hello</h1></article>", &DecodeContext)?;
+
+        assert_eq!(
+            codec.encode(&artifact, &EncodeContext::default())?,
+            b"<article><h1>Hello</h1></article>"
+        );
+        Ok(())
+    }
+}

crates/lupus/src/formats/mod.rs

@@ -1,11 +1,13 @@
 pub mod csv;
+pub mod html;
 pub mod http_form;
 pub mod json;
 pub mod protobuf;
 pub mod text;
 pub mod xml;
 
 pub use csv::CsvCodec;
+pub use html::HtmlCodec;
 pub use http_form::HttpFormCodec;
 pub use json::JsonCodec;
 pub use protobuf::{ProtobufCodec, data_to_value, value_to_data};

crates/lupus/src/formats/xml.rs

@@ -34,7 +34,7 @@ impl Codec for XmlCodec {
     }
 }
 
-fn parse_xml(input: &str) -> Result<Markup, ConvertError> {
+pub(crate) fn parse_xml(input: &str) -> Result<Markup, ConvertError> {
     let mut parser = XmlParser::new(input);
     parser.skip_misc()?;
     let root = parser.parse_node()?;
@@ -286,7 +286,7 @@ impl<'a> XmlParser<'a> {
     }
 }
 
-fn write_xml(markup: &Markup, pretty: bool) -> String {
+pub(crate) fn write_xml(markup: &Markup, pretty: bool) -> String {
     let mut output = String::new();
     write_node(&markup.root, 0, pretty, &mut output);
     output