swordfish 0.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzVjN2FlM2EwNzY2ZWQxOTJiZjdiZmVlZTZiZDdhMTE2MjYyNWQ1Ng==
+  data.tar.gz: !binary |-
+    MTU0ZjQzMTRiOTkzMGU5NDdkMDk0MzAyZTc5NTkyNTBiNzQwOGNiMA==
+SHA512:
+  metadata.gz: !binary |-
+    ZWM2M2IzZjJmMmExMGYxNGU3MTllNmE2ZjQ2YTdlZDhiOTE0YWU3YjYwYzBl
+    MjBiY2ZiYTE0MWQ2OWRlYTkyYzE3ZTg1Y2I4NDIwOWYxNDY3MDk1ZWM0NjYw
+    YzcxYmVjZjEzNWEyNjI5NmU5OWM1Y2IyZTg3YzBhNWFhNjliNjg=
+  data.tar.gz: !binary |-
+    NmI2NGQ4ZjIxOWI2YzEzNWI5OTEwMzE4NzEyYjRmZjg2MmJjOTcwMDQ1OWYx
+    NzZjZjBjZmEyMzhhMTcwNjEyMzE1M2RkNzM2ZWQwZTE1YzhiMjVhNWRmOTQx
+    NWJlZTdkMTY1MDg0YTY5NDcwMGUzODdkM2I4ODFmOWEzMWM1MjE=

data/README.md

@@ -0,0 +1,4 @@
+swordfish
+=====
+
+Document parser

data/lib/swordfish/document.rb

@@ -0,0 +1,37 @@
+require 'swordfish/stylesheet'
+require 'swordfish/nodes/base'
+require 'swordfish/nodes/text'
+require 'swordfish/nodes/paragraph'
+require 'swordfish/nodes/list'
+require 'swordfish/nodes/list_item'
+require 'swordfish/nodes/hyperlink'
+require 'swordfish/nodes/table'
+require 'swordfish/nodes/table_row'
+require 'swordfish/nodes/table_cell'
+
+# Swordfish::Document is the internal representation of a parsed document.
+
+module Swordfish
+  class Document
+    
+    attr_reader :nodes   # An array of all top-level elements in the document
+
+    # On initialization, set the nodes list to an empty array
+    def initialize
+      @nodes = []
+    end
+
+    # Pass in a node and append it to the nodes array
+    def append(node)
+      if Swordfish::Node.constants.include? node.class.to_s.split('::').last.to_sym
+        @nodes << node
+      else
+        raise ArgumentError, "Object is not a node"
+      end
+    end
+
+    def to_html
+      @nodes.map(&:to_html).join
+    end
+  end
+end

data/lib/swordfish/formats/docx.rb

@@ -0,0 +1,274 @@
+require 'zip'
+require 'nokogiri'
+require 'swordfish/document'
+
+# Swordfish::DOCX defines a parser for .docx (Office OpenXML) formats
+
+module Swordfish
+  class DOCX
+
+    attr_reader :swordfish_doc   # The Swordfish::Document corresponding to the parsed document
+    
+    # Parse a document and return a Swordfish::Document object
+    def self.open(filepath)
+      # .docx is a zipped file format consisting of several XML files.
+      # Read in the content of each needed file.
+      docx_archive = Zip::File.open(filepath)
+      document = docx_archive.read 'word/document.xml'
+      styles = docx_archive.read 'word/styles.xml'
+      numbering = docx_archive.read 'word/numbering.xml'
+      relationships = docx_archive.read 'word/_rels/document.xml.rels'
+
+      # Parse the XML files and generate the Swordfish::Document
+      swordfish_docx = new document, styles, numbering, relationships
+      swordfish_docx.swordfish_doc
+    end
+
+    def initialize(document_xml, styles_xml, numbering_xml, relationships_xml)
+      @swordfish_doc = Swordfish::Document.new
+      parse_styles styles_xml
+      parse_numbering numbering_xml
+      parse_relationships relationships_xml
+      parse document_xml
+    end
+
+    private
+
+    # Take the contents of the build buffer and flush them into the Swordfish::Document object.
+    # This buffer is needed for certain docx constructs that consist of multiple top-level
+    # elements but correspond to a single Swordfish::Node, such as lists.
+    def flush
+      @swordfish_doc.append(@buffer) if @buffer
+      @buffer = nil
+    end
+
+    # Parse the document structure XML
+    def parse(document_xml)
+      @xml = Nokogiri::XML(document_xml)
+
+      # Iterate over each element node and dispatch it to the appropriate parser
+      @xml.xpath('//w:body').children.each do |node|
+        case node.name
+          when 'p'
+            if node.xpath('.//w:numPr').length == 0
+              # Regular paragraph
+              flush
+              @swordfish_doc.append _node_parse_paragraph(node)
+            else
+              # List paragraph
+              # (Don't flush because we need to first ensure the list is fully parsed)
+              _node_parse_list(node)
+            end
+          when 'tbl'
+            flush
+            @swordfish_doc.append _node_parse_table(node)
+        end
+      end
+      flush
+    end
+
+    # Parse styles out of a docx element property nodeset (*Pr) and stylize the Swordfish::Node
+    def get_styles_for_node(swordfish_node, xml_nodeset)
+      return unless xml_nodeset
+      xml_nodeset.children.each do |style_node|
+        case style_node.name
+          when 'i'
+            swordfish_node.stylize :italic
+          when 'b'
+            swordfish_node.stylize :bold
+          when 'u'
+            swordfish_node.stylize :underline
+          when 'strike'
+            swordfish_node.stylize :strikethrough
+          when 'vertAlign'
+            if style_node['w:val'] == 'superscript'
+              swordfish_node.stylize :superscript
+            elsif style_node['w:val'] == 'subscript'
+              swordfish_node.stylize :subscript
+            end
+        end
+      end
+    end
+
+    # Parse the document styles XML
+    def parse_styles(styles_xml)
+    end
+
+    # Parse the abstract numbering XML (defining things such as list numbering)
+    def parse_numbering(numbering_xml)
+      # The XML maps a numbering ID (numId) to an abstract numbering schema ID (abstractNumId).
+      # The abstract numbering schema defines display formats for each level of indentation (lvl).
+      # This function will load up the relevant data into the @numbering class variable in the form
+      # of a nested hash: @numbering[numbering ID][indentation level] = number format.
+      @numbering = {}
+      xml = Nokogiri::XML(numbering_xml)
+      xml.xpath("//w:num").each do |num|
+        numId = num['w:numId'].to_i
+        abstractNumId = num.xpath("./w:abstractNumId")[0]['w:val'].to_i
+        abstract_numbering = {}
+        xml.xpath("//w:abstractNum[@w:abstractNumId='#{abstractNumId}']/w:lvl").each do |level_format|
+          level = level_format['w:ilvl'].to_i
+          format = level_format.xpath("./w:numFmt")[0]['w:val']
+          abstract_numbering[level] = format
+        end
+        @numbering[numId] = abstract_numbering
+      end
+    end
+
+    # Parse the relationships XML (defining things such as internal references and external links)
+    def parse_relationships(relationships_xml)
+      # The XML contains a list of relationships identified by an id. Each relationship includes
+      # a target attribute designating the reference. THis function will load up the relevant
+      # data into the @relationships class variable in the form of a hash:
+      # @relationships[relationship ID] = target URI.
+      @relationships = {}
+      xml = Nokogiri::XML(relationships_xml)
+      xml.css("Relationship").each do |rel| # Nokogiri doesn't seem to like XPath here for some reason
+        @relationships[rel['Id']] = rel['Target']
+      end
+    end
+
+    # NODE PARSERS
+    # Each of the methods below (beginning with '_node') are specialized parsers for handling
+    # a particular type of XML element.
+
+    # Parse one or more runs
+    def _node_parse_runs(node)
+      # The 'run' is the basic unit of text in Office OpenXML. A paragraph, table cell, or other
+      # block element may contain one or more runs, and each run has an associated set of styles.
+      texts = []
+      node.children.each do |run_xml|
+        case run_xml.name
+          when 'r'
+            # A true run node
+            text = Swordfish::Node::Text.new
+            text.content = run_xml.xpath('./w:t')[0].content
+            get_styles_for_node(text, run_xml.xpath('./w:rPr')[0])
+            texts << text
+          when 'hyperlink'
+            # Hyperlink nodes are placed amongst other run nodes, but
+            # they themselves also contain runs. Hyperlinks include
+            # a relationship ID attribute defining their reference.
+            link = Swordfish::Node::Hyperlink.new
+            link.href = @relationships[run_xml['r:id']]
+            _node_parse_runs(run_xml).each {|r| link.append(r)}
+            texts << link
+        end
+      end
+      texts
+    end
+
+    # Parse a paragraph
+    def _node_parse_paragraph(node)
+      paragraph = Swordfish::Node::Paragraph.new
+      _node_parse_runs(node).each {|r| paragraph.append(r)}
+      paragraph
+    end
+
+    # Parse a list
+    def _node_parse_list(node)
+      # In Office OpenXML, a list is not a distinct element type, but rather a
+      # specialized paragraph that references an abstract numbering scheme
+      # and includes an indentation level. As a result, the build buffer
+      # must be used to assemble the Swordfish::Node representation of the list,
+      # since the only way to tell the list has been fully parsed is to encounter
+      # a non-list element.
+
+      # Get the list item's abstract numbering and level
+      list_item = Swordfish::Node::ListItem.new
+      _node_parse_runs(node).each {|r| list_item.append(r)}
+      level = node.xpath(".//w:numPr/w:ilvl")[0]['w:val'].to_i
+      numbering_scheme = node.xpath(".//w:numPr/w:numId")[0]['w:val'].to_i
+
+      # If the build buffer is empty, this is a new list
+      unless @buffer
+        @buffer = Swordfish::Node::List.new
+        @buffer.stylize @numbering[numbering_scheme][level].to_sym
+      end
+
+      # Compare the level of this list item to the bottommost node in
+      # the build buffer to determine where in the hierarchy to add
+      # this node (i.e., are we dealing with list nesting or not?)
+      if @buffer.depth_of_final_node >= level
+        # Add sibling to existing list
+        target = @buffer
+        level.times do
+          target = target.last_list_item.nested_list
+        end
+        target.append list_item
+      elsif @buffer.depth_of_final_node < level
+        # Add new nested list
+        target = @buffer
+        (level - 1).times do
+          target = target.last_list_item.nested_list
+        end
+        list = Swordfish::Node::List.new
+        list.append list_item
+        list.stylize @numbering[numbering_scheme][level].to_sym
+        target.last_list_item.append list
+      end
+    end
+
+    # Parse a table
+    def _node_parse_table(node)
+      table = Swordfish::Node::Table.new
+      node.xpath("./w:tr").each do |row|
+        table.append _node_parse_table_row(row)
+      end
+      table
+    end
+
+    # Parse a table row
+    def _node_parse_table_row(node)
+      row = Swordfish::Node::TableRow.new
+      node.xpath('./w:tc').each do |cell|
+        row.append _node_parse_table_cell(cell)
+      end
+      row
+    end
+
+    # Parse a table cell
+    def _node_parse_table_cell(node)
+      # In a Swordfish::Node::Table object, the number of table cells must equal the
+      # total number of rows times the total number of columns; that is, even if
+      # two cells are merged together, there must be a Swordfish::Node::TableCell for
+      # each one. Merges are defined using the "merge_up" and "merge_left" properties.
+
+      cell = Swordfish::Node::TableCell.new
+      extra_cells = []
+
+      # Get the inner content of the cell
+      node.xpath("./w:p").each do |paragraph|
+        cell.append _node_parse_paragraph(paragraph)
+      end
+      
+      # Determine whether this cell spans multiple rows. In Office OpenXML,
+      # a table cell is defined in every row, even if the cell is vertically-merged. The representation
+      # of the merged cell within each row is given a vMerge property, with the topmost one also
+      # having a vMerge value of "restart", and the others having no vMerge value.
+      if node.xpath("./w:tcPr/w:vMerge").length > 0 && node.xpath("./w:tcPr/w:vMerge")[0]['w:val'].nil?
+        cell.merge_up = true
+      end
+
+      # Determine whether this cell spans multiple columns. Unlike with vertical merges,
+      # a horizontally-merged Office OpenXML cell is only defined once, but is given a gridSpan
+      # property defining the number of columns it spans. Since Swordfish requires a cell for each
+      # column, loop to generate the additional cells, and set their merge_left values appropriately.
+      if node.xpath("./w:tcPr/w:gridSpan").length > 0
+        node.xpath("./w:tcPr/w:gridSpan")[0]['w:val'].to_i.-(1).times do
+          c = Swordfish::Node::TableCell.new
+          c.merge_left = true
+          extra_cells << c
+        end
+      end
+
+      # Return the generated cell or cells
+      if extra_cells.empty?
+        return cell
+      else
+        return [cell] + extra_cells
+      end
+    end
+
+  end
+end

data/lib/swordfish/nodes/base.rb

@@ -0,0 +1,47 @@
+# Superclass for all Swordfish::Node objects
+
+module Swordfish
+  module Node
+    class Base
+
+      attr_accessor :content
+      attr_reader :children
+      attr_reader :style
+
+      # Initialize with a blank stylesheet and no children
+      def initialize
+        @style = Swordfish::Stylesheet.new []
+        @children = []
+      end
+
+      # Append a node or nodes to this node as a child
+      def append(node)
+        @children ||= []
+        @children << node
+        @children.flatten!
+      end
+
+      # Take a style or styles and add them to this node's stylesheet
+      def stylize(styles)
+        @style.merge styles
+      end
+
+      # Every subclass must implement to_html in order to be converted to HTML
+      def to_html
+        raise NotImplementedError
+      end
+
+      # Given a hash, create instance variables for each key in that hash.
+      # This is used for communication between nodes in the hierarchy.
+      def inform!(hash)
+        hash.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+      end
+
+    end
+
+    class BadContentError < Exception
+    end
+  end
+end

data/lib/swordfish/nodes/hyperlink.rb

@@ -0,0 +1,15 @@
+# A hyperlink node.
+
+module Swordfish
+  module Node
+    class Hyperlink < Base
+
+      attr_accessor :href
+
+      def to_html
+        "<a href='#{@href}'>#{@children.map(&:to_html).join}</a>"
+      end
+
+    end
+  end
+end

data/lib/swordfish/nodes/list.rb

@@ -0,0 +1,33 @@
+# A list node
+
+module Swordfish
+  module Node
+    class List < Base
+
+      def to_html
+        if @style.bullet?
+          "<ul>#{@children.map(&:to_html).join}</ul>"
+        else
+          "<ol>#{@children.map(&:to_html).join}</ol>"
+        end
+      end
+
+      # Get the zero-indexed depth of the bottommost child list
+      # (This is not the deepest node, just the last child)
+      def depth_of_final_node
+        depth = 0
+        node = self
+        while !@children.empty? && node = node.last_list_item.nested_list do
+          depth += 1
+        end
+        depth
+      end
+
+      # Return the final child list item (no nesting)
+      def last_list_item
+        @children.last
+      end
+
+    end
+  end
+end

data/lib/swordfish/nodes/list_item.rb

@@ -0,0 +1,18 @@
+# A list item node
+
+module Swordfish
+  module Node
+    class ListItem < Base
+
+      def to_html
+        "<li>#{@children.map(&:to_html).join}</li>"
+      end
+
+      # Return the nested list, or nil if this list item has no nested lists
+      def nested_list
+        @children.last.is_a?(Swordfish::Node::List) ? @children.last : nil
+      end
+
+    end
+  end
+end

data/lib/swordfish/nodes/paragraph.rb

@@ -0,0 +1,17 @@
+# A paragraph node
+
+module Swordfish
+  module Node
+    class Paragraph < Base
+
+      def to_html
+        if @content
+          "<p>#{@content}</p>"
+        else
+          "<p>#{@children.map(&:to_html).join}</p>"
+        end
+      end
+
+    end
+  end
+end

data/lib/swordfish/nodes/table.rb

@@ -0,0 +1,85 @@
+# A table node
+
+module Swordfish
+  module Node
+    class Table < Base
+
+      # Get the number of rows in the table
+      def rows
+        @children.length
+      end
+
+      # Get the number of columns in the table
+      def cols
+        @children[0].children.length
+      end
+
+      # Return the TableCell object at a given position
+      def cell_at(row, col)
+        @children[row].children[col]
+      end
+
+      def to_html
+        collapse_cells!
+        "<table><tbody>#{@children.map(&:to_html).join}</tbody></table>"
+      end
+
+      private
+
+      # A Swordfish::Node::Table always contains rows*cols cells, even
+      # if some of them are to be merged. This method determines how
+      # cells ought to be merged together and then informs each cell
+      # of its configuration, so that each cell will then properly know
+      # how to render itself (if at all).
+      def collapse_cells!
+        # Create a 2D array representing each cell, and give each one
+        # an initial colspan and rowspan of 1
+        structure = []
+        rows.times do
+          r = []
+          cols.times do
+            r << {:colspan => 1, :rowspan => 1}
+          end
+          structure << r
+        end
+
+        # Iterate over each table cell and see if it has the merge_up
+        # or merge_left properties set. If so, find the corresponding
+        # "parent" cell and incremenet its colspan or rowspan appropriately.
+        # If the cell is to be merged up or left, set its value to nil
+        # within the "structure" variable.
+        rows.times do |r|
+          cols.times do |c|
+            if cell_at(r, c).merge_up?
+              (r-1).downto(0).each do |i|
+                unless structure[i][c].nil?
+                  structure[i][c][:rowspan] += 1
+                  break
+                end
+              end
+              structure[r][c] = nil
+            end
+            if cell_at(r, c).merge_left?
+              (c-1).downto(0).each do |i|
+                unless structure[r][i].nil?
+                  structure[r][i][:colspan] += 1
+                  break
+                end
+              end
+              structure[r][c] = nil
+            end
+          end
+        end
+
+        # Inform every table cell of its calculated colspan and rowspan.
+        # If the cell is not to be drawn, set its rowspan and colspan to 0.
+        rows.times do |r|
+          cols.times do |c|
+            cell_at(r, c).inform!(structure[r][c] || {:colspan => 0, :rowspan => 0})
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/swordfish/nodes/table_cell.rb

@@ -0,0 +1,37 @@
+# A table cell node
+
+module Swordfish
+  module Node
+    class TableCell < Base
+
+      attr_accessor :merge_left
+      attr_accessor :merge_up
+      attr_reader :rowspan
+      attr_reader :colspan
+
+      # True if this cell is merged with the one to the left
+      def merge_left?
+        !!@merge_left
+      end
+
+      # True if this cell is merged with the one above
+      def merge_up?
+        !!@merge_up
+      end
+
+      def to_html
+        return nil if @colspan == 0 && @rowspan == 0
+
+        if @rowspan && @rowspan > 1
+          rowspan = " rowspan=#{@rowspan}"
+        end
+        if @colspan && @colspan > 1
+          colspan = " colspan=#{@colspan}"
+        end
+
+        "<td#{rowspan}#{colspan}>#{@children.map(&:to_html).join}</td>"
+      end
+
+    end
+  end
+end

data/lib/swordfish/nodes/table_row.rb

@@ -0,0 +1,13 @@
+# A table row node
+
+module Swordfish
+  module Node
+    class TableRow < Base
+
+      def to_html
+        "<tr>#{@children.map(&:to_html).join}</tr>"
+      end
+
+    end
+  end
+end

data/lib/swordfish/nodes/text.rb

@@ -0,0 +1,25 @@
+# A generic text node
+
+module Swordfish
+  module Node
+    class Text < Base
+
+      # Override Base append because a text node should never have children
+      def append(node)
+        raise BadContentError
+      end
+
+      def to_html
+        html = @content
+        html = "<i>#{html}</i>" if @style.italic?
+        html = "<b>#{html}</b>" if @style.bold?
+        html = "<u>#{html}</u>" if @style.underline?
+        html = "<strike>#{html}</strike>" if @style.strikethrough?
+        html = "<sup>#{html}</sup>" if @style.superscript?
+        html = "<sub>#{html}</sub>" if @style.subscript?
+        html
+      end
+
+    end
+  end
+end

data/lib/swordfish/stylesheet.rb

@@ -0,0 +1,42 @@
+# Swordfish::Stylesheet represents formatting applied to a node
+
+module Swordfish
+  class Stylesheet
+    
+    # Define all supported values here
+    SUPPORTED_STYLES = [
+      # Inline styles
+      :bold, :italic, :underline, :superscript, :subscript, :strikethrough,
+      # List enumeration styles
+      :bullet, :decimal, :lowerLetter, :lowerRoman
+    ]
+
+    # Initialize a stylesheet with an optional list of styles
+    def initialize(styles)
+      @styles = []
+      merge styles
+    end
+
+    # Take a style or list of styles and add them to an existing stylesheet
+    def merge(styles)
+      styles = [styles] unless styles.is_a?(Array)
+      @styles |= styles.select{|s| SUPPORTED_STYLES.include?(s)}
+    end
+    
+    # For each supported style, define a boolean method to check its presence
+    # (i.e., :bold?, :italic?, etc.)
+    SUPPORTED_STYLES.each do |style|
+      define_method "#{style}?".to_sym do
+        has_style?(style)
+      end
+    end
+
+    private
+
+    # Check if a style is included in a stylesheet
+    def has_style?(style)
+      @styles.include? style
+    end
+
+  end
+end

data/lib/swordfish.rb

@@ -0,0 +1,19 @@
+require 'swordfish/document'
+require 'swordfish/formats/docx'
+
+module Swordfish
+  
+  # Main entry point into the parser. Pass in a filepath and return a parsed document.
+  def self.open(filepath)
+    extension = filepath.split('.').last.downcase
+    case extension
+      when 'docx'
+        Swordfish::DOCX.open(filepath)
+      else
+        raise UnsupportedFormatError, "'#{extension}' is not a recognized file format"
+    end
+  end
+
+  class UnsupportedFormatError < LoadError
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: swordfish
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Martin Posthumus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple library for various word processor formats focusing primarily
+  around conversion to HTML
+email: martin.posthumus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/swordfish.rb
+- lib/swordfish/document.rb
+- lib/swordfish/formats/docx.rb
+- lib/swordfish/nodes/base.rb
+- lib/swordfish/nodes/hyperlink.rb
+- lib/swordfish/nodes/list.rb
+- lib/swordfish/nodes/list_item.rb
+- lib/swordfish/nodes/paragraph.rb
+- lib/swordfish/nodes/table.rb
+- lib/swordfish/nodes/table_cell.rb
+- lib/swordfish/nodes/table_row.rb
+- lib/swordfish/nodes/text.rb
+- lib/swordfish/stylesheet.rb
+homepage: https://github.com/voikya/swordfish
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+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 simple library for various word processor formats
+test_files: []
+has_rdoc: