docx 0.13.1 → 0.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d639e88e5950b94157fc4f81b14f0f8bf355abb4fdedd24b7f40dc00eafb72d7
-  data.tar.gz: e64400d25d919b4cd51f4b876d7f35c3433841523055866dff2c300f7c15aca7
+  metadata.gz: a6559deefb9d0bfae3c8101274040ebf8968827360a3f871d2f1d23440e6bbcb
+  data.tar.gz: 4ad8c35b486f9fb9aeac833f78f9425dbac5364f4c1d0d16e168685434695210
 SHA512:
-  metadata.gz: d2ad2931111374349dd03ca04bef655a9eaa797b84d688198ebeac84cdf93af147d4f8fd5a561c4e506d7f823c9b22884c698a315d7e2bb505357c7c6da9316a
-  data.tar.gz: 25cb0bc5f3b67b4af1874b902fbdfe3061205cee0c8b288187924b80cb50a6bd5a7076ea497be702a07241841da146055b3be0dbffeb90c20922f851ad31588c
+  metadata.gz: bb062084c4bd71c5ca72fca4f7eae5fe17869eca2533c5d668a4cd8c2963544fff8737b836676ca22073c19ec6fca7f9a78bf0ad5789f7172d149ad75d87a455
+  data.tar.gz: bea34b169aa1c320cab0d9bd8de4a6a02e91e50a327d60192d9e9e5f53e8d9c977a7b713d0cd5be4d3ba05573f0850481cc69c707b96edf29609a4be8e08cd14

data/lib/docx/containers/container.rb

@@ -18,6 +18,19 @@ module Docx
         def remove!
           @node.remove
         end
+
+        private
+
+        # Remove the line breaks and tabs (nodes matched by +separator_xpath+)
+        # lying between the w:t nodes +first_t+ and +last_t+, which are matched
+        # by +text_xpath+.
+        def remove_separators_between(first_t, last_t, text_xpath, separator_xpath)
+          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
       end
     end
   end

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,39 +85,15 @@ 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?
-
-            offsets = []
-            cursor = 0
-            runs.each do |run|
-              offsets << cursor
-              cursor += run.text.length
-            end
-            full_text = runs.map(&:text).join
-
-            match = full_text.match(pattern, search_from)
-            break unless match
-            break if match.end(0) == match.begin(0) # ignore empty matches
-
-            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 = '' }
+          while (match = find_match(pattern, search_from))
+            replaced = match[0].sub(pattern, replacement)
+            replace_text_range(match.begin(0)...match.end(0), replaced)
 
             # advance past the inserted replacement so it is not re-matched
-            search_from = match_start + replaced.length
+            search_from = match.begin(0) + replaced.length
           end
           self
         end
@@ -165,6 +145,50 @@ 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
+
+        # The paragraph's w:t, in document order; their contents joined make up #text.
+        def text_nodes
+          @node.xpath(TEXT_XPATH).map { |t_node| Elements::Text.new(t_node) }
+        end
+
+        # The first match of +pattern+ in the paragraph text at or after +from+,
+        # or nil when there is none. An empty match also gives nil, so that
+        # #substitute stops rather than loop on it.
+        def find_match(pattern, from)
+          match = text_nodes.map(&:content).join.match(pattern, from)
+          match unless match.nil? || match[0].empty?
+        end
+
+        # Replace the characters in +range+ of the paragraph text with +string+.
+        # The string goes into the w:t holding the range's first character; the
+        # rest of the range is cut from the following w:t, and line breaks and
+        # tabs inside it are removed.
+        def replace_text_range(range, string)
+          texts = text_nodes
+          # boundaries[i]...boundaries[i + 1] is where texts[i] sits in the text
+          boundaries = texts.each_with_object([0]) { |text, acc| acc << acc.last + text.content.length }
+          first = texts.each_index.find { |i| boundaries[i + 1] > range.begin }
+          last  = texts.each_index.find { |i| boundaries[i + 1] >= range.end }
+
+          head = texts[first].content[0...(range.begin - boundaries[first])]
+          tail = texts[last].content[(range.end - boundaries[last])..]
+          if first == last
+            texts[first].content = head + string + tail
+            return
+          end
+
+          texts[first].content = head + string
+          texts[(first + 1)...last].each { |text| text.content = '' }
+          texts[last].content = tail
+          remove_separators_between(texts[first].node, texts[last].node, TEXT_XPATH, SEPARATOR_XPATH)
+        end
+
         def style_property
           properties&.at_xpath('w:pStyle') || properties&.add_child('<w:pStyle/>').first
         end

data/lib/docx/containers/text_run.rb

@@ -14,6 +14,12 @@ module Docx
           strike: false
         }
 
+        # The w:t of the run, or of the runs of a hyperlink, in document order.
+        TEXT_XPATH = 'w:t|w:r/w:t'
+        # Line breaks and tabs that sit between those w:t.
+        SEPARATOR_XPATH = %w[br tab cr].map { |tag| "w:#{tag}|w:r/w:#{tag}" }.join('|')
+        private_constant :TEXT_XPATH, :SEPARATOR_XPATH
+
         def self.tag
           'r'
         end
@@ -23,8 +29,7 @@ module Docx
 
         def initialize(node, document_properties = {})
           @node = node
-          @text_nodes = @node.xpath('w:t').map {|t_node| Elements::Text.new(t_node) }
-          @text_nodes = @node.xpath('w:t|w:r/w:t').map {|t_node| Elements::Text.new(t_node) }
+          @text_nodes = @node.xpath(TEXT_XPATH).map {|t_node| Elements::Text.new(t_node) }
 
           @properties_tag = 'rPr'
           @text       = parse_text || ''
@@ -33,14 +38,28 @@ module Docx
           @font_size = @document_properties[:font_size]
         end
 
-        # Set text of text run
+        # Set text of text run.
+        #
+        # The text from the first through the last w:t is replaced: the content
+        # goes into the first w:t, and the other w:t and the line breaks and
+        # tabs between them are removed (#text never includes breaks or tabs,
+        # so a plain string cannot say where they belong). Anything before the
+        # first or after the last w:t, such as a trailing page break, is kept.
+        # To replace part of a paragraph while keeping its line breaks in place,
+        # use Paragraph#substitute.
         def text=(content)
-          if @text_nodes.size == 1
-            @text_nodes.first.content = content
-          elsif @text_nodes.empty?
+          if @text_nodes.empty?
             new_t = Elements::Text.create_within(self)
             new_t.content = content
             @text_nodes << new_t
+          else
+            first, *rest = @text_nodes
+            first.content = content
+            unless rest.empty?
+              remove_separators_between(first.node, rest.last.node, TEXT_XPATH, SEPARATOR_XPATH)
+              rest.each { |text_node| text_node.node.remove }
+              @text_nodes = [first]
+            end
           end
           reset_text
         end

data/lib/docx/elements/bookmark.rb

@@ -17,14 +17,12 @@ module Docx
 
       # Insert text before bookmarkStart node
       def insert_text_before(text)
-        text_run = get_run_before
-        text_run.text = "#{text_run.text}#{text}"
+        append_to_run(get_run_before, text)
       end
 
       # Insert text after bookmarkStart node
       def insert_text_after(text)
-        text_run = get_run_after
-        text_run.text = "#{text}#{text_run.text}"
+        prepend_to_run(get_run_after, text)
       end
 
       # insert multiple lines starting with paragraph containing bookmark node.
@@ -103,6 +101,38 @@ module Docx
 
       private
 
+      # A run's text, line breaks and tabs, in document order.
+      RUN_CONTENT_XPATH = 'w:t|w:br|w:tab|w:cr'
+      private_constant :RUN_CONTENT_XPATH
+
+      # Add text at the very end of the run, which sits just before the
+      # bookmark: to its last w:t, or to a new w:t when the run ends with a
+      # break or tab. The rest of the run is left as it is (#197).
+      def append_to_run(run, text)
+        last = run.node.xpath(RUN_CONTENT_XPATH).last
+        if last && run.node.xpath('w:t').include?(last)
+          Text.new(last).content = last.content + text
+        else
+          Text.create_within(run).content = text
+        end
+      end
+
+      # Add text at the very start of the run, which sits just after the
+      # bookmark: to its first w:t, or to a new w:t when the run starts with
+      # a break or tab. The rest of the run is left as it is (#197).
+      def prepend_to_run(run, text)
+        first = run.node.xpath(RUN_CONTENT_XPATH).first
+        if first && run.node.xpath('w:t').include?(first)
+          Text.new(first).content = text + first.content
+        elsif first
+          new_t = Text.create_with(run)
+          new_t.node = first.add_previous_sibling(new_t.node)
+          new_t.content = text
+        else
+          Text.create_within(run).content = text
+        end
+      end
+
       # The w:p the bookmark sits inside, or nil when it is block-level.
       def enclosing_paragraph
         @node.at_xpath("./parent::w:p")

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/version.rb

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

metadata

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