sablon 0.0.18 → 0.0.19.beta1

data/lib/sablon/processor/document.rb

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+module Sablon
+  module Processor
+    class Document
+      def self.process(xml_node, context, properties = {})
+        processor = new(parser)
+        processor.manipulate xml_node, Sablon::Context.transform(context)
+        processor.write_properties xml_node, properties if properties.any?
+        xml_node
+      end
+
+      def self.parser
+        @parser ||= Sablon::Parser::MailMerge.new
+      end
+
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def manipulate(xml_node, context)
+        operations = build_operations(@parser.parse_fields(xml_node))
+        operations.each do |step|
+          step.evaluate context
+        end
+        cleanup(xml_node)
+        xml_node
+      end
+
+      def write_properties(xml_node, properties)
+        if start_page_number = properties[:start_page_number] || properties["start_page_number"]
+          section_properties = SectionProperties.from_document(xml_node)
+          section_properties.start_page_number = start_page_number
+        end
+      end
+
+      private
+      def build_operations(fields)
+        OperationConstruction.new(fields).operations
+      end
+
+      def cleanup(xml_node)
+        fill_empty_table_cells xml_node
+      end
+
+      def fill_empty_table_cells(xml_node)
+        xml_node.xpath("//w:tc[count(*[name() = 'w:p'])=0 or not(*)]").each do |blank_cell|
+          filler = Nokogiri::XML::Node.new("w:p", xml_node.document)
+          blank_cell.add_child filler
+        end
+      end
+
+      class Block < Struct.new(:start_field, :end_field)
+        def self.enclosed_by(start_field, end_field)
+          @blocks ||= [RowBlock, ParagraphBlock, InlineParagraphBlock]
+          block_class = @blocks.detect { |klass| klass.encloses?(start_field, end_field) }
+          block_class.new start_field, end_field
+        end
+
+        def process(context)
+          replaced_node = Nokogiri::XML::Node.new("tmp", start_node.document)
+          replaced_node.children = Nokogiri::XML::NodeSet.new(start_node.document, body.map(&:dup))
+          Processor::Document.process replaced_node, context
+          replaced_node.children
+        end
+
+        def replace(content)
+          content.each { |n| start_node.add_next_sibling n }
+          remove_control_elements
+        end
+
+        def remove_control_elements
+          body.each &:remove
+          start_node.remove
+          end_node.remove
+        end
+
+        def body
+          return @body if defined?(@body)
+          @body = []
+          node = start_node
+          while (node = node.next_element) && node != end_node
+            @body << node
+          end
+          @body
+        end
+
+        def start_node
+          @start_node ||= self.class.parent(start_field).first
+        end
+
+        def end_node
+          @end_node ||= self.class.parent(end_field).first
+        end
+
+        def self.encloses?(start_field, end_field)
+          parent(start_field).any? && parent(end_field).any?
+        end
+      end
+
+      class RowBlock < Block
+        def self.parent(node)
+          node.ancestors ".//w:tr"
+        end
+
+        def self.encloses?(start_field, end_field)
+          super && parent(start_field) != parent(end_field)
+        end
+      end
+
+      class ParagraphBlock < Block
+        def self.parent(node)
+          node.ancestors ".//w:p"
+        end
+
+        def self.encloses?(start_field, end_field)
+          super && parent(start_field) != parent(end_field)
+        end
+      end
+
+      class InlineParagraphBlock < Block
+        def self.parent(node)
+          node.ancestors ".//w:p"
+        end
+
+        def remove_control_elements
+          body.each &:remove
+          start_field.remove
+          end_field.remove
+        end
+
+        def start_node
+          @start_node ||= start_field.end_node
+        end
+
+        def end_node
+          @end_node ||= end_field.start_node
+        end
+
+        def self.encloses?(start_field, end_field)
+          super && parent(start_field) == parent(end_field)
+        end
+      end
+
+      class OperationConstruction
+        def initialize(fields)
+          @fields = fields
+          @operations = []
+        end
+
+        def operations
+          while @fields.any?
+            @operations << consume(true)
+          end
+          @operations.compact
+        end
+
+        def consume(allow_insertion)
+          @field = @fields.shift
+          return unless @field
+          case @field.expression
+          when /^=/
+            if allow_insertion
+              Statement::Insertion.new(Expression.parse(@field.expression[1..-1]), @field)
+            end
+          when /([^ ]+):each\(([^ ]+)\)/
+            block = consume_block("#{$1}:endEach")
+            Statement::Loop.new(Expression.parse($1), $2, block)
+          when /([^ ]+):if\(([^)]+)\)/
+            block = consume_block("#{$1}:endIf")
+            Statement::Condition.new(Expression.parse($1), block, $2)
+          when /([^ ]+):if/
+            block = consume_block("#{$1}:endIf")
+            Statement::Condition.new(Expression.parse($1), block)
+          end
+        end
+
+        def consume_block(end_expression)
+          start_field = end_field = @field
+          while end_field && end_field.expression != end_expression
+            consume(false)
+            end_field = @field
+          end
+
+          if end_field
+            Block.enclosed_by start_field, end_field
+          else
+            raise TemplateError, "Could not find end field for «#{start_field.expression}». Was looking for «#{end_expression}»"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sablon/processor/numbering.rb

@@ -0,0 +1,47 @@
+module Sablon
+  module Processor
+    class Numbering
+      LIST_DEFINITION = <<-XML.gsub(/^\s+/, '').tr("\n", '')
+        <w:num w:numId="%s">
+          <w:abstractNumId w:val="%s" />
+        </w:num>
+      XML
+
+      def self.process(doc)
+        processor = new(doc)
+        processor.manipulate
+        doc
+      end
+
+      def initialize(doc)
+        @doc = doc
+      end
+
+      def manipulate
+        Sablon::Numbering.instance.definitions.each do |definition|
+          abstract_num_ref = find_definition(definition.style)
+          abstract_num_copy = abstract_num_ref.dup
+          abstract_num_copy['w:abstractNumId'] = definition.numid
+          abstract_num_copy.xpath('./w:nsid').each(&:remove)
+          container.prepend_child abstract_num_copy
+          container.add_child(LIST_DEFINITION % [definition.numid, abstract_num_copy['w:abstractNumId']])
+        end
+        @doc
+      end
+
+      private
+      def container
+        @container ||= @doc.xpath('//w:numbering').first
+      end
+
+      def find_definition(style)
+        abstract_num = @doc.xpath("//w:abstractNum[descendant-or-self::*[w:pStyle[@w:val='#{style}']]]").first
+        if abstract_num
+          abstract_num
+        else
+          raise ArgumentError, "Could not find w:abstractNum definition for style: #{style.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/sablon/processor/section_properties.rb

@@ -1,5 +1,5 @@
 module Sablon
-  class Processor
+  module Processor
     class SectionProperties
       def self.from_document(document_xml)
         new document_xml.at_xpath(".//w:sectPr")

data/lib/sablon/template.rb

@@ -18,15 +18,19 @@ module Sablon
 
     private
     def render(context, properties = {})
+      Sablon::Numbering.instance.reset!
+      Zip.sort_entries = true # required to process document.xml before numbering.xml
       Zip::OutputStream.write_buffer(StringIO.new) do |out|
         Zip::File.open(@path).each do |entry|
           entry_name = entry.name
           out.put_next_entry(entry_name)
           content = entry.get_input_stream.read
           if entry_name == 'word/document.xml'
-            out.write(process(content, context, properties))
+            out.write(process(Processor::Document, content, context, properties))
           elsif entry_name =~ /word\/header\d*\.xml/ || entry_name =~ /word\/footer\d*\.xml/
-            out.write(process(content, context))
+            out.write(process(Processor::Document, content, context))
+          elsif entry_name == 'word/numbering.xml'
+            out.write(process(Processor::Numbering, content))
           else
             out.write(content)
           end
@@ -38,9 +42,9 @@ module Sablon
     #
     # IMPORTANT: Open Office does not ignore whitespace around tags.
     # We need to render the xml without indent and whitespace.
-    def process(content, context, *args)
+    def process(processor, content, *args)
       document = Nokogiri::XML(content)
-      Processor.process(document, context, *args).to_xml(indent: 0, save_with: 0)
+      processor.process(document, *args).to_xml(indent: 0, save_with: 0)
     end
   end
 end

data/lib/sablon/version.rb

@@ -1,3 +1,3 @@
 module Sablon
-  VERSION = "0.0.18"
+  VERSION = "0.0.19.beta1"
 end

data/test/html/converter_test.rb

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+require "test_helper"
+
+class HTMLConverterTest < Sablon::TestCase
+  def setup
+    super
+    @converter = Sablon::HTMLConverter.new
+  end
+
+  def test_convert_text_inside_div
+    input = '<div>Lorem ipsum dolor sit amet</div>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <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)
+  end
+
+  def test_convert_text_inside_p
+    input = '<p>Lorem ipsum dolor 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 ipsum dolor sit amet</w:t></w:r>
+</w:p>
+DOCX
+    assert_equal normalize_wordml(expected_output), @converter.process(input)
+  end
+
+  def test_convert_text_inside_multiple_divs
+    input = '<div>Lorem ipsum</div><div>dolor sit amet</div>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem ipsum</w:t></w:r>
+</w:p>
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <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)
+  end
+
+  def test_convert_newline_inside_div
+    input = '<div>Lorem ipsum<br>dolor sit amet</div>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr><w:pStyle w:val="Paragraph" /></w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem ipsum</w:t></w:r>
+  <w:r><w:br/></w:r>
+  <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)
+  end
+
+  def test_convert_strong_tags_inside_div
+    input = '<div>Lorem&nbsp;<strong>ipsum dolor</strong>&nbsp;sit amet</div>'
+    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:b /></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)
+  end
+
+  def test_convert_em_tags_inside_div
+    input = '<div>Lorem&nbsp;<em>ipsum dolor</em>&nbsp;sit amet</div>'
+    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:i /></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)
+  end
+
+  def test_unorderd_lists
+    input = '<ul><li>Lorem</li><li>ipsum</li><li>dolor</li></ul>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListBullet" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListBullet" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space="preserve">ipsum</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListBullet" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <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 [Sablon::Numbering::Definition.new(1001, 'ListBullet')], Sablon::Numbering.instance.definitions
+  end
+
+  def test_ordered_lists
+    input = '<ol><li>Lorem</li><li>ipsum</li><li>dolor</li></ol>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListNumber" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListNumber" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space="preserve">ipsum</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListNumber" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <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 [Sablon::Numbering::Definition.new(1001, 'ListNumber')], Sablon::Numbering.instance.definitions
+  end
+
+  def test_mixed_lists
+    input = '<ol><li>Lorem</li></ol><ul><li>ipsum</li></ul><ol><li>dolor</li></ol>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListNumber" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space=\"preserve\">Lorem</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListBullet" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1002" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space="preserve">ipsum</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListNumber" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1003" />
+    </w:numPr>
+  </w:pPr>
+  <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 [Sablon::Numbering::Definition.new(1001, 'ListNumber'),
+                  Sablon::Numbering::Definition.new(1002, 'ListBullet'),
+                  Sablon::Numbering::Definition.new(1003, 'ListNumber')], Sablon::Numbering.instance.definitions
+  end
+
+  def test_nested_unordered_lists
+    input = '<ul><li>Lorem<ul><li>ipsum<ul><li>dolor</li></ul></li></ul></li></ul>'
+    expected_output = <<-DOCX.strip
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListBullet" />
+    <w:numPr>
+      <w:ilvl w:val="0" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space="preserve">Lorem</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListBullet" />
+    <w:numPr>
+      <w:ilvl w:val="1" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <w:r><w:t xml:space="preserve">ipsum</w:t></w:r>
+</w:p>
+
+<w:p>
+  <w:pPr>
+    <w:pStyle w:val="ListBullet" />
+    <w:numPr>
+      <w:ilvl w:val="2" />
+      <w:numId w:val="1001" />
+    </w:numPr>
+  </w:pPr>
+  <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 [Sablon::Numbering::Definition.new(1001, 'ListBullet')], Sablon::Numbering.instance.definitions
+  end
+
+  private
+  def normalize_wordml(wordml)
+    wordml.gsub(/^\s+/, '').tr("\n", '')
+  end
+end
+
+class HTMLConverterASTTest < Sablon::TestCase
+  def setup
+    super
+    @converter = Sablon::HTMLConverter.new
+  end
+
+  def test_div
+    input = '<div>Lorem ipsum dolor sit amet</div>'
+    ast = @converter.processed_ast(input).to_a
+    assert_equal [Sablon::HTMLConverter::Paragraph], ast.map(&:class)
+    assert_equal ['Paragraph'], ast.map(&:style)
+  end
+
+
+  def test_ul
+    input = '<ul><li>Lorem</li><li>ipsum</li></ul>'
+    ast = @converter.processed_ast(input).to_a
+    assert_equal [Sablon::HTMLConverter::ListParagraph, Sablon::HTMLConverter::ListParagraph], ast.map(&:class)
+    assert_equal ["ListBullet", "ListBullet"], ast.map(&:style)
+  end
+
+  def test_ol
+    input = '<ol><li>Lorem</li><li>ipsum</li></ol>'
+    ast = @converter.processed_ast(input).to_a
+    assert_equal [Sablon::HTMLConverter::ListParagraph, Sablon::HTMLConverter::ListParagraph], ast.map(&:class)
+    assert_equal ["ListNumber", "ListNumber"], ast.map(&:style)
+  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)
+  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)
+  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)
+  end
+end