docx 0.13.0 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 236ded16324395b50579ba21fdc84891251ffc75b9bd1f5c65c4d125c6689c2f
-  data.tar.gz: d994c54de22f1829928d4fe60087d8f4667905d4e13e88e9b607a9ae3ac34077
+  metadata.gz: db1fd167dc6ddfecc81518f27cd78fc203d74738ffe52b2877251b2ed291c297
+  data.tar.gz: 7c2f230a44f18ceffffcbbfa55d212ebdd2a58651823aa78d303cc64493aa461
 SHA512:
-  metadata.gz: a5a969c0011ac31aba461a485474015b230a76d2c449275f90a5267f4ee9b38ba698090561fea0cade728502be7db6e306c8d9a29cc662400122ed138a209e18
-  data.tar.gz: f0e12812fd5d488162a4d263a41d095e31ab0500824ae99cc58f4fafe82ef4468b44fa68bcf0db86b3ecd305cd263602334dfbea81fa14622d7303060e461779
+  metadata.gz: 6e1af62546207b59b6b2bcd193c83aaafc11258dcb50d7c52bcd2251b77552704b39d5667a709cdc9fdd005c37e00e3530acd9fb88df565ba10db361d6032d98
+  data.tar.gz: 7d753f33adc0795e12cea763d32e01d4cf76777d1cf7f5c8d815991efccfd0ede2b513a7a99c5558824e972e17ffd86460f661d87f7003dd916cca2cdbc06498

data/lib/docx/containers/paragraph.rb

@@ -70,9 +70,13 @@ module Docx
         # such as "{{fi", "rst_na", "me}}"). The per-run TextRun#substitute cannot
         # match those, but this can, because it joins the runs first.
         #
-        # The matched region is collapsed into the first run it touches, so that
-        # run's formatting is kept while the other spanned runs are emptied; runs
-        # outside the match are left untouched.
+        # The substitution works on the paragraph's w:t nodes, so it also handles
+        # runs holding several w:t (LibreOffice writes "text<w:br/>text" in one
+        # run) and placeholders that start inside a hyperlink. The replacement
+        # goes into the w:t holding the first matched character, so that run's
+        # formatting is used; the rest of the match is cut from the following
+        # w:t, and line breaks and tabs inside the match are dropped. Text,
+        # breaks and tabs outside the match stay where they are.
         #
         # +pattern+ may be a String or a Regexp; +replacement+ follows String#sub
         # semantics, so capture-group backreferences (e.g. '\1') work with a Regexp.
@@ -81,20 +85,19 @@ module Docx
         #   paragraph.substitute('{{first_name}}', 'Jane')   # => "Hello Jane!"
         #   paragraph.substitute(/\{\{(\w+)\}\}/, 'value of \1')
         #
-        # See https://github.com/ruby-docx/docx/issues/147
+        # See https://github.com/ruby-docx/docx/issues/147 and #187
         def substitute(pattern, replacement)
           search_from = 0
           loop do
-            runs = text_runs
-            break if runs.empty?
+            texts = @node.xpath(TEXT_XPATH).map { |t_node| Elements::Text.new(t_node) }
 
             offsets = []
             cursor = 0
-            runs.each do |run|
+            texts.each do |text|
               offsets << cursor
-              cursor += run.text.length
+              cursor += text.content.length
             end
-            full_text = runs.map(&:text).join
+            full_text = texts.map(&:content).join
 
             match = full_text.match(pattern, search_from)
             break unless match
@@ -102,15 +105,21 @@ module Docx
 
             match_start = match.begin(0)
             match_end   = match.end(0) # exclusive
-            first = offsets.rindex { |offset| offset <= match_start }
-            last  = offsets.rindex { |offset| offset < match_end }
-
-            combined = runs[first..last].map(&:text).join
-            local_start = match_start - offsets[first]
-            local_end   = match_end - offsets[first]
-            replaced = combined[local_start...local_end].sub(pattern, replacement)
-            runs[first].text = combined[0...local_start] + replaced + combined[local_end..-1]
-            ((first + 1)..last).each { |index| runs[index].text = '' }
+            # the w:t holding the first and the last matched character
+            first = texts.each_index.find { |i| offsets[i] + texts[i].content.length > match_start }
+            last  = texts.each_index.find { |i| offsets[i] + texts[i].content.length >= match_end }
+
+            replaced = match[0].sub(pattern, replacement)
+            head = texts[first].content[0...(match_start - offsets[first])]
+            tail = texts[last].content[(match_end - offsets[last])..]
+            if first == last
+              texts[first].content = head + replaced + tail
+            else
+              texts[first].content = head + replaced
+              texts[(first + 1)...last].each { |text| text.content = '' }
+              texts[last].content = tail
+              remove_separators_between(texts[first].node, texts[last].node)
+            end
 
             # advance past the inserted replacement so it is not re-matched
             search_from = match_start + replaced.length
@@ -165,6 +174,22 @@ module Docx
 
         private
 
+        # The w:t read by #text (those of the runs and hyperlink runs), in
+        # document order.
+        TEXT_XPATH = 'w:r/w:t|w:hyperlink/w:r/w:t'
+        # Line breaks and tabs that sit between those w:t.
+        SEPARATOR_XPATH = %w[br tab cr].map { |tag| "w:r/w:#{tag}|w:hyperlink/w:r/w:#{tag}" }.join('|')
+        private_constant :TEXT_XPATH, :SEPARATOR_XPATH
+
+        # Remove the line breaks and tabs lying between two w:t of a match.
+        def remove_separators_between(first_t, last_t)
+          separators = @node.xpath(SEPARATOR_XPATH).to_a
+          nodes = @node.xpath("#{TEXT_XPATH}|#{SEPARATOR_XPATH}").to_a
+          from = nodes.index(first_t)
+          to = nodes.index(last_t)
+          nodes[(from + 1)...to].each { |node| node.remove if separators.include?(node) }
+        end
+
         def style_property
           properties&.at_xpath('w:pStyle') || properties&.add_child('<w:pStyle/>').first
         end

data/lib/docx/containers/text_run.rb

@@ -40,6 +40,7 @@ module Docx
           elsif @text_nodes.empty?
             new_t = Elements::Text.create_within(self)
             new_t.content = content
+            @text_nodes << new_t
           end
           reset_text
         end

data/lib/docx/document.rb

@@ -113,6 +113,9 @@ module Docx
     end
 
     def hyperlink_relationships
+      # @rels is nil when the document has no relationships part (#192)
+      return Nokogiri::XML::NodeSet.new(Nokogiri::XML::Document.new) unless @rels
+
       @rels.xpath("//xmlns:Relationship[contains(@Type,'hyperlink')]")
     end
 

data/lib/docx/elements/bookmark.rb

@@ -51,28 +51,92 @@ module Docx
 
       # Get text run immediately prior to bookmark node
       def get_run_before
-        # at_xpath returns the first match found and preceding-sibling returns siblings in the
-        # order they appear in the document not the order as they appear when moving out from
-        # the starting node
-        if not (r_nodes = @node.xpath("./preceding-sibling::w:r")).empty?
-          r_node = r_nodes.last
-          Containers::TextRun.new(r_node)
-        else
+        if enclosing_paragraph
+          # at_xpath returns the first match found and preceding-sibling returns siblings in the
+          # order they appear in the document not the order as they appear when moving out from
+          # the starting node
+          unless (r_nodes = @node.xpath("./preceding-sibling::w:r")).empty?
+            return Containers::TextRun.new(r_nodes.last)
+          end
+
           new_r = Containers::TextRun.create_with(self)
           new_r.insert_before(self)
-          new_r
+          return new_r
         end
+
+        # Block-level bookmark (e.g. Google Docs places bookmarkStart/End directly
+        # under w:body). Add a run to the preceding paragraph, or to a new
+        # paragraph before the bookmark, so the run lives inside a w:p.
+        run_at_paragraph_end(@node.xpath("./preceding-sibling::w:p").last) ||
+          run_in_new_paragraph { |paragraph| @node.add_previous_sibling(paragraph) }
       end
 
       # Get text run immediately after bookmark node
       def get_run_after
-        if (r_node = @node.at_xpath("./following-sibling::w:r"))
-          Containers::TextRun.new(r_node)
-        else
+        if enclosing_paragraph
+          if (r_node = @node.at_xpath("./following-sibling::w:r"))
+            return Containers::TextRun.new(r_node)
+          end
+
           new_r = Containers::TextRun.create_with(self)
           new_r.insert_after(self)
-          new_r
+          return new_r
+        end
+
+        # Block-level bookmark: add a run to the following paragraph, or to a new
+        # paragraph after the bookmark.
+        run_at_paragraph_start(@node.at_xpath("./following-sibling::w:p")) ||
+          run_in_new_paragraph { |paragraph| @node.add_next_sibling(paragraph) }
+      end
+
+      # Override Element#parent_paragraph so insert_multiple_lines also works for
+      # block-level bookmarks. For those we fill a fresh paragraph inserted at the
+      # bookmark, rather than an adjacent existing paragraph, so we neither crash
+      # (no enclosing paragraph) nor overwrite unrelated content.
+      def parent_paragraph
+        return Containers::Paragraph.new(enclosing_paragraph) if enclosing_paragraph
+
+        paragraph = Nokogiri::XML::Node.new("w:p", @node.document)
+        @node.add_next_sibling(paragraph)
+        Containers::Paragraph.new(paragraph)
+      end
+
+      private
+
+      # The w:p the bookmark sits inside, or nil when it is block-level.
+      def enclosing_paragraph
+        @node.at_xpath("./parent::w:p")
+      end
+
+      # A new run inserted at the start of paragraph_node (after w:pPr if present).
+      # Returns nil when paragraph_node is nil.
+      def run_at_paragraph_start(paragraph_node)
+        return nil unless paragraph_node
+
+        new_r = Containers::TextRun.create_with(self)
+        if (props = paragraph_node.at_xpath("w:pPr"))
+          props.add_next_sibling(new_r.node)
+        else
+          paragraph_node.prepend_child(new_r.node)
         end
+        new_r
+      end
+
+      # A new run appended to the end of paragraph_node. nil when it is nil.
+      def run_at_paragraph_end(paragraph_node)
+        return nil unless paragraph_node
+
+        Containers::TextRun.create_within(Containers::Paragraph.new(paragraph_node))
+      end
+
+      # Create a run wrapped in a fresh w:p; the block positions that paragraph
+      # relative to the bookmark.
+      def run_in_new_paragraph
+        new_r = Containers::TextRun.create_with(self)
+        paragraph = Nokogiri::XML::Node.new("w:p", @node.document)
+        paragraph.add_child(new_r.node)
+        yield paragraph
+        new_r
       end
     end
   end

data/lib/docx/elements/element.rb

@@ -42,7 +42,8 @@ module Docx
 
       # Insert node as first child (after properties)
       def prepend_to(element)
-        @node = element.node.properties.add_next_sibling(@node)
+        properties = element.properties if element.respond_to?(:properties)
+        @node = properties ? properties.add_next_sibling(@node) : element.node.prepend_child(@node)
         self
       end
 

data/lib/docx/elements/text.rb

@@ -13,6 +13,8 @@ module Docx
 
       def content=(args)
         @node.content = args
+        # Without xml:space="preserve", Word drops leading and trailing spaces.
+        @node['xml:space'] = 'preserve' if args.to_s.match?(/\A\s|\s\z/)
       end
 
       def initialize(node)

data/lib/docx/helpers.rb

@@ -4,7 +4,7 @@ module Docx
     # than the default inspect method. But you can still get the default inspect method by passing
     # true as the first argument.
     def inspect(full = false)
-      return(super) if full
+      return super() if full
 
       variable_values =
         instance_variables.map do |var|

data/lib/docx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Docx #:nodoc:
-  VERSION = '0.13.0'
+  VERSION = '0.13.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docx
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.13.2
 platform: ruby
 authors:
 - Christopher Hunt