Merge pull request #1060 from bmkiefer/markdown-add-to-track

markdown: add to track

config.json

@@ -941,6 +941,19 @@
     {
       "core": false,
       "difficulty": 7,
+      "slug": "markdown",
+      "topics": [
+        "strings",
+        "conditionals",
+        "pattern_matching",
+        "refactoring"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "cc18f2e5-4e36-47d6-aa60-8ca5ff54019a"
+    },
+    {
+      "core": false,
+      "difficulty": 7,
       "slug": "poker",
       "topics": [
         "games",

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

@@ -0,0 +1,96 @@
+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 parseUnderscore(parseDoubleUnderscore(markdown));
+    }
+
+    private String parseUnderscore(String markdown) {
+        return parseViaRegex(markdown, "_", "em");
+    }
+
+    private String parseDoubleUnderscore(String markdown) {
+        return parseViaRegex(markdown, "__", "strong");
+    }
+
+    private String parseViaRegex(String markdown, String delimiter, String tag) {
+        String pattern = delimiter + "(.+)" + delimiter;
+        String replacement = wrap("$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/main/java/Markdown.java

@@ -0,0 +1,83 @@
+class Markdown {
+  
+    String parse(String markdown) {
+
+        String[] lines = markdown.split("\n");
+
+        String result = "";
+
+        boolean activeList = false;
+
+        for (int i = 0; i < lines.length; i++) {
+
+            String theLine = parseHeader(lines[i]);
+          
+            if (theLine == null) {
+              theLine = parseListItem(lines[i]);
+            }
+    
+            if (theLine == null) 
+            {
+                theLine = parseParagraph(lines[i]);
+            }
+
+            if (theLine.matches("(<li>).*") && !theLine.matches("(<h).*") && !theLine.matches("(<p>).*") && !activeList) {
+                activeList = true;
+              result = result + "<ul>";
+                result = result + theLine;
+            } 
+            
+            else if (!theLine.matches("(<li>).*") && activeList) {
+                activeList = false;
+                result = result + "</ul>";
+                result = result + theLine;
+            } else {
+              result = result + theLine;
+            }
+        }
+
+        if (activeList) {
+            result = result + "</ul>";
+        }
+
+        return result;
+    }
+
+    private String parseHeader(String markdown) {
+        int count = 0;
+
+        for (int i = 0; i < markdown.length() && markdown.charAt(i) == '#'; i++) 
+        {
+            count++;
+        }
+
+        if (count == 0) { return null; }
+
+        return "<h" + Integer.toString(count) + ">" + markdown.substring(count + 1) + "</h" + Integer.toString(count)+ ">";
+    }
+
+    private String parseListItem(String markdown) {
+        if (markdown.startsWith("*")) {
+            String skipAsterisk = markdown.substring(2);
+            String listItemString = parseSomeSymbols(skipAsterisk);
+            return "<li>" + listItemString + "</li>";
+        }
+
+        return null;
+    }
+
+    private String parseParagraph(String markdown) {
+        return "<p>" + parseSomeSymbols(markdown) + "</p>";
+    }
+
+    private String parseSomeSymbols(String markdown) {
+
+        String lookingFor = "__(.+)__";
+        String update = "<strong>$1</strong>";
+        String workingOn = markdown.replaceAll(lookingFor, update);
+
+        lookingFor = "_(.+)_";
+        update = "<em>$1</em>";
+        return workingOn.replaceAll(lookingFor, update);
+    }
+}

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'