docx-parser 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc8f13a3627d0f0616472ac34111777cdd98ed11b54f147f3043b72044121e8d
+  data.tar.gz: 0e820cb74de1e3e33ea23073352f8db22e081d6a2eb2ffa8468e14b91e7fdf05
+SHA512:
+  metadata.gz: b7ee4968132be5bba2e7424cde9b6cf71ef7f17e095a4ee13e3e7d43d69ee797817b9d7ac183e189e00dd7e124a10a261e70ff49b4aebcb907e1184e6e58041c
+  data.tar.gz: 80d8a1291c07b6284ecb49e37a4496576c52331b35448c2db34357a45c1d7eea2c377ce5a928620a1ade604e15abdbfbfe817f24bcd6a18779c1d564e9a51b41

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Marcus Ortiz, http://marcusortiz.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,192 @@
+# docx
+
+[![Gem Version](https://badge.fury.io/rb/docx.svg)](https://badge.fury.io/rb/docx)
+[![Ruby](https://github.com/ruby-docx/docx/workflows/Ruby/badge.svg)](https://github.com/ruby-docx/docx/actions?query=workflow%3ARuby)
+[![Coverage Status](https://coveralls.io/repos/github/ruby-docx/docx/badge.svg?branch=master)](https://coveralls.io/github/ruby-docx/docx?branch=master)
+[![Gitter](https://badges.gitter.im/ruby-docx/community.svg)](https://gitter.im/ruby-docx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+A ruby library/gem for interacting with `.docx` files. currently capabilities include reading paragraphs/bookmarks, inserting text at bookmarks, reading tables/rows/columns/cells and saving the document.
+
+## Usage
+
+### Prerequisites
+
+- Ruby 2.5 or later
+
+### Install
+
+Add the following line to your application's Gemfile:
+
+```ruby
+gem 'docx'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+Or install it yourself as:
+
+```shell
+gem install docx
+```
+
+### Reading
+
+``` ruby
+require 'docx'
+
+# Create a Docx::Document object for our existing docx file
+doc = Docx::Document.open('example.docx')
+
+# Retrieve and display paragraphs
+doc.paragraphs.each do |p|
+  puts p
+end
+
+# Retrieve and display bookmarks, returned as hash with bookmark names as keys and objects as values
+doc.bookmarks.each_pair do |bookmark_name, bookmark_object|
+  puts bookmark_name
+end
+```
+
+Don't have a local file but a buffer? Docx handles those to:
+
+```ruby
+require 'docx'
+
+# Create a Docx::Document object from a remote file
+doc = Docx::Document.open(buffer)
+
+# Everything about reading is the same as shown above
+```
+
+### Rendering html
+``` ruby
+require 'docx'
+
+# Retrieve and display paragraphs as html
+doc = Docx::Document.open('example.docx')
+doc.paragraphs.each do |p|
+  puts p.to_html
+end
+```
+
+### Reading tables
+
+``` ruby
+require 'docx'
+
+# Create a Docx::Document object for our existing docx file
+doc = Docx::Document.open('tables.docx')
+
+first_table = doc.tables[0]
+puts first_table.row_count
+puts first_table.column_count
+puts first_table.rows[0].cells[0].text
+puts first_table.columns[0].cells[0].text
+
+# Iterate through tables
+doc.tables.each do |table|
+  table.rows.each do |row| # Row-based iteration
+    row.cells.each do |cell|
+      puts cell.text
+    end
+  end
+
+  table.columns.each do |column| # Column-based iteration
+    column.cells.each do |cell|
+      puts cell.text
+    end
+  end
+end
+```
+
+### Writing
+
+``` ruby
+require 'docx'
+
+# Create a Docx::Document object for our existing docx file
+doc = Docx::Document.open('example.docx')
+
+# Insert a single line of text after one of our bookmarks
+doc.bookmarks['example_bookmark'].insert_text_after("Hello world.")
+
+# Insert multiple lines of text at our bookmark
+doc.bookmarks['example_bookmark_2'].insert_multiple_lines_after(['Hello', 'World', 'foo'])
+
+# Remove paragraphs
+doc.paragraphs.each do |p|
+  p.remove! if p.to_s =~ /TODO/
+end
+
+# Substitute text, preserving formatting
+doc.paragraphs.each do |p|
+  p.each_text_run do |tr|
+    tr.substitute('_placeholder_', 'replacement value')
+  end
+end
+
+# Save document to specified path
+doc.save('example-edited.docx')
+```
+
+### Writing to tables
+
+``` ruby
+require 'docx'
+
+# Create a Docx::Document object for our existing docx file
+doc = Docx::Document.open('tables.docx')
+
+# Iterate over each table
+doc.tables.each do |table|
+  last_row = table.rows.last
+  
+  # Copy last row and insert a new one before last row
+  new_row = last_row.copy
+  new_row.insert_before(last_row)
+
+  # Substitute text in each cell of this new row
+  new_row.cells.each do |cell|
+    cell.paragraphs.each do |paragraph|
+      paragraph.each_text_run do |text|
+        text.substitute('_placeholder_', 'replacement value')
+      end
+    end
+  end
+end
+
+doc.save('tables-edited.docx')
+```
+
+### Advanced
+
+``` ruby
+require 'docx'
+
+d = Docx::Document.open('example.docx')
+
+# The Nokogiri::XML::Node on which an element is based can be accessed using #node
+d.paragraphs.each do |p|
+  puts p.node.inspect
+end
+
+# The #xpath and #at_xpath methods are delegated to the node from the element, saving a step
+p_element = d.paragraphs.first
+p_children = p_element.xpath("//child::*") # selects all children
+p_child = p_element.at_xpath("//child::*") # selects first child
+```
+
+## Development
+
+### todo
+
+* Calculate element formatting based on values present in element properties as well as properties inherited from parents
+* Default formatting of inserted elements to inherited values
+* Implement formattable elements.
+* Implement styles.
+* Easier multi-line text insertion at a single bookmark (inserting paragraph nodes after the one containing the bookmark)

data/lib/docx/containers/container.rb

@@ -0,0 +1,24 @@
+require 'docx/elements'
+
+module Docx
+  module Elements
+    module Containers
+      module Container
+        # Relation methods
+        # TODO: Create a properties object, include Element
+        def properties
+          @node.at_xpath("./#{@properties_tag}")
+        end
+
+        # Erase text within an element
+        def blank!
+          @node.xpath(".//w:t").each {|t| t.content = '' }
+        end
+
+        def remove!
+          @node.remove
+        end
+      end
+    end
+  end
+end

data/lib/docx/containers/paragraph.rb

@@ -0,0 +1,96 @@
+require 'docx/containers/text_run'
+require 'docx/containers/container'
+
+module Docx
+  module Elements
+    module Containers
+      class Paragraph
+        include Container
+        include Elements::Element
+
+        def self.tag
+          'p'
+        end
+
+
+        # Child elements: pPr, r, fldSimple, hlink, subDoc
+        # http://msdn.microsoft.com/en-us/library/office/ee364458(v=office.11).aspx
+        def initialize(node, document_properties = {})
+          @node = node
+          @properties_tag = 'pPr'
+          @document_properties = document_properties
+          @font_size = @document_properties[:font_size]
+        end
+
+        # Set text of paragraph
+        def text=(content)
+          if text_runs.size == 1
+            text_runs.first.text = content
+          elsif text_runs.size == 0
+            new_r = TextRun.create_within(self)
+            new_r.text = content
+          else
+            text_runs.each {|r| r.node.remove }
+            new_r = TextRun.create_within(self)
+            new_r.text = content
+          end
+        end
+
+        # Return text of paragraph
+        def to_s
+          text_runs.map(&:text).join('')
+        end
+
+        # Return paragraph as a <p></p> HTML fragment with formatting based on properties.
+        def to_html
+          html = ''
+          text_runs.each do |text_run|
+            html << text_run.to_html
+          end
+          styles = { 'font-size' => "#{font_size}pt" }
+          styles['text-align'] = alignment if alignment
+          html_tag(:p, content: html, styles: styles)
+        end
+
+
+        # Array of text runs contained within paragraph
+        def text_runs
+          @node.xpath('w:r|w:hyperlink').map { |r_node| Containers::TextRun.new(r_node, @document_properties) }
+        end
+
+        # Iterate over each text run within a paragraph
+        def each_text_run
+          text_runs.each { |tr| yield(tr) }
+        end
+
+        def aligned_left?
+          ['left', nil].include?(alignment)
+        end
+
+        def aligned_right?
+          alignment == 'right'
+        end
+
+        def aligned_center?
+          alignment == 'center'
+        end
+
+        def font_size
+          size_tag = @node.xpath('w:pPr//w:sz').first
+          size_tag ? size_tag.attributes['val'].value.to_i / 2 : @font_size
+        end
+        
+        alias_method :text, :to_s
+
+        private
+
+        # Returns the alignment if any, or nil if left
+        def alignment
+          alignment_tag = @node.xpath('.//w:jc').first
+          alignment_tag ? alignment_tag.attributes['val'].value : nil
+        end
+
+      end
+    end
+  end
+end

data/lib/docx/containers/table.rb

@@ -0,0 +1,51 @@
+require 'docx/containers/table_row'
+require 'docx/containers/table_column'
+require 'docx/containers/container'
+
+module Docx
+  module Elements
+    module Containers
+      class Table
+        include Container
+        include Elements::Element
+
+        def self.tag
+          'tbl'
+        end
+
+        def initialize(node)
+          @node = node
+          @properties_tag = 'tblGrid'
+        end
+
+        # Array of row
+        def rows
+          @node.xpath('w:tr').map {|r_node| Containers::TableRow.new(r_node) }
+        end
+
+        def row_count
+          @node.xpath('w:tr').count
+        end
+
+        # Array of column
+        def columns
+          columns_containers = []
+          (0..(column_count-1)).each do |i|
+            columns_containers[i] = Containers::TableColumn.new @node.xpath("w:tr//w:tc[#{i+1}]")
+          end
+          columns_containers
+        end
+
+        def column_count
+          @node.xpath('w:tblGrid/w:gridCol').count
+        end
+
+        # Iterate over each row within a table
+        def each_rows
+          rows.each { |r| yield(r) }
+        end
+        
+      end
+    end
+  end
+end

data/lib/docx/containers/table_cell.rb

@@ -0,0 +1,39 @@
+require 'docx/containers/text_run'
+require 'docx/containers/container'
+
+module Docx
+  module Elements
+    module Containers
+      class TableCell
+        include Container
+        include Elements::Element
+
+        def self.tag
+          'tc'
+        end
+
+        def initialize(node)
+          @node = node
+          @properties_tag = 'tcPr'
+        end
+
+        # Return text of paragraph's cell
+        def to_s
+          paragraphs.map(&:text).join('')
+        end
+
+        # Array of paragraphs contained within cell
+        def paragraphs
+          @node.xpath('w:p').map {|p_node| Containers::Paragraph.new(p_node) }
+        end
+
+        # Iterate over each text run within a paragraph's cell
+        def each_paragraph
+          paragraphs.each { |tr| yield(tr) }
+        end
+        
+        alias_method :text, :to_s
+      end
+    end
+  end
+end

data/lib/docx/containers/table_column.rb

@@ -0,0 +1,29 @@
+require 'docx/containers/table_cell'
+require 'docx/containers/container'
+
+module Docx
+  module Elements
+    module Containers
+      class TableColumn
+        include Container
+        include Elements::Element
+
+        def self.tag
+          'w:gridCol'
+        end
+
+        def initialize(cell_nodes)
+          @node = ''
+          @properties_tag = ''
+          @cells = cell_nodes.map { |c_node| Containers::TableCell.new(c_node) }
+        end
+
+        # Array of cells contained within row
+        def cells
+          @cells
+        end
+        
+      end
+    end
+  end
+end

data/lib/docx/containers/table_row.rb

@@ -0,0 +1,28 @@
+require 'docx/containers/table_cell'
+require 'docx/containers/container'
+
+module Docx
+  module Elements
+    module Containers
+      class TableRow
+        include Container
+        include Elements::Element
+
+        def self.tag
+          'tr'
+        end
+
+        def initialize(node)
+          @node = node
+          @properties_tag = ''
+        end
+
+        # Array of cells contained within row
+        def cells
+          @node.xpath('w:tc').map {|c_node| Containers::TableCell.new(c_node) }
+        end
+        
+      end
+    end
+  end
+end

data/lib/docx/containers/text_run.rb

@@ -0,0 +1,115 @@
+require 'docx/containers/container'
+
+module Docx
+  module Elements
+    module Containers
+      class TextRun
+        include Container
+        include Elements::Element
+
+        DEFAULT_FORMATTING = {
+          italic:    false,
+          bold:      false,
+          underline: false
+        }
+        
+        def self.tag
+          'r'
+        end
+
+        attr_reader :text
+        attr_reader :formatting
+        attr_reader :text_nodes
+        
+        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) }
+
+          @properties_tag = 'rPr'
+          @text       = parse_text || ''
+          @formatting = parse_formatting || DEFAULT_FORMATTING
+          @document_properties = document_properties
+          @font_size = @document_properties[:font_size]
+        end
+
+        # Set text of text run
+        def text=(content)
+          if @text_nodes.size == 1
+            @text_nodes.first.content = content
+          elsif @text_nodes.empty?
+            new_t = Elements::Text.create_within(self)
+            new_t.content = content
+          end
+        end
+
+        # Returns text contained within text run
+        def parse_text
+          @text_nodes.map(&:content).join('')
+        end
+
+        # Substitute text in text @text_nodes
+        def substitute(match, replacement)
+          @text_nodes.each do |text_node|
+            text_node.content = text_node.content.gsub(match, replacement)
+          end
+        end
+
+        def parse_formatting
+          {
+            italic:    !@node.xpath('.//w:i').empty?,
+            bold:      !@node.xpath('.//w:b').empty?,
+            underline: !@node.xpath('.//w:u').empty?
+          }
+        end
+
+        def to_s
+          @text
+        end
+
+        # Return text as a HTML fragment with formatting based on properties.
+        def to_html
+          html = @text
+          html = html_tag(:em, content: html) if italicized?
+          html = html_tag(:strong, content: html) if bolded?
+          styles = {}
+          styles['text-decoration'] = 'underline' if underlined?
+          # No need to be granular with font size down to the span level if it doesn't vary.
+          styles['font-size'] = "#{font_size}pt" if font_size != @font_size 
+          html = html_tag(:span, content: html, styles: styles) unless styles.empty?
+          html = html_tag(:a, content: html, attributes: {href: href, target: "_blank"}) if hyperlink?
+          return html
+        end
+
+        def italicized?
+          @formatting[:italic]
+        end
+        
+        def bolded?
+          @formatting[:bold]
+        end
+        
+        def underlined?
+          @formatting[:underline]
+        end
+
+        def hyperlink?
+          @node.name == 'hyperlink'
+        end
+
+        def href
+          @document_properties[:hyperlinks][hyperlink_id]
+        end
+
+        def hyperlink_id
+          @node.attributes['id'].value
+        end        
+
+        def font_size
+          size_tag = @node.xpath('w:rPr//w:sz').first
+          size_tag ? size_tag.attributes['val'].value.to_i / 2 : @font_size
+        end
+      end
+    end
+  end
+end

data/lib/docx/containers.rb

@@ -0,0 +1,4 @@
+require 'docx/containers/container'
+require 'docx/containers/text_run'
+require 'docx/containers/paragraph'
+require 'docx/containers/table'

data/lib/docx/core_ext/module.rb

@@ -0,0 +1,172 @@
+unless Object.const_defined?("ActiveSupport")
+  class Module
+    # Provides a delegate class method to easily expose contained objects' public methods
+    # as your own. Pass one or more methods (specified as symbols or strings)
+    # and the name of the target object via the <tt>:to</tt> option (also a symbol
+    # or string). At least one method and the <tt>:to</tt> option are required.
+    #
+    # Delegation is particularly useful with Active Record associations:
+    #
+    #   class Greeter < ActiveRecord::Base
+    #     def hello
+    #       'hello'
+    #     end
+    #
+    #     def goodbye
+    #       'goodbye'
+    #     end
+    #   end
+    #
+    #   class Foo < ActiveRecord::Base
+    #     belongs_to :greeter
+    #     delegate :hello, to: :greeter
+    #   end
+    #
+    #   Foo.new.hello   # => "hello"
+    #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+    #
+    # Multiple delegates to the same target are allowed:
+    #
+    #   class Foo < ActiveRecord::Base
+    #     belongs_to :greeter
+    #     delegate :hello, :goodbye, to: :greeter
+    #   end
+    #
+    #   Foo.new.goodbye # => "goodbye"
+    #
+    # Methods can be delegated to instance variables, class variables, or constants
+    # by providing them as a symbols:
+    #
+    #   class Foo
+    #     CONSTANT_ARRAY = [0,1,2,3]
+    #     @@class_array  = [4,5,6,7]
+    #
+    #     def initialize
+    #       @instance_array = [8,9,10,11]
+    #     end
+    #     delegate :sum, to: :CONSTANT_ARRAY
+    #     delegate :min, to: :@@class_array
+    #     delegate :max, to: :@instance_array
+    #   end
+    #
+    #   Foo.new.sum # => 6
+    #   Foo.new.min # => 4
+    #   Foo.new.max # => 11
+    #
+    # It's also possible to delegate a method to the class by using +:class+:
+    #
+    #   class Foo
+    #     def self.hello
+    #       "world"
+    #     end
+    #
+    #     delegate :hello, to: :class
+    #   end
+    #
+    #   Foo.new.hello # => "world"
+    #
+    # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+    # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+    # delegated to.
+    #
+    #   Person = Struct.new(:name, :address)
+    #
+    #   class Invoice < Struct.new(:client)
+    #     delegate :name, :address, to: :client, prefix: true
+    #   end
+    #
+    #   john_doe = Person.new('John Doe', 'Vimmersvej 13')
+    #   invoice = Invoice.new(john_doe)
+    #   invoice.client_name    # => "John Doe"
+    #   invoice.client_address # => "Vimmersvej 13"
+    #
+    # It is also possible to supply a custom prefix.
+    #
+    #   class Invoice < Struct.new(:client)
+    #     delegate :name, :address, to: :client, prefix: :customer
+    #   end
+    #
+    #   invoice = Invoice.new(john_doe)
+    #   invoice.customer_name    # => 'John Doe'
+    #   invoice.customer_address # => 'Vimmersvej 13'
+    #
+    # If the delegate object is +nil+ an exception is raised, and that happens
+    # no matter whether +nil+ responds to the delegated method. You can get a
+    # +nil+ instead with the +:allow_nil+ option.
+    #
+    #   class Foo
+    #     attr_accessor :bar
+    #     def initialize(bar = nil)
+    #       @bar = bar
+    #     end
+    #     delegate :zoo, to: :bar
+    #   end
+    #
+    #   Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+    #
+    #   class Foo
+    #     attr_accessor :bar
+    #     def initialize(bar = nil)
+    #       @bar = bar
+    #     end
+    #     delegate :zoo, to: :bar, allow_nil: true
+    #   end
+    #
+    #   Foo.new.zoo   # returns nil
+    def delegate(*methods)
+      options = methods.pop
+      unless options.is_a?(Hash) && to = options[:to]
+        raise ArgumentError, 'Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
+      end
+
+      prefix, allow_nil = options.values_at(:prefix, :allow_nil)
+
+      if prefix == true && to =~ /^[^a-z_]/
+        raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
+      end
+
+      method_prefix = \
+        if prefix
+          "#{prefix == true ? to : prefix}_"
+        else
+          ''
+        end
+
+      file, line = caller.first.split(':', 2)
+      line = line.to_i
+
+      to = to.to_s
+      to = 'self.class' if to == 'class'
+
+      methods.each do |method|
+        # Attribute writer methods only accept one argument. Makes sure []=
+        # methods still accept two arguments.
+        definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
+
+        if allow_nil
+          module_eval(<<-EOS, file, line - 2)
+            def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
+              if #{to} || #{to}.respond_to?(:#{method})         #   if client || client.respond_to?(:name)
+                #{to}.#{method}(#{definition})                  #     client.name(*args, &block)
+              end                                               #   end
+            end                                                 # end
+          EOS
+        else
+          exception = %(raise "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+
+          module_eval(<<-EOS, file, line - 1)
+            def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
+              #{to}.#{method}(#{definition})                    #   client.name(*args, &block)
+            rescue NoMethodError                                # rescue NoMethodError
+              if #{to}.nil?                                     #   if client.nil?
+                #{exception}                                    #     # add helpful message to the exception
+              else                                              #   else
+                raise                                           #     raise
+              end                                               #   end
+            end                                                 # end
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/docx/document.rb

@@ -0,0 +1,208 @@
+require 'docx/containers'
+require 'docx/elements'
+require 'nokogiri'
+require 'zip'
+
+module Docx
+  # The Document class wraps around a docx file and provides methods to
+  # interface with it.
+  #
+  #   # get a Docx::Document for a docx file in the local directory
+  #   doc = Docx::Document.open("test.docx")
+  #
+  #   # get the text from the document
+  #   puts doc.text
+  #
+  #   # do the same thing in a block
+  #   Docx::Document.open("test.docx") do |d|
+  #     puts d.text
+  #   end
+  class Document
+    attr_reader :xml, :doc, :zip, :styles
+
+    def initialize(path_or_io, options = {})
+      @replace = {}
+
+      # if path-or_io is string && does not contain a null byte
+      if (path_or_io.instance_of?(String) && !/\u0000/.match?(path_or_io))
+        @zip = Zip::File.open(path_or_io)
+      else
+        @zip = Zip::File.open_buffer(path_or_io)
+      end
+
+      document = @zip.glob('word/document*.xml').first
+      raise Errno::ENOENT if document.nil?
+
+      @document_xml = document.get_input_stream.read
+      @doc = Nokogiri::XML(@document_xml)
+      load_styles
+      yield(self) if block_given?
+    ensure
+      @zip.close
+    end
+
+    # This stores the current global document properties, for now
+    def document_properties
+      {
+        font_size: font_size,
+        hyperlinks: hyperlinks
+      }
+    end
+
+    # With no associated block, Docx::Document.open is a synonym for Docx::Document.new. If the optional code block is given, it will be passed the opened +docx+ file as an argument and the Docx::Document oject will automatically be closed when the block terminates. The values of the block will be returned from Docx::Document.open.
+    # call-seq:
+    #   open(filepath) => file
+    #   open(filepath) {|file| block } => obj
+    def self.open(path, &block)
+      new(path, &block)
+    end
+
+    def paragraphs
+      @doc.xpath('//w:document//w:body/w:p').map { |p_node| parse_paragraph_from p_node }
+    end
+
+    def bookmarks
+      bkmrks_hsh = {}
+      bkmrks_ary = @doc.xpath('//w:bookmarkStart').map { |b_node| parse_bookmark_from b_node }
+      # auto-generated by office 2010
+      bkmrks_ary.reject! { |b| b.name == '_GoBack' }
+      bkmrks_ary.each { |b| bkmrks_hsh[b.name] = b }
+      bkmrks_hsh
+    end
+
+    def tables
+      @doc.xpath('//w:document//w:body//w:tbl').map { |t_node| parse_table_from t_node }
+    end
+
+    # Some documents have this set, others don't.
+    # Values are returned as half-points, so to get points, that's why it's divided by 2.
+    def font_size
+      return nil unless @styles
+
+      size_tag = @styles.xpath('//w:docDefaults//w:rPrDefault//w:rPr//w:sz').first
+      size_tag ? size_tag.attributes['val'].value.to_i / 2 : nil
+    end
+
+    # Hyperlink targets are extracted from the document.xml.rels file
+    def hyperlinks
+      hyperlink_relationships.each_with_object({}) do |rel, hash|
+        hash[rel.attributes['Id'].value] = rel.attributes['Target'].value
+      end
+    end
+
+    def hyperlink_relationships
+      @rels.xpath("//xmlns:Relationship[contains(@Type,'hyperlink')]")
+    end
+
+    ##
+    # *Deprecated*
+    #
+    # Iterates over paragraphs within document
+    # call-seq:
+    #   each_paragraph => Enumerator
+    def each_paragraph
+      paragraphs.each { |p| yield(p) }
+    end
+
+    # call-seq:
+    #   to_s -> string
+    def to_s
+      paragraphs.map(&:to_s).join("\n")
+    end
+
+    # Output entire document as a String HTML fragment
+    def to_html
+      paragraphs.map(&:to_html).join("\n")
+    end
+
+    # Save document to provided path
+    # call-seq:
+    #   save(filepath) => void
+    def save(path)
+      update
+      Zip::OutputStream.open(path) do |out|
+        zip.each do |entry|
+          next unless entry.file?
+
+          out.put_next_entry(entry.name)
+
+          if @replace[entry.name]
+            out.write(@replace[entry.name])
+          else
+            out.write(zip.read(entry.name))
+          end
+        end
+      end
+      zip.close
+    end
+
+    # Output entire document as a StringIO object
+    def stream
+      update
+      stream = Zip::OutputStream.write_buffer do |out|
+        zip.each do |entry|
+          next unless entry.file?
+
+          out.put_next_entry(entry.name)
+
+          if @replace[entry.name]
+            out.write(@replace[entry.name])
+          else
+            out.write(zip.read(entry.name))
+          end
+        end
+      end
+
+      stream.rewind
+      stream
+    end
+
+    alias text to_s
+
+    def replace_entry(entry_path, file_contents)
+      @replace[entry_path] = file_contents
+    end
+
+    private
+
+    def load_styles
+      @styles_xml = @zip.read('word/styles.xml')
+      @styles = Nokogiri::XML(@styles_xml)
+      load_rels
+    rescue Errno::ENOENT => e
+      warn e.message
+      nil
+    end
+
+    def load_rels
+      rels_entry = @zip.glob('word/_rels/document*.xml.rels').first
+      raise Errno::ENOENT unless rels_entry
+
+      @rels_xml = rels_entry.get_input_stream.read
+      @rels = Nokogiri::XML(@rels_xml)
+    end
+
+    #--
+    # TODO: Flesh this out to be compatible with other files
+    # TODO: Method to set flag on files that have been edited, probably by inserting something at the
+    # end of methods that make edits?
+    #++
+    def update
+      replace_entry 'word/document.xml', doc.serialize(save_with: 0)
+    end
+
+    # generate Elements::Containers::Paragraph from paragraph XML node
+    def parse_paragraph_from(p_node)
+      Elements::Containers::Paragraph.new(p_node, document_properties)
+    end
+
+    # generate Elements::Bookmark from bookmark XML node
+    def parse_bookmark_from(b_node)
+      Elements::Bookmark.new(b_node)
+    end
+
+    def parse_table_from(t_node)
+      Elements::Containers::Table.new(t_node)
+    end
+  end
+end

data/lib/docx/elements/bookmark.rb

@@ -0,0 +1,79 @@
+require 'docx/elements/element'
+
+module Docx
+  module Elements
+    class Bookmark
+      include Element
+      attr_accessor :name
+
+      def self.tag
+        'bookmarkStart'
+      end
+
+      def initialize(node)
+        @node = node
+        @name = @node['w:name']
+      end
+
+      # Insert text before bookmarkStart node
+      def insert_text_before(text)
+        text_run = get_run_before
+        text_run.text = "#{text_run.text}#{text}"
+      end
+
+      # Insert text after bookmarkStart node
+      def insert_text_after(text)
+        text_run = get_run_after
+        text_run.text = "#{text}#{text_run.text}"
+      end
+
+      # insert multiple lines starting with paragraph containing bookmark node.
+      def insert_multiple_lines(text_array)
+        # Hold paragraphs to be inserted into, corresponding to the index of the strings in the text array
+        paragraphs = []
+        paragraph = self.parent_paragraph
+        # Remove text from paragraph
+        paragraph.blank!
+        paragraphs << paragraph
+        for i in 0...(text_array.size - 1)
+          # Copy previous paragraph
+          new_p = paragraphs[i].copy
+          # Insert as sibling of previous paragraph
+          new_p.insert_after(paragraphs[i])
+          paragraphs << new_p
+        end
+
+        # Insert text into corresponding newly created paragraphs
+        paragraphs.each_index do |index|
+          paragraphs[index].text = text_array[index]
+        end
+      end
+
+      # 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
+          new_r = Containers::TextRun.create_with(self)
+          new_r.insert_before(self)
+          new_r
+        end
+      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
+          new_r = Containers::TextRun.create_with(self)
+          new_r.insert_after(self)
+          new_r
+        end
+      end
+    end
+  end
+end

data/lib/docx/elements/element.rb

@@ -0,0 +1,105 @@
+require 'nokogiri'
+require 'docx/elements'
+require 'docx/containers'
+
+module Docx
+  module Elements
+    module Element
+      DEFAULT_TAG = ''
+
+      # Ensure that a 'tag' corresponding to the XML element that defines the element is defined
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.const_set(:TAG, Element::DEFAULT_TAG) unless base.const_defined?(:TAG)
+      end
+
+      attr_accessor :node
+      delegate :at_xpath, :xpath, :to => :@node
+
+      # TODO: Should create a docx object from this
+      def parent(type = '*')
+        @node.at_xpath("./parent::#{type}")
+      end
+
+      # Get parent paragraph of element
+      def parent_paragraph
+        Elements::Containers::Paragraph.new(parent('w:p'))
+      end
+
+      # Insertion methods
+      # Insert node as last child
+      def append_to(element)
+        @node = element.node.add_child(@node)
+        self
+      end
+
+      # Insert node as first child (after properties)
+      def prepend_to(element)
+        @node = element.node.properties.add_next_sibling(@node)
+        self
+      end
+
+      def insert_after(element)
+        # Returns newly re-parented node
+        @node = element.node.add_next_sibling(@node)
+        self
+      end
+
+      def insert_before(element)
+        @node = element.node.add_previous_sibling(@node)
+        self
+      end
+
+      # Creation/edit methods
+      def copy
+        self.class.new(@node.dup)
+      end
+
+      # A method to wrap content in an HTML tag.
+      # Currently used in paragraph and text_run for the to_html methods
+      #
+      # content:: The base text content for the tag.
+      # styles:: Hash of the inline CSS styles to be applied. e.g.
+      #          { 'font-size' => '12pt', 'text-decoration' => 'underline' }
+      #
+      def html_tag(name, options = {})
+        content = options[:content]
+        styles = options[:styles]
+        attributes = options[:attributes]
+
+        html = "<#{name.to_s}"
+        
+        unless styles.nil? || styles.empty?
+          styles_array = []
+          styles.each do |property, value|
+            styles_array << "#{property.to_s}:#{value};"
+          end
+          html << " style=\"#{styles_array.join('')}\""
+        end
+        
+        unless attributes.nil? || attributes.empty?
+          attributes.each do |attr_name, attr_value|
+            html << " #{attr_name}=\"#{attr_value}\""
+          end
+        end
+        
+        html << ">"
+        html << content if content
+        html << "</#{name.to_s}>"
+      end
+
+      module ClassMethods
+        def create_with(element)
+          # Need to somehow get the xml document accessible here by default, but this is alright in the interim
+          self.new(Nokogiri::XML::Node.new("w:#{self.tag}", element.node))
+        end
+
+        def create_within(element)
+          new_element = create_with(element)
+          new_element.append_to(element)
+          new_element
+        end
+      end
+    end
+  end
+end

data/lib/docx/elements/text.rb

@@ -0,0 +1,17 @@
+module Docx
+  module Elements
+    class Text
+      include Element
+      delegate :content, :content=, :to => :@node
+
+      def self.tag
+        't'
+      end
+
+
+      def initialize(node)
+        @node = node
+      end
+    end
+  end
+end

data/lib/docx/elements.rb

@@ -0,0 +1,3 @@
+require 'docx/elements/bookmark'
+require 'docx/elements/element'
+require 'docx/elements/text'

data/lib/docx/version.rb

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

data/lib/docx.rb

@@ -0,0 +1,7 @@
+require 'docx/version'
+
+module Docx #:nodoc:
+  autoload :Document, 'docx/document'
+end
+
+require 'docx/core_ext/module'

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: docx-parser
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Christopher Hunt
+- Marcus Ortiz
+- Higgins Dragon
+- Toms Mikoss
+- Sebastian Wittenkamp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.4
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls_reborn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: thin wrapper around rubyzip and nokogiri as a way to get started with
+  docx files
+email:
+- jd.martinez1062@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/docx.rb
+- lib/docx/containers.rb
+- lib/docx/containers/container.rb
+- lib/docx/containers/paragraph.rb
+- lib/docx/containers/table.rb
+- lib/docx/containers/table_cell.rb
+- lib/docx/containers/table_column.rb
+- lib/docx/containers/table_row.rb
+- lib/docx/containers/text_run.rb
+- lib/docx/core_ext/module.rb
+- lib/docx/document.rb
+- lib/docx/elements.rb
+- lib/docx/elements/bookmark.rb
+- lib/docx/elements/element.rb
+- lib/docx/elements/text.rb
+- lib/docx/version.rb
+homepage: https://github.com/jdmartinez1062/docx
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key: 
+specification_version: 4
+summary: a ruby library/gem for interacting with .docx files with a light modification
+  from the docx gem in order to allow easier use of the parsed data. Forked from docx
+  gem
+test_files: []