parchment 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0d6c2118023a45879f6d70a6a9504da8af5e2942
+  data.tar.gz: a2a64bf4e2d264dd56f003a066fa027df6b0c911
+SHA512:
+  metadata.gz: 92165f1b6633f8ae88545b415b5c53dddb532d0a9f9f84860dbc1e64cc381d84c2ac520da87e10a6a09d6e361dbb0b38c052f60ab6f7a3f1b2ae31590ffb79b5
+  data.tar.gz: d8d175ba3eff1d82cb5bf45680bfd498e1d7b362fb021074fae9b166f904bec55d91430e31cbbbdf8b2064ab0d7e27e0537f2e535adee0659cf5c4881735920b

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Allen Petlock
+
+MIT License
+
+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/Parchment.rdoc

@@ -0,0 +1,4 @@
+# = Parchment
+#
+# Parchment is a simple library for interacting with word processing
+# document files.

data/README.md

@@ -0,0 +1,41 @@
+# Parchment
+
+Parchment is a simple, flexible library for interacting with word processing
+document files. Initially intended for outputting .docx and .odt files as
+HTML fragments, it is built to be flexible for future use.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'parchment'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parchment
+
+## Usage
+
+    require 'parchment'
+    doc = Parchment.read('path/to/file.odt')
+    doc.to_html
+
+## Contributing
+
+1. Fork it ( https://github.com/apetlock/parchment/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+### RSpec tests
+
+I love TDD/BDD, but not to an insane level. Any tests written should test
+input and output. Did the file get read properly? Is it outputting properly?
+Internals do not need to be tested. For example, testing if a paragraph is
+aligned_right? is necessary. Making sure that the class stores the alignment
+as String 'right' is not.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+desc 'Run RSpec tests'
+RSpec::Core::RakeTask.new :spec
+task test: :spec
+
+desc 'Generate RDoc documentation'
+RDoc::Task.new :doc do |rdoc|
+  rdoc.rdoc_files.include('Parchment.rdoc', 'lib/**/*.rb')
+  rdoc.main = 'Parchment.rdoc'
+  rdoc.rdoc_dir = 'doc'
+  rdoc.options << '--force-update'
+end
+
+desc 'Launch library console'
+task :console do
+  sh 'irb -I lib -r parchment'
+end
+
+desc 'description'
+task :default do
+  puts 'Available commands: test, doc, console'
+end

data/lib/parchment.rb

@@ -0,0 +1,27 @@
+require 'parchment/document'
+require 'parchment/formats/odt/odt'
+require 'parchment/formats/docx/docx'
+
+module Parchment
+
+  # Reads +path+ and determines which format module to use for reading
+  # the file.
+  #
+  def self.read(path)
+    extension = path.split('.').last
+    case extension
+    when 'odt'
+      Parchment::ODT.read(path)
+    when 'docx'
+      Parchment::DOCX.read(path)
+    else
+      raise UnsupportedFileFormatError, 'File format is not supported.'
+    end
+  end
+
+  class UnsupportedFileFormatError < LoadError
+  end
+
+  class MissingFormatterMethodError < NotImplementedError
+  end
+end

data/lib/parchment/document.rb

@@ -0,0 +1,77 @@
+require 'nokogiri'
+require 'parchment/paragraph'
+require 'parchment/style'
+
+module Parchment
+
+  # = Primary Document class.
+  #
+  # A Document is the primary "container" for everything necessary to format
+  # and display its contents. Holds Paragraph and Style objects.
+  #
+  class Document
+
+    # (Array) All the Styles that belong to the Document that other objects
+    # (i.e. Paragraphs, TextRuns) can reference and apply.
+    attr_reader :styles
+
+    # (Array) Paragraph objects that belong to the Document.
+    attr_reader :paragraphs
+
+    # (Style) A Style referenced when style attributes on the child are
+    # not available.
+    attr_reader :default_paragraph_style
+
+    # content_file:: (File) The primary content file of the document.
+    # styles_file:: (File) The styles file from the document.
+    #
+    def initialize(content_file, styles_file)
+      @content_xml = Nokogiri::XML(content_file)
+      @styles_xml = Nokogiri::XML(styles_file)
+      set_styles
+      set_paragraphs
+    end
+
+    # Returns the Style based on the +id+ given.
+    #
+    # The XML document formats in particular store their styles in elements
+    # with unique identifiers. OpenOffice uses these extensively, relying
+    # on them to specify formatting for the text. DOCX, not so much, but
+    # it does have user-defined styles.
+    #
+    #--
+    # DOCX styles are not implemented yet.
+    #++
+    #
+    # id:: (String) The unique identifier of the Style.
+    #
+    def get_style_by_id(id)
+      styles.select { |style| id == style.id }.first
+    end
+
+    # Output entire document as a HTML fragment String.
+    #
+    def to_html
+      paragraphs.map(&:to_html).join('\n')
+    end
+
+    private
+
+      # These methods add the Document's children and default settings.
+      #
+      # These methods should be defined in the appropriate class in the
+      # formatter module. i.e. Parchment::ODT::Document will have these.
+      #
+      def set_paragraphs
+        raise MissingFormatterMethodError
+      end
+
+      def set_styles
+        raise MissingFormatterMethodError
+      end
+
+      def set_default_paragraph_style
+        raise MissingFormatterMethodError
+      end
+  end
+end

data/lib/parchment/formats/docx/document.rb

@@ -0,0 +1,30 @@
+require 'parchment/document'
+require_relative 'paragraph'
+require_relative 'style'
+
+module Parchment
+  module DOCX
+    class Document < Parchment::Document
+
+      private
+
+        # These methods parse and add the Document's children and defaults.
+        #
+        def set_paragraphs
+          set_default_paragraph_style
+          paragraph_nodes = @content_xml.xpath('.//w:document//w:body//w:p')
+          @paragraphs = paragraph_nodes.map { |node| Parchment::DOCX::Paragraph.new(node, self) }
+        end
+
+        def set_styles
+          style_nodes = @styles_xml.xpath('.//w:style')
+          @styles = style_nodes.map { |node| Parchment::DOCX::Style.new_from_node(node) }
+        end
+
+        def set_default_paragraph_style
+          doc_style_node = @styles_xml.xpath('.//w:docDefaults').first
+          @default_paragraph_style = Parchment::DOCX::Style.new_default_style(doc_style_node)
+        end
+    end
+  end
+end

data/lib/parchment/formats/docx/docx.rb

@@ -0,0 +1,17 @@
+require 'zip'
+require_relative 'document'
+
+module Parchment
+
+  # = Parchment OfficeOpen (.docx) format parser
+  #
+  module DOCX
+
+    def self.read(path)
+      zip = Zip::File.open(path)
+      document_file = zip.read('word/document.xml')
+      styles_file = zip.read('word/styles.xml')
+      Parchment::DOCX::Document.new(document_file, styles_file)
+    end
+  end
+end

data/lib/parchment/formats/docx/paragraph.rb

@@ -0,0 +1,51 @@
+require 'parchment/paragraph'
+require_relative 'style'
+require_relative 'text_run'
+
+module Parchment
+  module DOCX
+    class Paragraph < Parchment::Paragraph
+
+      def initialize(node, document)
+        @node = node
+        @style_id = nil
+        @document = document
+        set_style
+        super()
+      end
+
+      private
+
+        # Because OfficeOpen puts all formatting on the individual
+        # elements rather than refer to a defined style, they need
+        # to be created from the element itself.
+        #
+        def set_style
+          @style = Style.new
+
+          alignment_node = @node.xpath('.//w:jc').first
+          alignment = alignment_node ? alignment_node.attributes['val'].value : nil
+          @style.instance_variable_set('@text_align', alignment.to_sym) if alignment
+
+          size_node = @node.xpath('w:pPr//w:sz').first
+          font_size = size_node ? size_node.attributes['val'].value.to_i / 2 : nil
+          @style.instance_variable_set('@font_size', font_size)
+
+          bold_node = @node.xpath('w:pPr//w:b').first
+          @style.instance_variable_set('@font_weight', 'bold') if bold_node
+
+          italic_node = @node.xpath('w:pPr//w:i').first
+          @style.instance_variable_set('@font_style', 'italic') if italic_node
+
+          underline_node = @node.xpath('w:pPr//w:u').first
+          @style.instance_variable_set('@text_underline_style', 'solid') if underline_node
+        end
+
+        def set_text_runs
+          @text_runs = @node.xpath('.//w:r').map do |child|
+            Parchment::DOCX::TextRun.new(child, self, @document)
+          end
+        end
+    end
+  end
+end

data/lib/parchment/formats/docx/style.rb

@@ -0,0 +1,48 @@
+require 'parchment/style'
+
+module Parchment
+  module DOCX
+    class Style < Parchment::Style
+
+      #--
+      # I don't like particularly how this is set up, but the OfficeOpen
+      # format has styles split up between a global docDefaults and separate
+      # styles which relate to the ones set up in word. Unlike ODT, all
+      # the styles are set on paragraphs and runs individually, rather than
+      # referring to an embedded style. But, we still want a style Object,
+      # so there's two creation methods here.
+      #++
+      def initialize
+      end
+
+      # Creates a new Style from the XML w:style element passed in.
+      #
+      def self.new_from_node(node)
+        style = self.new
+        @node = node
+        instance_variable_set('@family',@node.attributes['type'].value)
+        instance_variable_set('@id', @node.attributes['styleId'].value)
+        return style
+      end
+
+      # The OfficeOpen format has a spcific docDefaults block which
+      # describes the globals for the document. This creates a Style
+      # Object from that element.
+      #
+      def self.new_default_style(node)
+        style = self.new
+
+        # Right now, only concerned about document global font size.
+        #
+        # OfficeOpen specifications store the font size as half-points. Meaning if
+        # something is at 12 points, it will be 24. We want actual full-point size.
+        #
+        font_size_tag = node.xpath('//w:docDefaults//w:rPrDefault//w:rPr//w:sz').first
+        font_size = font_size_tag ? font_size_tag.attributes['val'].value.to_i / 2 : nil
+
+        style.instance_variable_set('@font_size', font_size)
+        return style
+      end
+    end
+  end
+end

data/lib/parchment/formats/docx/text_run.rb

@@ -0,0 +1,35 @@
+module Parchment
+  module DOCX
+    class TextRun < Parchment::TextRun
+
+      def initialize(node, paragraph, document)
+        @node = node
+        set_style
+        super(paragraph, document)
+      end
+
+      private
+
+        # Because OfficeOpen puts all formatting on the individual
+        # elements rather than refer to a defined style, they need
+        # to be created from the element itself.
+        #
+        def set_style
+          @style = Style.new
+
+          size_node = @node.xpath('.//w:sz').first
+          font_size = size_node ? size_node.attributes['val'].value.to_i / 2 : nil
+          @style.instance_variable_set('@font_size', font_size)
+
+          font_weight = @node.xpath('.//w:b').empty? ? 'normal' : 'bold'
+          @style.instance_variable_set('@font_weight', font_weight)
+
+          font_style = @node.xpath('.//w:i').empty? ? 'normal' : 'italic'
+          @style.instance_variable_set('@font_style', font_style)
+
+          underline_style = @node.xpath('.//w:u').empty? ? nil : 'solid'
+          @style.instance_variable_set('@text_underline_style', underline_style)
+        end
+    end
+  end
+end

data/lib/parchment/formats/odt/document.rb

@@ -0,0 +1,32 @@
+require 'parchment/document'
+require_relative 'paragraph'
+require_relative 'style'
+
+module Parchment
+  module ODT
+    class Document < Parchment::Document
+
+      private
+
+        # These methods parse and add the Document's children and defaults.
+        #
+        def set_paragraphs
+          set_default_paragraph_style
+          paragraph_nodes = @content_xml.xpath('.//office:body/office:text/text:p')
+          @paragraphs = paragraph_nodes.map { |node| Parchment::ODT::Paragraph.new(node, self) }
+        end
+
+        def set_styles
+          style_nodes = @content_xml.xpath('.//office:automatic-styles/style:style')
+          @styles = style_nodes.map { |node| Parchment::ODT::Style.new(node) }
+        end
+
+        def set_default_paragraph_style
+          style_nodes = @styles_xml.xpath('.//office:styles/style:default-style').select do |style|
+            style.attributes['family'].value == 'paragraph'
+          end
+          @default_paragraph_style = Parchment::ODT::Style.new(style_nodes.first)
+        end
+    end
+  end
+end

data/lib/parchment/formats/odt/odt.rb

@@ -0,0 +1,17 @@
+require 'zip'
+require_relative 'document'
+
+module Parchment
+
+  # = Parchment OpenOffice (.odt) format parser
+  #
+  module ODT
+
+    def self.read(path)
+      zip = Zip::File.open(path)
+      document_file = zip.read('content.xml')
+      styles_file = zip.read('styles.xml')
+      Parchment::ODT::Document.new(document_file, styles_file)
+    end
+  end
+end

data/lib/parchment/formats/odt/paragraph.rb

@@ -0,0 +1,26 @@
+require 'parchment/paragraph'
+require_relative 'style'
+require_relative 'text_run'
+
+module Parchment
+  module ODT
+    class Paragraph < Parchment::Paragraph
+
+      def initialize(node, document)
+        @node = node
+        @style_id = @node.attributes['style-name'].value
+        @document = document
+        @style = @document.get_style_by_id(@style_id)
+        super()
+      end
+
+      private
+
+        def set_text_runs
+          @text_runs = @node.children.map do |child|
+            Parchment::ODT::TextRun.new(child, self, @document)
+          end
+        end
+    end
+  end
+end

data/lib/parchment/formats/odt/style.rb

@@ -0,0 +1,49 @@
+require 'parchment/style'
+
+module Parchment
+  module ODT
+    class Style < Parchment::Style
+
+      # Because the OpenOffice standard uses 'start', 'end', etc.
+      ALIGNMENT_CONVERSION = {
+        start: :left,
+        end: :right,
+        center: :center
+      }
+
+      TEXT_PROPERTIES = [
+        'font-size',
+        'font-weight',
+        'font-style',
+        'text-underline-style'
+      ]
+
+      def initialize(node)
+        @node = node
+        @node.attributes.map { |k, v| [k, v.value] }.each do |prop|
+          prop_name = prop[0].gsub('-', '_')
+          instance_variable_set("@#{prop_name}", prop[1])
+        end
+        instance_variable_set("@id", @name)
+        @node.children.each do |style_child|
+          case style_child.name
+          when 'paragraph-properties'
+            if style_child.attributes['text-align']
+              @text_align = ALIGNMENT_CONVERSION[style_child.attributes['text-align'].value.to_sym]
+            end
+          when 'text-properties'
+            TEXT_PROPERTIES.each do |prop|
+              style_attr = style_child.attributes[prop]
+              if style_attr
+                value = style_attr.value
+                value = value.to_i if prop == 'font-size'
+                instance_variable_set("@#{prop.gsub('-', '_')}", value)
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/parchment/formats/odt/text_run.rb

@@ -0,0 +1,18 @@
+module Parchment
+  module ODT
+    class TextRun < Parchment::TextRun
+
+      def initialize(node, paragraph, document)
+        @node = node
+        if @node.attributes.empty?
+          @style = paragraph.style
+        else
+          @style_id = @node.attributes['style-name'].value
+          @style = document.get_style_by_id(@style_id)
+        end
+        super(paragraph, document)
+      end
+
+    end
+  end
+end

data/lib/parchment/helpers.rb

@@ -0,0 +1,36 @@
+module Parchment
+
+  # Helper methods useful to multiple classes.
+  #
+  module Helpers
+
+    # Wraps content in an HTML tag, returning the element.
+    # Currently used in Paragraph and TextRun for the to_html methods
+    #
+    # name:: (String) The name of the HTML tag. (e.g. 'p', 'span')
+    # options:: (Hash) Options that describe the element.
+    #
+    # ==== Options
+    # +content:+ (String) The base text content for the tag.
+    # 
+    # +styles:+ (Hash) CSS styles and values 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
+  end
+end

data/lib/parchment/paragraph.rb

@@ -0,0 +1,72 @@
+require 'parchment/style'
+require 'parchment/text_run'
+require 'parchment/helpers'
+
+module Parchment
+
+  # A Paragraph holds several TextRun objects and default formatting for them.
+  #
+  class Paragraph
+    include Parchment::Helpers
+
+    # (Style) The primary Style for the Paragraph.
+    attr_reader :style
+
+    # (Array) All the TextRun children that the Paragraph has.
+    attr_reader :text_runs
+
+    # (Integer) It's what it sounds like.
+    attr_reader :default_font_size
+
+    # This does not accept any arguments because the primary work
+    # for this is done in the formatter's subclass.
+    #
+    def initialize
+      raise MissingFormatterMethodError unless @node
+      @default_font_size = @document.default_paragraph_style.font_size
+      set_text_runs
+    end
+
+    # The font size of the Paragraph. Will return the Document's default
+    # font size if not defined.
+    #
+    def font_size
+      @style.font_size || @default_font_size
+    end
+
+    # This is a method constructor which creates Boolean methods (e.g. bold?,
+    # italic?) based on the available formatting options defined in Style.
+    #
+    Parchment::Style::AVAILABLE_FORMATTING.each do |styling|
+      define_method("#{styling}?") { style.public_send("#{styling}?") }
+    end
+
+    # Output the unformatted Paragraph's content as a String.
+    #
+    def to_s
+      @node.content
+    end
+    alias :text :to_s
+
+    # Return a HTML element String with formatting based on the Paragraph's
+    # properties.
+    #
+    def to_html
+      html = ''
+      text_runs.each { |text_run| html << text_run.to_html }
+      styles = { 'font-size' => "#{font_size}pt" }
+      styles['text-align'] = @style.text_align unless @style.aligned_left?
+      html_tag(:p, content: html, styles: styles)
+    end
+
+    private
+
+      # Parses and creates the TextRun objects that belong to the Paragraph.
+      #
+      # *This needs to be defined in the formatter's Paragraph class.*
+      #
+      def set_text_runs
+        raise MissingFormatterMethodError
+      end
+  end
+end

data/lib/parchment/style.rb

@@ -0,0 +1,61 @@
+module Parchment
+  class Style
+
+    AVAILABLE_FORMATTING = %w(
+      bold
+      italic
+      underline
+      aligned_left
+      aligned_right
+      aligned_center
+    )
+
+    attr_reader :id,
+                :name,
+                :family,
+                :parent_style_name,
+                :text_align,
+                :font_size,
+                :font_weight,
+                :font_style,
+                :text_underline_style
+
+    # This needs to be defined in each format's subclass.
+    #
+    def initialize(node)
+      raise MissingFormatterMethodError
+    end
+
+    def paragraph?
+      @family == 'paragraph'
+    end
+
+    def text?
+      @family == 'text'
+    end
+
+    def bold?
+      @font_weight == 'bold'
+    end
+
+    def italic?
+      @font_style == 'italic'
+    end
+
+    def underline?
+      !@text_underline_style.nil?
+    end
+
+    def aligned_left?
+      [:left, nil].include?(@text_align)
+    end
+
+    def aligned_right?
+      @text_align == :right
+    end
+
+    def aligned_center?
+      @text_align == :center
+    end
+  end
+end

data/lib/parchment/text_run.rb

@@ -0,0 +1,57 @@
+require 'parchment/helpers'
+
+module Parchment
+
+  # A "run" of text within a Paragraph. Each run may have its own style
+  # attributes different from that of the Paragraph. These are iterated
+  # through to generate a line of formatted output.
+  #
+  class TextRun
+    include Parchment::Helpers
+
+    # (Style) The primary Style for the TextRun.
+    attr_reader :style
+
+    def initialize(paragraph, document)
+      raise MissingFormatterMethodError unless @node
+      @content = @node.content
+      @default_font_size = paragraph.font_size
+    end
+
+    # The font size of the TextRun. Will return the Paragraph's default
+    # font size if not defined.
+    #
+    def font_size
+      @style.font_size || @default_font_size
+    end
+
+    # This is a method constructor which creates Boolean methods (e.g. bold?,
+    # italic?) based on the available formatting options defined in Style.
+    #
+    Parchment::Style::AVAILABLE_FORMATTING.each do |styling|
+      define_method("#{styling}?") { style.public_send("#{styling}?") }
+    end
+
+    # Output the unformatted TextRun's content as a String.
+    #
+    def to_s
+      @content
+    end
+    alias :text :to_s
+
+    # Return a HTML element String with formatting based on the TextRun's
+    # properties.
+    #
+    def to_html
+      html = @content
+      html = html_tag(:em, content: html) if italic?
+      html = html_tag(:strong, content: html) if bold?
+      styles = {}
+      styles['text-decoration'] = 'underline' if underline?
+      # 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 != @default_font_size
+      html = html_tag(:span, content: html, styles: styles) unless styles.empty?
+      return html
+    end
+  end
+end

data/lib/parchment/version.rb

@@ -0,0 +1,3 @@
+module Parchment
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: parchment
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Allen Petlock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+description: A simple library for reading and intereacting with word processing documents,
+  such as ODT, DOCX, etc.
+email:
+- apetlock@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/parchment/text_run.rb
+- lib/parchment/formats/docx/docx.rb
+- lib/parchment/formats/docx/text_run.rb
+- lib/parchment/formats/docx/document.rb
+- lib/parchment/formats/docx/style.rb
+- lib/parchment/formats/docx/paragraph.rb
+- lib/parchment/formats/odt/text_run.rb
+- lib/parchment/formats/odt/document.rb
+- lib/parchment/formats/odt/style.rb
+- lib/parchment/formats/odt/odt.rb
+- lib/parchment/formats/odt/paragraph.rb
+- lib/parchment/document.rb
+- lib/parchment/style.rb
+- lib/parchment/version.rb
+- lib/parchment/helpers.rb
+- lib/parchment/paragraph.rb
+- lib/parchment.rb
+- README.md
+- LICENSE.md
+- Parchment.rdoc
+homepage: https://github.com/apetlock/parchment
+licenses:
+- MIT
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Simple word processing document interaction
+test_files: []