sablon 0.1.1 → 0.2.0

data/lib/sablon/processor/section_properties.rb

@@ -1,12 +1,18 @@
 module Sablon
   module Processor
     class SectionProperties
-      def self.from_document(document_xml)
-        new document_xml.at_xpath(".//w:sectPr")
+      def self.process(xml_node, env)
+        processor = new(xml_node)
+        processor.write_properties(env.section_properties)
       end
 
-      def initialize(properties_node)
-        @properties_node = properties_node
+      def initialize(xml_node)
+        @properties_node = xml_node.at_xpath(".//w:sectPr")
+      end
+
+      def write_properties(properties = {})
+        return unless properties["start_page_number"]
+        self.start_page_number = properties["start_page_number"]
       end
 
       def start_page_number
@@ -18,6 +24,7 @@ module Sablon
       end
 
       private
+
       def find_or_add_pg_num_type
         pg_num_type || begin
                          node = Nokogiri::XML::Node.new "w:pgNumType", @properties_node.document

data/lib/sablon/template.rb

@@ -1,5 +1,38 @@
+require 'sablon/document_object_model/model'
+require 'sablon/processor/document'
+require 'sablon/processor/section_properties'
+
 module Sablon
+  # Creates a template from an MS Word doc that can be easily manipulated
   class Template
+    attr_reader :document
+
+    class << self
+      # Adds a new processor to the processors hash. The +pattern+ is used
+      # to select which files the processor should handle. Multiple processors
+      # can be added for the same pattern.
+      def register_processor(pattern, klass, replace_all: false)
+        processors[pattern] = [] if replace_all
+        #
+        if processors[pattern].empty?
+          processors[pattern] = [klass]
+        else
+          processors[pattern] << klass
+        end
+      end
+
+      # Returns the processor classes with a pattern matching the
+      # entry name. If none match nil is returned.
+      def get_processors(entry_name)
+        key = processors.keys.detect { |pattern| entry_name =~ pattern }
+        processors[key]
+      end
+
+      def processors
+        @processors ||= Hash.new([])
+      end
+    end
+
     def initialize(path)
       @path = path
     end
@@ -19,63 +52,71 @@ module Sablon
     private
 
     def render(context, properties = {})
-      created_dirs = []
-      relations_file_content = nil
+      # initialize environment
+      @document = Sablon::DOM::Model.new(Zip::File.open(@path))
       env = Sablon::Environment.new(self, context)
-      Zip.sort_entries = true # required to process document.xml before numbering.xml
+      env.section_properties = properties
+      #
+      # process files
+      process(env)
+      #
       Zip::OutputStream.write_buffer(StringIO.new) do |out|
-        Zip::File.open(@path).each do |entry|
-          entry_name = entry.name
-          created_dirs = create_dirs_in_zipfile(created_dirs, entry_name, out)
-          out.put_next_entry(entry_name)
-          content = entry.get_input_stream.read
-          if entry_name == 'word/document.xml'
-            out.write(process(Processor::Document, content, env, properties))
-          elsif entry_name =~ /word\/header\d*\.xml/ || entry_name =~ /word\/footer\d*\.xml/
-            out.write(process(Processor::Document, content, env))
-          elsif entry_name == 'word/numbering.xml'
-            out.write(process(Processor::Numbering, content, env))
-          elsif entry_name == 'word/_rels/document.xml.rels'
-            relations_file_content = content
-          else
-            out.write(content)
-          end
-        end
-        if relations_file_content
-          env.relationship.add_found_relationships(relations_file_content, out)
-        end
+        generate_output_file(out, @document.zip_contents)
       end
     end
 
-    # creates directories of the unzipped docx file in the newly created docx file e.g. in case of
-    # word/_rels/document.xml.rels it creates word/ and _rels directories to apply recursive zipping.
-    # This is a hack to fix the issue of getting a corrupted file when any referencing between the
-    # xml files happen like in the case of implementing hyperlinks
-    #
-    def create_dirs_in_zipfile(previous_created_dirs, entry_name, output_stream)
-      created_dirs = previous_created_dirs
-      entry_name_tokens = entry_name.split('/')
-      entry_name_tokens.pop()
-      if entry_name_tokens.length > 1
-        prev_dir = ''
-        entry_name_tokens.each do |dir_name|
-          prev_dir += dir_name + '/'
-          unless created_dirs.include? prev_dir
-            output_stream.put_next_entry(prev_dir)
-            created_dirs << prev_dir
-          end
-        end
+    # Processes all of te entries searching for ones that match the pattern.
+    # The hash is converted into an array first to avoid any possible
+    # modification during iteration errors (i.e. creation of a new rels file).
+    def process(env)
+      @document.zip_contents.to_a.each do |(entry_name, content)|
+        @document.current_entry = entry_name
+        processors = Template.get_processors(entry_name)
+        processors.each { |processor| processor.process(content, env) }
       end
-      created_dirs
     end
 
-    # process the sablon xml template with the given +context+.
-    #
     # IMPORTANT: Open Office does not ignore whitespace around tags.
     # We need to render the xml without indent and whitespace.
-    def process(processor, content, *args)
-      document = Nokogiri::XML(content)
-      processor.process(document, *args).to_xml(indent: 0, save_with: 0)
+    def generate_output_file(zip_out, contents)
+      # output entries to zip file
+      created_dirs = []
+      contents.each do |entry_name, content|
+        create_dirs_in_zipfile(created_dirs, File.dirname(entry_name), zip_out)
+        zip_out.put_next_entry(entry_name)
+        #
+        # convert Nokogiri XML to string
+        if content.instance_of? Nokogiri::XML::Document
+          content = content.to_xml(indent: 0, save_with: 0)
+        end
+        #
+        zip_out.write(content)
+      end
+    end
+
+    # creates directories of the unzipped docx file in the newly created
+    # docx file e.g. in case of word/_rels/document.xml.rels it creates
+    # word/ and _rels directories to apply recursive zipping. This is a
+    # hack to fix the issue of getting a corrupted file when any referencing
+    # between the xml files happen like in the case of implementing hyperlinks.
+    # The created_dirs array is augmented in place using '<<'
+    def create_dirs_in_zipfile(created_dirs, entry_path, output_stream)
+      entry_path_tokens = entry_path.split('/')
+      return created_dirs unless entry_path_tokens.length > 1
+      #
+      prev_dir = ''
+      entry_path_tokens.each do |dir_name|
+        prev_dir += dir_name + '/'
+        next if created_dirs.include? prev_dir
+        #
+        output_stream.put_next_entry(prev_dir)
+        created_dirs << prev_dir
+      end
     end
   end
+
+  # Register the standard processors
+  Template.register_processor(%r{word/document.xml}, Sablon::Processor::Document)
+  Template.register_processor(%r{word/document.xml}, Sablon::Processor::SectionProperties)
+  Template.register_processor(%r{word/(?:header|footer)\d*\.xml}, Sablon::Processor::Document)
 end

data/lib/sablon/version.rb

@@ -1,3 +1,3 @@
 module Sablon
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/test/configuration_test.rb

@@ -16,24 +16,24 @@ class ConfigurationTest < Sablon::TestCase
     }
     # test initialization without type
     tag = @config.register_html_tag(:test_tag, **options)
-    assert_equal @config.permitted_html_tags[:test_tag], tag
-    assert_equal tag.name, :test_tag
-    assert_equal tag.type, :inline
-    assert_equal tag.ast_class, Sablon::HTMLConverter::Paragraph
-    assert_equal tag.attributes, dummy: 'value'
-    assert_equal tag.properties, pstyle: 'ListBullet'
-    assert_equal tag.allowed_children, %i[_inline ol ul li]
+    assert_equal tag, @config.permitted_html_tags[:test_tag]
+    assert_equal :test_tag, tag.name
+    assert_equal :inline, tag.type
+    assert_equal Sablon::HTMLConverter::Paragraph, tag.ast_class
+    assert_equal({ dummy: 'value' }, tag.attributes)
+    assert_equal({ 'pstyle' => 'ListBullet' }, tag.properties)
+    assert_equal %i[_inline ol ul li], tag.allowed_children
 
     # test initialization with type
     tag = @config.register_html_tag('test_tag2', :block, **options)
-    assert_equal @config.permitted_html_tags[:test_tag2], tag
-    assert_equal tag.name, :test_tag2
-    assert_equal tag.type, :block
+    assert_equal tag, @config.permitted_html_tags[:test_tag2]
+    assert_equal :test_tag2, tag.name
+    assert_equal :block, tag.type
   end
 
   def test_remove_tag
     tag = @config.register_html_tag(:test)
-    assert_equal @config.remove_html_tag(:test), tag
+    assert_equal tag, @config.remove_html_tag(:test)
     assert_nil @config.permitted_html_tags[:test]
   end
 
@@ -77,9 +77,9 @@ class ConfigurationHTMLTagTest < Sablon::TestCase
   def test_html_tag_full_init
     args = ['a', 'inline', ast_class: Sablon::HTMLConverter::Run]
     tag = Sablon::Configuration::HTMLTag.new(*args)
-    assert_equal tag.name, :a
-    assert_equal tag.type, :inline
-    assert_equal tag.ast_class, Sablon::HTMLConverter::Run
+    assert_equal :a, tag.name
+    assert_equal :inline, tag.type
+    assert_equal Sablon::HTMLConverter::Run, tag.ast_class
     #
     options = {
       ast_class: :run,
@@ -89,12 +89,12 @@ class ConfigurationHTMLTagTest < Sablon::TestCase
     }
     tag = Sablon::Configuration::HTMLTag.new('a', 'inline', **options)
     #
-    assert_equal tag.name, :a
-    assert_equal tag.type, :inline
-    assert_equal tag.ast_class, Sablon::HTMLConverter::Run
-    assert_equal tag.attributes, dummy: 'value1'
-    assert_equal tag.properties, dummy2: 'value2'
-    assert_equal tag.allowed_children, [:text]
+    assert_equal :a, tag.name
+    assert_equal :inline, tag.type
+    assert_equal Sablon::HTMLConverter::Run, tag.ast_class
+    assert_equal({ dummy: 'value1' }, tag.attributes)
+    assert_equal({ 'dummy2' => 'value2' }, tag.properties)
+    assert_equal [:text], tag.allowed_children
   end
 
   def test_html_tag_init_block_without_class
@@ -113,10 +113,10 @@ class ConfigurationHTMLTagTest < Sablon::TestCase
     # test default allowances
     assert div.allowed_child?(text) # all inline elements allowed
     assert div.allowed_child?(olist) # tag name is included even though it is bock leve
-    assert_equal div.allowed_child?(div), false # other block elms are not allowed
+    assert_equal false, div.allowed_child?(div) # other block elms are not allowed
 
     # test olist with allowances for all blocks but no inline
     assert olist.allowed_child?(div) # all block elements allowed
-    assert_equal olist.allowed_child?(text), false # no inline elements
+    assert_equal false, olist.allowed_child?(text) # no inline elements
   end
 end

data/test/content_test.rb

@@ -238,3 +238,53 @@ class ContentWordMLTest < Sablon::TestCase
     assert_xml_equal output, @document
   end
 end
+
+class ContentImageTest < Sablon::TestCase
+  def setup
+    base_path = Pathname.new(File.expand_path('../', __FILE__))
+    fixture_dir = base_path.join('fixtures')
+    @image_path = fixture_dir.join('images', 'r2d2.jpg')
+    @expected = Sablon::Content::Image.new(@image_path.to_s)
+  end
+
+  def test_inspect
+    assert_equal '#<Image r2d2.jpg:{}>', @expected.inspect
+    #
+    # set some rid's and retest
+    @expected.rid_by_file['word/test.xml'] = 'rId1'
+    assert_equal '#<Image r2d2.jpg:{"word/test.xml"=>"rId1"}>', @expected.inspect
+  end
+
+  def test_wraps_image_from_string_path
+    #
+    tested = Sablon.content(:image, @image_path.to_s)
+    assert_equal @expected, tested
+  end
+
+  def test_wraps_image_from_readable_object_that_can_be_basenamed
+    tested = Sablon.content(:image, open(@image_path.to_s, 'rb'))
+    assert_equal @expected, tested
+  end
+
+  def test_wraps_image_from_readable_object_with_filename_supplied
+    data = StringIO.new(IO.binread(@image_path.to_s))
+    tested = Sablon.content(:image, data, filename: File.basename(@image_path))
+    assert_equal @expected, tested
+  end
+
+  def test_wraps_readable_object_that_responds_to_filename
+    readable = Struct.new(:data, :filename) { alias read data }
+    #
+    readable = readable.new(IO.binread(@image_path.to_s), File.basename(@image_path))
+    tested = Sablon.content(:image, readable)
+    assert_equal @expected, tested
+  end
+
+  def test_raises_error_when_no_filename
+    data = StringIO.new(IO.binread(@image_path.to_s))
+    #
+    assert_raises ArgumentError do
+      Sablon.content(:image, data)
+    end
+  end
+end

data/test/context_test.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 require "test_helper"
 
-class EnvironmentTest < Sablon::TestCase
+class ContextTest < Sablon::TestCase
   def test_converts_symbol_keys_to_string_keys
     context = Sablon::Context.transform_hash(a: 1, b: { c: 2, "d" => 3 })
     assert_equal({ "a" => 1, "b" => { "c" => 2, "d" => 3 } }, context)
@@ -25,4 +25,40 @@ class EnvironmentTest < Sablon::TestCase
                    "otherkey" => nil,
                    "normalkey" => nil}, context)
   end
+
+  def test_recognizes_image_keys
+    base_path = Pathname.new(File.expand_path("../", __FILE__))
+    img_path = "#{base_path}/fixtures/images/c3po.jpg"
+    context = {
+      test: 'result',
+      'image:image' =>  img_path
+    }
+    #
+    context = Sablon::Context.transform_hash(context)
+    assert_equal({ "test" => "result",
+                   "image" => Sablon.content(:image, img_path) },
+                 context)
+  end
+
+  def test_converts_hashes_nested_in_arrays
+    input_context = {
+      test: 'result',
+      items: [
+        { name: 'Key1', value: 'Value1'  },
+        { 'name' => 'Key2', 'html:value' => '<b>Test</b>' }
+      ],
+      'word_ml:runs' => '<w:r><w:t>Text</w:t><w:r>'
+    }
+    expected_context = {
+      'test' => 'result',
+      'items' => [
+        { 'name' => 'Key1', 'value' => 'Value1'  },
+        { 'name' => 'Key2', 'value' => Sablon.content(:html, '<b>Test</b>') }
+      ],
+      'runs' => Sablon.content(:word_ml, '<w:r><w:t>Text</w:t><w:r>')
+    }
+    #
+    context = Sablon::Context.transform_hash(input_context)
+    assert_equal expected_context, context
+  end
 end

data/test/environment_test.rb

@@ -13,14 +13,17 @@ class EnvironmentTest < Sablon::TestCase
   def test_alter_context
     # set initial context
     env = Sablon::Environment.new(nil, a: 1, b: { c: 2, "d" => 3 })
+
     # alter context to change a single key and set a new one
     env2 = env.alter_context(a: "a", e: "new-key")
     assert_equal({ "a" => "a", "b" => { "c" => 2, "d" => 3 }, "e" => "new-key" }, env2.context)
+
     # check that the old context was not modified
     assert_equal({"a" => 1, "b" => { "c" => 2, "d" => 3 }}, env.context)
+
     # check that numbering and template are the same references
     assert env.template.equal?(env2.template), "#{env.template} != #{env2.template}"
-    assert env.numbering.equal?(env2.numbering), "#{env.numbering} != #{env2.numbering}"
+
     # check that a new context reference was created
     assert !env.context.equal?(env2.context), "#{env.context} == #{env2.context}"
   end

data/test/executable_test.rb

@@ -1,8 +1,6 @@
 require "test_helper"
 
 class ExecutableTest < Sablon::TestCase
-  include Sablon::Test::Assertions
-
   def setup
     super
     @base_path = Pathname.new(File.expand_path("../", __FILE__))

data/test/fixtures/xml/image.xml

@@ -0,0 +1,91 @@
+<w:p>
+  <w:r>
+    <w:fldChar w:fldCharType="begin"/>
+  </w:r>
+  <w:r>
+    <w:instrText xml:space="preserve"> MERGEFIELD @item.image:start \* MERGEFORMAT </w:instrText>
+  </w:r>
+  <w:r>
+    <w:fldChar w:fldCharType="separate"/>
+  </w:r>
+  <w:r>
+    <w:rPr>
+      <w:noProof/>
+    </w:rPr>
+    <w:t>«@item.image:start»</w:t>
+  </w:r>
+  <w:r>
+    <w:fldChar w:fldCharType="end"/>
+  </w:r>
+</w:p>
+<w:p >
+  <w:r>
+    <w:rPr>
+      <w:noProof/>
+    </w:rPr>
+    <w:drawing>
+      <wp:inline distT="0" distB="0" distL="0" distR="0">
+        <wp:extent cx="1875155" cy="1249045"/>
+        <wp:effectExtent l="0" t="0" r="0" b="0"/>
+        <wp:docPr id="2" name="Picture 2"/>
+        <wp:cNvGraphicFramePr>
+          <a:graphicFrameLocks xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" noChangeAspect="1"/>
+        </wp:cNvGraphicFramePr>
+        <a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
+          <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
+            <pic:pic xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">
+              <pic:nvPicPr>
+                <pic:cNvPr id="2" name="placeholder.png"/>
+                <pic:cNvPicPr/>
+              </pic:nvPicPr>
+              <pic:blipFill>
+                <a:blip r:embed="rId4">
+                  <a:extLst>
+                    <a:ext uri="{28A0092B-C50C-407E-A947-70E740481C1C}">
+                      <a14:useLocalDpi xmlns:a14="http://schemas.microsoft.com/office/drawing/2010/main" val="0"/>
+                    </a:ext>
+                  </a:extLst>
+                </a:blip>
+                <a:stretch>
+                  <a:fillRect/>
+                </a:stretch>
+              </pic:blipFill>
+              <pic:spPr>
+                <a:xfrm>
+                  <a:off x="0" y="0"/>
+                  <a:ext cx="1875155" cy="1249045"/>
+                </a:xfrm>
+                <a:prstGeom prst="rect">
+                  <a:avLst/>
+                </a:prstGeom>
+              </pic:spPr>
+            </pic:pic>
+          </a:graphicData>
+        </a:graphic>
+      </wp:inline>
+    </w:drawing>
+  </w:r>
+</w:p>
+<w:p>
+  <w:r>
+    <w:fldChar w:fldCharType="begin"/>
+  </w:r>
+  <w:r>
+    <w:instrText xml:space="preserve"> MERGEFIELD @item.image:end \* MERGEFORMAT </w:instrText>
+  </w:r>
+  <w:r>
+    <w:fldChar w:fldCharType="separate"/>
+  </w:r>
+  <w:r>
+    <w:rPr>
+      <w:noProof/>
+    </w:rPr>
+    <w:t>«@item.image:end»</w:t>
+  </w:r>
+  <w:r>
+    <w:rPr>
+      <w:noProof/>
+    </w:rPr>
+    <w:fldChar w:fldCharType="end"/>
+  </w:r>
+</w:p>