Move to cmark-hamlet; +find_testable_code

Author: johncf

Cargo.lock

@@ -4,7 +4,6 @@ name = "rustdoc"
 version = "0.0.0"
 
 [dependencies]
-maud = "0.8.0"
-maud_macros = "*"
-maud-pulldown-cmark = "^0.1"
-pulldown-cmark = "0.0.5"
+pulldown-cmark = "0.0.8"
+hamlet = { git = "https://github.com/Nemo157/hamlet", branch = "events" }
+cmark-hamlet = { git = "https://github.com/critiqjo/cmark-hamlet", branch = "adapter" }

Cargo.toml

@@ -27,11 +27,12 @@
 use rustc::session::config::get_unstable_features_setting;
 use std::borrow::Cow;
 use std::cell::RefCell;
-use std::fmt;
+use std::fmt::{self, Write};
 use syntax::feature_gate::UnstableFeatures;
 
-use maud_pulldown_cmark::Markdown as CMarkMaudAda;
-use pulldown_cmark::{Parser, Event, Tag};
+use cmark::{Parser, Event as CmEvent, Tag};
+use hamlet::Token as HmToken;
+use cmark_hamlet;
 
 //use html::render::derive_id;
 //use html::toc::TocBuilder;
@@ -76,63 +77,80 @@ thread_local!(pub static PLAYGROUND_KRATE: RefCell<Option<Option<String>>> = {
 });
 
 pub fn render(w: &mut fmt::Formatter, md: &str, _: bool) -> fmt::Result {
-    let mut rust_block = None;
-    let events = Parser::new(md).map(|ev| match ev {
-        Event::Start(Tag::CodeBlock(lang)) => {
-            info!("lang: {}", lang);
-            if LangString::parse(&*lang).rust {
-                rust_block = Some(String::from(""));
-                Event::Html(Cow::Borrowed(""))
-            } else {
-                Event::Start(Tag::CodeBlock(lang))
+    let mut rust_block = false;
+    for hm_tok in cmark_hamlet::Adapter::new(Parser::new(md), true) {
+        match hm_tok {
+            HmToken::StartTag { ref name, .. } |
+            HmToken::EndTag { ref name } if rust_block && name.as_ref() == "code" => (),
+            HmToken::StartTag { name: Cow::Borrowed("pre"), ref attrs, .. } => {
+                let is_rust = attrs.get("data-lang")
+                                   .map(|lang| LangString::parse(lang).rust);
+                if let Some(true) = is_rust {
+                    rust_block = true;
+                } else {
+                    try!(write!(w, "{}", hm_tok));
+                }
             }
-        },
-        Event::End(Tag::CodeBlock(_)) => {
-            if rust_block.is_some() {
-                let code = rust_block.take().unwrap();
-                let mut s = String::from("\n");
+            HmToken::Text(ref text) if rust_block => {
+                let code = text.as_ref();
+                // insert newline to clearly separate it from the
+                // previous block so we can shorten the html output
+                let mut out = String::from("\n");
                 PLAYGROUND_KRATE.with(|krate| {
-                    // insert newline to clearly separate it from the
-                    // previous block so we can shorten the html output
                     krate.borrow().as_ref().map(|krate| {
                         let test = code.lines().map(|l| {
                             stripped_filtered_line(l).unwrap_or(l)
                         }).collect::<Vec<&str>>().join("\n");
                         let krate = krate.as_ref().map(|s| &**s);
                         let test = test::maketest(&test, krate, false,
                                                   &Default::default());
-                        s.push_str(&format!("<span class='rusttest'>{}</span>", Escape(&test)));
+                        out.push_str(&format!("<span class='rusttest'>{}</span>", Escape(&test)));
                     });
-                    let text = code.lines().filter(|l| {
+                    let filtered_code = code.lines().filter(|l| {
                         stripped_filtered_line(l).is_none()
                     }).collect::<Vec<&str>>().join("\n");
-                    s.push_str(&highlight::highlight(&text,
-                                                     Some("rust-example-rendered"),
-                                                     None));
+                    out.push_str(&highlight::highlight(&filtered_code,
+                                                       Some("rust-example-rendered"),
+                                                       None));
                 });
-                Event::Html(Cow::Owned(s))
-            } else {
-                ev
+                try!(write!(w, "{}", out));
             }
-        },
-        Event::Text(text) => {
-            if let Some(code) = rust_block.as_mut() {
-                code.push_str(&*text);
-                Event::Html(Cow::Borrowed(""))
-            } else {
-                Event::Text(text)
+            HmToken::EndTag{name: Cow::Borrowed("pre")} if rust_block => {
+                rust_block = false;
             }
-        },
-        _ => ev,
-    });
-
-    html!(*w, {
-        ^CMarkMaudAda::from_events(events)
-    })
+            _ => try!(write!(w, "{}", hm_tok)),
+        }
+    }
+    Ok(())
 }
 
-pub fn find_testable_code(_: &str, _: &mut ::test::Collector) {
-    unimplemented!()
+pub fn find_testable_code(md: &str, tests: &mut ::test::Collector) {
+    let mut block_info = None;
+    for hm_tok in cmark_hamlet::Adapter::new(Parser::new(md), true) {
+        match hm_tok {
+            HmToken::StartTag { name: Cow::Borrowed("pre"), attrs, .. } => {
+                block_info = attrs.get("data-lang")
+                                  .map(|lang| LangString::parse(lang));
+            }
+            HmToken::Text(ref text) if block_info.is_some() => {
+                let block_info = block_info.as_ref().unwrap();
+                if block_info.rust {
+                    let lines = text.lines().map(|l| {
+                        stripped_filtered_line(l).unwrap_or(l)
+                    });
+                    let clean_code = lines.collect::<Vec<&str>>().join("\n");
+                    tests.add_test(clean_code,
+                                   block_info.should_panic, block_info.no_run,
+                                   block_info.ignore, block_info.test_harness,
+                                   block_info.compile_fail);
+                }
+            }
+            HmToken::EndTag{name: Cow::Borrowed("pre")} if block_info.is_some() => {
+                block_info = None;
+            }
+            _ => (),
+        }
+    }
 }
 
 #[derive(Eq, PartialEq, Clone, Debug)]
@@ -211,22 +229,21 @@ impl<'a> fmt::Display for MarkdownWithToc<'a> {
 
 pub fn plain_summary_line(md: &str) -> String {
     let events = Parser::new(md).map(|ev| match ev {
-        Event::Start(Tag::Code) => Event::Text(Cow::Borrowed("`")),
-        Event::End(Tag::Code) => Event::Text(Cow::Borrowed("`")),
-        Event::Start(Tag::Link(_, text)) => Event::Text(text),
-        Event::Start(Tag::Image(_, text)) => Event::Text(text),
-        Event::Html(html) | Event::InlineHtml(html) => Event::Text(html),
-        ev @ Event::Text(_) => ev,
-        _ => Event::Html(Cow::Borrowed("")),
+        CmEvent::Start(Tag::Code) => CmEvent::Text(Cow::Borrowed("`")),
+        CmEvent::End(Tag::Code) => CmEvent::Text(Cow::Borrowed("`")),
+        CmEvent::Start(Tag::Link(_, text)) => CmEvent::Text(text),
+        CmEvent::Start(Tag::Image(_, text)) => CmEvent::Text(text),
+        CmEvent::Html(html) | CmEvent::InlineHtml(html) => CmEvent::Text(html),
+        ev @ CmEvent::Text(_) => ev,
+        _ => CmEvent::Html(Cow::Borrowed("")),
     });
 
-    let mut buf = String::new();
-
-    html!(buf, {
-        ^CMarkMaudAda::from_events(events)
-    }).unwrap();
-
-    buf
+    let hm_toks = cmark_hamlet::Adapter::new(events, false);
+    let mut ret = String::from("");
+    for tok in hm_toks {
+        write!(ret, "{}", tok).unwrap();
+    }
+    ret
 }
 
 #[cfg(test)]

src/html/markdown.rs

@@ -26,9 +26,6 @@
 #![feature(unicode)]
 #![feature(question_mark)]
 
-#![feature(plugin)]
-#![plugin(maud_macros)]
-
 extern crate arena;
 extern crate getopts;
 extern crate libc;
@@ -46,9 +43,9 @@ extern crate test as testing;
 extern crate rustc_unicode;
 #[macro_use] extern crate log;
 
-extern crate maud;
-extern crate maud_pulldown_cmark;
-extern crate pulldown_cmark;
+extern crate pulldown_cmark as cmark;
+extern crate hamlet;
+extern crate cmark_hamlet;
 
 extern crate serialize as rustc_serialize; // used by deriving