sheets 0.9.0

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+doc/*

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Bradley J. Spaulding
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+Sheets
+==========
+
+Sheets is a Facade on top of many spreadsheet formats, presenting them as simple, unified, native ruby arrays. It is intended to allow applications to easily import data from a wide variety of spreadsheet formats.
+
+With Sheets, all cell values are strings representing the final, evaluated value of the cell. 
+
+This does mean that, in some cases, you will be casting data back into its native format. 
+
+However, this eliminates the need to deal with multiple spreadsheet formats and normalize data types in your application logic.
+
+Your application only needs to care about the layout of the spreadsheet, and the format *you* want the data in.
+
+Usage
+----------
+
+To retrieve a list of parseable spreadsheet formats at runtime:
+
+    Sheets::Base.parseable_formats # => ["csv", "xls", "xlsx", "ods"]
+
+To open a spreadsheet, pass initialize Sheets::Base.new either a file path:
+
+    Sheets::Base.new( '/path/to/a/spreadsheet.(format)' )
+
+or a file handle:
+
+    Sheets::Base.new( File.open('/path/to/a/spreadsheet.(format)') )
+
+By default, Sheets will use the basename of the file to detect the spreadsheet type. You can override this by passing in the :format option:
+
+*This is necessary if you pass Sheets an IO object, like StringIO, that doesn't have metadata like a filename/path.*
+
+    Sheets::Base.new( an_io_object_with_spreadsheet_data, :format => :xls )
+
+Once you have imported a sheet, you can either grab the array:
+
+    sheet = Sheets::Base.new( # ... )
+    sheet.to_array
+
+or utilize any of the Enumerable functions on the sheet:
+
+    sheet = Sheets::Base.new( # ... )
+    sheet.collect {|row| puts row }
+
+Additionally, you may output the sheet in any of the renderable formats:
+
+    Sheets::Base.renderable_formats # => ['csv', 'xls']
+    sheet = Sheets::Base.new( file )
+    sheet.to_csv
+    sheet.to_xls
+
+Sheets::Base will skip the parsing phase if initialized with an array, allowing you to render arrays to a native spreadsheet format:
+
+    my_awesome_data = [ ["Date", "Spent", "Earned"], ["2011-04-11", "$0.00", "$5,000.00"] ]
+    sheet = Sheets::Base.new( my_awesome_data )
+    sheet.to_csv
+    sheet.to_xls
+
+Adding Parsers
+------------
+
+Parsers subclass Sheets::Parsers::Base, live in the Sheets::Parsers namespace and should respond to two methods:
+
+* formats: returns an array of string format names (file extensions) that this parser class supports
+* to_array: returns a simple array representation of the spreadsheet.
+
+Parsers have access to @data and @format in order to do their parsing. See lib/sheets/parsers/* for examples.
+
+Adding Renderers
+------------
+
+Renderers subclass Sheets::Renderers::Base, live in the Sheets::Renderers namespace and should respond to:
+
+* formats: returns an array of string format names that this parser class supports
+* to\_#{format}: For each format that a renderer supports, it should respond to "to\_#{format}", returning the file data of that format.
+
+Renderers are given access to the results of Sheets::Base#to_array as @data. See lib/sheets/renderers/* for examples.
+
+License
+----------
+
+Sheets is licensed under the [MIT License](http://www.opensource.org/licenses/mit-license.php). 
+
+Please note that Sheets is dependent upon the Spreadsheet gem, which is licensed under the [GPLv3](http://www.opensource.org/licenses/gpl-3.0.html).
+
+Credits
+----------
+
+Sheets takes full advantage of the great work done in these gems:
+
+* [Spreadsheet](http://spreadsheet.rubyforge.org/) - mhatakeyama@ywesee.com, zdavatz@ywesee.com
+* [Roo](http://roo.rubyforge.org/) - [Thomas Preymesser](mailto:thopre@gmail.com)

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :test do
+  require File.join(File.expand_path(File.dirname(__FILE__)), 'test', 'test_helper.rb')
+  Dir[ File.join(File.expand_path(File.dirname(__FILE__)), 'test', '**', '*_test.rb') ].each {|file| require file }
+end

data/lib/sheets.rb

@@ -0,0 +1,21 @@
+module Sheets
+  module Parsers; end
+  module Renderers; end
+
+  class UnsupportedSpreadsheetFormatError < StandardError; end
+end
+
+lib_path = File.expand_path(File.dirname(__FILE__))
+
+# Load Parsers
+require File.join lib_path, 'sheets', 'parseable.rb'
+require File.join lib_path, 'sheets', 'parsers', 'base.rb'
+Dir[ File.join lib_path, 'sheets', 'parsers', '*_parser.rb' ].each {|file| require file }
+
+# Load Renderers
+require File.join lib_path, 'sheets', 'renderable.rb'
+require File.join lib_path, 'sheets', 'renderers', 'base.rb'
+Dir[ File.join lib_path, 'sheets', 'renderers', '*_renderer.rb' ].each {|file| require file }
+
+# Load Sheets::Base
+require File.join lib_path, 'sheets', 'base.rb'

data/lib/sheets/base.rb

@@ -0,0 +1,28 @@
+module Sheets
+  class Base
+    include Parseable
+    include Renderable
+
+    def initialize(file, options = {})
+      if file.is_a?(Array)
+        @data = file
+        @extension = options[:format].to_s
+        return
+      end
+
+      file = File.open(file.to_s) unless file.respond_to? :read
+      options[:format] ||= File.basename(file.path || "").split('.')[-1]
+      
+      @data = file.read
+      @extension = options[:format].to_s
+      @file_path = File.expand_path(file.path || "")
+
+      raise UnsupportedSpreadsheetFormatError, "Couldn't find a parser for the '#{@extension}' format." if parser.nil?
+    end
+
+    alias_method :default_to_array, :to_array
+    def to_array
+      @data.is_a?(Array) ? @data : default_to_array
+    end
+  end
+end

data/lib/sheets/parseable.rb

@@ -0,0 +1,39 @@
+module Sheets
+  module Parseable
+    include Enumerable
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def parseable_formats
+        Sheets::Parsers.constants.collect {|constant_name| Sheets::Parsers.const_get(constant_name) }.map(&:formats).flatten.uniq
+      end
+    end
+
+    def each
+      to_array.each {|row| yield row }
+    end
+
+    def to_array
+      parser.send(:to_array)
+    end
+
+    private
+    def parser_class
+      classes = Sheets::Parsers.constants.map do |constant_name|
+        constant = Sheets::Parsers.const_get(constant_name)
+        constant if constant && constant.respond_to?(:formats) && constant.formats.map(&:to_s).include?(@extension)
+      end
+
+      classes.delete(nil)
+
+      classes.first
+    end
+
+    def parser
+      @parser ||= parser_class.new(@data, @extension, @file_path) unless parser_class.nil?
+    end
+  end
+end

data/lib/sheets/parsers/base.rb

@@ -0,0 +1,23 @@
+class Sheets::Parsers::Base
+  def initialize(data, format, file_path)
+    @data = data
+    @format = format
+    @file_path = file_path
+  end
+
+  def io
+    StringIO.new(@data)
+  end
+
+  def self.parses(*args)
+    self.formats = args.map(&:to_s)
+  end
+
+  def self.formats
+    @formats ||= []
+  end
+
+  def self.formats=(new_formats)
+    @formats = new_formats
+  end
+end

data/lib/sheets/parsers/csv_parser.rb

@@ -0,0 +1,9 @@
+require 'csv'
+
+class Sheets::Parsers::CSVParser < Sheets::Parsers::Base
+  parses :csv
+
+  def to_array
+    CSV.parse( @data )
+  end
+end

data/lib/sheets/parsers/roo_parser.rb

@@ -0,0 +1,28 @@
+require 'roo'
+
+class Sheets::Parsers::RooParser < Sheets::Parsers::Base
+  parses :xls, :xlsx, :ods
+
+  ROO_CLASS = {
+    :xls  => Excel,
+    :xlsx => Excelx,
+    :ods  => Openoffice
+  }
+
+  def to_array
+    array = []
+    (spreadsheet.first_row..spreadsheet.last_row).each do |row_num|
+      row = []
+      (spreadsheet.first_column..spreadsheet.last_column).each do |column_num|
+        row << spreadsheet.cell(row_num, column_num).to_s
+      end
+      array << row
+    end
+    array
+  end
+
+  private
+  def spreadsheet
+    ROO_CLASS[@format.to_sym].new(@file_path)
+  end
+end

data/lib/sheets/renderable.rb

@@ -0,0 +1,36 @@
+module Sheets
+  module Renderable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def renderable_formats
+        Sheets::Renderers.constants.collect {|constant_name| Sheets::Renderers.const_get(constant_name) }.map(&:formats).flatten.uniq
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      match = method_name.to_s.match(/\Ato_(.*)/i)
+      format = match[1] unless match.nil?
+      
+      format.nil? || !self.class.renderable_formats.include?(format) ? super(method_name, args, block) : renderer(format).send(method_name)
+    end
+
+    private
+    def renderer_class(format)
+      classes = Sheets::Renderers.constants.map do |constant_name|
+        constant = Sheets::Renderers.const_get(constant_name)
+        constant if constant && constant.respond_to?(:formats) && constant.formats.map(&:to_s).include?(format)
+      end
+
+      classes.delete(nil)
+
+      classes.first      
+    end
+
+    def renderer(format = @extension)
+      @renderer ||= renderer_class(format).new(to_array, format) unless renderer_class(format).nil?
+    end
+  end
+end

data/lib/sheets/renderers/base.rb

@@ -0,0 +1,18 @@
+class Sheets::Renderers::Base
+  def initialize(data, format)
+    @data = data
+    @format = format
+  end
+
+  def self.renders(*args)
+    self.formats = args.map(&:to_s)
+  end
+
+  def self.formats
+    @formats ||= []
+  end
+
+  def self.formats=(new_formats)
+    @formats = new_formats
+  end
+end

data/lib/sheets/renderers/csv_renderer.rb

@@ -0,0 +1,7 @@
+class Sheets::Renderers::CSVRenderer < Sheets::Renderers::Base
+  renders :csv
+
+  def to_csv
+    @data.collect {|row| row.join(',') }.join("\n")
+  end
+end

data/lib/sheets/renderers/excel_renderer.rb

@@ -0,0 +1,22 @@
+class Sheets::Renderers::ExcelRenderer < Sheets::Renderers::Base
+  renders :xls
+
+  def to_xls
+    workbook = Spreadsheet::Excel::Workbook.new
+    worksheet = Spreadsheet::Excel::Worksheet.new
+    workbook.add_worksheet(worksheet)
+
+    @data.each_with_index do |row, row_index|
+      row.each_with_index do |cell, col_index|
+        worksheet[row_index, col_index] = cell
+      end
+    end
+
+    # Tried to use StringIO here, but ran into encoding issues with Ruby 1.8.7. 
+    file_path = "tmp_excel_render_#{Time.now.to_i}"
+    File.open(file_path, 'w+') {|file| workbook.write(file) }
+    File.read(file_path)
+  ensure
+    File.delete( file_path ) if File.exists?( file_path )
+  end
+end

data/lib/sheets/version.rb

@@ -0,0 +1,3 @@
+module Sheets
+  VERSION = "0.9.0"
+end

data/sheets.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sheets/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sheets"
+  s.version     = Sheets::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bradley J. Spaulding"]
+  s.email       = ["brad.spaulding@gmail.com"]
+  s.homepage    = "https://github.com/bspaulding/Sheets"
+  s.summary     = %q{Sheets provides a Facade for importing spreadsheets that gives the application control. Any Spreadsheet can be represented as either (1) a two dimensional array, or (2) an array of hashes. Sheets' goal is to convert any spreadsheet format to one of these native Ruby data structures.}
+  s.description = %q{Work with spreadsheets easily in a native ruby format.}
+
+  s.rubyforge_project = "sheets"
+
+  s.add_dependency('roo', '>= 1.9.3')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/base_test.rb

@@ -0,0 +1,19 @@
+class TestBase < Test::Unit::TestCase
+  EXAMPLE_DATA = [
+    ["Date", "Impressions", "Clicks", "Actions"],
+    ["2011-01-01", "10", "10", "10"],
+    ["2011-01-02", "10", "10", "10"],
+    ["2011-01-03", "10", "10", "10"],
+    ["2011-01-04", "10", "10", "10"],
+    ["2011-01-05", "10", "10", "10"],
+    ["2011-01-06", "10", "10", "10"],
+    ["2011-01-07", "10", "10", "10"],
+    ["2011-01-08", "10", "10", "10"],
+    ["2011-01-09", "10", "10", "10"],
+    ["2011-01-10", "10", "10", "10"]      
+  ]
+
+  def test_initialize_with_array
+    assert_equal EXAMPLE_DATA, Sheets::Base.new( EXAMPLE_DATA ).to_array
+  end
+end

data/test/data/simple.csv

@@ -0,0 +1,11 @@
+Date,Impressions,Clicks,Actions
+2011-01-01,10,10,10
+2011-01-02,10,10,10
+2011-01-03,10,10,10
+2011-01-04,10,10,10
+2011-01-05,10,10,10
+2011-01-06,10,10,10
+2011-01-07,10,10,10
+2011-01-08,10,10,10
+2011-01-09,10,10,10
+2011-01-10,10,10,10

data/test/generators/test_classes.rb

@@ -0,0 +1,7 @@
+def test_classes_for_collection(collection, &block)
+  collection.each do |object|
+    test_class = Class.new(Test::Unit::TestCase)
+    Object.const_set("Test#{object.to_s.split(':')[-1]}Interface", test_class)
+    test_class.instance_exec(object, &block)
+  end
+end

data/test/parseable_test.rb

@@ -0,0 +1,9 @@
+class TestParseable < Test::Unit::TestCase
+  Sheets::Base.parseable_formats.each do |format|
+    define_method "test_sheet_parses_#{format}" do
+      assert_nothing_raised do
+        Sheets::Base.new( File.join('test', 'data', "simple.#{format}") ).to_array
+      end
+    end
+  end
+end

data/test/parsers/basic_parsers_test.rb

@@ -0,0 +1,18 @@
+parser_classes = (Sheets::Parsers.constants - ["Base"]).map {|constant_name| Sheets::Parsers.const_get(constant_name) }
+
+test_classes_for_collection parser_classes do |parser_class|
+  define_method :test_provides_formats do
+    assert parser_class.respond_to? :formats, "#{parser_class} doesn't respond_to formats."
+  end
+
+  define_method :test_formats_not_empty do
+    assert !parser_class.formats.empty?, "#{parser_class} doesn't render any formats."
+  end
+
+  parser_class.formats.each do |format|
+    define_method "test_#{format}_to_array" do
+      parser = parser_class.new([], format, nil)
+      assert parser.respond_to?("to_array"), "#{parser.inspect} doesn't respond to to_array"
+    end
+  end
+end

data/test/parsers/csv_parser_test.rb

@@ -0,0 +1,37 @@
+class TestCSVParser < Test::Unit::TestCase
+
+  def test_to_array
+    file_path = generate_test_spreadsheet
+    assert_equal Sheets::Base.new( file_path ).to_array, example_spreadsheet_data
+  ensure
+    File.delete( file_path ) if File.exists?( file_path )
+  end
+
+  private
+  def example_spreadsheet_data
+    [
+      ["Date", "Impressions", "Clicks", "Actions"],
+      ["2011-01-01", "10", "10", "10"],
+      ["2011-01-02", "10", "10", "10"],
+      ["2011-01-03", "10", "10", "10"],
+      ["2011-01-04", "10", "10", "10"],
+      ["2011-01-05", "10", "10", "10"],
+      ["2011-01-06", "10", "10", "10"],
+      ["2011-01-07", "10", "10", "10"],
+      ["2011-01-08", "10", "10", "10"],
+      ["2011-01-09", "10", "10", "10"],
+      ["2011-01-10", "10", "10", "10"]      
+    ]
+  end
+    
+  def generate_test_spreadsheet
+    filename = "test_simple_#{Time.new.to_i}.csv"
+    file_path = File.join('.', filename)
+
+    File.open( file_path, 'w+' ) do |file|
+      file.write( example_spreadsheet_data.collect {|row| row.join(',') }.join("\n") )
+    end
+    
+    file_path
+  end
+end

data/test/renderable_test.rb

@@ -0,0 +1,8 @@
+class TestRenderable < Test::Unit::TestCase
+  Sheets::Base.renderable_formats.each do |renderable_format|
+    define_method "test_sheet_responds_to_#{renderable_format}" do
+      sheet = Sheets::Base.new( File.join('test', 'data', 'simple.csv') )
+      assert_nothing_raised { sheet.send("to_#{renderable_format}") }
+    end
+  end
+end

data/test/renderers/basic_renderers_test.rb

@@ -0,0 +1,18 @@
+renderer_classes = (Sheets::Renderers.constants - ["Base"]).map {|constant_name| Sheets::Renderers.const_get(constant_name) }
+
+test_classes_for_collection renderer_classes do |renderer_class|
+  define_method :test_provides_formats do
+    assert renderer_class.respond_to? :formats, "#{renderer_class} doesn't respond_to formats."
+  end
+
+  define_method :test_formats_not_empty do
+    assert !renderer_class.formats.empty?, "#{renderer_class} doesn't render any formats."
+  end
+
+  renderer_class.formats.each do |format|
+    define_method "test_to_#{format}" do
+      renderer = renderer_class.new([], format)
+      assert renderer.respond_to?("to_#{format}"), "#{renderer.inspect} doesn't respond to to_#{format}"
+    end
+  end
+end

data/test/renderers/csv_renderer_test.rb

@@ -0,0 +1,25 @@
+class TestCSVRenderer < Test::Unit::TestCase
+
+  def test_to_csv
+    renderer = Sheets::Renderers::CSVRenderer.new(example_spreadsheet_data, :csv)
+
+    assert_equal renderer.to_csv, example_spreadsheet_data.collect {|row| row.join(',') }.join("\n")
+  end
+
+  private
+  def example_spreadsheet_data
+    [
+      ["Date", "Impressions", "Clicks", "Actions"],
+      ["2011-01-01", "10", "10", "10"],
+      ["2011-01-02", "10", "10", "10"],
+      ["2011-01-03", "10", "10", "10"],
+      ["2011-01-04", "10", "10", "10"],
+      ["2011-01-05", "10", "10", "10"],
+      ["2011-01-06", "10", "10", "10"],
+      ["2011-01-07", "10", "10", "10"],
+      ["2011-01-08", "10", "10", "10"],
+      ["2011-01-09", "10", "10", "10"],
+      ["2011-01-10", "10", "10", "10"]      
+    ]
+  end
+end

data/test/renderers/excel_renderer_test.rb

@@ -0,0 +1,42 @@
+class TestExcelRenderer < Test::Unit::TestCase
+
+  EXAMPLE_DATA = [
+    ["Date", "Impressions", "Clicks", "Actions"],
+    ["2011-01-01", "10", "10", "10"],
+    ["2011-01-02", "10", "10", "10"],
+    ["2011-01-03", "10", "10", "10"],
+    ["2011-01-04", "10", "10", "10"],
+    ["2011-01-05", "10", "10", "10"],
+    ["2011-01-06", "10", "10", "10"],
+    ["2011-01-07", "10", "10", "10"],
+    ["2011-01-08", "10", "10", "10"],
+    ["2011-01-09", "10", "10", "10"],
+    ["2011-01-10", "10", "10", "10"]      
+  ]
+
+  def test_to_xls
+    renderer = Sheets::Renderers::ExcelRenderer.new(EXAMPLE_DATA, :xls)
+
+    file_path = File.expand_path( File.join('test', 'data', "excel_render_test_#{Time.now.to_i}.xls") )
+    File.open(file_path, 'w+') {|file| file.write(renderer.to_xls) }
+
+    assert_equal EXAMPLE_DATA, Sheets::Base.new( file_path ).to_array
+  ensure
+    File.delete( file_path ) if File.exists?( file_path )
+  end
+
+  Sheets::Base.parseable_formats.each do |parseable_format|
+    define_method "test_#{parseable_format}_to_xls" do
+      begin
+        sheet = Sheets::Base.new( File.join('test', 'data', "simple.#{parseable_format}") )
+
+        file_path = File.expand_path( File.join('test', 'data', "excel_render_test_#{Time.now.to_i}.xls") )
+        File.open(file_path, 'w+') {|file| file.write(sheet.to_xls) }
+
+        assert_equal sheet.to_array, Sheets::Base.new( file_path ).to_array
+      ensure  
+        File.delete( file_path ) if File.exists?( file_path )
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+
+puts 'Loading Test Generators'
+Dir[ File.join(File.expand_path(File.dirname(__FILE__)), 'generators', '*.rb') ].each {|file| puts "- #{file}"; require file }
+
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'sheets.rb')

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification 
+name: sheets
+version: !ruby/object:Gem::Version 
+  hash: 59
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- Bradley J. Spaulding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-11 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: roo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 53
+        segments: 
+        - 1
+        - 9
+        - 3
+        version: 1.9.3
+  type: :runtime
+  version_requirements: *id001
+description: Work with spreadsheets easily in a native ruby format.
+email: 
+- brad.spaulding@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sheets.rb
+- lib/sheets/base.rb
+- lib/sheets/parseable.rb
+- lib/sheets/parsers/base.rb
+- lib/sheets/parsers/csv_parser.rb
+- lib/sheets/parsers/roo_parser.rb
+- lib/sheets/renderable.rb
+- lib/sheets/renderers/base.rb
+- lib/sheets/renderers/csv_renderer.rb
+- lib/sheets/renderers/excel_renderer.rb
+- lib/sheets/version.rb
+- sheets.gemspec
+- test/base_test.rb
+- test/data/simple.csv
+- test/data/simple.ods
+- test/data/simple.xls
+- test/data/simple.xlsx
+- test/generators/test_classes.rb
+- test/parseable_test.rb
+- test/parsers/basic_parsers_test.rb
+- test/parsers/csv_parser_test.rb
+- test/renderable_test.rb
+- test/renderers/basic_renderers_test.rb
+- test/renderers/csv_renderer_test.rb
+- test/renderers/excel_renderer_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/bspaulding/Sheets
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: sheets
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Sheets provides a Facade for importing spreadsheets that gives the application control. Any Spreadsheet can be represented as either (1) a two dimensional array, or (2) an array of hashes. Sheets' goal is to convert any spreadsheet format to one of these native Ruby data structures.
+test_files: 
+- test/base_test.rb
+- test/data/simple.csv
+- test/data/simple.ods
+- test/data/simple.xls
+- test/data/simple.xlsx
+- test/generators/test_classes.rb
+- test/parseable_test.rb
+- test/parsers/basic_parsers_test.rb
+- test/parsers/csv_parser_test.rb
+- test/renderable_test.rb
+- test/renderers/basic_renderers_test.rb
+- test/renderers/csv_renderer_test.rb
+- test/renderers/excel_renderer_test.rb
+- test/test_helper.rb