feat: use a custom builder pattern

README.md

@@ -20,44 +20,30 @@
 ## Example
 
 ```rust
-Invoice {
-    generating_system: "test",
-    invoice_currency: "EUR",
-    document_title: "An invoice",
-    language: "de",
-    invoice_number: "993433000298",
-    invoice_date: "2020-01-01",
-    biller: Biller {
-        vat_identification_number: "ATU51507409",
-        ..Default::default()
-    },
-    invoice_recipient: InvoiceRecipient {
-        vat_identification_number: "ATU18708634",
-        ..Default::default()
-    },
-    details: Details {
-        items: vec![
-            DetailsItem {
-                description: vec!["Schraubenzieher"],
-                quantity: dec!(100),
-                unit: "STK",
-                unit_price: dec!(10.20),
-                tax_item: TaxItem {
-                    tax_percent: dec!(20),
-                    tax_category: TaxCategory::S,
-                },
-                ..Default::default()
-            },
-        ],
-    },
-    ..Default::default()
-}
+Invoice::new(
+    "test",
+    "EUR",
+    "993433000298",
+    "2020-01-01",
+    Biller::new("ATU51507409"),
+    InvoiceRecipient::new("ATU18708634"),
+)
+.with_item(
+    DetailsItem::new(
+        dec!(100),
+        "STK",
+        dec!(10.20),
+        TaxItem::new(dec!(20), TaxCategory::S),
+    )
+    .with_description("Schraubenzieher")
+)
+.with_document_title("An invoice")
+.with_language("de")
 .with_payment_method(
-    PaymentMethodPaymentCard {
-        primary_account_number: "123456*4321",
-        card_holder_name: Some("Name"),
-    },
-    Some("Comment"),
+    PaymentMethod::payment_card(
+        PaymentMethodPaymentCard::new("123456*4321").with_card_holder_name("Name"),
+    )
+    .with_comment("Comment"),
 )
 .to_xml_string()
 .unwrap(); // returns "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Invoice>...</Invoice>"

src/address.rs

@@ -2,17 +2,57 @@ use crate::xml::XmlElement;
 
 #[derive(Default)]
 pub struct Address<'a> {
-    pub name: &'a str,
-    pub street: Option<&'a str>,
-    pub town: &'a str,
-    pub zip: &'a str,
-    pub country: &'a str,
-    pub country_code: Option<&'a str>,
-    pub phone: Option<Vec<&'a str>>,
-    pub email: Option<Vec<&'a str>>,
+    name: &'a str,
+    street: Option<&'a str>,
+    town: &'a str,
+    zip: &'a str,
+    country: &'a str,
+    country_code: Option<&'a str>,
+    phone: Option<Vec<&'a str>>,
+    email: Option<Vec<&'a str>>,
 }
 
-impl Address<'_> {
+impl<'a> Address<'a> {
+    pub fn new(name: &'a str, town: &'a str, zip: &'a str, country: &'a str) -> Address<'a> {
+        Address {
+            name,
+            town,
+            zip,
+            country,
+            ..Default::default()
+        }
+    }
+
+    pub fn with_street(mut self, street: &'a str) -> Self {
+        self.street = Some(street);
+        self
+    }
+
+    pub fn with_country_code(mut self, country_code: &'a str) -> Self {
+        self.country_code = Some(country_code);
+        self
+    }
+
+    pub fn with_phone(mut self, phone_number: &'a str) -> Self {
+        let mut phone_numbers = match self.phone {
+            Some(p) => p,
+            None => vec![],
+        };
+        phone_numbers.push(phone_number);
+        self.phone = Some(phone_numbers);
+        self
+    }
+
+    pub fn with_email(mut self, email_address: &'a str) -> Self {
+        let mut email_addresses = match self.email {
+            Some(e) => e,
+            None => vec![],
+        };
+        email_addresses.push(email_address);
+        self.email = Some(email_addresses);
+        self
+    }
+
     pub fn as_xml(&self) -> XmlElement {
         let mut e = XmlElement::new("Address").with_text_element("Name", self.name);
 

src/biller.rs

@@ -5,14 +5,44 @@ use crate::{
 
 #[derive(Default)]
 pub struct Biller<'a> {
-    pub vat_identification_number: &'a str,
-    pub further_identification: Option<Vec<FurtherIdentification<'a>>>,
-    pub order_reference: Option<OrderReference<'a>>,
-    pub address: Option<Address<'a>>,
-    pub contact: Option<Contact<'a>>,
+    vat_identification_number: &'a str,
+    further_identification: Option<Vec<FurtherIdentification<'a>>>,
+    order_reference: Option<OrderReference<'a>>,
+    address: Option<Address<'a>>,
+    contact: Option<Contact<'a>>,
 }
 
-impl Biller<'_> {
+impl<'a> Biller<'a> {
+    pub fn new(vat_identification_number: &str) -> Biller {
+        Biller {
+            vat_identification_number,
+            ..Default::default()
+        }
+    }
+
+    pub fn with_further_identification(
+        mut self,
+        further_identification: FurtherIdentification<'a>,
+    ) -> Self {
+        let mut fi = match self.further_identification {
+            Some(fi) => fi,
+            None => vec![],
+        };
+        fi.push(further_identification);
+        self.further_identification = Some(fi);
+        self
+    }
+
+    pub fn with_address(mut self, address: Address<'a>) -> Self {
+        self.address = Some(address);
+        self
+    }
+
+    pub fn with_contact(mut self, contact: Contact<'a>) -> Self {
+        self.contact = Some(contact);
+        self
+    }
+
     pub fn as_xml(&self) -> XmlElement {
         let mut e = XmlElement::new("Biller")
             .with_text_element("VATIdentificationNumber", self.vat_identification_number);

src/contact.rs

@@ -2,13 +2,45 @@ use crate::xml::XmlElement;
 
 #[derive(Default)]
 pub struct Contact<'a> {
-    pub salutation: Option<&'a str>,
-    pub name: &'a str,
-    pub phone: Option<Vec<&'a str>>,
-    pub email: Option<Vec<&'a str>>,
+    salutation: Option<&'a str>,
+    name: &'a str,
+    phone: Option<Vec<&'a str>>,
+    email: Option<Vec<&'a str>>,
 }
 
-impl Contact<'_> {
+impl<'a> Contact<'a> {
+    pub fn new(name: &str) -> Contact {
+        Contact {
+            name,
+            ..Default::default()
+        }
+    }
+
+    pub fn with_salutation(mut self, salutation: &'a str) -> Self {
+        self.salutation = Some(salutation);
+        self
+    }
+
+    pub fn with_phone(mut self, phone_number: &'a str) -> Self {
+        let mut phone_numbers = match self.phone {
+            Some(p) => p,
+            None => vec![],
+        };
+        phone_numbers.push(phone_number);
+        self.phone = Some(phone_numbers);
+        self
+    }
+
+    pub fn with_email(mut self, email_address: &'a str) -> Self {
+        let mut email_addresses = match self.email {
+            Some(e) => e,
+            None => vec![],
+        };
+        email_addresses.push(email_address);
+        self.email = Some(email_addresses);
+        self
+    }
+
     pub fn as_xml(&self) -> XmlElement {
         let mut e = XmlElement::new("Contact");