docx 0.1.0 → 0.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZWNiNjA4ZjliOGU1MTQxZjdhNjhmYmU4OWQxMzkyMDM2MzMxOTI4Ng==
+  data.tar.gz: !binary |-
+    NTU2OWE0N2FkZWMzMmM4NDJkYjMwMTg0NTcyOWVhMmFlNGE4MTliZg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    OWJiMGQ5NmQ1OGFhYTdhODIyNzYyM2U4Yjk3NzQyMWY3YzUxNDZmOGY1NDAz
+    MDZlMDFkM2I0MWM5MzFmNTM0NGEyNDlmZTQ3ZmI4Yzg3NzUyZDliMzlkY2Ri
+    MzdiYmRhOTc0ZDhiYzg2ZGVmZTkzOTVhMTkwN2MzMDE4MDU4YjI=
+  data.tar.gz: !binary |-
+    NGMxZTdkMTQ3ODkxM2MyYTkyODAzZTRhMTQ1ZWU4NGU4MjI0Y2Y2MWM2Zjdj
+    Y2IyMzc5NGMyNjRkYTNkM2VmYzY5ZjhkMTE4MjczNDNhYTEzMGJiMWEwNWZh
+    NTBiZjkxMjc2MTQ2NDM1OTMzZjhiNGQ3ZGYxYTljNzNmZTQ0NmY=

data/LICENSE.md

@@ -1,21 +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.
+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

@@ -1,32 +1,50 @@
-# docx
-
-a ruby library/gem for interacting with `.docx` files
-
-## usage
-
-### basic
-
-``` ruby
-require 'docx'
-
-d = Docx::Document.open('example.docx')
-d.each_paragraph do |p|
-  puts d
-end
-```
-
-### advanced
-
-``` ruby
-require 'docx'
-
-d = Docx::Document.open('example.docx')
-d.each_paragraph do |p|
-  p.each_text_run do |run|
-    run.italicized?
-    run.bolded?
-    run.underlined?
-    run.formatting
-    run.text
-  end
-end
+# docx
+
+a ruby library/gem for interacting with `.docx` files
+
+## usage
+
+### install
+
+requires ruby (only tested with 1.9.3 so far)
+
+    gem install docx
+
+### basic
+
+``` ruby
+require 'docx'
+
+d = Docx::Document.open('example.docx')
+d.each_paragraph do |p|
+  puts d
+end
+```
+
+### advanced
+
+``` ruby
+require 'docx'
+
+d = Docx::Document.open('example.docx')
+d.each_paragraph do |p|
+  p.each_text_run do |run|
+    run.italicized?
+    run.bolded?
+    run.underlined?
+    run.formatting
+    run.text
+  end
+end
+```
+
+## Development
+
+### todo
+
+* Add better formatting identification for specific nodes and other formatting indicators (text size, paragraph spacing)
+* 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

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

data/lib/docx/containers.rb

@@ -1,2 +1,3 @@
-require 'docx/containers/text_run'
-require 'docx/containers/paragraph'
+require 'docx/containers/container'
+require 'docx/containers/text_run'
+require 'docx/containers/paragraph'

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
+
+        # TODO: Maybe merge and then clear so there is only one text node left.
+        def blank!
+          @node.xpath(".//w:t").each {|t| t.content = '' }
+        end
+      end
+    end
+  end
+end

data/lib/docx/containers/paragraph.rb

@@ -1,23 +1,50 @@
-require 'docx/containers/text_run'
-
-module Docx
-  module Containers
-    class Paragraph
-      attr_accessor :text_runs
-      
-      def initialize(txt_runs)
-        @text_runs = txt_runs
-      end
-      
-      def to_s
-        @text_runs.map(&:text).join('')
-      end
-      
-      def each_text_run
-        @text_runs.each { |tr| yield(tr) }
-      end
-      
-      alias_method :text, :to_s
-    end
-  end
-end
+require 'docx/containers/text_run'
+require 'docx/containers/container'
+
+module Docx
+  module Elements
+    module Containers
+      class Paragraph
+        include Container
+        include Elements::Element
+
+        TAG = 'p'
+
+        # Child elements: pPr, r, fldSimple, hlink, subDoc
+        # http://msdn.microsoft.com/en-us/library/office/ee364458(v=office.11).aspx
+        def initialize(node)
+          @node = node
+          @properties_tag = 'pPr'
+        end
+
+        # Handle direct text insertion into paragraph on some conditions
+        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
+
+        def to_s
+          text_runs.map(&:text).join('')
+        end
+
+        def text_runs
+          @node.xpath('w:r').map {|r_node| Containers::TextRun.new(r_node) }
+        end
+
+        def each_text_run
+          text_runs.each { |tr| yield(tr) }
+        end
+        
+        alias_method :text, :to_s
+      end
+    end
+  end
+end

data/lib/docx/containers/text_run.rb

@@ -1,35 +1,68 @@
-module Docx
-  module Containers
-    class TextRun
-      DEFAULT_FORMATTING = {
-        italic:    false,
-        bold:      false,
-        underline: false
-      }
-      
-      attr_reader :text
-      attr_reader :formatting
-      
-      def initialize(attrs)
-        @text       = attrs[:text] || ''
-        @formatting = attrs[:formatting] || DEFAULT_FORMATTING
-      end
-      
-      def to_s
-        @text
-      end
-      
-      def italicized?
-        @formatting[:italic]
-      end
-      
-      def bolded?
-        @formatting[:bold]
-      end
-      
-      def underlined?
-        @formatting[:underline]
-      end
-    end
-  end
-end
+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
+        }
+        
+        TAG = 'r'
+
+        attr_reader :text
+        attr_reader :formatting
+        
+        def initialize(node)
+          @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
+        end
+
+        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
+
+        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
+        
+        def italicized?
+          @formatting[:italic]
+        end
+        
+        def bolded?
+          @formatting[:bold]
+        end
+        
+        def underlined?
+          @formatting[:underline]
+        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

@@ -1,27 +1,54 @@
-require 'docx/parser'
-
-module Docx
-  class Document
-    attr_reader :paragraphs
-    
-    def initialize(path)
-      Parser.new(File.expand_path(path)) do |p|
-        @paragraphs = p.paragraphs
-      end
-    end
-    
-    def self.open(path)
-      self.new(path)
-    end
-    
-    def each_paragraph
-      @paragraphs.each { |p| yield(p) }
-    end
-    
-    def to_s
-      @paragraphs.map(&:to_s).join("\n")
-    end
-    
-    alias_method :text, :to_s
-  end
-end
+require 'docx/parser'
+require 'zip/zip'
+
+module Docx
+  class Document
+    delegate :paragraphs, :bookmarks, :to => :@parser
+    delegate :doc, :xml, :zip, :to => :@parser
+    def initialize(path, &block)
+      @replace = {}
+      if block_given?
+        @parser = Parser.new(File.expand_path(path), &block)
+      else
+        @parser = Parser.new(File.expand_path(path))
+      end
+    end
+    
+    def self.open(path, &block)
+      self.new(path, &block)
+    end
+
+    def each_paragraph
+      paragraphs.each { |p| yield(p) }
+    end
+    
+    def to_s
+      paragraphs.map(&:to_s).join("\n")
+    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["word/document.xml"] = doc.serialize :save_with => 0
+    end
+
+    def save(path)
+      update
+      Zip::ZipFile.open(path, Zip::ZipFile::CREATE) do |out|
+        zip.each do |entry|
+          out.get_output_stream(entry.name) do |o|
+            if @replace[entry.name]
+              o.write(@replace[entry.name])
+            else
+              o.write(zip.read(entry.name))
+            end
+          end
+        end
+      end
+      zip.close
+    end
+    
+    alias_method :text, :to_s
+  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,72 @@
+require 'docx/elements/element'
+
+module Docx
+  module Elements
+    class Bookmark
+      include Element
+      attr_accessor :name
+      
+      TAG = 'bookmarkStart'
+
+      def initialize(node)
+        @node = node
+        @name = @node['w:name']
+      end
+
+      def insert_text_before(text)
+        text_run = get_run_after
+        text_run.text = "#{text}#{text_run.text}"
+      end
+
+      def insert_text_after(text)
+        text_run = get_run_before
+        text_run.text = "#{text_run.text}#{text}"
+      end
+
+      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
+
+      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
+
+      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,71 @@
+require 'nokogiri'
+require 'docx/elements'
+require 'docx/containers'
+
+module Docx
+  module Elements
+    module Element
+      DEFAULT_TAG = ''
+
+      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
+
+      # TODO: Should create a docx paragraph from this
+      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
+
+      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.const_get(: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,13 @@
+module Docx
+  module Elements
+    class Text
+      include Element
+      delegate :content, :content=, :to => :@node
+      TAG = 't'
+
+      def initialize(node)
+        @node = node
+      end
+    end
+  end
+end

data/lib/docx/parser.rb

@@ -1,49 +1,42 @@
-require 'docx/containers'
-require 'nokogiri'
-require 'zip/zip'
-
-module Docx
-  class Parser
-    def initialize(path)
-      @zip = Zip::ZipFile.open(path)
-      @xml = Nokogiri::XML(@zip.find_entry('word/document.xml').get_input_stream)
-      
-      if block_given?
-        yield self
-        @zip.close
-      end
-    end
-    
-    def paragraphs
-      @xml.xpath('//w:document//w:body//w:p').map { |p_node| parse_paragraph_from p_node }
-    end
-    
-    private
-    
-    def parse_paragraph_from(p_node)
-      Containers::Paragraph.new(parse_runs_from(p_node))
-    end
-    
-    def parse_runs_from(p_node)
-      p_node.xpath('w:r').map do |r_node|
-        rpr_node = r_node.xpath('w:rPr')
-        Containers::TextRun.new({
-          text:       parse_text_from(r_node),
-          formatting: parse_formatting_from(rpr_node)
-        })
-      end
-    end
-    
-    def parse_text_from(r_node)
-      r_node.xpath('w:t').map(&:text).join('')
-    end
-    
-    def parse_formatting_from(rpr_node)
-      {
-        italic:    !rpr_node.xpath('w:i').empty?,
-        bold:      !rpr_node.xpath('w:b').empty?,
-        underline: !rpr_node.xpath('w:u').empty?
-      }
-    end
-  end
-end
+require 'docx/containers'
+require 'docx/elements'
+require 'nokogiri'
+require 'zip/zip'
+
+module Docx
+  class Parser
+    attr_reader :xml, :doc, :zip
+    def initialize(path)
+      @zip = Zip::ZipFile.open(path)
+      @xml = @zip.read('word/document.xml')
+      @doc = Nokogiri::XML(@xml)
+      if block_given?
+        yield self
+        @zip.close
+      end
+    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
+    
+    private
+    
+    def parse_paragraph_from(p_node)
+      Elements::Containers::Paragraph.new(p_node)
+    end
+
+    def parse_bookmark_from(b_node)
+      Elements::Bookmark.new(b_node)
+    end
+  end
+end

data/lib/docx/test.rb

@@ -0,0 +1,4 @@
+require_relative 'document'
+
+document = Docx::Document.new('../test/fixtures/basic.docx')
+puts document.bookmarks

data/lib/docx/version.rb

@@ -1,3 +1,3 @@
-module Docx
-  VERSION = '0.1.0'
-end
+module Docx
+  VERSION = '0.2.0'
+end

metadata

@@ -1,38 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: docx
 version: !ruby/object:Gem::Version
-  version: 0.1.0
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Marcus Ortiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-12 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &70332799492380 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :runtime
   prerelease: false
-  version_requirements: *70332799492380
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rubyzip
-  requirement: &70332799491720 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.9'
   type: :runtime
   prerelease: false
-  version_requirements: *70332799491720
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
 description: a ruby library/gem for interacting with .docx files
 email: mportiz08@gmail.com
 executables: []
@@ -41,35 +46,41 @@ extra_rdoc_files: []
 files:
 - README.md
 - LICENSE.md
+- lib/docx/containers/container.rb
 - lib/docx/containers/paragraph.rb
 - lib/docx/containers/text_run.rb
 - lib/docx/containers.rb
+- lib/docx/core_ext/module.rb
 - lib/docx/document.rb
+- lib/docx/elements/bookmark.rb
+- lib/docx/elements/element.rb
+- lib/docx/elements/text.rb
+- lib/docx/elements.rb
 - lib/docx/parser.rb
+- lib/docx/test.rb
 - lib/docx/version.rb
 - lib/docx.rb
 homepage: https://github.com/mportiz08/docx
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: a ruby library/gem for interacting with .docx files
 test_files: []