. // s << DIV(ID=id_, CLASS="plain"); serialize_pre_text (s, text_, length_, url_, "" /* id */); s << ~DIV; break; } case text_type::common_mark: case text_type::github_mark: { // Convert Markdown into XHTML wrapping it into the

element. // auto print_error = [&s, this] (const string& e) { s << DIV(ID=id_, CLASS="markdown") << SPAN(CLASS="error") << e << ~SPAN << ~DIV; }; // Note that the only possible reason for the following cmark API // calls to fail is the inability to allocate memory. Unfortunately, // instead of reporting the failure to the caller, the API issues // diagnostics to stderr and aborts the process. Let's decrease the // probability of such an event by limiting the text size to 64K. // if (text_.size () > 64 * 1024) { print_error (what_ + " is too long"); return; } string html; { char* r; { // Parse Markdown into the AST. // unique_ptr parser ( cmark_parser_new (CMARK_OPT_DEFAULT | CMARK_OPT_VALIDATE_UTF8), [] (cmark_parser* p) {cmark_parser_free (p);}); // Enable GitHub extensions in the parser, if requested. // if (type_ == text_type::github_mark) { auto add = [&parser] (const char* ext) { cmark_syntax_extension* e ( cmark_find_syntax_extension (ext)); // Built-in extension is only expected. // assert (e != nullptr); cmark_parser_attach_syntax_extension (parser.get (), e); }; add ("table"); add ("strikethrough"); add ("autolink"); // Somehow feels unsafe (there are some nasty warnings when // upstream's tasklist.c is compiled), so let's disable for now. // // add ("tasklist"); } cmark_parser_feed (parser.get (), text_.c_str (), text_.size ()); unique_ptr doc ( cmark_parser_finish (parser.get ()), [] (cmark_node* n) {cmark_node_free (n);}); // Strip the document "title". // if (strip_title_) { cmark_node* child (cmark_node_first_child (doc.get ())); if (child != nullptr && cmark_node_get_type (child) == CMARK_NODE_HEADING && cmark_node_get_heading_level (child) == 1) { cmark_node_unlink (child); cmark_node_free (child); } } // Render the AST into an XHTML fragment. // // Note that unlike GitHub we follow the default API behavior and // don't allow the raw HTML in Markdown (omitting the // CMARK_OPT_UNSAFE flag). This way we can assume the rendered // HTML is a well-formed XHTML fragment, which we rely upon for // truncation (see below). Note that by default the renderer // suppresses any HTML-alike markup and unsafe URLs (javascript:, // etc). // r = cmark_render_html (doc.get (), CMARK_OPT_DEFAULT, nullptr /* extensions */); } unique_ptr deleter ( r, [] (char* s) {cmark_get_default_mem_allocator ()->free (s);}); html = r; } // From the CommonMark Spec it follows that the resulting HTML can be // assumed a well-formed XHTML fragment with all the elements having // closing tags. But let's not assume this being the case (due to some // library bug or similar) and handle the xml::parsing exception. // try { fragment f (html, "gfm-html", url_ == nullptr ? 0 : length_); s << DIV(ID=id_, CLASS="markdown"); // Disable indentation not to introduce unwanted spaces. // s.suspend_indentation (); s << f; s.resume_indentation (); if (f.truncated) s << DIV(CLASS="more") << "... " << A(HREF=*url_) << "More" << ~A << ~DIV; s << ~DIV; } catch (const xml::parsing& e) { string error ("unable to parse " + what_ + " XHTML fragment: " + e.what ()); diag_ << error; print_error (error); } break; } } } // DIV_PAGER // DIV_PAGER:: DIV_PAGER (size_t current_page, size_t item_count, size_t item_per_page, size_t page_number_count, const string& url) : current_page_ (current_page), item_count_ (item_count), item_per_page_ (item_per_page), page_number_count_ (page_number_count), url_ (url) { } void DIV_PAGER:: operator() (serializer& s) const { if (item_count_ == 0 || item_per_page_ == 0) return; size_t pcount (item_count_ / item_per_page_); // Page count. if (item_count_ % item_per_page_) ++pcount; if (pcount > 1) { auto url ( [this](size_t page) -> string { return page == 0 ? url_ : url_ + (url_.find ('?') == string::npos ? "?p=" : "&p=") + to_string (page); }); s << DIV(ID="pager"); if (current_page_ > 0) s << A(ID="prev", HREF=url (current_page_ - 1)) << "Prev" << ~A; if (page_number_count_) { size_t offset (page_number_count_ / 2); size_t from (current_page_ > offset ? current_page_ - offset : 0); size_t to (min (from + page_number_count_, pcount)); // Display as many pages as allowed. // if (to - from < page_number_count_ && from > 0) from -= min (from, page_number_count_ - (to - from)); for (size_t p (from); p < to; ++p) { s << A(HREF=url (p)); if (p == current_page_) s << ID("curr"); s << p + 1 << ~A; } } if (current_page_ < pcount - 1) s << A(ID="next", HREF=url (current_page_ + 1)) << "Next" << ~A; s << ~DIV; } } // Convert the argument to a string conformant to the section // "3.2.5.1 The id attribute" of the HTML 5 specification at // http://www.w3.org/TR/html5/dom.html#the-id-attribute. // string html_id (const string& v) { ostringstream o; o << hex << uppercase << right << setfill ('0'); // Replace space characters (as specified at // http://www.w3.org/TR/html5/infrastructure.html#space-character) with // the respective escape sequences. // for (auto c: v) { switch (c) { case ' ': case '\t': case '\n': case '\r': case '\f': case '~': { // We use '~' as an escape character because it doesn't require // escaping in URLs. // o << "~" << setw (2) << static_cast (c); break; } default: o << c; break; } } return o.str (); } }