docx 0.2.03 → 0.6.0

data/lib/docx/containers/text_run.rb

@@ -13,17 +13,23 @@ module Docx
           underline: false
         }
         
-        TAG = 'r'
+        def self.tag
+          'r'
+        end
 
         attr_reader :text
         attr_reader :formatting
         
-        def initialize(node)
+        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
@@ -41,6 +47,13 @@ module Docx
           @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?,
@@ -52,7 +65,21 @@ module Docx
         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
@@ -64,6 +91,23 @@ module Docx
         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

data/lib/docx/core_ext/module.rb

@@ -1,172 +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
+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,87 +1,202 @@
-require 'docx/parser'
-require 'zip/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
-    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
-    
-    # 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
-
-    ##
-    # *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
-
-    # Save document to provided path
-    # call-seq:
-    #   save(filepath) => void
-    def save(path)
-      update
-      Zip::ZipOutputStream.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
-
-    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["word/document.xml"] = doc.serialize :save_with => 0
-    end
-
-  end
-end
+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.find_entry('word/document.xml')
+      document ||= @zip.find_entry('word/document2.xml')
+      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)
+      @rels_xml = @zip.read('word/_rels/document.xml.rels')
+      @rels = Nokogiri::XML(@rels_xml)
+    rescue Errno::ENOENT => e
+      warn e.message
+      nil
+    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