updated version

orderedlistparser: Add parsing support for fully numeric markdown lists

.editorconfig

@@ -8,5 +8,5 @@ indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
 
-[*.{h,hh,hpp,c,cc,cpp,cxx}]
+[*.{h,hh,hpp,c,cc,cpp,cxx,yml}]
 indent_size = 2

.travis.yml

@@ -1,18 +1,32 @@
-dist: trusty
 sudo: false
 language: cpp
-compiler: g++
+matrix:
-install: export CXX="g++-6"
+  include:
-addons:
+    - os: linux
+      dist: xenial
+      sudo: require
+      addons:
         apt:
           sources:
-      - ubuntu-toolchain-r-test
+            - sourceline: 'ppa:ubuntu-toolchain-r/test'
           packages:
-      - g++-6
+            - g++-7
+      env:
+        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+
+    - os: osx
+      osx_image: xcode10
+      compiler: clang
+      env:
+        - MATRIX_EVAL="CC=clang && CXX=clang++"
+
+before_install:
+  # This is necessary to solve https://github.com/travis-ci/travis-ci/issues/9649
+  - eval "${MATRIX_EVAL}"
 
 script:
   - mkdir tmp
   - cd tmp
   - cmake ..
-  - make
+  - make -j4
   - ../build/MaddyTests

AUTHORS

@@ -5,3 +5,7 @@ licensing terms detailed in LICENSE.
 a license to everyone to use it as detailed in LICENSE.)
 
 M. Petra Baranski (info@progsource.de)
+Patrick José Pereira (patrickelectric@gmail.com)
+Martin Kopecky (martin.kopecky357@gmail.com)
+Andrew Mettlach (dmmettlach@gmail.com)
+Evan Klitzke (evan@eklitzke.org)

CMakeLists.txt

@@ -25,10 +25,17 @@ file(GLOB_RECURSE MADDY_TESTS_FILES ${CMAKE_CURRENT_SOURCE_DIR}/tests/maddy/*.cp
 
 # ------------------------------------------------------------------------------
 
-set(
+if (UNIX)
+  set(
     CMAKE_CXX_FLAGS
     "${CMAKE_CXX_FLAGS} -g -std=c++${MADDY_CPP_VERSION} -Wall -Wpedantic -Wextra -Wno-ignored-qualifiers -fno-rtti -fno-exceptions -fsanitize=address -fno-omit-frame-pointer"
-)
+  )
+else()
+  set(
+    CMAKE_CXX_FLAGS
+    "${CMAKE_CXX_FLAGS} -std=c++${MADDY_CPP_VERSION}"
+  )
+endif()
 
 # ------------------------------------------------------------------------------
 
@@ -53,10 +60,9 @@ add_subdirectory(libs)
 
 # ------------------------------------------------------------------------------
 
-include_directories(
+add_library(maddy INTERFACE)
-  ${LIBS_INCLUDE_DIRS}
+target_include_directories(maddy INTERFACE
   ${MADDY_INCLUDE_DIR}
-  ${CMAKE_CURRENT_SOURCE_DIR}/tests
 )
 
 # ------------------------------------------------------------------------------
@@ -66,5 +72,9 @@ add_executable(
     ${MADDY_TESTS_FILES}
     ${CMAKE_CURRENT_SOURCE_DIR}/tests/main.cpp
 )
-target_link_libraries(MaddyTests gmock_main)
+target_include_directories(MaddyTests PUBLIC
+  ${LIBS_INCLUDE_DIRS}
+  ${CMAKE_CURRENT_SOURCE_DIR}/tests
+)
+target_link_libraries(MaddyTests maddy gmock_main)
 add_test(MaddyTests ${CMAKE_CURRENT_SOURCE_DIR}/build/MaddyTests)

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2017 M. Petra Baranski
+Copyright 2017, 2018, 2019, 2020 M. Petra Baranski
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

README.md

@@ -1,8 +1,9 @@
 # maddy
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version: 1.0.3](https://img.shields.io/badge/Version-1.0.3-brightgreen.svg)](https://semver.org/)
+[![Version: 1.1.2](https://img.shields.io/badge/Version-1.1.2-brightgreen.svg)](https://semver.org/)
-[![Build Status](https://travis-ci.org/progsource/maddy.svg?branch=master)](https://travis-ci.org/progsource/maddy)
+[![Travis Build Status](https://travis-ci.org/progsource/maddy.svg?branch=master)](https://travis-ci.org/progsource/maddy)
+[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/04m0lg27kigv1pg8/branch/master?svg=true)](https://ci.appveyor.com/project/progsource/maddy/branch/master)
 
 maddy is a C++ Markdown to HTML **header-only** parser library.
 
@@ -12,7 +13,9 @@ It actually should work on any OS, that supports the C++14 standard library.
 
 It is tested to work on:
 
-* Linux (without exceptions and without RTTI)
+* Linux (gcc)
+* OSX (clang)
+* Windows (Visual Studio 2017)
 
 ## Dependencies
 
@@ -39,7 +42,13 @@ and in the code, you can then do the following:
 #include "maddy/parser.h"
 
 std::stringstream markdownInput("");
-std::shared_ptr<maddy::Parser> parser = std::make_shared<maddy::Parser>();
+
+// config is optional
+std::shared_ptr<maddy::ParserConfig> config = std::make_shared<maddy::ParserConfig>();
+config->isEmphasizedParserEnabled = true; // default
+config->isHTMLWrappedInParagraph = true; // default
+
+std::shared_ptr<maddy::Parser> parser = std::make_shared<maddy::Parser>(config);
 std::string htmlOutput = parser->Parse(markdownInput);
 ```
 
@@ -66,6 +75,6 @@ make test # or run the executable in ../build/MaddyTests
 
 There are different possibilities:
 
-* Create a GitHub issue
+* [Create a GitHub issue](https://github.com/progsource/maddy/issues/new)
 * Create a pull request with an own branch (don't forget to put yourself in the
   AUTHORS file)

appveyor.yml

@@ -0,0 +1,15 @@
+image: Visual Studio 2017
+
+install:
+  - cmd: git submodule update --init --recursive
+
+before_build:
+  - cmd: mkdir tmp
+  - cmd: cd tmp
+  - cmd: cmake -G "Visual Studio 15 Win64" ..
+
+build:
+  project: $(APPVEYOR_BUILD_FOLDER)\tmp\$(APPVEYOR_PROJECT_NAME).sln
+
+test_script:
+  - cmd: ctest -VV -C "Debug"

docs/definitions.md

@@ -7,6 +7,10 @@ destroy the output, if there was HTML in your markdown.
 The Parser expects you to use spaces and not tabs for indentation in the
 markdown.
 
+If a line starts with `<` and `config->isHTMLWrappedInParagraph` is false, it
+expects that the upcoming line is HTML and therefor will not be surrounded by a
+paragraph.
+
 ## Headlines
 
 ```
@@ -40,11 +44,13 @@ results in
 ## Lists
 
 ### unordered
+Characters "*", "+" or "-" to make an unordered "bullet" list are equivalent.
+
 ```
 
-* unordered
+- unordered
 * list
-* items
++ items
 
 ```
 results in
@@ -62,8 +68,8 @@ results in
   * list
   * items
     * in
-    * an
+    + an
-  * hierarchy
+  - hierarchy
 
 ```
 results in
@@ -88,6 +94,26 @@ results in
 
 ```
 
+1. ordered
+2. list
+3. items
+
+```
+
+results in
+
+```html
+
+<ol>
+  <li>ordered</li>
+  <li>list</li>
+  <li>items</li>
+</ol>
+
+```
+
+```
+
 1. ordered
 * list
 * items
@@ -221,16 +247,30 @@ results in
 
 ```
 **bold text**
+__bold text__
 ```
 results in
 ```html
 <strong>bold text</strong>
+<strong>bold text</strong>
+```
+
+## italic
+
+```
+*italic text*
+```
+results in
+```html
+<i>italic text</i>
 ```
 
 ## emphasized
 
+This can be disabled by setting `config->isEmphasizedParserEnabled = false`.
+
 ```
-*emphasized text*
+_emphasized text_
 ```
 results in
 ```html
@@ -257,6 +297,17 @@ results in
 <hr/>
 ```
 
+## break line
+
+```
+New\r\nLine
+```
+results in
+```html
+New<br>
+Line
+```
+
 ## Images
 
 ```

include/maddy/blockparser.h

@@ -7,7 +7,11 @@
 // -----------------------------------------------------------------------------
 
 #include <functional>
+#include <sstream>
 #include <string>
+// windows compatibility includes
+#include <cctype>
+#include <algorithm>
 
 // -----------------------------------------------------------------------------
 
@@ -44,6 +48,13 @@ public:
     , getBlockParserForLineCallback(getBlockParserForLineCallback)
   {}
 
+  /**
+   * dtor
+   *
+   * @method
+   */
+  virtual ~BlockParser() {}
+
   /**
    * AddLine
    *
@@ -146,7 +157,8 @@ protected:
   {
     bool hasMetNonSpace = false;
 
-    uint32_t indentation = std::count_if(
+    uint32_t indentation = static_cast<uint32_t>(
+      std::count_if(
         line.begin(),
         line.end(),
         [&hasMetNonSpace](unsigned char c)
@@ -164,6 +176,7 @@ protected:
           hasMetNonSpace = true;
           return false;
         }
+      )
     );
 
     return indentation;

include/maddy/breaklineparser.h

@@ -0,0 +1,51 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#pragma once
+
+// -----------------------------------------------------------------------------
+
+#include <string>
+#include <regex>
+
+#include "maddy/lineparser.h"
+
+// -----------------------------------------------------------------------------
+
+namespace maddy {
+
+// -----------------------------------------------------------------------------
+
+/**
+ * BreakLineParser
+ *
+ * @class
+ */
+class BreakLineParser : public LineParser
+{
+public:
+  /**
+   * Parse
+   *
+   * From Markdown: `text\r\n text`
+   *
+   * To HTML: `text<br> text`
+   *
+   * @method
+   * @param {std::string&} line The line to interpret
+   * @return {void}
+   */
+  void
+  Parse(std::string& line) override
+  {
+    static std::regex re(R"((\r\n|\r))");
+    static std::string replacement = "<br>";
+
+    line = std::regex_replace(line, re, replacement);
+  }
+}; // class BreakLineParser
+
+// -----------------------------------------------------------------------------
+
+} // namespace maddy

include/maddy/emphasizedparser.h

@@ -30,7 +30,7 @@ public:
   /**
    * Parse
    *
-   * From Markdown: `text *text*`
+   * From Markdown: `text _text_`
    *
    * To HTML: `text <em>text</em>`
    *
@@ -41,7 +41,7 @@ public:
   void
   Parse(std::string& line) override
   {
-    static std::regex re("(?!.*`.*|.*<code>.*)\\*(?!.*`.*|.*<\\/code>.*)([^\\*]*)\\*(?!.*`.*|.*<\\/code>.*)");
+    static std::regex re("(?!.*`.*|.*<code>.*)_(?!.*`.*|.*<\\/code>.*)([^_]*)_(?!.*`.*|.*<\\/code>.*)");
     static std::string replacement = "<em>$1</em>";
 
     line = std::regex_replace(line, re, replacement);

include/maddy/htmlparser.h

@@ -0,0 +1,127 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#pragma once
+
+// -----------------------------------------------------------------------------
+
+#include <functional>
+#include <string>
+
+#include "maddy/blockparser.h"
+
+// -----------------------------------------------------------------------------
+
+namespace maddy {
+
+// -----------------------------------------------------------------------------
+
+/**
+ * HtmlParser
+ *
+ * @class
+ */
+class HtmlParser : public BlockParser
+{
+public:
+  /**
+   * ctor
+   *
+   * @method
+   * @param {std::function<void(std::string&)>} parseLineCallback
+   * @param {std::function<std::shared_ptr<BlockParser>(const std::string& line)>} getBlockParserForLineCallback
+   */
+   HtmlParser(
+    std::function<void(std::string&)> parseLineCallback,
+    std::function<std::shared_ptr<BlockParser>(const std::string& line)> getBlockParserForLineCallback
+  )
+    : BlockParser(parseLineCallback, getBlockParserForLineCallback)
+    , isStarted(false)
+    , isFinished(false)
+    , isGreaterThanFound(false)
+  {}
+
+  /**
+   * IsStartingLine
+   *
+   * If the line is starting with `<`, HTML is expected to follow.
+   * Nothing after that will be parsed, it only is copied.
+   *
+   * @method
+   * @param {const std::string&} line
+   * @return {bool}
+   */
+  static bool
+  IsStartingLine(const std::string& line)
+  {
+    return line[0] == '<';
+  }
+
+  /**
+   * IsFinished
+   *
+   * `>` followed by an empty line will end the HTML block.
+   *
+   * @method
+   * @return {bool}
+   */
+  bool
+  IsFinished() const override
+  {
+    return this->isFinished;
+  }
+
+protected:
+  bool
+  isInlineBlockAllowed() const override
+  {
+    return false;
+  }
+
+  bool
+  isLineParserAllowed() const override
+  {
+    return false;
+  }
+
+  void
+  parseBlock(std::string& line) override
+  {
+    if (!this->isStarted)
+    {
+      this->isStarted = true;
+    }
+
+    if (!line.empty() && line[line.size() - 1] == '>')
+    {
+      this->isGreaterThanFound = true;
+      return;
+    }
+
+    if (line.empty() && this->isGreaterThanFound)
+    {
+      this->isFinished = true;
+      return;
+    }
+
+    if (!line.empty() && this->isGreaterThanFound)
+    {
+      this->isGreaterThanFound = false;
+    }
+
+    if (!line.empty())
+    {
+      line += " ";
+    }
+  }
+
+private:
+  bool isStarted;
+  bool isFinished;
+  bool isGreaterThanFound;
+}; // class HtmlParser
+
+// -----------------------------------------------------------------------------
+
+} // namespace maddy

include/maddy/italicparser.h

@@ -0,0 +1,50 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#pragma once
+
+// -----------------------------------------------------------------------------
+
+#include <string>
+#include <regex>
+
+#include "maddy/lineparser.h"
+
+// -----------------------------------------------------------------------------
+
+namespace maddy {
+
+// -----------------------------------------------------------------------------
+
+/**
+ * ItalicParser
+ *
+ * @class
+ */
+class ItalicParser : public LineParser
+{
+public:
+  /**
+   * Parse
+   *
+   * From Markdown: `text *text*`
+   *
+   * To HTML: `text <i>text</i>`
+   *
+   * @method
+   * @param {std::string&} line The line to interpret
+   * @return {void}
+   */
+  void
+  Parse(std::string& line) override
+  {
+    std::regex re("(?!.*`.*|.*<code>.*)\\*(?!.*`.*|.*<\\/code>.*)([^\\*]*)\\*(?!.*`.*|.*<\\/code>.*)");
+    static std::string replacement = "<i>$1</i>";
+    line = std::regex_replace(line, re, replacement);
+  }
+}; // class ItalicParser
+
+// -----------------------------------------------------------------------------
+
+} // namespace maddy

include/maddy/lineparser.h

@@ -22,6 +22,13 @@ namespace maddy {
 class LineParser
 {
 public:
+  /**
+   * dtor
+   *
+   * @method
+   */
+  virtual ~LineParser() {}
+
   /**
    * Parse
    *

include/maddy/orderedlistparser.h

@@ -89,9 +89,9 @@ protected:
     bool isStartOfNewListItem = this->isStartOfNewListItem(line);
     uint32_t indentation = getIndentationWidth(line);
 
-    static std::regex orderedlineRegex("^1\\. ");
+    static std::regex orderedlineRegex("^[1-9]+[0-9]*\\. ");
     line = std::regex_replace(line, orderedlineRegex, "");
-    static std::regex unorderedlineRegex("^(\\* )");
+    static std::regex unorderedlineRegex("^\\* ");
     line = std::regex_replace(line, unorderedlineRegex, "");
 
     if (!this->isStarted)
@@ -132,7 +132,7 @@ private:
   bool
   isStartOfNewListItem(const std::string& line) const
   {
-    static std::regex re("^(?:1\\. |\\* ).*");
+    static std::regex re("^(?:[1-9]+[0-9]*\\. |\\* ).*");
     return std::regex_match(line, re);
   }
 }; // class OrderedListParser

include/maddy/paragraphparser.h

@@ -44,8 +44,9 @@ public:
   /**
    * IsStartingLine
    *
-   * If the line is not empty, it will be a paragraph. So this block parser has
+   * If the line is not empty, it will be a paragraph.
-   * to always run as the last one!
+   *
+   * This block parser has to always run as the last one!
    *
    * @method
    * @param {const std::string&} line

include/maddy/parser.h

@@ -10,11 +10,14 @@
 #include <functional>
 #include <string>
 
+#include "maddy/parserconfig.h"
+
 // BlockParser
 #include "maddy/checklistparser.h"
 #include "maddy/codeblockparser.h"
 #include "maddy/headlineparser.h"
 #include "maddy/horizontallineparser.h"
+#include "maddy/htmlparser.h"
 #include "maddy/orderedlistparser.h"
 #include "maddy/paragraphparser.h"
 #include "maddy/quoteparser.h"
@@ -22,9 +25,11 @@
 #include "maddy/unorderedlistparser.h"
 
 // LineParser
+#include "maddy/breaklineparser.h"
 #include "maddy/emphasizedparser.h"
 #include "maddy/imageparser.h"
 #include "maddy/inlinecodeparser.h"
+#include "maddy/italicparser.h"
 #include "maddy/linkparser.h"
 #include "maddy/strikethroughparser.h"
 #include "maddy/strongparser.h"
@@ -52,10 +57,13 @@ public:
    *
    * @method
    */
-  Parser()
+  Parser(std::shared_ptr<ParserConfig> config = nullptr)
-    : emphasizedParser(std::make_shared<EmphasizedParser>())
+    : config(config)
+    , breakLineParser(std::make_shared<BreakLineParser>())
+    , emphasizedParser(std::make_shared<EmphasizedParser>())
     , imageParser(std::make_shared<ImageParser>())
     , inlineCodeParser(std::make_shared<InlineCodeParser>())
+    , italicParser(std::make_shared<ItalicParser>())
     , linkParser(std::make_shared<LinkParser>())
     , strikeThroughParser(std::make_shared<StrikeThroughParser>())
     , strongParser(std::make_shared<StrongParser>())
@@ -65,11 +73,11 @@ public:
    * Parse
    *
    * @method
-   * @param {const std::stringstream&} markdown
+   * @param {const std::istream&} markdown
    * @return {std::string} HTML
    */
   std::string
-  Parse(std::stringstream& markdown) const
+  Parse(std::istream& markdown) const
   {
     std::string result = "";
     std::shared_ptr<BlockParser> currentBlockParser = nullptr;
@@ -109,9 +117,12 @@ public:
   }
 
 private:
+  std::shared_ptr<ParserConfig> config;
+  std::shared_ptr<BreakLineParser> breakLineParser;
   std::shared_ptr<EmphasizedParser> emphasizedParser;
   std::shared_ptr<ImageParser> imageParser;
   std::shared_ptr<InlineCodeParser> inlineCodeParser;
+  std::shared_ptr<ItalicParser> italicParser;
   std::shared_ptr<LinkParser> linkParser;
   std::shared_ptr<StrikeThroughParser> strikeThroughParser;
   std::shared_ptr<StrongParser> strongParser;
@@ -126,11 +137,19 @@ private:
 
     // Attention! StrongParser has to be before EmphasizedParser
     this->strongParser->Parse(line);
+
+    if (!this->config || this->config->isEmphasizedParserEnabled)
+    {
       this->emphasizedParser->Parse(line);
+    }
 
     this->strikeThroughParser->Parse(line);
 
     this->inlineCodeParser->Parse(line);
+
+    this->italicParser->Parse(line);
+
+    this->breakLineParser->Parse(line);
   }
 
   std::shared_ptr<BlockParser>
@@ -185,6 +204,14 @@ private:
     {
       parser = this->createUnorderedListParser();
     }
+    else if (
+      this->config &&
+      !this->config->isHTMLWrappedInParagraph &&
+      maddy::HtmlParser::IsStartingLine(line)
+    )
+    {
+      parser = std::make_shared<maddy::HtmlParser>(nullptr, nullptr);
+    }
     else if (maddy::ParagraphParser::IsStartingLine(line))
     {
       parser = std::make_shared<maddy::ParagraphParser>(

include/maddy/parserconfig.h

@@ -0,0 +1,31 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#pragma once
+
+// -----------------------------------------------------------------------------
+
+namespace maddy {
+
+// -----------------------------------------------------------------------------
+
+/**
+ * ParserConfig
+ *
+ * @class
+ */
+struct ParserConfig
+{
+  bool isEmphasizedParserEnabled;
+  bool isHTMLWrappedInParagraph;
+
+  ParserConfig()
+    : isEmphasizedParserEnabled(true)
+    , isHTMLWrappedInParagraph(true)
+  {}
+}; // class ParserConfig
+
+// -----------------------------------------------------------------------------
+
+} // namespace maddy

include/maddy/strongparser.h

@@ -30,9 +30,9 @@ public:
   /**
    * Parse
    *
-   * From Markdown: `text **text**`
+   * From Markdown: `text **text** __text__`
    *
-   * To HTML: `text <strong>text</strong>`
+   * To HTML: `text <strong>text</strong> <strong>text</strong>`
    *
    * @method
    * @param {std::string&} line The line to interpret
@@ -41,11 +41,17 @@ public:
   void
   Parse(std::string& line) override
   {
-    static std::regex re("(?!.*`.*|.*<code>.*)\\*\\*(?!.*`.*|.*<\\/code>.*)([^\\*\\*]*)\\*\\*(?!.*`.*|.*<\\/code>.*)");
+    static std::vector<std::regex> res
+    {
+      std::regex{"(?!.*`.*|.*<code>.*)\\*\\*(?!.*`.*|.*<\\/code>.*)([^\\*\\*]*)\\*\\*(?!.*`.*|.*<\\/code>.*)"},
+      std::regex{"(?!.*`.*|.*<code>.*)__(?!.*`.*|.*<\\/code>.*)([^__]*)__(?!.*`.*|.*<\\/code>.*)"}
+    };
     static std::string replacement = "<strong>$1</strong>";
-
+    for (const auto& re : res)
+    {
       line = std::regex_replace(line, re, replacement);
     }
+  }
 }; // class StrongParser
 
 // -----------------------------------------------------------------------------

include/maddy/unorderedlistparser.h

@@ -54,7 +54,7 @@ public:
   static bool
   IsStartingLine(const std::string& line)
   {
-    static std::regex re("^\\* .*");
+    static std::regex re("^[+*-] .*");
     return std::regex_match(line, re);
   }
 
@@ -89,7 +89,7 @@ protected:
     bool isStartOfNewListItem = IsStartingLine(line);
     uint32_t indentation = getIndentationWidth(line);
 
-    static std::regex lineRegex("^(\\* )");
+    static std::regex lineRegex("^([+*-] )");
     line = std::regex_replace(line, lineRegex, "");
 
     if (!this->isStarted)

tests/maddy/test_maddy_breaklineparser.cpp

@@ -0,0 +1,35 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#include <memory>
+
+#include "gmock/gmock.h"
+
+#include "maddy/breaklineparser.h"
+
+// -----------------------------------------------------------------------------
+
+TEST(MADDY_BREAKLINEPARSER, ItReplacesMarkdownWithBreakLineHTML)
+{
+  std::string text =
+    "Test the text\r\n"
+    "test text to check\r\n"
+    "check testing to text.\r"
+    "Check test to test text\r"
+    "This is a test\r\n"
+    "No more test to check";
+
+  std::string expected =
+    "Test the text<br>"
+    "test text to check<br>"
+    "check testing to text.<br>"
+    "Check test to test text<br>"
+    "This is a test<br>"
+    "No more test to check";
+  auto breakLineParser = std::make_shared<maddy::BreakLineParser>();
+
+  breakLineParser->Parse(text);
+
+  ASSERT_EQ(text, expected);
+}

tests/maddy/test_maddy_emphasizedparser.cpp

@@ -12,7 +12,7 @@
 
 TEST(MADDY_EMPHASIZEDPARSER, ItReplacesMarkdownWithEmphasizedHTML)
 {
-  std::string text = "some text *bla* text testing *it* out";
+  std::string text = "some text _bla_ text testing _it_ out";
   std::string expected = "some text <em>bla</em> text testing <em>it</em> out";
   auto emphasizedParser = std::make_shared<maddy::EmphasizedParser>();
 
@@ -23,7 +23,7 @@ TEST(MADDY_EMPHASIZEDPARSER, ItReplacesMarkdownWithEmphasizedHTML)
 
 TEST(MADDY_EMPHASIZEDPARSER, ItDoesNotParseInsideInlineCode)
 {
-  std::string text = "some text `*bla*` `/**text*/` testing *it* out";
+  std::string text = "some text `*bla*` `/**text*/` testing _it_ out";
   std::string expected = "some text `*bla*` `/**text*/` testing <em>it</em> out";
   auto emphasizedParser = std::make_shared<maddy::EmphasizedParser>();
 

tests/maddy/test_maddy_htmlparser.cpp

@@ -0,0 +1,82 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#include <memory>
+
+#include "gmock/gmock.h"
+
+#include "maddy/htmlparser.h"
+
+// -----------------------------------------------------------------------------
+
+class MADDY_HTMLPARSER : public ::testing::Test
+{
+protected:
+  std::shared_ptr<maddy::HtmlParser> pParser;
+
+  void
+  SetUp() override
+  {
+    this->pParser = std::make_shared<maddy::HtmlParser>(
+      nullptr,
+      nullptr
+    );
+  }
+};
+
+// -----------------------------------------------------------------------------
+
+TEST_F(MADDY_HTMLPARSER, IsFinishedReturnsFalseInTheBeginning)
+{
+  ASSERT_FALSE(pParser->IsFinished());
+}
+
+TEST_F(MADDY_HTMLPARSER, IsStartingLineReturnsFalseWhenFacedWithNoSmallerThan)
+{
+  const std::vector<std::string> markdown = {
+    "> quote"
+    , "some text"
+    , "* list"
+    , "1. numbered list"
+    , "|table>"
+  };
+
+  for (size_t i = 0; i < markdown.size(); ++i)
+  {
+    ASSERT_FALSE(maddy::HtmlParser::IsStartingLine(markdown[i]));
+  }
+}
+
+TEST_F(MADDY_HTMLPARSER, IsStartingLineReturnsTrueWhenFacedWithSmallerThan)
+{
+  const std::string markdown = "<div id=\"test\">test element</div>";
+
+  ASSERT_TRUE(maddy::HtmlParser::IsStartingLine(markdown));
+}
+
+TEST_F(MADDY_HTMLPARSER, ItReplacesNoHtml)
+{
+  const std::vector<std::string> markdown {
+    "some text in a paragraph"
+    , ""
+    , "<div> some HTML</div>"
+    , ""
+    , "<div>more"
+    , "HTML"
+    , "</div>"
+    , ""
+  };
+  const std::string expected = "some text in a paragraph <div> some HTML</div><div>more HTML </div>";
+
+  for (std::string md : markdown)
+  {
+    pParser->AddLine(md);
+  }
+  ASSERT_TRUE(pParser->IsFinished());
+
+  std::stringstream& output(pParser->GetResult());
+  const std::string& outputString = output.str();
+
+  ASSERT_EQ(expected, outputString);
+}

tests/maddy/test_maddy_italicparser.cpp

@@ -0,0 +1,23 @@
+/*
+ * This project is licensed under the MIT license. For more information see the
+ * LICENSE file.
+ */
+#include <memory>
+
+#include "gmock/gmock.h"
+
+#include "maddy/italicparser.h"
+
+// -----------------------------------------------------------------------------
+
+TEST(MADDY_ITALICPARSER, ItReplacesMarkdownWithItalicHTML)
+{
+
+  std::string text = "some text *bla* text testing *it* out";
+  std::string expected = "some text <i>bla</i> text testing <i>it</i> out";
+  auto italicParser = std::make_shared<maddy::ItalicParser>();
+
+  italicParser->Parse(text);
+
+  ASSERT_EQ(text, expected);
+}

tests/maddy/test_maddy_orderedlistparser.cpp

@@ -96,3 +96,26 @@ TEST_F(MADDY_ORDEREDLISTPARSER, ItReplacesMarkdownWithAnHierachicalHtmlList)
 
   ASSERT_EQ(expected, outputString);
 }
+
+TEST_F(MADDY_ORDEREDLISTPARSER, ItReplacesNumberedMarkdownListWithAnHtmlOrderedList)
+{
+  std::vector<std::string> markdown = {
+    "1. a"
+    , "94. b"
+    , "103. c"
+    , ""
+  };
+  std::string expected = "<ol><li>a</li><li>b</li><li>c</li></ol>";
+
+  for (std::string md : markdown)
+  {
+    olParser->AddLine(md);
+  }
+
+  ASSERT_TRUE(olParser->IsFinished());
+
+  std::stringstream& output(olParser->GetResult());
+  const std::string& outputString = output.str();
+
+  ASSERT_EQ(expected, outputString);
+}

tests/maddy/test_maddy_parser.cpp

@@ -19,3 +19,18 @@ TEST(MADDY_PARSER, ItShouldParse)
 
   ASSERT_EQ(testHtml, output);
 }
+
+TEST(MADDY_PARSER, ItShouldParseWithConfig)
+{
+  auto config = std::make_shared<maddy::ParserConfig>();
+  config->isEmphasizedParserEnabled = false;
+  config->isHTMLWrappedInParagraph = false;
+
+  auto parser = std::make_shared<maddy::Parser>(config);
+
+  std::stringstream markdown(testMarkdown);
+
+  const std::string output = parser->Parse(markdown);
+
+  ASSERT_EQ(testHtml2, output);
+}

tests/maddy/test_maddy_parser.h

@@ -11,9 +11,9 @@ const std::string testMarkdown = "# This is a test\n\
 This should result in a praragraph\n\
 it's that simple.\n\
 \n\
-* an unordered list\n\
+* an *unordered* list\n\
   * with some **hierarchy**\n\
-    1. and an *ordered*\n\
+    1. and an _ordered_\n\
     * list\n\
     * directly\n\
   * inside\n\
@@ -42,6 +42,8 @@ And well - let's see how an image would be shown:\n\
 \n\
 ---\n\
 \n\
+<a name=\"to top\"></a>\n\
+\n\
 ### and more headlines\n\
 \n\
 - [ ] how\n\
@@ -67,4 +69,5 @@ foot a|foot b|foot c\n\
 \n\
 ";
 
-const std::string testHtml = "<h1>This is a test</h1><p>This should result in a praragraph it's that simple. </p><ul><li>an unordered list<ul><li>with some <strong>hierarchy</strong><ol><li>and an <em>ordered</em></li><li>list</li><li>directly</li></ol></li><li>inside</li></ul></li></ul><pre><code>\nvar c = 'blub';\n</code></pre><blockquote><p>A Quote  </p><p>With some <s>text</s>  blocks inside  </p><ul><li>even a list </li><li>should be </li><li>possible </li></ul></blockquote><p>And well <code>inline code</code> should also work. </p><h2>Another Headline</h2><p>And not to forget <a href=\"http://progsource.de\">link to progsource</a> should work. And well - let's see how an image would be shown: </p><p><img src=\"http://progsource.de/img/progsource.png\" alt=\"an image\"/> </p><hr/><h3>and more headlines</h3><ul class=\"checklist\"><li><label><input type=\"checkbox\"/> how</label></li><li><label><input type=\"checkbox\"/> about<ul class=\"checklist\"><li><label><input type=\"checkbox\"/> a</label></li><li><label><input type=\"checkbox\" checked=\"checked\"/> nice</label></li></ul></label></li><li><label><input type=\"checkbox\" checked=\"checked\"/> check</label></li><li><label><input type=\"checkbox\"/> list</label></li></ul><h4>even a table</h4><table><thead><tr><th>Left header</th><th>middle header</th><th>last header</th></tr></thead><tbody><tr><td>cell 1</td><td>cell <strong>2</strong></td><td>cell 3</td></tr><tr><td>cell 4</td><td>cell 5</td><td>cell 6</td></tr></tbody><tfoot><tr><td>foot a</td><td>foot b</td><td>foot c</td></tr></tfoot></table><h5>h5</h5><h6>h6</h6>";
+const std::string testHtml = "<h1>This is a test</h1><p>This should result in a praragraph it's that simple. </p><ul><li>an <i>unordered</i> list<ul><li>with some <strong>hierarchy</strong><ol><li>and an <em>ordered</em></li><li>list</li><li>directly</li></ol></li><li>inside</li></ul></li></ul><pre><code>\nvar c = 'blub';\n</code></pre><blockquote><p>A Quote  </p><p>With some <s>text</s>  blocks inside  </p><ul><li>even a list </li><li>should be </li><li>possible </li></ul></blockquote><p>And well <code>inline code</code> should also work. </p><h2>Another Headline</h2><p>And not to forget <a href=\"http://progsource.de\">link to progsource</a> should work. And well - let's see how an image would be shown: </p><p><img src=\"http://progsource.de/img/progsource.png\" alt=\"an image\"/> </p><hr/><p><a name=\"to top\"></a> </p><h3>and more headlines</h3><ul class=\"checklist\"><li><label><input type=\"checkbox\"/> how</label></li><li><label><input type=\"checkbox\"/> about<ul class=\"checklist\"><li><label><input type=\"checkbox\"/> a</label></li><li><label><input type=\"checkbox\" checked=\"checked\"/> nice</label></li></ul></label></li><li><label><input type=\"checkbox\" checked=\"checked\"/> check</label></li><li><label><input type=\"checkbox\"/> list</label></li></ul><h4>even a table</h4><table><thead><tr><th>Left header</th><th>middle header</th><th>last header</th></tr></thead><tbody><tr><td>cell 1</td><td>cell <strong>2</strong></td><td>cell 3</td></tr><tr><td>cell 4</td><td>cell 5</td><td>cell 6</td></tr></tbody><tfoot><tr><td>foot a</td><td>foot b</td><td>foot c</td></tr></tfoot></table><h5>h5</h5><h6>h6</h6>";
+const std::string testHtml2 = "<h1>This is a test</h1><p>This should result in a praragraph it's that simple. </p><ul><li>an <i>unordered</i> list<ul><li>with some <strong>hierarchy</strong><ol><li>and an _ordered_</li><li>list</li><li>directly</li></ol></li><li>inside</li></ul></li></ul><pre><code>\nvar c = 'blub';\n</code></pre><blockquote><p>A Quote  </p><p>With some <s>text</s>  blocks inside  </p><ul><li>even a list </li><li>should be </li><li>possible </li></ul></blockquote><p>And well <code>inline code</code> should also work. </p><h2>Another Headline</h2><p>And not to forget <a href=\"http://progsource.de\">link to progsource</a> should work. And well - let's see how an image would be shown: </p><p><img src=\"http://progsource.de/img/progsource.png\" alt=\"an image\"/> </p><hr/><a name=\"to top\"></a><h3>and more headlines</h3><ul class=\"checklist\"><li><label><input type=\"checkbox\"/> how</label></li><li><label><input type=\"checkbox\"/> about<ul class=\"checklist\"><li><label><input type=\"checkbox\"/> a</label></li><li><label><input type=\"checkbox\" checked=\"checked\"/> nice</label></li></ul></label></li><li><label><input type=\"checkbox\" checked=\"checked\"/> check</label></li><li><label><input type=\"checkbox\"/> list</label></li></ul><h4>even a table</h4><table><thead><tr><th>Left header</th><th>middle header</th><th>last header</th></tr></thead><tbody><tr><td>cell 1</td><td>cell <strong>2</strong></td><td>cell 3</td></tr><tr><td>cell 4</td><td>cell 5</td><td>cell 6</td></tr></tbody><tfoot><tr><td>foot a</td><td>foot b</td><td>foot c</td></tr></tfoot></table><h5>h5</h5><h6>h6</h6>";

tests/maddy/test_maddy_strongparser.cpp

@@ -12,33 +12,87 @@
 
 TEST(MADDY_STRONGPARSER, ItReplacesMarkdownWithStrongHTML)
 {
-  std::string text = "some text **bla** text testing **it** out";
+  struct testIt
-  std::string expected = "some text <strong>bla</strong> text testing <strong>it</strong> out";
+  {
+    std::string text;
+    std::string expected;
+  };
+
+  std::vector<testIt> tests
+  {
+    {
+      "some text **bla** text testing **it** out",
+      "some text <strong>bla</strong> text testing <strong>it</strong> out"
+    },
+    {
+      "some text __bla__ text testing __it__ out",
+      "some text <strong>bla</strong> text testing <strong>it</strong> out"
+    },
+  };
+
   auto strongParser = std::make_shared<maddy::StrongParser>();
 
-  strongParser->Parse(text);
+  for (auto& test : tests)
-
+  {
-  ASSERT_EQ(expected, text);
+    strongParser->Parse(test.text);
+    ASSERT_EQ(test.expected, test.text);
+  }
 }
 
 TEST(MADDY_STRONGPARSER, ItReplacesEmphasizedMarkdownNotWithStrongHTML)
 {
-  std::string text = "some text *bla* text testing **it** out";
+  struct testIt
-  std::string expected = "some text *bla* text testing <strong>it</strong> out";
+  {
+    std::string text;
+    std::string expected;
+  };
+
+  std::vector<testIt> tests
+  {
+    {
+      "some text *bla* text testing **it** out",
+      "some text *bla* text testing <strong>it</strong> out"
+    },
+    {
+      "some text _bla_ text testing __it__ out",
+      "some text _bla_ text testing <strong>it</strong> out"
+    },
+  };
+
   auto strongParser = std::make_shared<maddy::StrongParser>();
 
-  strongParser->Parse(text);
+  for (auto& test : tests)
-
+  {
-  ASSERT_EQ(expected, text);
+    strongParser->Parse(test.text);
+    ASSERT_EQ(test.expected, test.text);
+  }
 }
 
 TEST(MADDY_STRONGPARSER, ItDoesNotParseInsideInlineCode)
 {
-  std::string text = "some text **bla** `/**text**/` testing `**it**` out";
+  struct testIt
-  std::string expected = "some text **bla** `/**text**/` testing `**it**` out";
+  {
+    std::string text;
+    std::string expected;
+  };
+
+  std::vector<testIt> tests
+  {
+    {
+      "some text **bla** `/**text**/` testing `**it**` out",
+      "some text **bla** `/**text**/` testing `**it**` out",
+    },
+    {
+      "some text _bla_ text testing __it__ out",
+      "some text _bla_ text testing <strong>it</strong> out"
+    },
+  };
+
   auto strongParser = std::make_shared<maddy::StrongParser>();
 
-  strongParser->Parse(text);
+  for (auto& test : tests)
-
+  {
-  ASSERT_EQ(expected, text);
+    strongParser->Parse(test.text);
+    ASSERT_EQ(test.expected, test.text);
+  }
 }

tests/maddy/test_maddy_unorderedlistparser.cpp

@@ -55,9 +55,14 @@ TEST_F(MADDY_UNORDEREDLISTPARSER, ItReplacesMarkdownWithAnHtmlUnorderedList)
   std::vector<std::string> markdown = {
     "* a"
     , "* b"
+	, "- c"
+	, "- d"
+	, "+ e"
+	, "+ f"
+	, "* g"
     , ""
   };
-  std::string expected = "<ul><li>a</li><li>b</li></ul>";
+  std::string expected = "<ul><li>a</li><li>b</li><li>c</li><li>d</li><li>e</li><li>f</li><li>g</li></ul>";
 
   for (std::string md : markdown)
   {
@@ -80,9 +85,12 @@ TEST_F(MADDY_UNORDEREDLISTPARSER, ItReplacesMarkdownWithAnHierachicalHtmlList)
     , "  * e"
     , "* b"
     , "  * c"
+	, "  + x"
+	, "  + y"
+	, "  - z"
     , ""
   };
-  std::string expected = "<ul><li>a<ul><li>d</li><li>e</li></ul></li><li>b<ul><li>c</li></ul></li></ul>";
+  std::string expected = "<ul><li>a<ul><li>d</li><li>e</li></ul></li><li>b<ul><li>c</li><li>x</li><li>y</li><li>z</li></ul></li></ul>";
 
   for (std::string md : markdown)
   {