sablon 0.1.1 → 0.2.0

data/lib/sablon/document_object_model/relationships.rb

@@ -0,0 +1,111 @@
+require 'pathname'
+require 'sablon/document_object_model/file_handler'
+
+module Sablon
+  module DOM
+    # Adds new relationships to the entry's corresponding relationships file
+    class Relationships < FileHandler
+      #
+      # extends the Model class so it now has an "add_relationship" method
+      def self.extend_model(model_klass)
+        super do
+          #
+          # adds a relationship to the rels file for the current entry
+          define_method(:add_relationship) do |rel_attr|
+            # detemine name of rels file to augment
+            rels_name = Relationships.rels_entry_name_for(@current_entry)
+
+            # create the file if needed and update DOM
+            create_entry_if_not_exist(rels_name, Relationships.file_template)
+            @dom[rels_name].add_relationship(rel_attr)
+          end
+          #
+          # adds file to the /word/media folder without overwriting an
+          # existing file
+          define_method(:add_media) do |name, data, rel_attr|
+            rel_attr[:Target] = "media/#{name}"
+            extension = name.match(/\.(\w+?)$/).to_a[1]
+            type = rel_attr[:Type].match(%r{/(\w+?)$}).to_a[1] + "/#{extension}"
+            #
+            if @zip_contents["word/#{rel_attr[:Target]}"]
+              names = @zip_contents.keys.map { |n| File.basename(n) }
+              pattern = "^(\\d+)-#{name}"
+              max_val = names.collect { |n| n.match(pattern).to_a[1].to_i }.max
+              rel_attr[:Target] = "media/#{max_val + 1}-#{name}"
+            end
+            #
+            # add the content to the zip and create the relationship
+            @zip_contents["word/#{rel_attr[:Target]}"] = data
+            add_content_type(extension, type)
+            add_relationship(rel_attr)
+          end
+          #
+          # locates an existing rId in the approprirate rels file
+          define_method(:find_relationship_by) do |attribute, value, entry = nil|
+            entry = @current_entry if entry.nil?
+            # find the rels file and search it if it exists
+            rels_name = Relationships.rels_entry_name_for(entry)
+            return unless @dom[rels_name]
+            #
+            @dom[rels_name].find_relationship_by(attribute, value)
+          end
+        end
+      end
+
+      def self.file_template
+        <<-XML.gsub(/^\s+|\n/, '')
+          <?xml version="1.0" encoding="UTF-8"?>
+          <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+          </Relationships>
+        XML
+      end
+
+      def self.rels_entry_name_for(entry_name)
+        par_dir = Pathname.new(File.dirname(entry_name))
+        par_dir.join('_rels', "#{File.basename(entry_name)}.rels").to_s
+      end
+
+      # Sets up the class instance to handle new relationships for a document.
+      # I only care about tags that have an integer component
+      def initialize(xml_node)
+        super
+        #
+        @relationships = xml_node.root
+        @max_rid = max_attribute_value('Relationship', 'Id')
+      end
+
+      # Finds the maximum value of an attribute by converting it to an
+      # integer. Non numeric portions of values are ignored.
+      def max_attribute_value(selector, attr_name)
+        super(@relationships, selector, attr_name, query_method: :css)
+      end
+
+      # adds a new relationship and returns the corresponding rId for it
+      def add_relationship(rel_attr)
+        rel_attr['Id'] = "rId#{next_rid}"
+        @relationships << relationship_tag(rel_attr)
+        #
+        rel_attr['Id']
+      end
+
+      # Reurns an XML node based on the attribute value or nil if one does
+      # not exist
+      def find_relationship_by(attribute, value)
+        @relationships.css(%(Relationship[#{attribute}="#{value}"])).first
+      end
+
+      private
+
+      # increments the max rid and returns it
+      def next_rid
+        @max_rid += 1
+      end
+
+      # Builds the relationship WordML tag and returns it
+      def relationship_tag(rel_attr)
+        attr_str = rel_attr.map { |k, v| %(#{k}="#{v}") }.join(' ')
+        "<Relationship #{attr_str}/>"
+      end
+    end
+  end
+end

data/lib/sablon/environment.rb

@@ -3,31 +3,28 @@ module Sablon
   # to manage data during template processing.
   class Environment
     attr_reader :template
-    attr_reader :numbering
     attr_reader :context
-    attr_reader :relationship
+    attr_reader :section_properties
 
     # returns a new environment with merged contexts
     def alter_context(context = {})
       new_context = @context.merge(context)
-      Environment.new(nil, new_context, self)
+      Environment.new(template, new_context)
+    end
+
+    # reader method for the DOM::Model instance stored on the template
+    def document
+      @template.document
+    end
+
+    def section_properties=(properties)
+      @section_properties = Context.transform_hash(properties)
     end
 
     private
 
-    def initialize(template, context = {}, parent_env = nil)
-      # pass attributes of the supplied environment to the new one or
-      # create new references
-      if parent_env
-        @template = parent_env.template
-        @numbering = parent_env.numbering
-        @relationship = parent_env.relationship
-      else
-        @template = template
-        @numbering = Numbering.new
-        @relationship = Relationship.new
-      end
-      #
+    def initialize(template, context = {})
+      @template = template
       @context = Context.transform_hash(context)
     end
   end

data/lib/sablon/html/ast.rb

@@ -30,8 +30,11 @@ module Sablon
         # process the styles as a hash and store values
         style_attrs = {}
         properties.each do |key, value|
+          key = key.strip if key.respond_to? :strip
+          value = value.strip if value.respond_to? :strip
+          #
           unless key.is_a? Symbol
-            key, value = *convert_style_property(key.strip, value.strip)
+            key, value = *convert_style_property(key, value)
           end
           style_attrs[key] = value if key
         end
@@ -127,8 +130,11 @@ module Sablon
     class Root < Collection
       def initialize(env, node)
         # strip text nodes from the root level element, these are typically
-        # extra whitespace from indenting the markup
-        node.search('./text()').remove
+        # extra whitespace from indenting the markup if there are any
+        # block level tags at the top level
+        if ASTBuilder.any_block_tags?(node.children)
+          node.search('./text()').remove
+        end
 
         # convert children from HTML to AST nodes
         super(ASTBuilder.html_to_ast(env, node.children, {}))
@@ -204,8 +210,8 @@ module Sablon
         #
         @definition = nil
         if node.ancestors(".//#{@list_tag}").length.zero?
-          # Only register a definition when upon the first list tag encountered
-          @definition = env.numbering.register(properties[:pStyle])
+          # Only register a definition upon the first list tag encountered
+          @definition = env.document.add_list_definition(properties['pStyle'])
         end
 
         # update attributes of all child nodes
@@ -214,10 +220,6 @@ module Sablon
         # Move any list tags that are a child of a list item up one level
         process_child_nodes(node)
 
-        # strip text nodes from the list level element, this is typically
-        # extra whitespace from indenting the markup
-        node.search('./text()').remove
-
         # convert children from HTML to AST nodes
         super(ASTBuilder.html_to_ast(env, node.children, properties))
       end
@@ -532,14 +534,13 @@ module Sablon
         @runs = Collection.new(@runs)
         @target = node.attributes['href'].value
         #
-        hyperlink_relation = {
-          Id: 'rId' + SecureRandom.uuid.delete('-'),
+        rel_attr = {
           Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink',
           Target: @target,
           TargetMode: 'External'
         }
-        env.relationship.relationships << hyperlink_relation
-        @attributes = { 'r:id' => hyperlink_relation[:Id] }
+        rid = env.document.add_relationship(rel_attr)
+        @attributes = { 'r:id' => rid }
       end
 
       def to_docx

data/lib/sablon/html/ast_builder.rb

@@ -9,6 +9,23 @@ module Sablon
         builder.nodes
       end
 
+      # Checks if there are any block level tags in the current node set
+      # this is used at the root level to determine if top level text nodes
+      # should be removed
+      def self.any_block_tags?(nodes)
+        nodes.detect { |node| fetch_tag(node.name).type == :block }
+      end
+
+      # Retrieves a HTMLTag instance from the permitted_html_tags hash or
+      # raises an ArgumentError if the tag is not registered
+      def self.fetch_tag(tag_name)
+        tag_name = tag_name.to_sym
+        unless Sablon::Configuration.instance.permitted_html_tags[tag_name]
+          raise ArgumentError, "Don't know how to handle HTML tag: #{tag_name}"
+        end
+        Sablon::Configuration.instance.permitted_html_tags[tag_name]
+      end
+
       private
 
       def initialize(env, nodes, properties)
@@ -42,11 +59,7 @@ module Sablon
       # retrieves a HTMLTag instance from the cpermitted_html_tags hash or
       # raises an ArgumentError if the tag is not registered in the hash
       def fetch_tag(tag_name)
-        tag_name = tag_name.to_sym
-        unless Sablon::Configuration.instance.permitted_html_tags[tag_name]
-          raise ArgumentError, "Don't know how to handle HTML tag: #{tag_name}"
-        end
-        Sablon::Configuration.instance.permitted_html_tags[tag_name]
+        self.class.fetch_tag(tag_name)
       end
 
       # Checking that the current tag is an allowed child of the parent_tag.

data/lib/sablon/html/node_properties.rb

@@ -35,11 +35,11 @@ module Sablon
       end
 
       def [](key)
-        @properties[key]
+        @properties[key.to_sym]
       end
 
       def []=(key, value)
-        @properties[key] = value
+        @properties[key.to_sym] = value
       end
 
       def to_docx
@@ -57,7 +57,7 @@ module Sablon
         #
         properties.each do |key, value|
           if whitelist.include? key.to_s
-            @properties[key] = value
+            @properties[key.to_sym] = value
           else
             @transferred_properties[key] = value
           end

data/lib/sablon/operations.rb

@@ -21,8 +21,36 @@ module Sablon
           iter_env = env.alter_context(iterator_name => item)
           block.process(iter_env)
         end
+        update_unique_ids(env, content)
         block.replace(content.reverse)
       end
+
+      private
+
+      # updates all unique id's present in the xml being copied
+      def update_unique_ids(env, content)
+        doc_xml = env.document.zip_contents[env.document.current_entry]
+        dom_entry = env.document[env.document.current_entry]
+        #
+        # update all docPr tags created
+        selector = "//*[local-name() = 'docPr']"
+        init_id_val = dom_entry.max_attribute_value(doc_xml, selector, 'id')
+        update_tag_attribute(content, 'docPr', 'id', init_id_val)
+        #
+        # update all cNvPr tags created
+        selector = "//*[local-name() = 'cNvPr']"
+        init_id_val = dom_entry.max_attribute_value(doc_xml, selector, 'id')
+        update_tag_attribute(content, 'cNvPr', 'id', init_id_val)
+      end
+
+      # Increments the attribute value of each element with the id by 1
+      def update_tag_attribute(content, tag_name, attr_name, init_val)
+        content.each do |nodeset|
+          nodeset.xpath(".//*[local-name() = '#{tag_name}']").each do |node|
+            node[attr_name] = (init_val += 1).to_s
+          end
+        end
+      end
     end
 
     class Condition < Struct.new(:conditon_expr, :block, :predicate)
@@ -50,6 +78,37 @@ module Sablon
         block.replace []
       end
     end
+
+    class Image < Struct.new(:image_reference, :block)
+      def evaluate(env)
+        image = image_reference.evaluate(env.context)
+        set_local_rid(env, image) if image
+        block.replace(image)
+      end
+
+      private
+
+      def set_local_rid(env, image)
+        if image.rid_by_file.keys.empty?
+          # Only add the image once, it is reused afterwards
+          rel_attr = {
+            Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image'
+          }
+          rid = env.document.add_media(image.name, image.data, rel_attr)
+          image.rid_by_file[env.document.current_entry] = rid
+        elsif image.rid_by_file[env.document.current_entry].nil?
+          # locate an existing relationship and duplicate it
+          entry = image.rid_by_file.keys.first
+          value = image.rid_by_file[entry]
+          #
+          rel = env.document.find_relationship_by('Id', value, entry)
+          rid = env.document.add_relationship(rel.attributes)
+          image.rid_by_file[env.document.current_entry] = rid
+        end
+        #
+        image.local_rid = image.rid_by_file[env.document.current_entry]
+      end
+    end
   end
 
   module Expression

data/lib/sablon/processor/document.rb

@@ -2,11 +2,9 @@
 module Sablon
   module Processor
     class Document
-      def self.process(xml_node, env, properties = {})
+      def self.process(xml_node, env)
         processor = new(parser)
         processor.manipulate xml_node, env
-        processor.write_properties xml_node, properties if properties.any?
-        xml_node
       end
 
       def self.parser
@@ -26,14 +24,8 @@ module Sablon
         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
@@ -51,7 +43,7 @@ module Sablon
 
       class Block < Struct.new(:start_field, :end_field)
         def self.enclosed_by(start_field, end_field)
-          @blocks ||= [RowBlock, ParagraphBlock, InlineParagraphBlock]
+          @blocks ||= [ImageBlock, RowBlock, ParagraphBlock, InlineParagraphBlock]
           block_class = @blocks.detect { |klass| klass.encloses?(start_field, end_field) }
           block_class.new start_field, end_field
         end
@@ -117,6 +109,48 @@ module Sablon
         end
       end
 
+      class ImageBlock < ParagraphBlock
+        def self.parent(node)
+          node.ancestors(".//w:p").first
+        end
+
+        def self.encloses?(start_field, end_field)
+          start_field.expression.start_with?('@')
+        end
+
+        def replace(image)
+          #
+          if image
+            nodes_between_fields.each do |node|
+              pic_prop = node.at_xpath('.//pic:cNvPr', pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture')
+              pic_prop.attributes['name'].value = image.name if pic_prop
+              blip = node.at_xpath('.//a:blip', a: 'http://schemas.openxmlformats.org/drawingml/2006/main')
+              blip.attributes['embed'].value = image.local_rid if blip
+            end
+          end
+          #
+          start_field.remove
+          end_field.remove
+        end
+
+        private
+
+        # Collects all nodes between the two nodes provided into an array.
+        # Each entry in the array should be a paragraph tag.
+        # https://stackoverflow.com/a/820776
+        def nodes_between_fields
+          first = self.class.parent(start_field)
+          last = self.class.parent(end_field)
+          #
+          result = [first]
+          until first == last
+            first = first.next
+            result << first
+          end
+          result
+        end
+      end
+
       class InlineParagraphBlock < Block
         def self.parent(node)
           node.ancestors ".//w:p"
@@ -171,6 +205,9 @@ module Sablon
           when /([^ ]+):if/
             block = consume_block("#{$1}:endIf")
             Statement::Condition.new(Expression.parse($1), block)
+          when /^@([^ ]+):start/
+            block = consume_block("@#{$1}:end")
+            Statement::Image.new(Expression.parse($1), block)
           when /^comment$/
             block = consume_block("endComment")
             Statement::Comment.new(block)