add markdown exercise to track

config.json

@@ -941,6 +941,18 @@
     {
       "core": false,
       "difficulty": 7,
+      "slug": "markdown",
+      "topics": [
+        "strings",
+        "conditionals",
+        "pattern_matching"
+      ],
+      "unlocked_by": "word-search",
+      "uuid": "377fe38b-08ad-4f3a-8118-a43c10f7b9b2"
+    },
+    {
+      "core": false,
+      "difficulty": 7,
       "slug": "poker",
       "topics": [
         "games",

exercises/markdown/.meta/src/reference/java/Markdown.java

@@ -0,0 +1,116 @@
+class Markdown {
+
+    String parse(String markdown)
+    {
+        String[] lines = markdown.split("\n");
+        StringBuilder result = new StringBuilder();
+        boolean activeList = false;
+
+        for (int i = 0; i < lines.length; i++)
+        {
+            String lineResult = parseLine(lines[i]);
+
+            if(lineResult.matches(".*(<li>).*") && !activeList){
+                activeList = true;
+                result.append("<ul>");
+                result.append(lineResult);
+            }
+            else if(!lineResult.matches(".*(<li>).*") && activeList){
+                activeList = false;
+                result.append("</ul>");
+                result.append(lineResult);
+            }
+            else {
+                result.append(lineResult);
+            }
+        }
+
+        if(activeList){
+            result.append("</ul>");
+        }
+
+        return result.toString();
+    }
+
+    private String parseLine(String markdown)
+    {
+        String result = parseHeader(markdown);
+
+        if (result == null)
+        {
+            result = parseListItem(markdown);
+        }
+
+        if (result == null)
+        {
+            result = parseParagraph(markdown);
+        }
+
+        return result;
+    }
+
+    private String parseHeader(String markdown)
+    {
+        int count = 0;
+
+        for (int i = 0; i < markdown.length(); i++)
+        {
+            if (markdown.charAt(i) == '#')
+            {
+                count++;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        if (count == 0)
+        {
+            return null;
+        }
+
+        return wrap(markdown.substring(count + 1), "h" + Integer.toString(count));
+    }
+
+    private String parseListItem(String markdown)
+    {
+        if (markdown.startsWith("*"))
+        {
+            return wrap(parseText(markdown.substring(2)), "li");
+        }
+
+        return null;
+    }
+
+    private String parseParagraph(String markdown)
+    {
+        return wrap(parseText(markdown), "p");
+    }
+
+    private String parseText(String markdown)
+    {
+        return parse_(parse__(markdown));
+    }
+
+    private String parse_(String markdown)
+    {
+        return parseViaRegex(markdown, "_", "em");
+    }
+
+    private String parse__(String markdown)
+    {
+        return parseViaRegex(markdown, "__", "strong");
+    }
+
+    private String parseViaRegex(String markdown, String delimiter, String tag)
+    {
+        String pattern = delimiter + "(.+)" + delimiter;
+        String replacement = "<" + tag + ">$1</" + tag + ">";
+        return markdown.replaceAll(pattern, replacement);
+    }
+
+    private String wrap(String text, String tag){
+        return "<" + tag + ">" + text + "</" + tag + ">";
+    }
+}

exercises/markdown/.meta/version

@@ -0,0 +1 @@
+1.1.0

exercises/markdown/README.md

@@ -0,0 +1,30 @@
+# Markdown
+
+Refactor a Markdown parser.
+
+The markdown exercise is a refactoring exercise. There is code that parses a
+given string with [Markdown
+syntax](https://guides.github.com/features/mastering-markdown/) and returns the
+associated HTML for that string. Even though this code is confusingly written
+and hard to follow, somehow it works and all the tests are passing! Your
+challenge is to re-write this code to make it easier to read and maintain
+while still making sure that all the tests keep passing.
+
+It would be helpful if you made notes of what you did in your refactoring in
+comments so reviewers can see that, but it isn't strictly necessary. The most
+important thing is to make the code better!
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/markdown/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/markdown/src/test/java/MarkdownTest.java

@@ -0,0 +1,95 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class MarkdownTest {
+
+    private Markdown markdown;
+
+    @Before
+    public void setup() {
+        markdown = new Markdown();
+    }
+
+    @Test
+    public void normalTextAsAParagraph() {
+        String input = "This will be a paragraph";
+        String expected = "<p>This will be a paragraph</p>";
+
+        assertEquals(expected, markdown.parse(input));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void italics() {
+        String input = "_This will be italic_";
+        String expected = "<p><em>This will be italic</em></p>";
+
+        assertEquals(expected, markdown.parse(input));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void boldText() {
+        String input = "__This will be bold__";
+        String expected = "<p><strong>This will be bold</strong></p>";
+
+        assertEquals(expected, markdown.parse(input));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void normalItalicsAndBoldText() {
+        String input = "This will _be_ __mixed__";
+        String expected = "<p>This will <em>be</em> <strong>mixed</strong></p>";
+
+        assertEquals(expected, markdown.parse(input) );
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void withH1HeaderLevel() {
+        String input = "# This will be an h1";
+        String expected = "<h1>This will be an h1</h1>";
+
+        assertEquals(expected, markdown.parse(input) );
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void withH2HeaderLevel() {
+        String input = "## This will be an h2";
+        String expected = "<h2>This will be an h2</h2>";
+
+        assertEquals(expected, markdown.parse(input) );
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void withH6HeaderLevel() {
+        String input = "###### This will be an h6";
+        String expected = "<h6>This will be an h6</h6>";
+
+        assertEquals(expected, markdown.parse(input) );
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void unorderedLists() {
+        String input = "* Item 1\n* Item 2";
+        String expected = "<ul><li>Item 1</li><li>Item 2</li></ul>";
+
+        assertEquals(expected, markdown.parse(input) );
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aLittleBitOfEverything() {
+        String input = "# Header!\n* __Bold Item__\n* _Italic Item_";
+        String expected = "<h1>Header!</h1><ul><li><strong>Bold Item</strong></li><li><em>Italic Item</em></li></ul>";
+
+        assertEquals(expected, markdown.parse(input) );
+    }
+}

exercises/settings.gradle

@@ -39,6 +39,7 @@ include 'largest-series-product'
 include 'linked-list'
 include 'list-ops'
 include 'luhn'
+include 'markdown'
 include 'matrix'
 include 'meetup'
 include 'minesweeper'