maud/maud_macros/tests/tests.rs

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

use std::fmt;

#[test]
fn literals() {
    let mut s = String::new();
    html!(s, "du\tcks" -23 3.14 '\n' "geese").unwrap();
    assert_eq!(s, "du\tcks-233.14\ngeese");
}

#[test]
fn escaping() {
    let mut s = String::new();
    html!(s, "<flim&flam>").unwrap();
    assert_eq!(s, "&lt;flim&amp;flam&gt;");
}

#[test]
fn semicolons() {
    let mut s = String::new();
    html!(s, {
        "one";
        "two";
        "three";
        ;;;;;;;;;;;;;;;;;;;;;;;;
        "four";
    }).unwrap();
    assert_eq!(s, "onetwothreefour");
}

#[test]
fn blocks() {
    let mut s = String::new();
    html!(s, {
        "hello"
        {
            " ducks" " geese"
        }
        " swans"
    }).unwrap();
    assert_eq!(s, "hello ducks geese swans");
}

mod elements {
    #[test]
    fn simple() {
        let mut s = String::new();
        html!(s, p { b { "pickle" } "barrel" i { "kumquat" } }).unwrap();
        assert_eq!(s, "<p><b>pickle</b>barrel<i>kumquat</i></p>");
    }

    #[test]
    fn nesting() {
        let mut s = String::new();
        html!(s, html body div p sup "butts").unwrap();
        assert_eq!(s, "<html><body><div><p><sup>butts</sup></p></div></body></html>");
    }

    #[test]
    fn empty() {
        let mut s = String::new();
        html!(s, "pinkie" br/ "pie").unwrap();
        assert_eq!(s, "pinkie<br>pie");
    }

    #[test]
    fn attributes() {
        let mut s = String::new();
        html!(s, {
            link rel="stylesheet" href="styles.css"/
            section id="midriff" {
                p class="hotpink" "Hello!"
            }
        }).unwrap();
        assert_eq!(s, concat!(
                r#"<link rel="stylesheet" href="styles.css">"#,
                r#"<section id="midriff"><p class="hotpink">Hello!</p></section>"#));
    }

    #[test]
    fn empty_attributes() {
        let mut s = String::new();
        html!(s, div readonly? input type="checkbox" checked? /).unwrap();
        assert_eq!(s, r#"<div readonly><input type="checkbox" checked></div>"#);
    }
}

mod splices {
    #[test]
    fn literals() {
        let mut s = String::new();
        html!(s, $"<pinkie>").unwrap();
        assert_eq!(s, "&lt;pinkie&gt;");
    }

    #[test]
    fn raw_literals() {
        let mut s = String::new();
        html!(s, $$"<pinkie>").unwrap();
        assert_eq!(s, "<pinkie>");
    }

    #[test]
    fn blocks() {
        let mut s = String::new();
        html!(s, {
            ${
                let mut result = 1i32;
                for i in 2..11 {
                    result *= i;
                }
                result
            }
        }).unwrap();
        assert_eq!(s, "3628800");
    }

    #[test]
    fn attributes() {
        let rocks = true;
        let mut s = String::new();
        html!(s, {
            input checked?=true /
            input checked?=false /
            input checked?=rocks /
            input checked?=(!rocks) /
        }).unwrap();
        assert_eq!(s, concat!(
                r#"<input checked>"#,
                r#"<input>"#,
                r#"<input checked>"#,
                r#"<input>"#));
    }

    static BEST_PONY: &'static str = "Pinkie Pie";

    #[test]
    fn statics() {
        let mut s = String::new();
        html!(s, $BEST_PONY).unwrap();
        assert_eq!(s, "Pinkie Pie");
    }

    #[test]
    fn closures() {
        let best_pony = "Pinkie Pie";
        let mut s = String::new();
        html!(s, $best_pony).unwrap();
        assert_eq!(s, "Pinkie Pie");
    }

    /// An example struct, for testing purposes only
    struct Creature {
        name: &'static str,
        /// Rating out of 10, where:
        /// * 0 is a naked mole rat with dysentery
        /// * 10 is Sweetie Belle in a milkshake
        adorableness: u32,
    }

    impl Creature {
        fn repugnance(&self) -> u32 {
            10 - self.adorableness
        }
    }

    #[test]
    fn structs() {
        let pinkie = Creature {
            name: "Pinkie Pie",
            adorableness: 9,
        };
        let mut s = String::new();
        html!(s, {
            "Name: " $pinkie.name ". Rating: " $pinkie.repugnance()
        }).unwrap();
        assert_eq!(s, "Name: Pinkie Pie. Rating: 1");
    }

    #[test]
    fn nested_macro_invocation() {
        let best_pony = "Pinkie Pie";
        let mut s = String::new();
        html!(s, $(format!("{}", best_pony))).unwrap();
        assert_eq!(s, "Pinkie Pie");
    }
}

#[test]
fn issue_13() {
    let owned = String::from("yay");
    let mut s = String::new();
    html!(s, $owned).unwrap();
    let _ = owned;
}

mod control {
    #[test]
    fn if_expr() {
        for (number, &name) in (1..4).zip(["one", "two", "three"].iter()) {
            let mut s = String::new();
            html!(s, {
                #if number == 1 {
                    "one"
                } #else if number == 2 {
                    "two"
                } #else if number == 3 {
                    "three"
                } #else {
                    "oh noes"
                }
            }).unwrap();
            assert_eq!(s, name);
        }
    }

    #[test]
    fn if_let() {
        for &(input, output) in [(Some("yay"), "yay"), (None, "oh noes")].iter() {
            let mut s = String::new();
            html!(s, {
                #if let Some(value) = input {
                    $value
                } #else {
                    "oh noes"
                }
            }).unwrap();
            assert_eq!(s, output);
        }
    }

    #[test]
    fn for_expr() {
        let ponies = ["Apple Bloom", "Scootaloo", "Sweetie Belle"];
        let mut s = String::new();
        html!(s, {
            ul #for pony in &ponies {
                li $pony
            }
        }).unwrap();
        assert_eq!(s, concat!(
                "<ul>",
                "<li>Apple Bloom</li>",
                "<li>Scootaloo</li>",
                "<li>Sweetie Belle</li>",
                "</ul>"));
    }
}

#[test]
fn html_utf8() {
    let mut buf = vec![];
    html_utf8!(buf, p "hello").unwrap();
    assert_eq!(buf, b"<p>hello</p>");
}

mod issue_10 {
    #[test]
    fn hyphens_in_element_names() {
        let mut s = String::new();
        html!(s, custom-element {}).unwrap();
        assert_eq!(s, "<custom-element></custom-element>");
    }

    #[test]
    fn hyphens_in_attribute_names() {
        let mut s = String::new();
        html!(s, this sentence-is="false" of-course? {}).unwrap();
        assert_eq!(s, r#"<this sentence-is="false" of-course></this>"#);
    }
}

#[test]
fn call() {
    fn ducks(w: &mut fmt::Write) -> fmt::Result {
        write!(w, "Ducks")
    }
    let mut s = String::new();
    let swans = |yes|
        if yes {
            |w: &mut fmt::Write| write!(w, "Swans")
        } else {
            panic!("oh noes")
        };
    html!(s, {
        #call ducks
        #call (|w: &mut fmt::Write| write!(w, "Geese"))
        #call swans(true)
    }).unwrap();
    assert_eq!(s, "DucksGeeseSwans");
}
Revert "Add `#call_box` instruction" This reverts commit 0311bab45ba045106c4bcd96844a0f7afaab29d7. 2015-09-26 13:56:52 +12:00			`#![feature(plugin)]`
Update Rust 2015-02-13 17:46:02 +13:00			`#![plugin(maud_macros)]`
First commit 2014-12-17 21:11:56 +13:00
Rename htmlthing to maud rocks 2014-12-18 19:49:49 +13:00			`extern crate maud;`
First commit 2014-12-17 21:11:56 +13:00
Revert "Add `#call_box` instruction" This reverts commit 0311bab45ba045106c4bcd96844a0f7afaab29d7. 2015-09-26 13:56:52 +12:00			`use std::fmt;`

First commit 2014-12-17 21:11:56 +13:00			`#[test]`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`fn literals() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, "du\tcks" -23 3.14 '\n' "geese").unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "du\tcks-233.14\ngeese");`
First commit 2014-12-17 21:11:56 +13:00			`}`
Add escaping 2014-12-19 11:53:40 +13:00
			`#[test]`
			`fn escaping() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, "<flim&flam>").unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "<flim&flam>");`
Add escaping 2014-12-19 11:53:40 +13:00			`}`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`#[test]`
			`fn semicolons() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`"one";`
			`"two";`
			`"three";`
			`;;;;;;;;;;;;;;;;;;;;;;;;`
			`"four";`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`assert_eq!(s, "onetwothreefour");`
			`}`

Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`#[test]`
			`fn blocks() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`"hello"`
			`{`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`" ducks" " geese"`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`
			`" swans"`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "hello ducks geese swans");`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`

Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`mod elements {`
			`#[test]`
			`fn simple() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, p { b { "pickle" } "barrel" i { "kumquat" } }).unwrap();`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`assert_eq!(s, "<p><b>pickle</b>barrel<i>kumquat</i></p>");`
			`}`

			`#[test]`
			`fn nesting() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, html body div p sup "butts").unwrap();`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`assert_eq!(s, "<html><body><div><p><sup>butts</sup></p></div></body></html>");`
			`}`

			`#[test]`
			`fn empty() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, "pinkie" br/ "pie").unwrap();`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`assert_eq!(s, "pinkie<br>pie");`
			`}`

			`#[test]`
			`fn attributes() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`link rel="stylesheet" href="styles.css"/`
			`section id="midriff" {`
			`p class="hotpink" "Hello!"`
			`}`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`assert_eq!(s, concat!(`
			`r#"<link rel="stylesheet" href="styles.css">"#,`
			`r#"<section id="midriff"><p class="hotpink">Hello!</p></section>"#));`
			`}`

			`#[test]`
			`fn empty_attributes() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, div readonly? input type="checkbox" checked? /).unwrap();`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`assert_eq!(s, r#"<div readonly><input type="checkbox" checked></div>"#);`
			`}`
			`}`

			`mod splices {`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`#[test]`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`fn literals() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, $"<pinkie>").unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "<pinkie>");`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`

			`#[test]`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`fn raw_literals() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, $$"<pinkie>").unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "<pinkie>");`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`

			`#[test]`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`fn blocks() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`${`
			`let mut result = 1i32;`
Use fancy new range syntax 2015-02-06 14:50:47 +13:00			`for i in 2..11 {`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`result *= i;`
			`}`
			`result`
			`}`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "3628800");`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`

Implement toggleable boolean attributes Closes #4 2015-01-29 13:47:11 +13:00			`#[test]`
			`fn attributes() {`
			`let rocks = true;`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Implement toggleable boolean attributes Closes #4 2015-01-29 13:47:11 +13:00			`input checked?=true /`
			`input checked?=false /`
			`input checked?=rocks /`
			`input checked?=(!rocks) /`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Implement toggleable boolean attributes Closes #4 2015-01-29 13:47:11 +13:00			`assert_eq!(s, concat!(`
			`r#"<input checked>"#,`
			`r#"<input>"#,`
			`r#"<input checked>"#,`
			`r#"<input>"#));`
			`}`

Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`static BEST_PONY: &'static str = "Pinkie Pie";`

			`#[test]`
			`fn statics() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, $BEST_PONY).unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "Pinkie Pie");`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`

			`#[test]`
Make tests significantly more sexy 2015-01-14 13:48:48 +13:00			`fn closures() {`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`let best_pony = "Pinkie Pie";`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, $best_pony).unwrap();`
Use shiny new slicing syntax 2015-01-07 17:54:43 +13:00			`assert_eq!(s, "Pinkie Pie");`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`
Finally make splicing variables work 2015-01-17 20:43:51 +13:00
Make splices a bit nicer to use 2015-01-18 20:18:21 +13:00			`/// An example struct, for testing purposes only`
			`struct Creature {`
			`name: &'static str,`
			`/// Rating out of 10, where:`
			`/// * 0 is a naked mole rat with dysentery`
			`/// * 10 is Sweetie Belle in a milkshake`
Switch from u8 to u32, as per style guidelines 2015-03-01 20:02:34 -05:00			`adorableness: u32,`
Make splices a bit nicer to use 2015-01-18 20:18:21 +13:00			`}`

			`impl Creature {`
Switch from u8 to u32, as per style guidelines 2015-03-01 20:02:34 -05:00			`fn repugnance(&self) -> u32 {`
Make splices a bit nicer to use 2015-01-18 20:18:21 +13:00			`10 - self.adorableness`
			`}`
			`}`

			`#[test]`
			`fn structs() {`
			`let pinkie = Creature {`
			`name: "Pinkie Pie",`
			`adorableness: 9,`
			`};`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Make splices a bit nicer to use 2015-01-18 20:18:21 +13:00			`"Name: " $pinkie.name ". Rating: " $pinkie.repugnance()`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Make splices a bit nicer to use 2015-01-18 20:18:21 +13:00			`assert_eq!(s, "Name: Pinkie Pie. Rating: 1");`
			`}`

Finally make splicing variables work 2015-01-17 20:43:51 +13:00			`#[test]`
			`fn nested_macro_invocation() {`
			`let best_pony = "Pinkie Pie";`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, $(format!("{}", best_pony))).unwrap();`
Finally make splicing variables work 2015-01-17 20:43:51 +13:00			`assert_eq!(s, "Pinkie Pie");`
			`}`
Rewrite the parser yay 2015-01-07 17:43:37 +13:00			`}`
Add regression test for #1 2015-01-26 12:31:11 +13:00
Add regression test for #13 2015-04-30 16:33:24 +12:00			`#[test]`
			`fn issue_13() {`
			`let owned = String::from("yay");`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, $owned).unwrap();`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let _ = owned;`
Add regression test for #13 2015-04-30 16:33:24 +12:00			`}`

Implement if/else 2015-02-27 09:27:45 +13:00			`mod control {`
			`#[test]`
			`fn if_expr() {`
			`for (number, &name) in (1..4).zip(["one", "two", "three"].iter()) {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Rename `$if` and `$for` to `#if` and `#for` `#if` and `#for` aren't splices. They are a different concept, so should have different syntax as well. 2015-09-12 13:53:14 +12:00			`#if number == 1 {`
Implement if/else 2015-02-27 09:27:45 +13:00			`"one"`
Rename `$if` and `$for` to `#if` and `#for` `#if` and `#for` aren't splices. They are a different concept, so should have different syntax as well. 2015-09-12 13:53:14 +12:00			`} #else if number == 2 {`
Implement if/else 2015-02-27 09:27:45 +13:00			`"two"`
Rename `$if` and `$for` to `#if` and `#for` `#if` and `#for` aren't splices. They are a different concept, so should have different syntax as well. 2015-09-12 13:53:14 +12:00			`} #else if number == 3 {`
Implement if/else 2015-02-27 09:27:45 +13:00			`"three"`
Rename `$if` and `$for` to `#if` and `#for` `#if` and `#for` aren't splices. They are a different concept, so should have different syntax as well. 2015-09-12 13:53:14 +12:00			`} #else {`
Implement if/else 2015-02-27 09:27:45 +13:00			`"oh noes"`
			`}`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Implement if/else 2015-02-27 09:27:45 +13:00			`assert_eq!(s, name);`
			`}`
			`}`
Implement `for` expressions 2015-03-14 21:08:08 +13:00
Support `if let` 2015-03-15 16:23:19 +13:00			`#[test]`
			`fn if_let() {`
			`for &(input, output) in [(Some("yay"), "yay"), (None, "oh noes")].iter() {`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Rename `$if` and `$for` to `#if` and `#for` `#if` and `#for` aren't splices. They are a different concept, so should have different syntax as well. 2015-09-12 13:53:14 +12:00			`#if let Some(value) = input {`
Support `if let` 2015-03-15 16:23:19 +13:00			`$value`
Rename `$if` and `$for` to `#if` and `#for` `#if` and `#for` aren't splices. They are a different concept, so should have different syntax as well. 2015-09-12 13:53:14 +12:00			`} #else {`
Support `if let` 2015-03-15 16:23:19 +13:00			`"oh noes"`
			`}`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Support `if let` 2015-03-15 16:23:19 +13:00			`assert_eq!(s, output);`
			`}`
			`}`

Implement `for` expressions 2015-03-14 21:08:08 +13:00			`#[test]`
			`fn for_expr() {`
			`let ponies = ["Apple Bloom", "Scootaloo", "Sweetie Belle"];`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`let mut s = String::new();`
Rename `write_html!` to `html!` It's more concise 2015-09-03 11:03:45 +12:00			`html!(s, {`
Rename `$if` and `$for` to `#if` and `#for` `#if` and `#for` aren't splices. They are a different concept, so should have different syntax as well. 2015-09-12 13:53:14 +12:00			`ul #for pony in &ponies {`
Implement `for` expressions 2015-03-14 21:08:08 +13:00			`li $pony`
			`}`
De-closureify the API Closes #18 2015-09-01 18:26:50 +12:00			`}).unwrap();`
Implement `for` expressions 2015-03-14 21:08:08 +13:00			`assert_eq!(s, concat!(`
			`"<ul>",`
			`"<li>Apple Bloom</li>",`
			`"<li>Scootaloo</li>",`
			`"<li>Sweetie Belle</li>",`
			`"</ul>"));`
			`}`
Implement if/else 2015-02-27 09:27:45 +13:00			`}`
Add `Utf8Writer` 2015-09-06 12:59:41 +12:00
			`#[test]`
Rename `write_html!` to `html_utf8!` The new name makes it clear what the macro is doing: encoding the output to UTF-8. 2015-09-12 14:21:01 +12:00			`fn html_utf8() {`
Add a `write_html!` macro This handles the common case of wrapping the stream in a `Utf8Writer`. 2015-09-07 19:43:48 +12:00			`let mut buf = vec![];`
Rename `write_html!` to `html_utf8!` The new name makes it clear what the macro is doing: encoding the output to UTF-8. 2015-09-12 14:21:01 +12:00			`html_utf8!(buf, p "hello").unwrap();`
Add `Utf8Writer` 2015-09-06 12:59:41 +12:00			`assert_eq!(buf, b"<p>hello</p>");`
			`}`
Handle hyphens in attribute and element names Closes #10 2015-09-15 17:47:32 +12:00
			`mod issue_10 {`
			`#[test]`
			`fn hyphens_in_element_names() {`
			`let mut s = String::new();`
			`html!(s, custom-element {}).unwrap();`
			`assert_eq!(s, "<custom-element></custom-element>");`
			`}`

			`#[test]`
			`fn hyphens_in_attribute_names() {`
			`let mut s = String::new();`
			`html!(s, this sentence-is="false" of-course? {}).unwrap();`
			`assert_eq!(s, r#"<this sentence-is="false" of-course></this>"#);`
			`}`
			`}`
Add `#call` instruction 2015-09-23 14:29:45 +12:00
Revert "Add `#call_box` instruction" This reverts commit 0311bab45ba045106c4bcd96844a0f7afaab29d7. 2015-09-26 13:56:52 +12:00			`#[test]`
			`fn call() {`
Add `#call` instruction 2015-09-23 14:29:45 +12:00			`fn ducks(w: &mut fmt::Write) -> fmt::Result {`
			`write!(w, "Ducks")`
			`}`
Revert "Add `#call_box` instruction" This reverts commit 0311bab45ba045106c4bcd96844a0f7afaab29d7. 2015-09-26 13:56:52 +12:00			`let mut s = String::new();`
			`let swans = \|yes\|`
			`if yes {`
			`\|w: &mut fmt::Write\| write!(w, "Swans")`
			`} else {`
			`panic!("oh noes")`
			`};`
			`html!(s, {`
			`#call ducks`
			`#call (\|w: &mut fmt::Write\| write!(w, "Geese"))`
			`#call swans(true)`
			`}).unwrap();`
			`assert_eq!(s, "DucksGeeseSwans");`
Add `#call` instruction 2015-09-23 14:29:45 +12:00			`}`
No results found.