ooxl 0.0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c939544ca8395b5cad397848b69e789073e4e036
+  data.tar.gz: 85910bb29f92f0bbfab570ca7125694efaa81a90
+SHA512:
+  metadata.gz: 42f4c2e796683bbafddb15312be2a9e175205c2d1b8cf51a19cabdb944ba0d18a92e1462fc80588c565bb937384e2cb92666ae6e2db3162fc1d88614bed4cd02
+  data.tar.gz: 0db40f7d63f5647c901fc94d85a63835f246794a11ab26dfb2523b1a908046b6b74a26943246b36cdffb39087cab4d4b39b3b22e2f00769c627f6e37a3c435e9

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/test

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in moon_xl.gemspec
+gemspec

data/README.md

@@ -0,0 +1,134 @@
+# OOXML Excel
+
+TODO: Description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ooxml_excel'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ooxml_excel
+
+## Usage
+
+### Using `OOXML::Excel` to read spreadsheet:
+```
+ooxml_excel = OOXML::Excel.new('example.xlsx')
+```
+
+### Fetching all sheets:
+```
+ooxml_excel.sheets # ['Test Sheet 1', 'Test Sheet 2']
+```
+
+### Accessing Rows and Cells
+```
+sheet = ooxml_excel.sheet('Test Sheet 1')
+
+# Rows
+sheet[0] # Access the first row
+sheet.rows[0] # Same as above
+
+# Cells
+sheet[0].cells # Fetch all cells
+sheet.rows[0].cells # longer way to do it
+
+sheet[0][0] # Access the first cell of the row
+sheet.rows[0].cells[0] # longer way to do it
+
+sheet[0][0].value # Access cell value
+sheet.rows[0].cells[0].value # longer way to do it
+
+ooxml_excel['Test Sheet 1'][0][0].value
+```
+
+### Iterating through each row:
+```
+# as an array of strings
+ooxml_excel.sheet('Test Sheet 1').each_row do |row|
+  # Do something here...
+  p row # ['text', 'text']
+end
+
+# as an array of objects
+ooxml_excel.sheet('Test Sheet 1').each_row_as_object do |row|
+  # Do something here...
+  p row.cells # [OOXML::Excel::Row::Cell, ...]
+end
+
+```
+
+### Fetching Columns
+```
+# Fetch all columns
+ooxml_excel.sheet('Test Sheet 1').columns
+
+# Checking if the column is hidden
+ooxml_excel.sheet('Test Sheet 1').column(1).hidden? # column index
+ooxml_excel.sheet('Test Sheet 1').column('A').hidden? # column letter
+```
+
+### Fetching Styles
+```
+# Font
+font_object = ooxml_excel.sheet('Test Sheet 1').font('A1')
+font_object.bold? # false
+font_object.name # Arial
+font_object.rgb_color # FFE10000
+font_object.size # 8
+
+# Cell Fill
+fill_object = ooxml_excel.sheet('Test Sheet 1').fill('A1')
+fill_object.bg_color # FFE10000
+fill_object.fg_color # FFE10000
+```
+### Fetching Data from named/cell range
+```
+# named range
+ooxml_excel.named_range('my_named_range') # ['value' 'from', 'range']
+
+# cell range
+ooxml['Lists'!$A$1:$A$6] # ['1','2','3','4','5','6']
+
+# or
+ooxml['Lists'!A1:A6] # ['1','2','3','4','5','6']
+
+# or loading a single value
+ooxml['Lists'!A1] # ['1']
+
+# or loading a box type values
+ooxml['Lists!A1:B2'] # [['1', '2'], ['2','3']]
+
+```
+### Fetching Data Validation
+```
+# All Validations
+data_validations = ooxml_excel.sheet('Test Sheet 1').data_validations
+
+# Specific validation for cell
+data_validation = ooxml.sheet('Input Sheet').data_validation('D4')
+
+data_validation.prompt # "Sample Validation Message"
+data_validation.formula # 20
+data_validation.type #textLength
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/halcjames/ooxml_excel.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ooxml_excel"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ooxl.rb

@@ -0,0 +1,18 @@
+# dependencies
+require 'nokogiri'
+require 'active_support/all'
+require 'zip'
+
+# gem
+require "ooxl/version"
+
+# library
+require "ooxl/ooxl"
+require "ooxl/util"
+require "ooxl/xl_objects/workbook"
+require "ooxl/xl_objects/comments"
+require "ooxl/xl_objects/styles"
+require "ooxl/xl_objects/sheet"
+require "ooxl/xl_objects/row"
+require "ooxl/xl_objects/column"
+require "ooxl/xl_objects/cell"

data/lib/ooxl/ooxl.rb

@@ -0,0 +1,90 @@
+class OOXL
+  include Enumerable
+  def initialize(spreadsheet_filepath)
+    @workbook = nil
+    @sheets = {}
+    @styles = []
+    @comments = {}
+    parse_spreadsheet_contents(spreadsheet_filepath)
+  end
+
+  def self.open(spreadsheet_filepath)
+    new(spreadsheet_filepath)
+  end
+
+  def sheets
+    @workbook.sheets.map { |sheet| sheet[:name]}
+  end
+
+  def each
+    sheets.each do |sheet_name|
+      yield sheet(sheet_name)
+    end
+  end
+
+  def sheet(sheet_name)
+    sheet_index = @workbook.sheets.index { |sheet| sheet[:name] == sheet_name}
+    raise "No #{sheet_name} in workbook." if sheet_index.nil?
+    sheet = @sheets.fetch((sheet_index+1).to_s)
+
+    # shared variables
+    sheet.name = sheet_name
+    sheet.comments = @comments[(sheet_index+1)]
+    sheet.styles = @styles
+    sheet.defined_names = @workbook.defined_names
+    sheet
+  end
+
+  def [](text)
+    # immediately treat as cell range if an exclamation point is detected
+    # otherwise, normally load a sheet
+
+    text.include?('!') ? load_list_values(text) : sheet(text)
+  end
+
+  def named_range(name)
+    # "Hidden11390550_39"=>"Hidden!$B$734:$B$735"
+    # ooxml.named_range('Hidden11390550_107')
+    # a typical named range would be be
+    # yes_no => 'Lists'!$A$1:$A$6
+    defined_name = @workbook.defined_names[name]
+    load_list_values(defined_name) if defined_name.present?
+  end
+
+  private
+
+  def load_list_values(range_text)
+    # get the sheet name => 'Lists'
+    sheet_name = range_text.gsub(/[\$\']/, '').scan(/^[^!]*/).first
+    # fetch the cell range => '$A$1:$A$6'
+    cell_range = range_text.gsub(/\$/, '').scan(/(?<=!).+/).first
+    # get the sheet object and fetch the cells in range
+    sheet(sheet_name).list_values_from_cell_range(cell_range)
+  end
+
+  def parse_spreadsheet_contents(spreadsheet)
+    shared_strings = []
+    Zip::File.open(spreadsheet) do |spreadsheet_zip|
+      spreadsheet_zip.each do |entry|
+        case entry.name
+        when /xl\/worksheets\/sheet(\d+)?\.xml/
+          sheet_id = entry.name.scan(/xl\/worksheets\/sheet(\d+)?\.xml/).flatten.first
+          @sheets[sheet_id] = OOXL::Sheet.new(entry.get_input_stream.read, shared_strings)
+        when /xl\/styles\.xml/
+          @styles = OOXL::Styles.load_from_stream(entry.get_input_stream.read)
+        when /xl\/comments(\d+)?\.xml/
+          comment_id = entry.name.scan(/xl\/comments(\d+)\.xml/).flatten.first
+          @comments[comment_id] = OOXL::Comments.load_from_stream(entry.get_input_stream.read)
+        when "xl/sharedStrings.xml"
+          Nokogiri.XML(entry.get_input_stream.read).remove_namespaces!.xpath('sst/si').each do |shared_string_node|
+            shared_strings << shared_string_node.at('t').text
+          end
+        when "xl/workbook.xml"
+          @workbook = OOXL::Workbook.load_from_stream(entry.get_input_stream.read)
+        else
+          # unsupported for now..
+        end
+      end
+    end
+  end
+end

data/lib/ooxl/util.rb

@@ -0,0 +1,16 @@
+class OOXL
+  module Util
+    COLUMN_LETTERS = ('A'..'ZZZZ').to_a
+    def letter_equivalent(index)
+      COLUMN_LETTERS.fetch(index)
+    end
+
+    def letter_index(letter)
+      COLUMN_LETTERS.index { |c_letter| c_letter == letter}
+    end
+
+    def uniform_reference(ref)
+      ref.to_s[/[A-Z]/] ? letter_index(ref) + 1 : ref
+    end
+  end
+end

data/lib/ooxl/version.rb

@@ -0,0 +1,3 @@
+class OOXL
+  VERSION = "0.0.1.2"
+end

data/lib/ooxl/xl_objects/cell.rb

@@ -0,0 +1,106 @@
+class OOXL
+  class BlankCell
+    attr_reader :id
+
+    def initialize(id)
+      @id = id
+    end
+    def value
+      nil
+    end
+  end
+
+  class Cell
+    attr_accessor :id, :type_id, :style_id, :value_id, :shared_strings, :styles
+
+    def initialize(**attrs)
+      attrs.each { |property, value| send("#{property}=", value)}
+    end
+
+    def next_id(offset: 1, location: "bottom")
+      _, column_letter, column_index = id.partition(/[A-Z]/)
+
+      # ensure that all are numbers
+      column_index = column_index.to_i
+      offset = offset.to_i if offset.is_a?(String)
+
+      # increment based on specified location
+      case location
+      when "top"
+        if column_index == 1 || column_index < offset
+          column_index = 1
+        else
+          column_index -= offset
+        end
+      when "bottom"
+        column_index += offset
+      when "left"
+        return id if column_letter == 'A'
+        1.upto(offset) { |count| column_letter = (column_letter.ord-1).chr unless column_letter == 'A' }
+      when "right"
+        1.upto(offset) { |count| column_letter.next! }
+      else
+        id
+      end
+
+      "#{column_letter}#{column_index}"
+    end
+
+    def type
+      @type ||= begin
+        case type_id
+        when 's' then :string
+        when 'n' then :number
+        when 'b' then :boolean
+        when 'd' then :date
+        when 'str' then :formula
+        when 'inlineStr' then :inline_str
+        else
+          :error
+        end
+      end
+    end
+
+    def style
+      @style ||= begin
+        if style_id.present?
+          style = styles.by_id(style_id.to_i)
+        end
+      end
+    end
+
+    def number_format
+      if (style.present?)
+        nf = style[:number_format]
+        (nf.present?) ? nf.gsub("\\", "") : nil
+      end
+    end
+
+    def font
+      (style.present?) ? style[:font] : nil
+    end
+
+    def fill
+      (style.present?) ? style[:fill]: nil
+    end
+
+    def value
+      case type
+      when :string
+        (value_id.present?) ? shared_strings[value_id.to_i] : nil
+      else
+        # TODO: to support other types soon
+        value_id
+      end
+    end
+
+    def self.load_from_node(cell_node, shared_strings, styles)
+      new(id: cell_node.attributes["r"].try(:value),
+          type_id: cell_node.attributes["t"].try(:value),
+          style_id: cell_node.attributes["s"].try(:value),
+          value_id: cell_node.at('v').try(:text),
+          shared_strings: shared_strings,
+          styles: styles )
+    end
+  end
+end

data/lib/ooxl/xl_objects/column.rb

@@ -0,0 +1,19 @@
+class OOXL
+  class Column
+    attr_accessor :id, :width, :custom_width, :id_range, :hidden
+    alias_method :hidden?, :hidden
+
+    def initialize(**attrs)
+      attrs.each { |property, value| send("#{property}=", value)}
+    end
+
+    def self.load_from_node(column_node)
+      hidden_attr = column_node.attributes["hidden"]
+      new(id: column_node.attributes["min"].try(:value),
+          width: column_node.attributes["width"].try(:value),
+          custom_width: column_node.attributes["custom_width"].try(:value),
+          id_range: (column_node.attributes["min"].value.to_i..column_node.attributes["max"].value.to_i).to_a,
+          hidden: (hidden_attr.present?) ? hidden_attr.value == "1" : false)
+    end
+  end
+end

data/lib/ooxl/xl_objects/comments.rb

@@ -0,0 +1,32 @@
+class OOXL
+  class Comments
+    attr_reader :comments
+
+    def initialize(comments)
+      @comments = comments
+    end
+
+    def [](id)
+      @comments[id]
+    end
+
+    def self.load_from_stream(comment_xml)
+      comment_xml =Nokogiri.XML(comment_xml).remove_namespaces!
+
+      comments = comment_xml.xpath("//comments/commentList/comment").map do |comment_node|
+        comment_text_node = comment_node.xpath('./text/r/t')
+
+        value = if comment_text_node.is_a?(Array)
+          comment_text_node.map { |comment_text_node| comment_text_node.text }.join('')
+        else
+          comment_text_node.text
+        end
+
+        # value = (comment_node.xpath('./text/r/t').last || comment_node.at_xpath('./text/r/t') || comment_node.at_xpath('./text/t')).text
+        id = comment_node.attributes["ref"].to_s
+        [id, value]
+      end.to_h
+      new(comments)
+    end
+  end
+end

data/lib/ooxl/xl_objects/row.rb

@@ -0,0 +1,29 @@
+class OOXL
+  class Row
+    include Enumerable
+    attr_accessor :id, :spans, :cells
+
+    def initialize(**attrs)
+      attrs.each { |property, value| send("#{property}=", value)}
+    end
+
+    def [](id)
+      cell = if id.is_a?(String)
+        cells.find { |row| row.id == id}
+      else
+        cells[id]
+      end
+      (cell.present?) ? cell : BlankCell.new(id)
+    end
+
+    def each
+      cells.each { |cell| yield cell }
+    end
+
+    def self.load_from_node(row_node, shared_strings, styles)
+      new(id: row_node.attributes["r"].try(:value),
+          spans: row_node.attributes["spans"].try(:value),
+          cells: row_node.xpath('c').map {  |cell_node| OOXL::Cell.load_from_node(cell_node, shared_strings, styles) } )
+    end
+  end
+end

data/lib/ooxl/xl_objects/sheet.rb

@@ -0,0 +1,156 @@
+require_relative 'sheet/data_validation'
+class OOXL
+  class Sheet
+    include OOXL::Util
+    include Enumerable
+    attr_reader :columns, :data_validations, :shared_strings
+    attr_accessor :comments, :styles, :defined_names, :name
+
+    def initialize(xml, shared_strings)
+      @xml = Nokogiri.XML(xml).remove_namespaces!
+      @shared_strings = shared_strings
+      @comments = {}
+      @defined_names = {}
+      @styles = []
+    end
+
+    def code_name
+      @code_name ||= @xml.xpath('//sheetPr').attribute('codeName').try(:value)
+    end
+
+    def comment(cell_ref)
+      @comments[cell_ref]
+    end
+
+    def data_validation(cell_ref)
+      data_validations.find { |data_validation| data_validation.in_sqref_range?(cell_ref)}
+    end
+
+    def column(id)
+      uniformed_reference = uniform_reference(id)
+      columns.find { |column| column.id_range.include?(uniformed_reference)}
+    end
+
+    def columns
+      @columns ||= begin
+        @xml.xpath('//cols/col').map do |column_node|
+          Column.load_from_node(column_node)
+        end
+      end
+    end
+
+    def [](id)
+      if id.is_a?(String)
+        rows.find { |row| row.id == id}
+      else
+        rows[id]
+      end
+    end
+
+    def row(index)
+      rows.find { |row| row.id == index.to_s}
+    end
+
+    def rows
+      @rows ||= begin
+        # TODO: get the value of merged cells
+        # merged_cells = @xml.xpath('//mergeCells/mergeCell').map { |merged_cell| merged_cell.attributes["ref"].try(:value) }
+        @xml.xpath('//sheetData/row').map do |row_node|
+          Row.load_from_node(row_node, @shared_strings, styles)
+        end
+      end
+    end
+
+    def each
+      rows.each { |row| yield row }
+    end
+
+    def font(cell_reference)
+      style_id = fetch_style_style_id(cell_reference)
+      if style_id.present?
+        style = @styles.by_id(style_id.to_i)
+
+        (style.present?) ? style[:font] : nil
+      end
+    end
+
+    def fill(cell_reference)
+      style_id = fetch_style_style_id(cell_reference)
+      if style_id.present?
+        style = @styles.by_id(style_id.to_i)
+        (style.present?) ? style[:fill] : nil
+      end
+    end
+
+
+    def data_validations
+      @data_validations ||= begin
+        @xml.xpath('//dataValidations/dataValidation').map do |data_validation_node|
+          Sheet::DataValidation.load_from_node(data_validation_node)
+        end
+      end
+    end
+
+    # a shortcut for:
+    # formula =  data_validation('A1').formula
+    # ooxl.named_range(formula)
+    def cell_range(cell_ref)
+      data_validation = data_validations.find { |data_validation| data_validation.in_sqref_range?(cell_ref)}
+      if data_validation.respond_to?(:type) && data_validation.type == "list"
+        if data_validation.formula[/[\s\$\,\:]/]
+          (data_validation.formula[/\$/].present?) ? "#{name}!#{data_validation.formula}" : data_validation.formula
+        else
+          @defined_names.fetch(data_validation.formula)
+        end
+      end
+    end
+
+    def list_values_from_cell_range(cell_range)
+      return [] if cell_range.blank?
+
+      # cell_range values separated by comma
+      if cell_range.include?(":")
+        cell_letters = cell_range.gsub(/[\d]/, '').split(':')
+        start_index, end_index = cell_range.gsub(/[^\d:]/, '').split(':').map(&:to_i)
+
+        # This will allow values from this pattern
+        # 'SheetName!A1:C3'
+        # The number after the cell letter will be the index
+        # 1 => start_index
+        # 3 => end_index
+        # Expected output would be: [['value', 'value', 'value'], ['value', 'value', 'value'], ['value', 'value', 'value']]
+        if cell_letters.uniq.size > 1
+          start_index.upto(end_index).map do  |row_index|
+            (cell_letters.first..cell_letters.last).map do |cell_letter|
+                row = rows[row_index-1]
+                next if row.blank?
+                row["#{cell_letter}#{row_index}"].value
+            end
+          end
+        else
+          cell_letter = cell_letters.uniq.first
+          (start_index..end_index).to_a.map do |row_index|
+            row = rows[row_index-1]
+            next if row.blank?
+            row["#{cell_letter}#{row_index}"].value
+          end
+        end
+      else
+        # when only one value: B2
+        row_index = cell_range.gsub(/[^\d:]/, '').split(':').map(&:to_i).first
+        row = rows[row_index-1]
+        return if row.blank?
+        [row[cell_range].value]
+      end
+    end
+
+    private
+    def fetch_style_style_id(cell_reference)
+      raise 'Invalid Cell Reference!' if cell_reference[/[A-Z]{1,}\d+/].blank?
+      row_index = cell_reference.scan(/[A-Z{1,}](\d+)/).flatten.first.to_i - 1
+      return if rows[row_index].blank? || rows[row_index][cell_reference].blank?
+      rows[row_index][cell_reference].style_id
+    end
+
+  end
+end

data/lib/ooxl/xl_objects/sheet/data_validation.rb

@@ -0,0 +1,69 @@
+class OOXL
+  class Sheet
+    class DataValidation
+      attr_accessor :allow_blank, :prompt, :type, :sqref, :formula
+
+      def in_sqref_range?(cell_id)
+        return if cell_id.blank?
+        cell_letter = cell_id.gsub(/[\d]/, '')
+        index = cell_id.gsub(/[^\d]/, '').to_i
+        range = sqref_range.find { |single_cell_letter_or_range, row_range| single_cell_letter_or_range.is_a?(Range) ? single_cell_letter_or_range.cover?(cell_letter) : single_cell_letter_or_range == cell_letter}
+        range.last.include?(index) if range.present?
+      end
+
+      def self.load_from_node(data_validation_node)
+        allow_blank = data_validation_node.attribute('allowBlank').try(:value)
+        prompt = data_validation_node.attribute('prompt').try(:value)
+        type = data_validation_node.attribute('type').try(:value)
+        sqref = data_validation_node.attribute('sqref').try(:value)
+        formula = data_validation_node.at('formula1').try(:content)
+
+        self.new(allow_blank: allow_blank,
+                 prompt: prompt,
+                 type: type,
+                 sqref: sqref,
+                 formula: formula)
+      end
+
+      private
+      def initialize(**attrs)
+        attrs.each { |property, value| send("#{property}=", value)}
+      end
+
+      def sqref_range
+        @sqref_range ||= begin
+          # "BH5:BH271 BI5:BI271"
+          if !sqref.include?(':')
+            cell_letter = sqref.gsub(/[\d]/, '')
+            index = sqref.gsub(/[^\d]/, '').to_i
+            { cell_letter => (index..index)}
+          else
+            sqref.split( ' ').map do |splitted_by_space_sqref|
+              # ["BH5:BH271, "BI5:BI271"]
+              if splitted_by_space_sqref.is_a?(Array)
+                splitted_by_space_sqref.map do |sqref|
+                  build_range(splitted_by_space_sqref)
+                end
+              else
+                # "BH5:BH271"
+                build_range(splitted_by_space_sqref)
+              end
+            end.to_h
+          end
+        end
+      end
+
+      def build_range(sqref)
+        splitted_sqref = sqref.gsub(/[\d]/, '')
+        sqref_without_letters = sqref.gsub(/[^\d:]/, '')
+        if sqref.include?(':')
+          start_letter, end_letter = splitted_sqref.split(':')
+          start_index, end_index = sqref_without_letters.split(':').map(&:to_i)
+          [(start_letter..end_letter),(start_index..end_index)]
+        else
+          [(splitted_sqref..splitted_sqref),(sqref_without_letters..sqref_without_letters)]
+        end
+      end
+    end
+  end
+end

data/lib/ooxl/xl_objects/styles.rb

@@ -0,0 +1,51 @@
+require_relative 'styles/cell_style_reference'
+require_relative 'styles/fill'
+require_relative 'styles/font'
+require_relative 'styles/number_formatting'
+class OOXL
+  class Styles
+    attr_accessor :fonts, :fills, :number_formats, :cell_style_xfs
+    def initialize(**attrs)
+      attrs.each { |property, value| send("#{property}=", value)}
+    end
+
+    def by_id(id)
+      cell_style = cell_style_xfs.fetch(id)
+      {
+        font: fonts_by_index(cell_style.font_id),
+        fill: fills_by_index(cell_style.fill_id),
+        number_format: number_formats_by_index(cell_style.number_formatting_id),
+      }
+    end
+
+    def fonts_by_index(font_index)
+      @fonts[font_index]
+    end
+
+    def fills_by_index(fill_index)
+      @fills[fill_index]
+    end
+
+    def number_formats_by_index(number_format_index)
+      @number_formats.find { |number_format| number_format.id == number_format_index.to_s}.try(:code)
+    end
+
+    def self.load_from_stream(xml_stream)
+      style_doc = Nokogiri.XML(xml_stream).remove_namespaces!
+      fonts = style_doc.xpath('//fonts/font')
+      fills = style_doc.xpath('//fills/fill')
+      number_formats = style_doc.xpath('//numFmts/numFmt')
+      # This element contains the master formatting records (xf) which
+      # define the formatting applied to cells in this workbook.
+      # link: https://msdn.microsoft.com/en-us/library/documentformat.openxml.spreadsheet.cellformats(v=office.14).aspx
+      cell_style_xfs =  style_doc.xpath('//cellXfs/xf')
+
+      self.new(
+        fonts: fonts.map { |font_node| Styles::Font.load_from_node(font_node)},
+        fills: fills.map { |fill_node| Styles::Fill.load_from_node(fill_node) if fill_node.to_s.include?('patternFill')},
+        number_formats: number_formats.map { |num_fmt_node| Styles::NumberFormatting.load_from_node(num_fmt_node) },
+        cell_style_xfs: cell_style_xfs.map { |cell_style_xfs_node| Styles::CellStyleReference.load_from_node(cell_style_xfs_node)}
+      )
+    end
+  end
+end

data/lib/ooxl/xl_objects/styles/cell_style_reference.rb

@@ -0,0 +1,19 @@
+class OOXL
+  class Styles
+    class CellStyleReference
+      attr_accessor :id, :number_formatting_id, :fill_id, :font_id
+      def initialize(**attrs)
+        attrs.each { |property, value| send("#{property}=", value)}
+      end
+      def self.load_from_node(cell_style_xfs_node)
+        attributes = cell_style_xfs_node.attributes
+        self.new(
+          id: attributes["xfId"].value.to_i,
+          number_formatting_id: attributes["numFmtId"].value.to_i,
+          fill_id: attributes["fillId"].value.to_i,
+          font_id: attributes["fontId"].value.to_i
+        )
+      end
+    end
+  end
+end

data/lib/ooxl/xl_objects/styles/fill.rb

@@ -0,0 +1,31 @@
+class OOXL
+  class Styles
+    class Fill
+      attr_accessor :pattern_type, :fg_color, :fg_color_theme, :fg_color_tint, :bg_color_index, :bg_color, :fg_color_index
+
+      def initialize(**attrs)
+        attrs.each { |property, value| send("#{property}=", value)}
+      end
+      def self.load_from_node(fill_node)
+        pattern_fill = fill_node.at('patternFill')
+
+        pattern_type = pattern_fill.attributes["patternType"].value
+        if pattern_type == "solid"
+          fg_color = pattern_fill.at('fgColor')
+          bg_color = pattern_fill.at('bgColor')
+          fg_color_index = fg_color.class == Nokogiri::XML::Element ? fg_color.attributes["indexed"].try(:value) : nil
+
+          self.new(pattern_type: pattern_type,
+                  fg_color: (fg_color.present?) ? fg_color.attributes["rgb"].try(:value) : nil,
+                  fg_color_theme: (fg_color.present?) ? fg_color.attributes["theme"].try(:value) : nil,
+                  fg_color_tint:  (fg_color.present?) ? fg_color.attributes["tint"].try(:value) : nil,
+                  bg_color: (bg_color.present?) ?  bg_color.attributes["rgb"].try(:value) : nil,
+                  bg_color_index: (bg_color.present?) ?  bg_color.attributes["index"].try(:value) : nil,
+                  fg_color_index: fg_color_index)
+        else
+          self.new(pattern_type: pattern_type)
+        end
+      end
+    end
+  end
+end

data/lib/ooxl/xl_objects/styles/font.rb

@@ -0,0 +1,24 @@
+class OOXL
+  class Styles
+    class Font
+      attr_accessor :size, :name, :rgb_color, :theme, :bold
+      alias_method :bold?, :bold
+      def initialize(**attrs)
+        attrs.each { |property, value| send("#{property}=", value)}
+      end
+      def self.load_from_node(font_node)
+        font_size_node = font_node.at('sz')
+        font_color_node = font_node.at('color')
+        font_name_node = font_node.at('name')
+        font_bold_node = font_node.at('b')
+        self.new(
+          size: font_size_node && font_size_node.attributes["val"].value,
+          name: font_name_node && font_name_node.attributes["val"].value,
+          rgb_color: font_color_node && font_color_node.attributes["rgb"].try(:value) ,
+          theme: font_color_node && font_color_node.attributes["theme"].try(:value),
+          bold: font_bold_node.present?
+        )
+      end
+    end
+  end
+end

data/lib/ooxl/xl_objects/styles/number_formatting.rb

@@ -0,0 +1,13 @@
+class OOXL
+  class Styles
+    class NumberFormatting
+      attr_accessor :id, :code
+      def self.load_from_node(num_fmt_node)
+        new_format = self.new.tap do |number_format|
+          number_format.id = num_fmt_node.attributes["numFmtId"].try(:value)
+          number_format.code = num_fmt_node.attributes["formatCode"].try(:value)
+        end
+      end
+    end
+  end
+end

data/lib/ooxl/xl_objects/workbook.rb

@@ -0,0 +1,32 @@
+class OOXL
+  class Workbook
+    def initialize(xml)
+      @xml = xml
+    end
+
+    def sheets
+      @sheets ||= begin
+        @xml.xpath('//sheets/sheet').map do |sheet_node|
+          name = sheet_node.attribute('name').value
+          rel_id = sheet_node.attribute('id').value.gsub(/[^\d+]/, '')
+          sheet_id = sheet_node.attribute('sheetId').value
+          { name: name, sheet_id: sheet_id, relationship_id: rel_id}
+        end
+      end
+    end
+
+    def defined_names
+      @defined_names ||= begin
+        @xml.xpath('//definedNames/definedName').map do |defined_names_node|
+          name = defined_names_node.attribute('name').value
+          reference = defined_names_node.text
+          [name, reference]
+        end.to_h
+      end
+    end
+
+    def self.load_from_stream(xml_stream)
+      self.new (Nokogiri.XML(xml_stream).remove_namespaces!)
+    end
+  end
+end

data/ooxml_excel.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ooxl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ooxl"
+  spec.version       = OOXL::VERSION
+  spec.authors       = ["James Mones"]
+  spec.email         = ["bajong009@gmail.com"]
+  spec.summary       = %q{OOXL Excel - Parse Excel Spreadsheets (xlsx, xlsm).}
+  spec.description   = %q{A Ruby spreadsheet parser for Excel (xlsx, xlsm).}
+  spec.homepage      = "https://github.com/halcjames/ooxml_excel"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'nokogiri', '~> 1'
+  spec.add_dependency 'rubyzip', '~> 1.1', '< 2.0.0'
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: ooxl
+version: !ruby/object:Gem::Version
+  version: 0.0.1.2
+platform: ruby
+authors:
+- James Mones
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: nokogiri
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A Ruby spreadsheet parser for Excel (xlsx, xlsm).
+email:
+- bajong009@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/ooxl.rb
+- lib/ooxl/ooxl.rb
+- lib/ooxl/util.rb
+- lib/ooxl/version.rb
+- lib/ooxl/xl_objects/cell.rb
+- lib/ooxl/xl_objects/column.rb
+- lib/ooxl/xl_objects/comments.rb
+- lib/ooxl/xl_objects/row.rb
+- lib/ooxl/xl_objects/sheet.rb
+- lib/ooxl/xl_objects/sheet/data_validation.rb
+- lib/ooxl/xl_objects/styles.rb
+- lib/ooxl/xl_objects/styles/cell_style_reference.rb
+- lib/ooxl/xl_objects/styles/fill.rb
+- lib/ooxl/xl_objects/styles/font.rb
+- lib/ooxl/xl_objects/styles/number_formatting.rb
+- lib/ooxl/xl_objects/workbook.rb
+- ooxml_excel.gemspec
+homepage: https://github.com/halcjames/ooxml_excel
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: OOXL Excel - Parse Excel Spreadsheets (xlsx, xlsm).
+test_files: []