sablon 0.0.21 → 0.0.22

data/test/fixtures/xml/comment_block_and_comment_as_key.xml

@@ -0,0 +1,31 @@
+<w:r><w:t xml:space="preserve">Before </w:t></w:r>
+<w:p>
+<w:fldSimple w:instr=" MERGEFIELD comment \* MERGEFORMAT ">
+  <w:r>
+    <w:rPr><w:noProof/></w:rPr>
+    <w:t>«comment»</w:t>
+  </w:r>
+</w:fldSimple>
+</w:p>
+<w:p>
+<w:r>
+  <w:t>Inside Comment! </w:t>
+</w:r>
+</w:p>
+<w:p>
+<w:fldSimple w:instr=" MERGEFIELD endComment \* MERGEFORMAT ">
+  <w:r>
+    <w:rPr><w:noProof/></w:rPr>
+    <w:t>«endComment»</w:t>
+  </w:r>
+</w:fldSimple>
+</w:p>
+<w:p>
+<w:fldSimple w:instr=" MERGEFIELD =comment \* MERGEFORMAT ">
+  <w:r w:rsidR="004B49F0">
+    <w:rPr><w:noProof/></w:rPr>
+    <w:t>«=comment»</w:t>
+  </w:r>
+</w:fldSimple>
+</w:p>
+<w:r><w:t xml:space="preserve">After </w:t></w:r>

data/test/html/ast_builder_test.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+require "test_helper"
+
+# Tests some low level private methods in the ASTBuilder class. #process_nodes
+# and self.html_to_ast are covered extensively in converter_test.rb
+class HTMLConverterASTBuilderTest < Sablon::TestCase
+  def setup
+    super
+    @env = Sablon::Environment.new(nil)
+  end
+
+  def test_fetch_tag
+    @bulider = new_builder
+    tag = Sablon::Configuration.instance.permitted_html_tags[:span]
+    assert_equal @bulider.send(:fetch_tag, :span), tag
+    # check that strings are converted into symbols
+    assert_equal @bulider.send(:fetch_tag, 'span'), tag
+    # test uknown tag raises error
+    e = assert_raises ArgumentError do
+      @bulider.send(:fetch_tag, :unknown_tag)
+    end
+    assert_equal "Don't know how to handle HTML tag: unknown_tag", e.message
+  end
+
+  def test_validate_structure
+    @bulider = new_builder
+    root = Sablon::Configuration.instance.permitted_html_tags['#document-fragment'.to_sym]
+    div = Sablon::Configuration.instance.permitted_html_tags[:div]
+    span = Sablon::Configuration.instance.permitted_html_tags[:span]
+    # test valid relationship
+    assert_nil @bulider.send(:validate_structure, div, span)
+    # test inverted relationship
+    e = assert_raises ArgumentError do
+      @bulider.send(:validate_structure, span, div)
+    end
+    assert_equal "Invalid HTML structure: div is not a valid child element of span.", e.message
+    # test inline tag with no parent
+    e = assert_raises ArgumentError do
+      @bulider.send(:validate_structure, root, span)
+    end
+    assert_equal "Invalid HTML structure: span needs to be wrapped in a block level tag.", e.message
+  end
+
+  def test_merge_properties
+    @builder = new_builder
+    node = Nokogiri::HTML.fragment('<span style="color: #F00; text-decoration: underline wavy">Test</span>').children[0]
+    tag = Struct.new(:properties).new(rStyle: 'Normal')
+    # test that properties are merged across all three arguments
+    props = @builder.send(:merge_node_properties, node, tag, 'background-color' => '#00F')
+    assert_equal({ 'background-color' => '#00F', rStyle: 'Normal', 'color' => '#F00', 'text-decoration' => 'underline wavy' }, props)
+    # test that parent properties are overriden by tag properties
+    props = @builder.send(:merge_node_properties, node, tag, rStyle: 'Citation', 'background-color' => '#00F')
+    assert_equal({ 'background-color' => '#00F', rStyle: 'Normal', 'color' => '#F00', 'text-decoration' => 'underline wavy' }, props)
+    # test that inline properties override parent styles
+    node = Nokogiri::HTML.fragment('<span style="color: #F00">Test</span>').children[0]
+    props = @builder.send(:merge_node_properties, node, tag, 'color' => '#00F')
+    assert_equal({ rStyle: 'Normal', 'color' => '#F00' }, props)
+  end
+
+  private
+
+  def new_builder(nodes = [], properties = {})
+    Sablon::HTMLConverter::ASTBuilder.new(@env, nodes, properties)
+  end
+end

data/test/html/ast_test.rb

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+require "test_helper"
+
+class HTMLConverterASTTest < Sablon::TestCase
+  def setup
+    super
+    @converter = Sablon::HTMLConverter.new
+    @converter.instance_variable_set(:@env, Sablon::Environment.new(nil))
+  end
+
+  def test_div
+    input = '<div>Lorem ipsum dolor sit amet</div>'
+    ast = @converter.processed_ast(input)
+    assert_equal '<Root: [<Paragraph{Normal}: [<Run{}: Lorem ipsum dolor sit amet>]>]>', ast.inspect
+  end
+
+  def test_p
+    input = '<p>Lorem ipsum dolor sit amet</p>'
+    ast = @converter.processed_ast(input)
+    assert_equal '<Root: [<Paragraph{Paragraph}: [<Run{}: Lorem ipsum dolor sit amet>]>]>', ast.inspect
+  end
+
+  def test_b
+    input = '<p>Lorem <b>ipsum dolor sit amet</b></p>'
+    ast = @converter.processed_ast(input)
+    assert_equal '<Root: [<Paragraph{Paragraph}: [<Run{}: Lorem >, <Run{b}: ipsum dolor sit amet>]>]>', ast.inspect
+  end
+
+  def test_i
+    input = '<p>Lorem <i>ipsum dolor sit amet</i></p>'
+    ast = @converter.processed_ast(input)
+    assert_equal '<Root: [<Paragraph{Paragraph}: [<Run{}: Lorem >, <Run{i}: ipsum dolor sit amet>]>]>', ast.inspect
+  end
+
+  def test_br_in_strong
+    input = '<div><strong>Lorem<br />ipsum<br />dolor</strong></div>'
+    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
+    assert_equal "[<Run{b}: Lorem>, <Newline>, <Run{b}: ipsum>, <Newline>, <Run{b}: dolor>]", par.runs.inspect
+  end
+
+  def test_br_in_em
+    input = '<div><em>Lorem<br />ipsum<br />dolor</em></div>'
+    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
+    assert_equal "[<Run{i}: Lorem>, <Newline>, <Run{i}: ipsum>, <Newline>, <Run{i}: dolor>]", par.runs.inspect
+  end
+
+  def test_nested_strong_and_em
+    input = '<div><strong>Lorem <em>ipsum</em> dolor</strong></div>'
+    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
+    assert_equal "[<Run{b}: Lorem >, <Run{b;i}: ipsum>, <Run{b}:  dolor>]", par.runs.inspect
+  end
+
+  def test_ignore_last_br_in_div
+    input = '<div>Lorem ipsum dolor sit amet<br /></div>'
+    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
+    assert_equal "[<Run{}: Lorem ipsum dolor sit amet>]", par.runs.inspect
+  end
+
+  def test_ignore_br_in_blank_div
+    input = '<div><br /></div>'
+    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
+    assert_equal "[]", par.runs.inspect
+  end
+
+  def test_headings
+    input = '<h1>First</h1><h2>Second</h2><h3>Third</h3>'
+    ast = @converter.processed_ast(input)
+    assert_equal "<Root: [<Paragraph{Heading1}: [<Run{}: First>]>, <Paragraph{Heading2}: [<Run{}: Second>]>, <Paragraph{Heading3}: [<Run{}: Third>]>]>", ast.inspect
+  end
+
+  def test_h_with_formatting
+    input = '<h1><strong>Lorem</strong> ipsum dolor <em>sit <u>amet</u></em></h1>'
+    ast = @converter.processed_ast(input)
+    assert_equal "<Root: [<Paragraph{Heading1}: [<Run{b}: Lorem>, <Run{}:  ipsum dolor >, <Run{i}: sit >, <Run{i;u=single}: amet>]>]>", ast.inspect
+  end
+
+  def test_ul
+    input = '<ul><li>Lorem</li><li>ipsum</li></ul>'
+    ast = @converter.processed_ast(input)
+    assert_equal "<Root: [<List: [<Paragraph{ListBullet}: [<Run{}: Lorem>]>, <Paragraph{ListBullet}: [<Run{}: ipsum>]>]>]>", ast.inspect
+  end
+
+  def test_ol
+    input = '<ol><li>Lorem</li><li>ipsum</li></ol>'
+    ast = @converter.processed_ast(input)
+    assert_equal "<Root: [<List: [<Paragraph{ListNumber}: [<Run{}: Lorem>]>, <Paragraph{ListNumber}: [<Run{}: ipsum>]>]>]>", ast.inspect
+  end
+
+  def test_num_id
+    ast = @converter.processed_ast('<ol><li>Some</li><li>Lorem</li></ol><ul><li>ipsum</li></ul><ol><li>dolor</li><li>sit</li></ol>')
+    assert_equal %w[1001 1001 1002 1003 1003], get_numpr_prop_from_ast(ast, :numId)
+  end
+
+  def test_nested_lists_have_the_same_numid
+    ast = @converter.processed_ast('<ul><li>Lorem<ul><li>ipsum<ul><li>dolor</li></ul></li></ul></li></ul>')
+    assert_equal %w[1001 1001 1001], get_numpr_prop_from_ast(ast, :numId)
+  end
+
+  def test_keep_nested_list_order
+    input = '<ul><li>1<ul><li>1.1<ul><li>1.1.1</li></ul></li><li>1.2</li></ul></li><li>2<ul><li>1.3<ul><li>1.3.1</li></ul></li></ul></li></ul>'
+    ast = @converter.processed_ast(input)
+    assert_equal %w[1001], get_numpr_prop_from_ast(ast, :numId).uniq
+    assert_equal %w[0 1 2 1 0 1 2], get_numpr_prop_from_ast(ast, :ilvl)
+  end
+
+  private
+
+  # returns the numid attribute from paragraphs
+  def get_numpr_prop_from_ast(ast, key)
+    values = []
+    ast.grep(Sablon::HTMLConverter::ListParagraph).each do |para|
+      numpr = para.instance_variable_get('@properties')[:numPr]
+      numpr.each { |val| values.push(val[key]) if val[key] }
+    end
+    values
+  end
+end

data/test/html/converter_test.rb

@@ -4,6 +4,8 @@ require "test_helper"
 class HTMLConverterTest < Sablon::TestCase
   def setup
     super
+    @env = Sablon::Environment.new(nil)
+    @numbering = @env.numbering
     @converter = Sablon::HTMLConverter.new
   end
 
@@ -15,7 +17,7 @@ class HTMLConverterTest < Sablon::TestCase
   <w:r><w:t xml:space="preserve">Lorem ipsum dolor sit amet</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_text_inside_p
@@ -26,7 +28,7 @@ DOCX
   <w:r><w:t xml:space="preserve">Lorem ipsum dolor sit amet</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_text_inside_multiple_divs
@@ -41,7 +43,7 @@ DOCX
   <w:r><w:t xml:space="preserve">dolor sit amet</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_newline_inside_div
@@ -54,7 +56,7 @@ DOCX
   <w:r><w:t xml:space="preserve">dolor sit amet</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_strong_tags_inside_div
@@ -67,23 +69,36 @@ DOCX
   <w:r><w:t xml:space="preserve"> sit amet</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_convert_span_tags_inside_p
+    input = '<p>Lorem&nbsp;<span>ipsum dolor</span>&nbsp;sit amet</p>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem </w:t></w:r>
+  <w:r><w:t xml:space="preserve">ipsum dolor</w:t></w:r>
+  <w:r><w:t xml:space="preserve"> sit amet</w:t></w:r></w:p>
+DOCX
+
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_u_tags_inside_p
-    input = '<p>Lorem&nbsp;<u>ipsum dolor</u>&nbsp;sit amet</div>'
+    input = '<p>Lorem&nbsp;<u>ipsum dolor</u>&nbsp;sit amet</p>'
     expected_output = <<-DOCX.strip
 <w:p>
   <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
   <w:r><w:t xml:space="preserve">Lorem </w:t></w:r>
   <w:r>
-    <w:rPr><w:u w:val="single"/></w:rPr>
+    <w:rPr><w:u w:val="single" /></w:rPr>
     <w:t xml:space="preserve">ipsum dolor</w:t>
   </w:r>
   <w:r><w:t xml:space="preserve"> sit amet</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_em_tags_inside_div
@@ -96,7 +111,55 @@ DOCX
   <w:r><w:t xml:space="preserve"> sit amet</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_convert_s_tags_inside_p
+    input = '<p>Lorem&nbsp;<s>ipsum dolor</s>&nbsp;sit amet</p>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem </w:t></w:r>
+  <w:r>
+    <w:rPr><w:strike w:val="true" /></w:rPr>
+    <w:t xml:space="preserve">ipsum dolor</w:t>
+  </w:r>
+  <w:r><w:t xml:space="preserve"> sit amet</w:t></w:r>
+</w:p>
+    DOCX
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_convert_sub_tags_inside_p
+    input = '<p>Lorem&nbsp;<sub>ipsum dolor</sub>&nbsp;sit amet</p>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem </w:t></w:r>
+  <w:r>
+    <w:rPr><w:vertAlign w:val="subscript" /></w:rPr>
+    <w:t xml:space="preserve">ipsum dolor</w:t>
+  </w:r>
+  <w:r><w:t xml:space="preserve"> sit amet</w:t></w:r>
+</w:p>
+    DOCX
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_convert_sup_tags_inside_p
+    input = '<p>Lorem&nbsp;<sup>ipsum dolor</sup>&nbsp;sit amet</p>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem </w:t></w:r>
+  <w:r>
+    <w:rPr><w:vertAlign w:val="superscript" /></w:rPr>
+    <w:t xml:space="preserve">ipsum dolor</w:t>
+  </w:r>
+  <w:r><w:t xml:space="preserve"> sit amet</w:t></w:r>
+</w:p>
+    DOCX
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_br_tags_inside_strong
@@ -115,7 +178,7 @@ DOCX
     </w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_convert_h1
@@ -126,7 +189,7 @@ DOCX
   <w:r><w:t xml:space="preserve">Lorem ipsum dolor</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
   def test_unorderd_lists
@@ -165,9 +228,9 @@ DOCX
   <w:r><w:t xml:space="preserve">dolor</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
 
-    assert_equal [Sablon::Numbering::Definition.new(1001, 'ListBullet')], Sablon::Numbering.instance.definitions
+    assert_equal [Sablon::Numbering::Definition.new(1001, 'ListBullet')], @numbering.definitions
   end
 
   def test_ordered_lists
@@ -206,9 +269,9 @@ DOCX
   <w:r><w:t xml:space="preserve">dolor</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
 
-    assert_equal [Sablon::Numbering::Definition.new(1001, 'ListNumber')], Sablon::Numbering.instance.definitions
+    assert_equal [Sablon::Numbering::Definition.new(1001, 'ListNumber')], @numbering.definitions
   end
 
   def test_mixed_lists
@@ -247,11 +310,11 @@ DOCX
   <w:r><w:t xml:space="preserve">dolor</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
 
     assert_equal [Sablon::Numbering::Definition.new(1001, 'ListNumber'),
                   Sablon::Numbering::Definition.new(1002, 'ListBullet'),
-                  Sablon::Numbering::Definition.new(1003, 'ListNumber')], Sablon::Numbering.instance.definitions
+                  Sablon::Numbering::Definition.new(1003, 'ListNumber')], @numbering.definitions
   end
 
   def test_nested_unordered_lists
@@ -290,116 +353,352 @@ DOCX
   <w:r><w:t xml:space="preserve">dolor</w:t></w:r>
 </w:p>
 DOCX
-    assert_equal normalize_wordml(expected_output), @converter.process(input)
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    assert_equal [Sablon::Numbering::Definition.new(1001, 'ListBullet')], @numbering.definitions
+  end
 
-    assert_equal [Sablon::Numbering::Definition.new(1001, 'ListBullet')], Sablon::Numbering.instance.definitions
+  def test_unknown_tag
+    e = assert_raises ArgumentError do
+      process('<badtag/>')
+    end
+    assert_match(/Don't know how to handle HTML tag:/, e.message)
   end
 
   private
+
+  def process(input)
+    @converter.process(input, @env)
+  end
+
   def normalize_wordml(wordml)
     wordml.gsub(/^\s+/, '').tr("\n", '')
   end
 end
 
-class HTMLConverterASTTest < Sablon::TestCase
+class HTMLConverterStyleTest < Sablon::TestCase
   def setup
     super
+    @env = Sablon::Environment.new(nil)
     @converter = Sablon::HTMLConverter.new
   end
 
-  def test_div
-    input = '<div>Lorem ipsum dolor sit amet</div>'
-    ast = @converter.processed_ast(input)
-    assert_equal '<Root: [<Paragraph{Normal}: [<Text{}: Lorem ipsum dolor sit amet>]>]>', ast.inspect
-  end
+  # testing direct CSS style -> WordML conversion for paragraphs
+
+  def test_paragraph_with_background_color
+    input = '<p style="background-color: #123456"></p>'
+    expected_output = para_with_ppr('<w:shd w:val="clear" w:fill="123456" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_paragraph_with_borders
+    # Basic single line black border
+    input = '<p style="border: 1px"></p>'
+    ppr = <<-DOCX.strip
+      <w:pBdr>
+        <w:top w:sz="2" w:val="single" w:color="000000" />
+        <w:bottom w:sz="2" w:val="single" w:color="000000" />
+        <w:left w:sz="2" w:val="single" w:color="000000" />
+        <w:right w:sz="2" w:val="single" w:color="000000" />
+      </w:pBdr>
+    DOCX
+    expected_output = para_with_ppr(ppr)
+    assert_equal normalize_wordml(expected_output), process(input)
+    # border with a line style
+    input = '<p style="border: 1px wavy"></p>'
+    ppr = <<-DOCX.strip
+      <w:pBdr>
+        <w:top w:sz="2" w:val="wavy" w:color="000000" />
+        <w:bottom w:sz="2" w:val="wavy" w:color="000000" />
+        <w:left w:sz="2" w:val="wavy" w:color="000000" />
+        <w:right w:sz="2" w:val="wavy" w:color="000000" />
+      </w:pBdr>
+    DOCX
+    expected_output = para_with_ppr(ppr)
+    assert_equal normalize_wordml(expected_output), process(input)
+    # border with line style and color
+    input = '<p style="border: 1px wavy #123456"></p>'
+    ppr = <<-DOCX.strip
+      <w:pBdr>
+        <w:top w:sz="2" w:val="wavy" w:color="123456" />
+        <w:bottom w:sz="2" w:val="wavy" w:color="123456" />
+        <w:left w:sz="2" w:val="wavy" w:color="123456" />
+        <w:right w:sz="2" w:val="wavy" w:color="123456" />
+      </w:pBdr>
+    DOCX
+    expected_output = para_with_ppr(ppr)
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_paragraph_with_text_align
+    input = '<p style="text-align: both"></p>'
+    expected_output = para_with_ppr('<w:jc w:val="both" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
 
-  def test_p
-    input = '<p>Lorem ipsum dolor sit amet</p>'
-    ast = @converter.processed_ast(input)
-    assert_equal '<Root: [<Paragraph{Paragraph}: [<Text{}: Lorem ipsum dolor sit amet>]>]>', ast.inspect
+  def test_paragraph_with_vertical_align
+    input = '<p style="vertical-align: baseline"></p>'
+    expected_output = para_with_ppr('<w:textAlignment w:val="baseline" />')
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_b
-    input = '<p>Lorem <b>ipsum dolor sit amet</b></p>'
-    ast = @converter.processed_ast(input)
-    assert_equal '<Root: [<Paragraph{Paragraph}: [<Text{}: Lorem >, <Text{bold}: ipsum dolor sit amet>]>]>', ast.inspect
+  def test_paragraph_with_unsupported_property
+    input = '<p style="unsupported: true"></p>'
+    expected_output = para_with_ppr('')
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_i
-    input = '<p>Lorem <i>ipsum dolor sit amet</i></p>'
-    ast = @converter.processed_ast(input)
-    assert_equal '<Root: [<Paragraph{Paragraph}: [<Text{}: Lorem >, <Text{italic}: ipsum dolor sit amet>]>]>', ast.inspect
+  def test_run_with_background_color
+    input = '<p><span style="background-color: #123456">test</span></p>'
+    expected_output = run_with_rpr('<w:shd w:val="clear" w:fill="123456" />')
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_br_in_strong
-    input = '<div><strong>Lorem<br />ipsum<br />dolor</strong></div>'
-    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
-    assert_equal "[<Text{bold}: Lorem>, <Newline>, <Text{bold}: ipsum>, <Newline>, <Text{bold}: dolor>]", par.runs.inspect
+  def test_run_with_color
+    input = '<p><span style="color: #123456">test</span></p>'
+    expected_output = run_with_rpr('<w:color w:val="123456" />')
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_br_in_em
-    input = '<div><em>Lorem<br />ipsum<br />dolor</em></div>'
-    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
-    assert_equal "[<Text{italic}: Lorem>, <Newline>, <Text{italic}: ipsum>, <Newline>, <Text{italic}: dolor>]", par.runs.inspect
-  end
+  def test_run_with_font_size
+    input = '<p><span style="font-size: 20">test</span></p>'
+    expected_output = run_with_rpr('<w:sz w:val="40" />')
+    assert_equal normalize_wordml(expected_output), process(input)
 
-  def test_nested_strong_and_em
-    input = '<div><strong>Lorem <em>ipsum</em> dolor</strong></div>'
-    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
-    assert_equal "[<Text{bold}: Lorem >, <Text{bold|italic}: ipsum>, <Text{bold}:  dolor>]", par.runs.inspect
-  end
+    # test that non-numeric are ignored
+    input = '<p><span style="font-size: 20pts">test</span></p>'
+    assert_equal normalize_wordml(expected_output), process(input)
 
-  def test_ignore_last_br_in_div
-    input = '<div>Lorem ipsum dolor sit amet<br /></div>'
-    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
-    assert_equal "[<Text{}: Lorem ipsum dolor sit amet>]", par.runs.inspect
+    # test that floats round up
+    input = '<p><span style="font-size: 19.1pts">test</span></p>'
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_ignore_br_in_blank_div
-    input = '<div><br /></div>'
-    par = @converter.processed_ast(input).grep(Sablon::HTMLConverter::Paragraph).first
-    assert_equal "[]", par.runs.inspect
+  def test_run_with_font_style
+    input = '<p><span style="font-style: bold">test</span></p>'
+    expected_output = run_with_rpr('<w:b />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    # test that non-numeric are ignored
+    input = '<p><span style="font-style: italic">test</span></p>'
+    expected_output = run_with_rpr('<w:i />')
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_run_with_font_wieght
+    input = '<p><span style="font-weight: bold">test</span></p>'
+    expected_output = run_with_rpr('<w:b />')
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_run_with_text_decoration
+    # testing underline configurations
+    input = '<p><span style="text-decoration: underline">test</span></p>'
+    expected_output = run_with_rpr('<w:u w:val="single" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    input = '<p><span style="text-decoration: underline dash">test</span></p>'
+    expected_output = run_with_rpr('<w:u w:val="dash" w:color="auto" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    input = '<p><span style="text-decoration: underline dash #123456">test</span></p>'
+    expected_output = run_with_rpr('<w:u w:val="dash" w:color="123456" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    # testing line-through
+    input = '<p><span style="text-decoration: line-through">test</span></p>'
+    expected_output = run_with_rpr('<w:strike w:val="true" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    # testing that unsupported values are passed through as a toggle
+    input = '<p><span style="text-decoration: strike">test</span></p>'
+    expected_output = run_with_rpr('<w:strike w:val="true" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    input = '<p><span style="text-decoration: emboss">test</span></p>'
+    expected_output = run_with_rpr('<w:emboss w:val="true" />')
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_headings
-    input = '<h1>First</h1><h2>Second</h2><h3>Third</h3>'
-    ast = @converter.processed_ast(input)
-    assert_equal "<Root: [<Paragraph{Heading1}: [<Text{}: First>]>, <Paragraph{Heading2}: [<Text{}: Second>]>, <Paragraph{Heading3}: [<Text{}: Third>]>]>", ast.inspect
+  def test_run_with_vertical_align
+    input = '<p><span style="vertical-align: subscript">test</span></p>'
+    expected_output = run_with_rpr('<w:vertAlign w:val="subscript" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    input = '<p><span style="vertical-align: superscript">test</span></p>'
+    expected_output = run_with_rpr('<w:vertAlign w:val="superscript" />')
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_h_with_formatting
-    input = '<h1><strong>Lorem</strong> ipsum dolor <em>sit <u>amet</u></em></h1>'
-    ast = @converter.processed_ast(input)
-    assert_equal "<Root: [<Paragraph{Heading1}: [<Text{bold}: Lorem>, <Text{}:  ipsum dolor >, <Text{italic}: sit >, <Text{italic|underline}: amet>]>]>", ast.inspect
+  def test_run_with_unsupported_property
+    input = '<p><span style="unsupported: true">test</span></p>'
+    expected_output = '<w:p><w:pPr><w:pStyle w:val="Paragraph" /></w:pPr><w:r><w:t xml:space="preserve">test</w:t></w:r></w:p>'
+    assert_equal normalize_wordml(expected_output), process(input)
   end
 
-  def test_ul
-    input = '<ul><li>Lorem</li><li>ipsum</li></ul>'
-    ast = @converter.processed_ast(input)
-    assert_equal "<Root: [<Paragraph{ListBullet}: [<Text{}: Lorem>]>, <Paragraph{ListBullet}: [<Text{}: ipsum>]>]>", ast.inspect
+  # tests with nested runs and styles
+
+  def test_paragraph_props_passed_to_runs
+    input = '<p style="color: #123456"><b>Lorem</b><span>ipsum</span></p>'
+    expected_output = <<-DOCX.strip
+      <w:p>
+        <w:pPr>
+          <w:pStyle w:val="Paragraph" />
+        </w:pPr>
+        <w:r>
+          <w:rPr>
+             <w:color w:val="123456" />
+            <w:b />
+          </w:rPr>
+          <w:t xml:space="preserve">Lorem</w:t>
+        </w:r>
+        <w:r>
+          <w:rPr>
+            <w:color w:val="123456" />
+          </w:rPr>
+          <w:t xml:space="preserve">ipsum</w:t>
+        </w:r>
+      </w:p>
+    DOCX
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_run_prop_override_paragraph_prop
+    input = '<p style="text-align: center; color: #FF0000">Lorem<span style="color: blue;">ipsum</span></p>'
+    expected_output = <<-DOCX.strip
+      <w:p>
+        <w:pPr>
+          <w:pStyle w:val="Paragraph" />
+          <w:jc w:val="center" />
+        </w:pPr>
+        <w:r>
+          <w:rPr>
+            <w:color w:val="FF0000" />
+          </w:rPr>
+          <w:t xml:space="preserve">Lorem</w:t>
+        </w:r>
+        <w:r>
+          <w:rPr>
+            <w:color w:val="blue" />
+          </w:rPr>
+          <w:t xml:space="preserve">ipsum</w:t>
+        </w:r>
+      </w:p>
+    DOCX
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_inline_style_overrides_tag_style
+    # Note: a toggle property can not be removed once it becomes a symbol
+    # unless there is a specific CSS style that will set it to false. This
+    # is because CSS styles can only override parent properties not remove them.
+    input = '<p><u style="text-decoration: underline wavyDouble">test</u></p>'
+    expected_output = run_with_rpr('<w:u w:val="wavyDouble" w:color="auto" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+  end
+
+  def test_conversion_of_a_registered_tag_without_ast_class
+    # This registers a new tag with the configuration object and then trys
+    # to convert it
+    Sablon.configure do |config|
+      config.register_html_tag(:bgcyan, :inline, properties: { 'highlight' => { val: 'cyan' } })
+    end
+    #
+    input = '<p><bgcyan>test</bgcyan></p>'
+    expected_output = run_with_rpr('<w:highlight w:val="cyan" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    # remove the tag to avoid any accidental side effects
+    Sablon.configure do |config|
+      config.remove_html_tag(:bgcyan)
+    end
+  end
+
+  def test_conversion_of_a_registered_tag_with_ast_class
+    Sablon.configure do |config|
+      # create the AST class and then pass it onto the register tag method
+      ast_class = Class.new(Sablon::HTMLConverter::Node) do
+        def self.name
+          'TestInstr'
+        end
+
+        def initialize(_env, node, _properties)
+          @content = node.text
+        end
+
+        def inspect
+          @content
+        end
+
+        def to_docx
+          "<w:instrText xml:space=\"preserve\"> #{@content} </w:instrText>"
+        end
+      end
+      #
+      config.register_html_tag(:test_instr, :inline, ast_class: ast_class)
+    end
+    #
+    input = '<p><test_instr>test</test_instr></p>'
+    expected_output = <<-DOCX.strip
+      <w:p>
+        <w:pPr>
+          <w:pStyle w:val="Paragraph" />
+        </w:pPr>
+        <w:instrText xml:space="preserve"> test </w:instrText>
+      </w:p>
+    DOCX
+    assert_equal normalize_wordml(expected_output), process(input)
+
+    # remove the tag to avoid any accidental side effects
+    Sablon.configure do |config|
+      config.remove_html_tag(:test_instr)
+    end
+  end
+
+  def test_conversion_of_registered_style_attribute
+    Sablon.configure do |config|
+      converter = ->(v) { return :highlight, v }
+      config.register_style_converter(:run, 'test-highlight', converter)
+    end
+    #
+    input = '<p><span style="test-highlight: green">test</span></p>'
+    expected_output = run_with_rpr('<w:highlight w:val="green" />')
+    assert_equal normalize_wordml(expected_output), process(input)
+    #
+    Sablon.configure do |config|
+      config.remove_style_converter(:run, 'test-highlight')
+    end
   end
 
-  def test_ol
-    input = '<ol><li>Lorem</li><li>ipsum</li></ol>'
-    ast = @converter.processed_ast(input)
-    assert_equal "<Root: [<Paragraph{ListNumber}: [<Text{}: Lorem>]>, <Paragraph{ListNumber}: [<Text{}: ipsum>]>]>", ast.inspect
+  private
+
+  def process(input)
+    @converter.process(input, @env)
   end
 
-  def test_num_id
-    ast = @converter.processed_ast('<ol><li>Some</li><li>Lorem</li></ol><ul><li>ipsum</li></ul><ol><li>dolor</li><li>sit</li></ol>')
-    assert_equal [1001, 1001, 1002, 1003, 1003], ast.grep(Sablon::HTMLConverter::ListParagraph).map(&:numid)
+  def para_with_ppr(ppr_str)
+    para_str = '<w:p><w:pPr><w:pStyle w:val="Paragraph" />%s</w:pPr></w:p>'
+    format(para_str, ppr_str)
   end
 
-  def test_nested_lists_have_the_same_numid
-    ast = @converter.processed_ast('<ul><li>Lorem<ul><li>ipsum<ul><li>dolor</li></ul></li></ul></li></ul>')
-    assert_equal [1001, 1001, 1001], ast.grep(Sablon::HTMLConverter::ListParagraph).map(&:numid)
+  def run_with_rpr(rpr_str)
+    para_str = <<-DOCX.strip
+      <w:p>
+        <w:pPr>
+          <w:pStyle w:val="Paragraph" />
+        </w:pPr>
+        <w:r>
+          <w:rPr>
+            %s
+          </w:rPr>
+          <w:t xml:space="preserve">test</w:t>
+        </w:r>
+      </w:p>
+    DOCX
+    format(para_str, rpr_str)
   end
 
-  def test_keep_nested_list_order
-    input = '<ul><li>1<ul><li>1.1<ul><li>1.1.1</li></ul></li><li>1.2</li></ul></li><li>2<ul><li>1.3<ul><li>1.3.1</li></ul></li></ul></li></ul>'
-    ast = @converter.processed_ast(input)
-    list_p = ast.grep(Sablon::HTMLConverter::ListParagraph)
-    assert_equal [1001], list_p.map(&:numid).uniq
-    assert_equal [0, 1, 2, 1, 0, 1, 2], list_p.map(&:ilvl)
+  def normalize_wordml(wordml)
+    wordml.gsub(/^\s+/, '').tr("\n", '')
   end
 end