bitops-docx 0.2.07

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 746f86da717d8e88492061e60c5394f5ee54b38c
+  data.tar.gz: 5ca6b5f0cbc0bfc26f79e9c8efbddbf11878df70
+SHA512:
+  metadata.gz: 470948df1d7d617e731090a2336a4e2e3c8aa9789e699c66936d653d26c68d98b39ba61714f257601ea38ddde3d5a2bafa9096a3666abcd741b0bd88cf9891ea
+  data.tar.gz: a04e5def0dff4febe5311ca62b21f0887edeb2b9863c425c261e9cdab0efebce966f9929c0f770c76be7fe790dc9f0f497792dbacffcb013af4e1ee4d8674157

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,114 @@
+# This is a fork!!!
+
+This library stands on the shoulders of the original [docx](https://github.com/chrahunt/docx) -- it is my hope that [@chrahunt](https://github.com/chrahunt) will pull the changes I've incorporated into this library back into his original library.
+
+This library depends on the latest version of rubyzip and incorporates changes from these two pull requests:
+* [Paragraph alignment, text run font sizes, and HTML output](https://github.com/chrahunt/docx/pull/13) from [@higginsdragon](https://github.com/higginsdragon)
+* [File replacement within document](https://github.com/chrahunt/docx/pull/18) from [@tmikoss](https://github.com/tmikoss)
+
+# docx
+
+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
+
+### install
+
+requires ruby (tested with 2.1.1)
+
+    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
+```
+
+### 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'])
+
+# Save document to specified path
+doc.save('example-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.rb

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

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/containers/container.rb

@@ -0,0 +1,20 @@
+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
+      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/w:r').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,92 @@
+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
+        
+        def initialize(node, document_properties = {})
+          @node = node
+          @text_nodes = @node.xpath('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
+
+        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?
+          return html
+        end
+
+        def italicized?
+          @formatting[:italic]
+        end
+        
+        def bolded?
+          @formatting[:bold]
+        end
+        
+        def underlined?
+          @formatting[:underline]
+        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/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,148 @@
+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, &block)
+      @replace = {}
+      @zip = Zip::File.open(path)
+      @document_xml = @zip.read('word/document.xml')
+      @doc = Nokogiri::XML(@document_xml)
+      @styles_xml = @zip.read('word/styles.xml')
+      @styles = Nokogiri::XML(@styles_xml)
+      if block_given?
+        yield self
+        @zip.close
+      end
+    end
+
+
+    # This stores the current global document properties, for now
+    def document_properties
+      {
+        font_size: font_size
+      }
+    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)
+      self.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 = Hash.new
+      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
+      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
+
+    ##
+    # *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|
+          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
+
+    alias_method :text, :to_s
+
+    def replace_entry(entry_path, file_contents)
+      @replace[entry_path] = file_contents
+    end
+
+    private
+
+    #--
+    # 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.rb

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

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_after
+        text_run.text = "#{text}#{text_run.text}"
+      end
+
+      # Insert text after bookmarkStart node
+      def insert_text_after(text)
+        text_run = get_run_before
+        text_run.text = "#{text_run.text}#{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,96 @@
+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]
+
+        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
+        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/version.rb

@@ -0,0 +1,3 @@
+module Docx #:nodoc:
+  VERSION = '0.2.07'
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: bitops-docx
+version: !ruby/object:Gem::Version
+  version: 0.2.07
+platform: ruby
+authors:
+- Christopher Hunt
+- Marcus Ortiz
+- Higgins Dragon
+- Toms Mikoss
+- Sebastian Wittenkamp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: a ruby library/gem for interacting with .docx files
+email:
+- sebastian@bitops.io
+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/bitops/docx
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: a ruby library/gem for interacting with .docx files
+test_files: []