tabular 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Scott Willson
+
+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

@@ -0,0 +1,46 @@
+Tabular is a Ruby library for reading, writing, and manipulating CSV, tab-delimited and Excel data.
+
+I extracted it from production code. Still extracting it, actually. I need to read structured data and manipulate it via a common interface before persisting it with ActiveRecord.
+
+
+Dependencies
+------------
+For tab-delimited data: Ruby standard lib
+For CSV: FasterCSV
+For Excel: Spreadsheet gem
+
+
+Examples
+--------
+>> table = Table.read("test/fixtures/sample.csv")
+>> table.rows.size
+=> 4
+
+Access Table Rows by index:
+>> table[0]
+
+And Row cells as a Hash:
+>> table[0][:last_name]
+=> "Willson"
+
+
+Usage
+-----
+Table.read assumes that .txt files are tab-delimited, .csv files are comma-delimited, and .xls files are Excel. It assumes that the first row is the header row, and normalizes the header to lower-case with underscores. E.g., "Last Name" becomes "last_name".
+
+Table.new accepts an Array of Arrays.
+
+Table.new also accepts an options hash. Currently, :columns is the only option. Examples:
+:city_state => :location -- Maps :city_state column to :location. A column with a "City State" header would be accessed as row[:location]
+:flyer_approved  => { :column_type => :boolean } -- Coerce :flyer_approved column cells to booleans.
+
+
+Tests
+-----
+There's basic test coverage. More comprehensive test coverage needs to be extracted from original projects. Run 'rake test'.
+
+
+Copyright
+---------
+
+Copyright (c) 2009 Scott Willson. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "tabular"
+    gemspec.summary = "Read, write, and manipulate CSV, tab-delimited and Excel data"
+    gemspec.description = "Tabular is a Ruby library for reading, writing, and manipulating CSV, tab-delimited and Excel data."
+    gemspec.email = "scott.willson@gmail.cpm"
+    gemspec.homepage = "http://github.com/scottwillson/tabular"
+    gemspec.authors = ["Scott Willson"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "tabular #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/tabular.rb

@@ -0,0 +1,10 @@
+require "rubygems"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")
+
+require "tabular/column.rb"
+require "tabular/columns.rb"
+require "tabular/row.rb"
+require "tabular/table.rb"
+
+require "tabular/support/object"

data/lib/tabular/column.rb

@@ -0,0 +1,50 @@
+module Tabular
+  class Column
+    attr_reader :key, :column_type
+    
+    def initialize(key = nil, columns_map = {})
+      key = symbolize(key)
+      columns_map = columns_map || {}
+      map_for_key = columns_map[key]
+    
+      @column_type = :string
+      case map_for_key
+      when nil
+        @key = key
+        @column_type = :date if key == :date
+      when Symbol
+        @key = map_for_key
+        @column_type = :date if key == :date
+      when Hash
+        @key = key
+        @column_type = map_for_key[:column_type] 
+      else
+        raise "Expected Symbol or Hash, but was #{map_for_key.class}"
+      end
+    end
+
+    def symbolize(key)
+      return nil if key.blank?
+      
+      begin
+        key.to_s.strip.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          gsub(/ +/, "_").
+          downcase.
+          to_sym
+      rescue
+        nil
+      end
+    end
+    
+    def inspect
+      "#<Tabular::Column #{key} #{column_type}>"
+    end
+    
+    def to_s
+      key
+    end
+  end
+end

data/lib/tabular/columns.rb

@@ -0,0 +1,55 @@
+module Tabular
+  # The Table's header: a list of Columns.
+  class Columns
+    # +data+ -- array of header names
+    # +columns_map+ -- see Table. Maps column names and type conversion.
+    def initialize(data, columns_map = {})
+      @columns_map = columns_map
+      @column_indexes = {}
+      @columns_by_key = {}
+      index = 0
+      @columns = nil
+      @columns = data.map do |column|
+        new_column = Tabular::Column.new(column, columns_map)
+        unless new_column.key.blank?
+          @column_indexes[new_column.key] = index
+          @columns_by_key[new_column.key] = new_column
+        end
+        index = index + 1
+        new_column
+      end
+    end
+    
+    # Is the a Column with this key? Keys are lower-case, underscore symbols.
+    # Example: :postal_code
+    def has_key?(key)
+      @columns.any? { |column| column.key == key }
+    end
+    
+    # Column for +key+
+    def [](key)
+      @columns_by_key[key]
+    end
+    
+    # Zero-based index of Column for +key+
+    def index(key)
+      @column_indexes[key]
+    end
+    
+    # Call +block+ for each Column
+    def each(&block)
+      @columns.each(&block)
+    end
+    
+    # Add a new Column with +key+
+    def <<(key)
+      column = Column.new(key, @columns_map)
+      unless column.key.blank?
+        @column_indexes[column.key] = @columns.size
+        @column_indexes[@columns.size] = column
+        @columns_by_key[column.key] = column
+      end
+      @columns << column
+    end
+  end
+end

data/lib/tabular/row.rb

@@ -0,0 +1,80 @@
+module Tabular
+  # Associate list of cells. Each Table has a list of Rows. Access Row cells via symbols. Ex: row[:city]
+  class Row
+    include Enumerable
+    
+    # +columns+ -- array of string
+    # +cell+ -- array (not neccessarily Strings)
+    def initialize(columns, cells = [])
+      @columns = columns
+      @array = cells
+      @hash = nil
+    end
+    
+    # Cell value by symbol. E.g., row[:phone_number]
+    def [](key)
+      hash[key]
+    end
+    
+    # Set cell value. Adds cell to end of Row and adds new Column if there is no Column fo +key_
+    def []=(key, value)
+      if @columns.has_key?(key)
+        @array[@columns.index(key)] = value
+      else
+        @array << value
+        @columns << key
+      end
+      hash[key] = value
+    end
+    
+    # Call +block+ for each cell
+    def each(&block)
+      @array.each(&block)
+    end
+
+    # For pretty-printing cell values
+    def join(sep = nil)
+      @array.join(sep)
+    end
+    
+    def to_hash
+      hash.dup
+    end
+    
+    def inspect
+      hash.inspect
+    end
+    
+    def to_s
+      @array.join(", ").to_s
+    end
+
+
+    protected
+    
+    
+    def hash #:nodoc:
+      unless @hash
+        @hash = Hash.new
+        @columns.each do |column|
+          index = @columns.index(column.key)
+          if index
+            case column.column_type
+            when :boolean
+              @hash[column.key] = [1, "1", true, "true"].include?(@array[index])
+            when :date
+              if @array[index].is_a?(Date) || @array[index].is_a?(DateTime) || @array[index].is_a?(Time)
+                @hash[column.key] = @array[index]
+              else
+                @hash[column.key] = Date.parse(@array[index], true)
+              end
+            else
+              @hash[column.key] = @array[index]
+            end
+          end
+        end
+      end
+      @hash
+    end
+  end
+end

data/lib/tabular/support/object.rb

@@ -0,0 +1,59 @@
+# Copied from Rails' ActiveSupport
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # to
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+    
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/tabular/table.rb

@@ -0,0 +1,65 @@
+module Tabular
+  # Simple Enumerable list of Hashes. Use Table.read(file_path) to read file.
+  class Table
+    attr_reader :columns, :rows
+    
+    # Assumes .txt = tab-delimited, .csv = CSV, .xls = Excel. Assumes first row is the header.
+    # Normalizes column names to lower-case with underscores.
+    def self.read(file_path, *options)
+      raise "Could not find '#{file_path}'" unless File.exists?(file_path)
+      
+      case File.extname(file_path)
+      when ".xls", ".xlsx"
+        require "spreadsheet"
+        # Row#to_a coerces Excel data to Strings, but we want Dates and Numbers
+        data = []
+        Spreadsheet.open(file_path).worksheets.first.each do |excel_row|
+          data << excel_row.inject([]) { |row, cell| row << cell; row }
+        end
+      when ".txt"
+        require "csv"
+        data = ::CSV.open(file_path, "r","\t").collect { |row| row }
+      when ".csv"
+        require "fastercsv"
+        data = FasterCSV.read(file_path)
+      end
+      
+      Table.new data, options
+    end
+    
+    # Pass data in as +rows+. Expects rows to be an Enumerable of Enumerables. 
+    # Maps rows to Hash-like Tabular::Rows.
+    #
+    # Options:
+    # :column => { :original_name => :preferred_name, :column_name => { :column_type => :boolean } }
+    def initialize(rows = [], *options)
+      if options
+        options = options.flatten.first || {}
+      else
+        options = {}
+      end
+      
+      rows.each do |row|
+        if columns
+          @rows << Tabular::Row.new(columns, row)
+        else
+          @columns = Tabular::Columns.new(row, options[:columns])
+          @rows = []
+        end
+      end
+    end
+    
+    # Return Row at zero-based index, or nil if Row is out of bounds
+    def [](index)
+      rows[index]
+    end
+    
+    def inspect
+      rows.map { |row| row.join(",") }.join("\n")
+    end
+    
+    def to_s
+      "#<#{self.class} #{rows.size}>"
+    end
+  end
+end

data/tabular.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{tabular}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Scott Willson"]
+  s.date = %q{2009-12-15}
+  s.description = %q{Tabular is a Ruby library for reading, writing, and manipulating CSV, tab-delimited and Excel data.}
+  s.email = %q{scott.willson@gmail.cpm}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    "LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "lib/tabular.rb",
+     "lib/tabular/column.rb",
+     "lib/tabular/columns.rb",
+     "lib/tabular/row.rb",
+     "lib/tabular/support/object.rb",
+     "lib/tabular/table.rb",
+     "tabular.gemspec",
+     "test/column_test.rb",
+     "test/columns_test.rb",
+     "test/fixtures/blank.txt",
+     "test/fixtures/excel.xls",
+     "test/fixtures/sample.csv",
+     "test/helper.rb",
+     "test/row_test.rb",
+     "test/table_test.rb"
+  ]
+  s.homepage = %q{http://github.com/scottwillson/tabular}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Read, write, and manipulate CSV, tab-delimited and Excel data}
+  s.test_files = [
+    "test/column_test.rb",
+     "test/columns_test.rb",
+     "test/helper.rb",
+     "test/row_test.rb",
+     "test/table_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/column_test.rb

@@ -0,0 +1,39 @@
+require "helper"
+
+module Tabular
+  class ColumnTest < Test::Unit::TestCase
+    def test_new_nil
+      column = Column.new
+      assert_equal nil, column.to_s, "blank column to_s"
+      assert_equal nil, column.key, "blank column key"
+    end
+    
+    def test_new
+      assert_equal :date, Column.new("date").key, "column key"
+      assert_equal :date, Column.new(:date).key, "column key"
+      assert_equal :date, Column.new("Date").key, "column key"
+      assert_equal :date, Column.new(" Date  ").key, "column key"
+      assert_equal :date, Column.new("DATE").key, "column key"
+      assert_equal :start_date, Column.new("StartDate").key, "column key"
+      assert_equal :start_date, Column.new("Start Date").key, "column key"
+    end
+    
+    def test_mapping
+      assert_equal :city, Column.new(:location, :location => :city).key, "column key"
+    end
+    
+    def test_type
+      column = Column.new("name")
+      assert_equal :name, column.key, "key"
+      assert_equal :string, column.column_type, "column_type"
+      
+      column = Column.new("date")
+      assert_equal :date, column.key, "key"
+      assert_equal :date, column.column_type, "column_type"
+
+      column = Column.new("phone", :phone => { :column_type => :integer })
+      assert_equal :phone, column.key, "key"
+      assert_equal :integer, column.column_type, "column_type"
+    end
+  end
+end

data/test/columns_test.rb

@@ -0,0 +1,64 @@
+require "helper"
+
+module Tabular
+  class ColumnsTest < Test::Unit::TestCase
+    def test_new_blank
+      columns = Columns.new([])
+      assert_equal false, columns.has_key?(:name), "has_key? :name"
+      assert_equal nil, columns[:name], "[:name]"
+      assert_equal nil, columns.index(nil), "index"
+      assert_equal nil, columns.index(""), "index"
+      assert_equal nil, columns.index(:name), "index"
+      columns.each { |c| c.nil? }
+    end
+    
+    def test_new
+      columns = Columns.new(["date", "first name", "LastName"])
+      assert_equal false, columns.has_key?(:location), "has_key? :location"
+      assert_equal true, columns.has_key?(:date), "has_key? :date"
+      assert_equal true, columns.has_key?(:first_name), "has_key? :first_name"
+      assert_equal true, columns.has_key?(:last_name), "has_key? :last_name"
+      assert_equal false, columns.has_key?("first name"), "has_key? 'first name'"
+      
+      column = columns[:first_name]
+      assert_equal :first_name, column.key, "column[:first_name] Column key"
+
+      assert_equal 1, columns.index(:first_name), "index of :first_name"
+    end
+    
+    def test_columns_map
+      columns = Columns.new(["date"], :start_date => :date)
+      assert_equal true, columns.has_key?(:date), "has_key? :date"
+      assert_equal false, columns.has_key?(:start_date), "has_key? :start_date"
+    end
+    
+    def test_each
+      columns = Columns.new(["date", "first name", "LastName"])
+      columns_from_each = []
+      columns.each { |c| columns_from_each << c.key }
+      assert_equal [ :date, :first_name, :last_name ], columns_from_each, "column keys from #each"
+    end
+    
+    def test_push_onto_blank
+      columns = Columns.new([])
+      columns << "city state"
+      assert_equal true, columns.has_key?(:city_state), "has_key? :city_state"
+      assert_equal 0, columns.index(:city_state), "index of new column"
+
+      column = columns[:city_state]
+      assert_equal :city_state, column.key, "column[:city_state] Column key"
+    end
+    
+    def test_push
+      columns = Columns.new(["first", "second"])
+      columns << "third"
+      assert_equal true, columns.has_key?(:third), "has_key? :third"
+      assert_equal 0, columns.index(:first), "index of existing column"
+      assert_equal 1, columns.index(:second), "index of existing column"
+      assert_equal 2, columns.index(:third), "index of new column"
+
+      column = columns[:third]
+      assert_equal :third, column.key, "column[:third] Column key"
+    end
+  end
+end

data/test/fixtures/sample.csv

@@ -0,0 +1,5 @@
+"Place ","Number","Last Name","First Name","Team","Category Raced"
+"1","189","Willson","Scott","Gentle Lover","Senior Men 1/2/3","11",,"11"
+"2","190","Phinney","Harry","CCCP","Senior Men 1/2/3","9",,
+"3","10a","Holland","Steve","Huntair","Senior Men 1/2/3",,"3",
+"dnf","100","Bourcier","Paul","Hutch's","Senior Men 1/2/3",,,"1"

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'tabular'
+
+class Test::Unit::TestCase
+end

data/test/row_test.rb

@@ -0,0 +1,57 @@
+require "helper"
+
+module Tabular
+  class RowTest < Test::Unit::TestCase
+    def test_new
+      row = Row.new([])
+      assert_equal nil, row[:city], "[]"
+      
+      assert_equal "", row.join, "join"
+      assert_equal({}, row.to_hash, "to_hash")
+      assert_equal "{}", row.inspect, "inspect"
+      assert_equal "", row.to_s, "to_s"
+      
+      # Test each
+      row.each { |c| c.nil? }
+    end
+    
+    def test_set
+      columns = Columns.new([ "planet", "star" ])
+      row = Row.new(columns, [ "Mars", "Sun" ])
+      
+      assert_equal "Sun", row[:star], "row[:star]"
+      
+      row[:star] = "Solaris"
+      assert_equal "Solaris", row[:star], "row[:star]"
+      
+      row[:astronaut] = "Buzz"
+      assert_equal "Buzz", row[:astronaut], "row[:astronaut]"
+    end
+    
+    def test_join
+      columns = Columns.new([ "planet", "star" ])
+      row = Row.new(columns, [ "Mars", "Sun" ])
+      assert_equal "MarsSun", row.join, "join"
+      assert_equal "Mars-Sun", row.join("-"), "join '-'"
+    end
+    
+    def test_to_hash
+      columns = Columns.new([ "planet", "star" ])
+      row = Row.new(columns, [ "Mars", "Sun" ])
+      assert_equal({ :planet => "Mars", :star => "Sun"}, row.to_hash, "to_hash")
+    end
+    
+    def test_inspect
+      columns = Columns.new([ "planet", "star" ])
+      row = Row.new(columns, [ "Mars", "Sun" ])
+      assert_equal "{:planet=>\"Mars\", :star=>\"Sun\"}", row.inspect, "inspect"
+    end
+    
+    def test_to_s
+      columns = Columns.new([ "planet", "star" ])
+      row = Row.new(columns, [ "Mars", "Sun" ])
+      assert_equal "Mars, Sun", row.to_s, "to_s"
+    end
+  end
+end
+

data/test/table_test.rb

@@ -0,0 +1,37 @@
+require "helper"
+
+module Tabular
+  class TableTest < Test::Unit::TestCase
+    def test_read_from_blank_txt_file
+      table = Table.read(File.expand_path(File.dirname(__FILE__) + "/fixtures/blank.txt"))
+    end
+    
+    # "Place ","Number","Last Name","First Name","Team","Category Raced"
+    # "1","189","Willson","Scott","Gentle Lover","Senior Men 1/2/3","11",,"11"
+    # "2","190","Phinney","Harry","CCCP","Senior Men 1/2/3","9",,
+    # "3","10a","Holland","Steve","Huntair","Senior Men 1/2/3",,"3",
+    # "dnf","100","Bourcier","Paul","Hutch's","Senior Men 1/2/3",,,"1"
+    def test_read_from_csv
+      table = Table.read(File.expand_path(File.dirname(__FILE__) + "/fixtures/sample.csv"))
+      assert_equal 4, table.rows.size, "rows"
+
+      assert_equal "1", table[0][:place], "0.0"
+      assert_equal "189", table[0][:number], "0.1"
+      assert_equal "Willson", table[0][:last_name], "0.2"
+      assert_equal "Scott", table[0][:first_name], "0.3"
+      assert_equal "Gentle Lover", table[0][:team], "0.4"
+
+      assert_equal "dnf", table[3][:place], "3.0"
+      assert_equal "100", table[3][:number], "3.1"
+      assert_equal "Bourcier", table[3][:last_name], "3.2"
+      assert_equal "Paul", table[3][:first_name], "3.3"
+      assert_equal "Hutch's", table[3][:team], "3.4"
+    end
+    
+    def test_read_from_excel
+      table = Table.read(File.expand_path(File.dirname(__FILE__) + "/fixtures/excel.xls"))
+      assert_equal Date.new(2006, 1, 20), table[0][:date], "0.0"
+    end
+  end
+end
+

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: tabular
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Scott Willson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-15 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Tabular is a Ruby library for reading, writing, and manipulating CSV, tab-delimited and Excel data.
+email: scott.willson@gmail.cpm
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- lib/tabular.rb
+- lib/tabular/column.rb
+- lib/tabular/columns.rb
+- lib/tabular/row.rb
+- lib/tabular/support/object.rb
+- lib/tabular/table.rb
+- tabular.gemspec
+- test/column_test.rb
+- test/columns_test.rb
+- test/fixtures/blank.txt
+- test/fixtures/excel.xls
+- test/fixtures/sample.csv
+- test/helper.rb
+- test/row_test.rb
+- test/table_test.rb
+has_rdoc: true
+homepage: http://github.com/scottwillson/tabular
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Read, write, and manipulate CSV, tab-delimited and Excel data
+test_files: 
+- test/column_test.rb
+- test/columns_test.rb
+- test/helper.rb
+- test/row_test.rb
+- test/table_test.rb