docx 0.13.2 → 0.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db1fd167dc6ddfecc81518f27cd78fc203d74738ffe52b2877251b2ed291c297
-  data.tar.gz: 7c2f230a44f18ceffffcbbfa55d212ebdd2a58651823aa78d303cc64493aa461
+  metadata.gz: a6559deefb9d0bfae3c8101274040ebf8968827360a3f871d2f1d23440e6bbcb
+  data.tar.gz: 4ad8c35b486f9fb9aeac833f78f9425dbac5364f4c1d0d16e168685434695210
 SHA512:
-  metadata.gz: 6e1af62546207b59b6b2bcd193c83aaafc11258dcb50d7c52bcd2251b77552704b39d5667a709cdc9fdd005c37e00e3530acd9fb88df565ba10db361d6032d98
-  data.tar.gz: 7d753f33adc0795e12cea763d32e01d4cf76777d1cf7f5c8d815991efccfd0ede2b513a7a99c5558824e972e17ffd86460f661d87f7003dd916cca2cdbc06498
+  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

@@ -88,41 +88,12 @@ module Docx
         # See https://github.com/ruby-docx/docx/issues/147 and #187
         def substitute(pattern, replacement)
           search_from = 0
-          loop do
-            texts = @node.xpath(TEXT_XPATH).map { |t_node| Elements::Text.new(t_node) }
-
-            offsets = []
-            cursor = 0
-            texts.each do |text|
-              offsets << cursor
-              cursor += text.content.length
-            end
-            full_text = texts.map(&:content).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
-            # 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 }
-
+          while (match = find_match(pattern, search_from))
             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
+            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
@@ -181,13 +152,41 @@ module Docx
         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) }
+        # 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

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

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

metadata

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