From 87d8554726e81add059b211c6b120dc8d5003849 Mon Sep 17 00:00:00 2001
From: Michael Williamson <mike@zwobble.org>
Date: Fri, 21 Jul 2017 12:31:11 +0100
Subject: Add style mapping for small caps

---
 NEWS                                               |  2 ++
 README.md                                          | 11 ++++++++++
 .../internal/conversion/DocumentToHtml.java        |  3 +++
 .../zwobble/mammoth/internal/documents/Run.java    | 11 ++++++++--
 .../internal/docx/StatefulBodyXmlReader.java       |  5 +++++
 .../zwobble/mammoth/internal/styles/StyleMap.java  |  8 ++++++++
 .../mammoth/internal/styles/StyleMapBuilder.java   | 19 ++++++++++++++++-
 .../styles/parsing/DocumentMatcherParser.java      |  2 ++
 .../tests/conversion/DocumentToHtmlTests.java      | 17 +++++++++++++++
 .../tests/documents/DocumentElementMakers.java     |  6 ++++++
 .../zwobble/mammoth/tests/docx/BodyXmlTests.java   | 24 +++++++++++++++++++++-
 .../tests/styles/parsing/StyleMapParserTests.java  |  6 ++++++
 12 files changed, 110 insertions(+), 4 deletions(-)

diff --git a/NEWS b/NEWS
index c4582d0..c3f9040 100644
--- a/NEWS
+++ b/NEWS
@@ -10,6 +10,8 @@
 
 * Read children of v:group elements.
 
+* Add style mapping for small caps.
+
 # 1.3.1
 
 * Read children of w:object elements.
diff --git a/README.md b/README.md
index e890dd2..96a41f2 100644
--- a/README.md
+++ b/README.md
@@ -432,6 +432,17 @@ strike
 Note that this matches text that has had strikethrough explicitly applied to it.
 It will not match any text that is struckthrough because of its paragraph or run style.
 
+#### Small caps
+
+Match explicitly small caps text:
+
+```
+small-caps
+```
+
+Note that this matches text that has had small caps explicitly applied to it.
+It will not match any text that is small caps because of its paragraph or run style.
+
 ### HTML paths
 
 #### Single elements
diff --git a/src/main/java/org/zwobble/mammoth/internal/conversion/DocumentToHtml.java b/src/main/java/org/zwobble/mammoth/internal/conversion/DocumentToHtml.java
index 9e6d223..8b15106 100644
--- a/src/main/java/org/zwobble/mammoth/internal/conversion/DocumentToHtml.java
+++ b/src/main/java/org/zwobble/mammoth/internal/conversion/DocumentToHtml.java
@@ -166,6 +166,9 @@ public class DocumentToHtml {
             @Override
             public List<HtmlNode> visit(Run run, Context context) {
                 Supplier<List<HtmlNode>> nodes = () -> convertChildrenToHtml(run, context);
+                if (run.isSmallCaps()) {
+                    nodes = styleMap.getSmallCaps().orElse(HtmlPath.EMPTY).wrap(nodes);
+                }
                 if (run.isStrikethrough()) {
                     nodes = styleMap.getStrikethrough().orElse(HtmlPath.collapsibleElement("s")).wrap(nodes);
                 }
diff --git a/src/main/java/org/zwobble/mammoth/internal/documents/Run.java b/src/main/java/org/zwobble/mammoth/internal/documents/Run.java
index 29415c7..e047bf5 100644
--- a/src/main/java/org/zwobble/mammoth/internal/documents/Run.java
+++ b/src/main/java/org/zwobble/mammoth/internal/documents/Run.java
@@ -8,6 +8,7 @@ public class Run implements DocumentElement, HasChildren {
     private final boolean isItalic;
     private final boolean isUnderline;
     private final boolean isStrikethrough;
+    private final boolean isSmallCaps;
     private final VerticalAlignment verticalAlignment;
     private final Optional<Style> style;
     private final List<DocumentElement> children;
@@ -17,14 +18,16 @@ public class Run implements DocumentElement, HasChildren {
         boolean isItalic,
         boolean isUnderline,
         boolean isStrikethrough,
+        boolean isSmallCaps,
         VerticalAlignment verticalAlignment,
         Optional<Style> style,
-        List<DocumentElement> children)
-    {
+        List<DocumentElement> children
+    ) {
         this.isBold = isBold;
         this.isItalic = isItalic;
         this.isUnderline = isUnderline;
         this.isStrikethrough = isStrikethrough;
+        this.isSmallCaps = isSmallCaps;
         this.verticalAlignment = verticalAlignment;
         this.style = style;
         this.children = children;
@@ -46,6 +49,10 @@ public class Run implements DocumentElement, HasChildren {
         return isStrikethrough;
     }
 
+    public boolean isSmallCaps() {
+        return isSmallCaps;
+    }
+
     public VerticalAlignment getVerticalAlignment() {
         return verticalAlignment;
     }
diff --git a/src/main/java/org/zwobble/mammoth/internal/docx/StatefulBodyXmlReader.java b/src/main/java/org/zwobble/mammoth/internal/docx/StatefulBodyXmlReader.java
index 3d0d7f2..464884a 100644
--- a/src/main/java/org/zwobble/mammoth/internal/docx/StatefulBodyXmlReader.java
+++ b/src/main/java/org/zwobble/mammoth/internal/docx/StatefulBodyXmlReader.java
@@ -179,6 +179,7 @@ class StatefulBodyXmlReader {
                     isItalic(properties),
                     isUnderline(properties),
                     isStrikethrough(properties),
+                    isSmallCaps(properties),
                     readVerticalAlignment(properties),
                     style,
                     children
@@ -208,6 +209,10 @@ class StatefulBodyXmlReader {
         return readBooleanElement(properties, "w:strike");
     }
 
+    private boolean isSmallCaps(XmlElementLike properties) {
+        return readBooleanElement(properties, "w:smallCaps");
+    }
+
     private boolean readBooleanElement(XmlElementLike properties, String tagName) {
         return properties.findChild(tagName)
             .map(child -> child.getAttributeOrNone("w:val")
diff --git a/src/main/java/org/zwobble/mammoth/internal/styles/StyleMap.java b/src/main/java/org/zwobble/mammoth/internal/styles/StyleMap.java
index 9856d70..7959acb 100644
--- a/src/main/java/org/zwobble/mammoth/internal/styles/StyleMap.java
+++ b/src/main/java/org/zwobble/mammoth/internal/styles/StyleMap.java
@@ -23,6 +23,7 @@ public class StyleMap {
             Optionals.first(high.italic, low.italic),
             Optionals.first(high.underline, low.underline),
             Optionals.first(high.strikethrough, low.strikethrough),
+            Optionals.first(high.smallCaps, low.smallCaps),
             Optionals.first(high.commentReference, low.commentReference),
             Lists.eagerConcat(high.paragraphStyles, low.paragraphStyles),
             Lists.eagerConcat(high.runStyles, low.runStyles),
@@ -36,6 +37,7 @@ public class StyleMap {
     private final Optional<HtmlPath> italic;
     private final Optional<HtmlPath> underline;
     private final Optional<HtmlPath> strikethrough;
+    private final Optional<HtmlPath> smallCaps;
     private final Optional<HtmlPath> commentReference;
     private final List<StyleMapping<Paragraph>> paragraphStyles;
     private final List<StyleMapping<Run>> runStyles;
@@ -46,6 +48,7 @@ public class StyleMap {
         Optional<HtmlPath> italic,
         Optional<HtmlPath> underline,
         Optional<HtmlPath> strikethrough,
+        Optional<HtmlPath> smallCaps,
         Optional<HtmlPath> commentReference,
         List<StyleMapping<Paragraph>> paragraphStyles,
         List<StyleMapping<Run>> runStyles,
@@ -56,6 +59,7 @@ public class StyleMap {
         this.italic = italic;
         this.underline = underline;
         this.strikethrough = strikethrough;
+        this.smallCaps = smallCaps;
         this.commentReference = commentReference;
         this.paragraphStyles = paragraphStyles;
         this.runStyles = runStyles;
@@ -83,6 +87,10 @@ public class StyleMap {
         return strikethrough;
     }
 
+    public Optional<HtmlPath> getSmallCaps() {
+        return smallCaps;
+    }
+
     public Optional<HtmlPath> getCommentReference() {
         return commentReference;
     }
diff --git a/src/main/java/org/zwobble/mammoth/internal/styles/StyleMapBuilder.java b/src/main/java/org/zwobble/mammoth/internal/styles/StyleMapBuilder.java
index 4972883..4e6e27b 100644
--- a/src/main/java/org/zwobble/mammoth/internal/styles/StyleMapBuilder.java
+++ b/src/main/java/org/zwobble/mammoth/internal/styles/StyleMapBuilder.java
@@ -11,6 +11,7 @@ import java.util.Optional;
 public class StyleMapBuilder {
     private Optional<HtmlPath> underline;
     private Optional<HtmlPath> strikethrough;
+    private Optional<HtmlPath> smallCaps;
     private Optional<HtmlPath> bold;
     private Optional<HtmlPath> italic;
     private Optional<HtmlPath> commentReference;
@@ -22,6 +23,7 @@ public class StyleMapBuilder {
         this.bold = Optional.empty();
         this.underline = Optional.empty();
         this.strikethrough = Optional.empty();
+        this.smallCaps = Optional.empty();
         this.italic = Optional.empty();
         this.commentReference = Optional.empty();
     }
@@ -46,6 +48,11 @@ public class StyleMapBuilder {
         return this;
     }
 
+    public StyleMapBuilder smallCaps(HtmlPath path) {
+        this.smallCaps = Optional.of(path);
+        return this;
+    }
+
     public StyleMapBuilder commentReference(HtmlPath path) {
         this.commentReference = Optional.of(path);
         return this;
@@ -67,6 +74,16 @@ public class StyleMapBuilder {
     }
 
     public StyleMap build() {
-        return new StyleMap(bold, italic, underline, strikethrough, commentReference, paragraphStyles, runStyles, breakStyles);
+        return new StyleMap(
+            bold,
+            italic,
+            underline,
+            strikethrough,
+            smallCaps,
+            commentReference,
+            paragraphStyles,
+            runStyles,
+            breakStyles
+        );
     }
 }
diff --git a/src/main/java/org/zwobble/mammoth/internal/styles/parsing/DocumentMatcherParser.java b/src/main/java/org/zwobble/mammoth/internal/styles/parsing/DocumentMatcherParser.java
index db0b1bb..9f8d32b 100644
--- a/src/main/java/org/zwobble/mammoth/internal/styles/parsing/DocumentMatcherParser.java
+++ b/src/main/java/org/zwobble/mammoth/internal/styles/parsing/DocumentMatcherParser.java
@@ -27,6 +27,8 @@ public class DocumentMatcherParser {
                 return StyleMapBuilder::underline;
             case "strike":
                 return StyleMapBuilder::strikethrough;
+            case "small-caps":
+                return StyleMapBuilder::smallCaps;
             case "comment-reference":
                 return StyleMapBuilder::commentReference;
             case "br":
diff --git a/src/test/java/org/zwobble/mammoth/tests/conversion/DocumentToHtmlTests.java b/src/test/java/org/zwobble/mammoth/tests/conversion/DocumentToHtmlTests.java
index ad85bbb..6155f5a 100644
--- a/src/test/java/org/zwobble/mammoth/tests/conversion/DocumentToHtmlTests.java
+++ b/src/test/java/org/zwobble/mammoth/tests/conversion/DocumentToHtmlTests.java
@@ -173,6 +173,23 @@ public class DocumentToHtmlTests {
             deepEquals(list(Html.element("del", list(Html.text("Hello"))))));
     }
 
+    @Test
+    public void smallCapsIsIgnoredByDefault() {
+        assertThat(
+            convertToHtml(run(withSmallCaps(true), withChildren(new Text("Hello")))),
+            deepEquals(list(Html.text("Hello"))));
+    }
+
+    @Test
+    public void smallCapsCanBeMappedUsingStyleMapping() {
+        assertThat(
+            convertToHtml(
+                run(withSmallCaps(true), withChildren(new Text("Hello"))),
+                StyleMap.builder().smallCaps(HtmlPath.element("span")).build()),
+
+            deepEquals(list(Html.element("span", list(Html.text("Hello"))))));
+    }
+
     @Test
     public void superscriptRunsAreWrappedInSuperscriptTags() {
         assertThat(
diff --git a/src/test/java/org/zwobble/mammoth/tests/documents/DocumentElementMakers.java b/src/test/java/org/zwobble/mammoth/tests/documents/DocumentElementMakers.java
index ea53458..4bff04d 100644
--- a/src/test/java/org/zwobble/mammoth/tests/documents/DocumentElementMakers.java
+++ b/src/test/java/org/zwobble/mammoth/tests/documents/DocumentElementMakers.java
@@ -19,6 +19,7 @@ public class DocumentElementMakers {
     private static final ArgumentKey<Boolean> ITALIC = new ArgumentKey<>("italic");
     private static final ArgumentKey<Boolean> UNDERLINE = new ArgumentKey<>("underline");
     private static final ArgumentKey<Boolean> STRIKETHROUGH = new ArgumentKey<>("strikethrough");
+    private static final ArgumentKey<Boolean> SMALL_CAPS = new ArgumentKey<>("smallCaps");
     private static final ArgumentKey<VerticalAlignment> VERTICAL_ALIGNMENT = new ArgumentKey<>("verticalAlignment");
     private static final ArgumentKey<List<DocumentElement>> CHILDREN = new ArgumentKey<>("children");
     private static final ArgumentKey<Boolean> IS_HEADER = new ArgumentKey<>("isHeader");
@@ -53,6 +54,10 @@ public class DocumentElementMakers {
         return arg(STRIKETHROUGH, strikethrough);
     }
 
+    public static Argument<Boolean> withSmallCaps(boolean smallCaps) {
+        return arg(SMALL_CAPS, smallCaps);
+    }
+
     public static Argument<VerticalAlignment> withVerticalAlignment(VerticalAlignment verticalAlignment) {
         return arg(VERTICAL_ALIGNMENT, verticalAlignment);
     }
@@ -106,6 +111,7 @@ public class DocumentElementMakers {
             arguments.get(ITALIC, false),
             arguments.get(UNDERLINE, false),
             arguments.get(STRIKETHROUGH, false),
+            arguments.get(SMALL_CAPS, false),
             arguments.get(VERTICAL_ALIGNMENT, VerticalAlignment.BASELINE),
             arguments.get(STYLE, Optional.empty()),
             arguments.get(CHILDREN, list())
diff --git a/src/test/java/org/zwobble/mammoth/tests/docx/BodyXmlTests.java b/src/test/java/org/zwobble/mammoth/tests/docx/BodyXmlTests.java
index fc67a28..c5756ae 100644
--- a/src/test/java/org/zwobble/mammoth/tests/docx/BodyXmlTests.java
+++ b/src/test/java/org/zwobble/mammoth/tests/docx/BodyXmlTests.java
@@ -443,12 +443,34 @@ public class BodyXmlTests {
             hasProperty("strikethrough", equalTo(true)));
     }
 
+    @Test
+    public void runIsNotSmallCapsIfSmallCapsElementIsNotPresent() {
+        XmlElement element = runXmlWithProperties();
+
+        assertThat(
+            readSuccess(bodyReader(), element),
+            hasProperty("smallCaps", equalTo(false)));
+    }
+
+    @Test
+    public void runIsSmallCapsIfSmallCapsElementIsPresent() {
+        XmlElement element = runXmlWithProperties(element("w:smallCaps"));
+
+        assertThat(
+            readSuccess(bodyReader(), element),
+            hasProperty("smallCaps", equalTo(true)));
+    }
+
     @RunWith(Parameterized.class)
     public static class RunBooleanPropertyTests {
         @Parameterized.Parameters(name = "propertyName: {0}, tagName: {1}")
         public static Collection<Object[]> data() {
             return list(new Object[][] {
-                {"bold", "w:b"}, {"underline", "w:u"}, {"italic", "w:i"}, {"strikethrough", "w:strike"}
+                {"bold", "w:b"},
+                {"underline", "w:u"},
+                {"italic", "w:i"},
+                {"strikethrough", "w:strike"},
+                {"smallCaps", "w:smallCaps"}
             });
         }
 
diff --git a/src/test/java/org/zwobble/mammoth/tests/styles/parsing/StyleMapParserTests.java b/src/test/java/org/zwobble/mammoth/tests/styles/parsing/StyleMapParserTests.java
index 89045a1..9837479 100644
--- a/src/test/java/org/zwobble/mammoth/tests/styles/parsing/StyleMapParserTests.java
+++ b/src/test/java/org/zwobble/mammoth/tests/styles/parsing/StyleMapParserTests.java
@@ -50,6 +50,12 @@ public class StyleMapParserTests {
         assertThat(styleMap, deepEquals(StyleMap.builder().strikethrough(HtmlPath.collapsibleElement("del")).build()));
     }
 
+    @Test
+    public void canMapSmallCaps() {
+        StyleMap styleMap = StyleMapParser.parse("small-caps => span");
+        assertThat(styleMap, deepEquals(StyleMap.builder().smallCaps(HtmlPath.collapsibleElement("span")).build()));
+    }
+
     @Test
     public void canMapCommentReference() {
         StyleMap styleMap = StyleMapParser.parse("comment-reference =>");
-- 
cgit v1.2.3