csv_madness 0.0.2

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.3.0"
+  gem "jeweler", "~> 1.8.4"
+  gem "debugger"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Bryce Anderson
+
+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.rdoc

@@ -0,0 +1,174 @@
+= csv_madness : turn your CSV rows into happycrazy objects.
+
+== What is it?
+
+CSV Madness tries to remove what little pain is left from Ruby's CSV class.  Load a CSV file, and manipulate your data using an array of objects with customizable getter/setter methods.
+
+
+== Why should I use it?
+
+I like brief code and I cannot lie.  
+
+
+== Examples
+
+CsvMadness makes some assumptions about your CSV file.  It does assume headers, for example.  
+
+The simplest case is when your columns are nicely named.  For example, if you have a csv file named <tt>~/data/people.csv</tt>:
+
+<code>
+"id","fname","lname","age","born"
+"1","Mary","Moore","27","1986-04-08 15:06:10"
+"2","Bill","Paxton","39","1974-02-22"
+"3","Charles","Darwin","72",""
+"4","Chuck","Norris","57","1901-03-02"
+</code>
+
+... then you can write code like so:
+
+'''require 'csv_madness'
+sheet = CsvMadness.load( "~/data/people.csv" )
+sheet.columns   # => [:id, :fname, :lname, :age, :born]
+sheet.records.map(&:id) # => ["1", "2", "3", "4"]
+sheet.set_column_type(:id, :float)
+sheet.records.map(&:id) # => [1.0, 2.0, 3.0, 4.0]
+sheet.alter_column(:id) do |id|
+  id + rand() - 0.5
+end    
+
+sheet.records.map(&:id) # => [0.7186, 2.30134, 2.90132, 4.30124]  (your results may vary)
+mary = sheet[0]
+
+"#{mary.lname}, #{mary.fname} (#{mary.id})"  # => "Moore, Mary (1)"
+'''
+
+If you're not satisfied with your column names, you can send your own, in the column order.  An index can also be provided, which will allow you to use <tt>.fetch()</tt> to find specific records quickly:
+
+'''require 'csv_madness'
+sheet = CsvMadness.load( "~/data/people.csv", 
+                         columns: [:uid, :first_name, :last_name, :years_on_planet, :birthday],
+                         index: :uid )
+
+sheet.fetch("2").years_on_planet      # => "39"
+'''
+
+**Note:** you can provide multiple indexes as an array.  However many columns you index, you'll run into trouble if the index isn't unique for each record.  (that may change in the future)
+
+
+It's useful to clean up your files.  Say you have:
+
+""""id","fname","lname","age","  born  "
+"1 ","Mary  ","Moore","27","1986-04-08 15:06:10"
+"","  Bill ","Paxton",,"  Feb. 22, 1974  "
+,"Charles "," Darwin","72 ",
+"4","Chuck","Norris",,"  2 March 1901   "
+"""
+
+Ick.  Missing IDs, inconsistent date formats, leading and trailing whitespace...  We can fix this.
+
+"""require 'csv_madness'
+sheet = CsvMadness.load( "~/data/people.csv" )
+sheet.alter_cells do |cell, record|
+  (cell || "").strip
+end   # removes leading and trailing whitespace, and turns nils into ""
+
+sheet.set_column_type(:id, :integer, nil)  # the last argument provides a default for blank records.
+
+# assumes the missing ids can be filled in sequentially.
+# While .alter_column() does take a blank as a second argument, 
+# that's not what we want here.  If a blank is provided, your 
+# code will never see the records with blank entries.
+sheet.alter_column(:id) do |id, record|
+  @count ||= 1
+  if id.nil?
+    id = @count
+    @count += 1
+  else
+    @count = id + 1
+  end
+  
+  id
+end
+
+sheet.records.map(&:id)    #  => [1, 2, 3, 4] 
+
+require 'time'
+sheet.alter_column(:born) do |date_string|
+  begin
+    Time.parse( date_string ).strftime("%Y-%m-%d")
+  rescue ArgumentError
+    ""
+  end
+end
+
+sheet.records.map(&:date)    #  => ["1986-04-08", "1974-02-22", "", "1901-03-02"] 
+
+# The same thing can be accomplished more simply by saying <tt>sheet.set_column_type(:date)</tt>. 
+# Even better, record.date is then a Time object
+
+# Now calculate everyone's age (ignoring and overriding the existing data)
+sheet.alter_column(:age) do |age, record|
+  if record.blank?(:born)
+    ""
+  else
+    ((Time.now - Time.parse(record.born)) / 365.25 / 24 / 60 / 60).to_i  # not production-worthy code
+  end
+end
+
+sheet.write_to_file( "~/data/people.clean.csv", force_quotes: true ) # save the cleaned data for the next stage of your process
+"""
+
+You could do something similar to clean and standardize phone numbers, detect and delete/complete invalid emails, etc.
+
+
+=== Adding and removing columns
+
+# Add 72 years to the date born.  
+sheet.set_column_type( :born, :date )  # replace date strings with Time objects
+
+sheet.add_column( :expected_death_date ) do |date, record|
+  record.born + ( 72 * 365 * 24 * 60 * 60 )
+end
+
+puts sheet[0].expected_death_date     # should be in 2058
+
+# But that's just morbid, so we drop the column
+sheet.drop_column( :expected_death_date )
+
+
+=== Using columns
+
+sheet.set_column_type( :id, :integer )
+
+
+# Returns each record's id, as an array
+sheet.column( :id ).max      #  ==> 4
+
+
+
+
+
+There are lots of other features, but they'll take time to test and document.
+
+
+
+
+
+
+== Contributing to csv_madness
+ 
+Instructions are boilerplate from Jeweler, but they make sense enough: 
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+
+== Copyright
+
+Copyright (c) 2013 Bryce Anderson. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "csv_madness"
+  gem.homepage = "http://github.com/darthschmoo/csv_madness"
+  gem.license = "MIT"
+  gem.summary = %Q{CSV Madness turns your CSV rows into happycrazy objects.}
+  gem.description = %Q{CSV Madness removes what little pain is left from Ruby's CSV class.  Load a CSV file, and get back an array of objects with customizable getter/setter methods.}
+  gem.email = "keeputahweird@gmail.com"
+  gem.authors = ["Bryce Anderson"]
+  # dependencies defined in Gemfile
+  gem.files = [ "./lib/csv_madness/csv_recipe.rb", 
+                "./lib/csv_madness/record.rb", 
+                "./lib/csv_madness/sheet.rb", 
+                "./lib/csv_madness.rb", 
+                "./Gemfile",
+                "./VERSION",
+                "./README.rdoc",
+                "./Rakefile",
+                "./test/csv/simple.csv",
+                "./test/helper.rb",
+                "./test/test_csv_madness.rb" ]
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+# require 'rcov/rcovtask'
+# Rcov::RcovTask.new do |test|
+#   test.libs << 'test'
+#   test.pattern = 'test/**/test_*.rb'
+#   test.verbose = true
+#   test.rcov_opts << '--exclude "gems/*"'
+# end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "csv_madness #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/csv_madness.rb

@@ -0,0 +1,14 @@
+require 'csv'
+require 'pathname'
+require 'time'        # to use Time.parse to parse cells to get the date
+require 'debugger'
+
+require_relative 'csv_madness/data_accessor_module'
+require_relative 'csv_madness/sheet'
+require_relative 'csv_madness/record'
+
+CsvMadness.class_eval do
+  def self.load( csv, opts = {} )
+    CsvMadness::Sheet.from( csv, opts )
+  end
+end

data/lib/csv_madness/record.rb

@@ -0,0 +1,43 @@
+module CsvMadness
+  # Every Sheet you instantiate will have its very own,
+  # anonymous subclass of Record class, which will be 
+  # extended by the spreadsheet's own getter/setter module.
+  # 
+  # @csv_data is currently a CsvRow.  That may change in the
+  # future.  I'd like to be able to address by row and by
+  # symbol.
+  class Record
+    attr_accessor :csv_data
+    def initialize( data )
+      @csv_data = data
+    end
+    
+    def [] key
+      @csv_data[key] 
+    end
+    
+    def []= key, val
+      @csv_data[key] = val
+    end
+    
+    def columns
+      self.class.spreadsheet.columns
+    end
+    
+    def self.spreadsheet= sheet
+      @spreadsheet = sheet
+    end
+    
+    def self.spreadsheet
+      @spreadsheet
+    end
+    
+    def to_csv( opts = {} )
+      self.columns.map{|col| self.send(col) }.to_csv( opts )
+    end
+    
+    def blank?( col )
+      (self.send( col ).to_s || "").strip.length == 0
+    end
+  end
+end

data/lib/csv_madness/sheet.rb

@@ -0,0 +1,378 @@
+module CsvMadness
+  class Sheet
+    COLUMN_TYPES = {
+      number: Proc.new do |cell, record|
+        if (cell || "").strip.match(/^\d*$/)
+          cell.to_i
+        else
+          cell.to_f
+        end
+      end,
+      
+      integer: Proc.new do |cell, record|
+        cell.to_i
+      end,
+      
+      float:   Proc.new do |cell, record|
+        cell.to_f
+      end,
+      
+      date:    Proc.new do |cell, record|
+        begin
+          parse = Time.parse( cell )
+        rescue ArgumentError
+          parse = "Invalid Time Format: <#{cell}>"
+        end
+        parse
+      end
+    }
+    
+    # Used to make getter/setter names out of the original header strings.
+    # " hello;: world! " => :hello_world
+    def self.getter_name( name )
+      name = name.strip.gsub(/\s+/,"_").gsub(/(\W|_)+/, "" ).downcase
+      if name.match( /^\d/ )
+        name = "_#{name}"
+      end
+      
+      name.to_sym
+    end
+    
+    
+    # Paths to be searched when CsvMadness.load( "filename.csv" ) is called.
+    def self.add_search_path( path )
+      @search_paths ||= []
+      path = Pathname.new( path ).expand_path
+      @search_paths << path unless @search_paths.include?( path )
+    end
+    
+    def self.from( csv_file, opts = {} )
+      if f = find_spreadsheet_in_filesystem( csv_file )
+        Sheet.new( f, opts )
+      else
+        raise "File not found."
+      end
+    end
+    
+    # Search absolute/relative-to-current-dir before checking
+    # search paths.
+    def self.find_spreadsheet_in_filesystem( name )
+      @search_paths ||= []
+
+      expanded_path = Pathname.new( name ).expand_path
+      if expanded_path.exist?
+        return expanded_path
+      else   # look for it in the search paths
+        @search_paths.each do |p|
+          file = p.join( name )
+          if file.exist? && file.file?
+            return p.join( name )
+          end
+        end
+      end
+      
+      nil
+    end
+    
+    # opts are passed to underlying CSV (:row_sep, :encoding, :force_quotes)
+    def self.to_csv( spreadsheet, opts = {} )
+      out = spreadsheet.columns.to_csv( opts )
+      spreadsheet.records.inject( out ) do |output, record|
+        output << record.to_csv( opts )
+      end
+    end
+    
+    def self.write_to_file( spreadsheet, file, opts = {} )
+      file = Pathname.new(file).expand_path
+      File.open( file, "w" ) do |f|
+        f << spreadsheet.to_csv( opts )
+      end
+    end
+    
+    def write_to_file( file, opts = {} )
+      self.class.write_to_file( self, file, opts )
+    end
+
+    def to_csv( opts = {} )
+      self.records.inject( self.columns.to_csv( opts ) ) do |output, record|
+        output << record.to_csv( opts )
+      end
+    end
+    
+    attr_reader :columns, :records, :spreadsheet_file, :record_class
+    # opts: 
+    #   index: ( [:id, :id2 ] )
+    #       columns you want mapped for quick 
+    #       lookup of individual records
+    #
+    #   columns: ( [:fname, :lname, :age] )  
+    #       an array of symbols, corresponding
+    #       to the csv rows they represent (first, second, third)
+    #       and designating the method for calling the cell in 
+    #       a given record.  If not provided, it will guess based
+    #       on the header row.
+    #   
+    #   header:   false       
+    #       anything else, we assume the csv file has a header row
+    def initialize( spreadsheet, opts = {} )
+      @spreadsheet_file = self.class.find_spreadsheet_in_filesystem( spreadsheet )
+      @opts = opts
+      @opts[:header] = (@opts[:header] == false ? false : true)  # true unless already explicitly set to false
+      
+      load_csv
+      
+      set_initial_columns( @opts[:columns] )
+      
+
+      create_record_class
+      package
+      
+      @index_columns = case @opts[:index]
+      when NilClass
+        []
+      when Symbol
+        [ @opts[:index] ]
+      when Array
+        @opts[:index]
+      end
+        
+      reindex
+    end
+    
+    def [] offset
+      @records[offset]
+    end
+  
+    # Fetches an indexed record based on the column indexed and the keying object.
+    # If key is an array of keying objects, returns an array of records in the
+    # same order that the keying objects appear.
+    # Index column should yield a different, unique value for each record.
+    def fetch( index_col, key )
+      if key.is_a?(Array)
+        key.map{ |key| @indexes[index_col][key] }
+      else
+        @indexes[index_col][key]
+      end
+    end
+    
+    # function should take an object, and return either true or false
+    # returns an array of objects that respond true when put through the
+    # meat grinder
+    def filter( &block )
+      rval = []
+      @records.each do |record|
+        rval << record if ( yield record )
+      end
+    
+      rval
+    end
+    
+    # removes rows which fail the given test from the spreadsheet.
+    def filter!( &block )
+      @records = self.filter( &block )
+      reindex
+      @records
+    end
+  
+    def column col
+      @records.map(&col)
+    end
+    
+    # retrieve multiple columns.  Returns an array of the form
+    # [ [record1:col1, record1:col2...], [record2:col1, record2:col2...] [...] ]
+    def multiple_columns(*args)
+      @records.inject([]){ |memo, record|
+        memo << args.map{ |arg| record.send(arg) }
+        memo
+      }
+    end
+    
+    # if blank is defined, only the records which are non-blank in that
+    # column will actually be yielded.  The rest will be set to the provided
+    # default
+    def alter_cells( blank = :undefined, &block )
+      @columns.each_with_index do |column, cindex|
+        alter_column( column, blank, &block )
+      end
+    end
+
+    # if column doesn't exist, silently fails.  Proper behavior?  Dunno.
+    def alter_column( column, blank = :undefined, &block )
+      if cindex = @columns.index( column )
+        for record in @records
+          if record.blank?(column) && blank != :undefined
+            record[cindex] = blank
+          else
+            record[cindex] = yield( record[cindex], record )
+          end
+        end
+      end
+    end
+    
+    def add_column( column, &block )
+      raise "Column already exists" if @columns.include?( column )
+      @columns << column
+      
+      # add empty column to each row
+      @records.map{ |r|
+        r.csv_data << {column => ""} 
+      }
+      
+      update_data_accessor_module
+      
+      if block_given?
+        alter_column( column ) do |val, record|
+          yield val, record
+        end
+      end
+    end
+    
+    def drop_column( column )
+      raise "Column does not exist" unless @columns.include?( column )
+      
+      @columns.delete( column )
+      
+      key = column.to_s
+      
+      @records.map{ |r|
+        r.csv_data.delete( key )
+      }
+      
+      update_data_accessor_module
+    end
+    
+    def set_column_type( column, type, blank = :undefined )
+      alter_column( column, blank, &COLUMN_TYPES[type] )
+    end
+
+    # Note: If a block is given, the mod arg will be ignored.
+    def add_record_methods( mod = nil, &block )
+      if block_given?
+        mod = Module.new( &block )
+      end
+      @record_class.send( :include, mod )
+      self
+    end
+    
+    # Note: If implementation of Record[] changes, so must this.
+    def nils_are_blank_strings
+      alter_cells do |value, record|
+        value.nil? ? "" : value
+      end
+    end
+    
+    protected
+    def load_csv
+      # encoding seems to solve a specific problem with a specific spreadsheet, at an unknown cost.
+      @csv = CSV.new( File.read(@spreadsheet_file).force_encoding("ISO-8859-1").encode("UTF-8"), 
+                        { write_headers: true, 
+                          headers: ( @opts[:header] ? :first_row : false ) } )
+    end
+      
+    def add_to_index( col, key, record )
+      @indexes[col][key] = record
+    end
+    
+    # Reindexes the record lookup tables.
+    def reindex
+      @indexes = {}
+      for col in @index_columns
+        @indexes[col] = {}
+
+        for record in @records
+          add_to_index( col, record.send(col), record )
+        end
+      end
+    end
+    
+    # Each spreadsheet has its own anonymous record class, and each CSV row instantiates
+    # a record of this class.  This is where the getters and setters come from.
+    def create_record_class
+      create_data_accessor_module
+      @record_class = Class.new( CsvMadness::Record )
+      @record_class.spreadsheet = self
+      @record_class.send( :include, @module )
+    end
+    
+    # fetch the original headers from the CSV file.  If opts[:headers] is false,
+    # or the CSV file isn't loaded yet, returns an empty array.
+    def fetch_csv_headers
+      if @csv && @opts[:header]
+        if @csv.headers == true
+          @csv.shift
+          headers = @csv.headers
+          @csv.rewind   # shift/rewind, else @csv.headers only returns 'true'
+        else
+          headers = @csv.headers
+        end
+        headers
+      else
+        []
+      end
+    end
+    
+    # sets the list of columns. 
+    # If passed nil:
+    #   if the CSV file has headers, will try to create column names based on headers.
+    #   otherwise, you end up with accessors like record.col1, record.col2, record.col3...
+    # If the columns given doesn't match the number of columns in the spreadsheet 
+    # prints a warning and a comparison of the columns to the headers.
+    def set_initial_columns( columns = nil )
+      if columns.nil?
+        if @opts[:header] == false    #
+          @columns = (0...csv_column_count).map{ |i| :"col#{i}" }
+        else
+          @columns = fetch_csv_headers.map{ |name| self.class.getter_name( name ) }
+        end
+      else
+        @columns = columns
+        unless @columns.length == csv_column_count
+          puts "Warning <#{@spreadsheet_file}>: columns array does not match the number of columns in the spreadsheet." 
+          compare_columns_to_headers
+        end
+      end
+    end
+    
+    # Printout so the user can see which CSV columns are being matched to which
+    # getter/setters.  Helpful for debugging dropped or duplicate entries in the
+    # column list.
+    def compare_columns_to_headers
+      headers = fetch_csv_headers
+
+      for i in 0...([@columns, headers].map(&:length).max)
+        puts "\t#{i}:  #{@columns[i]} ==> #{headers[i]}"
+      end
+    end
+    
+    
+    # Create objects that respond to the recipe-named methods
+    def package
+      @records = []
+      @csv.each do |row|
+        @records << @record_class.new( row )
+      end
+    end
+  
+    # How many columns?  Based off the length of the headers.
+    def csv_column_count
+      fetch_csv_headers.length
+    end
+    
+    def columns_to_mapping
+      @columns.each_with_index.inject({}){ |memo, item| 
+        memo[item.first] = item.last
+        memo 
+      }
+    end
+  
+    def create_data_accessor_module
+      # columns = @columns                 # yes, this line is necessary. Module.new has its own @vars.
+      
+      @module = DataAccessorModule.new( columns_to_mapping )
+    end
+    
+    def update_data_accessor_module
+      @module.remap_accessors( columns_to_mapping )
+    end
+  end
+end

data/test/csv/simple.csv

@@ -0,0 +1,5 @@
+"id","fname","lname","age","born"
+"1","Mary","Moore","27","1986-04-08 15:06:10"
+"2","Bill","Paxton","39","1974-02-22"
+"3","Charles","Darwin","72","Invalid Date"
+"4","Chuck","Norris","57","1901-03-02"

data/test/helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'csv_madness'
+
+class Test::Unit::TestCase
+end

data/test/test_csv_madness.rb

@@ -0,0 +1,232 @@
+require 'helper'
+
+class TestCsvMadness < Test::Unit::TestCase
+  context "all:" do
+    setup do
+      @csv_search_path = Pathname.new( __FILE__ ).dirname.join("csv")
+      @csv_output_path = @csv_search_path.join("out")
+      CsvMadness::Sheet.add_search_path( @csv_search_path )
+    end
+
+    teardown do
+      if defined?(FileUtils)
+        FileUtils.rm_rf( Dir.glob( @csv_output_path.join("**","*") ) )
+      else
+        puts "fileutils not defined"
+        `rm -rf #{@csv_output_path.join('*')}`
+      end
+    end
+    
+    context "testing sheet basics" do
+      should "not accept duplicate search paths" do
+        CsvMadness::Sheet.add_search_path( Pathname.new( __FILE__ ).dirname.join("csv") )
+        assert_equal 1, CsvMadness::Sheet.instance_variable_get("@search_paths").length
+      end
+    
+      should "load a simple spreadsheet" do
+        simple = CsvMadness::Sheet.from("simple.csv")
+        assert_equal "Mary", simple[0].fname
+        assert_equal "Paxton", simple[1].lname
+        assert_equal "72", simple[2].age
+        assert_equal "1", simple[0].id
+        assert_equal [:id, :fname, :lname, :age, :born], simple.columns
+        assert_equal [:id, :fname, :lname, :age, :born], simple[0].columns
+      end
+    
+      should "index records properly on a simple spreadsheet, using custom columns" do
+        simple = CsvMadness.load( "simple.csv", 
+                                  columns: [:index, :given_name, :surname, :years_old, :born], 
+                                  index: [:index] )
+        bill = simple.fetch(:index, "2")
+        mary = simple.fetch(:index, "1")
+      
+        assert_equal "Bill", bill.given_name
+        assert_equal "Moore", mary.surname
+        assert_equal "1", mary.index
+      end
+    end
+  
+    context "testing transformations" do
+      context "with a simple spreadsheet loaded" do
+        setup do
+          @simple = CsvMadness.load( "simple.csv", index: [:id] )
+        end
+      
+        teardown do
+          @simple = nil
+        end
+      
+        should "transform every cell" do
+          @simple.alter_cells do |cell|
+            cell = "*#{cell}*"
+          end
+        
+          bill = @simple.fetch(:id, "2")
+          mary = @simple.fetch(:id, "1")
+        
+          assert_equal "*Bill*", bill.fname
+          assert_equal "*Moore*", mary.lname
+          assert_equal "*1*", mary.id
+        end
+      
+        should "transform every cell, accessing the whole record" do
+          @simple.alter_cells do |cell, record|
+            cell == record.id ? record.id : "#{record.id}: #{cell}"
+          end
+        
+          bill = @simple.fetch(:id, "2")
+          mary = @simple.fetch(:id, "1")
+
+          assert_equal "2: Bill", bill.fname
+          assert_equal "1: Moore", mary.lname
+          assert_equal "1", mary.id
+        end
+      
+        should "transform id column using alter_column" do
+          @simple.alter_column(:id) do |id|
+            (id.to_i * 2).to_s
+          end
+        
+          assert_equal %W(2 4 6 8), @simple.column(:id)
+        end
+      
+        should "set ID column to integers" do
+          @simple.set_column_type(:id, :integer)
+        
+          @simple.records.each do |record|
+            assert_kind_of Integer, record.id
+            assert_includes [1,2,3,4], record.id
+          end
+        end
+      
+        should "set ID column to floats" do
+          @simple.set_column_type(:id, :float)
+        
+          @simple.records.each do |record|
+            assert_kind_of Float, record.id
+            assert_includes [1.0,2.0,3.0,4.0], record.id
+          end
+        end
+        
+        should "parse a date column with one invalid date" do
+          @simple.set_column_type( :born, :date )
+          born1 = @simple[0].born
+          born3 = @simple[2].born
+          assert_kind_of Time, born1
+          assert_in_delta Time.parse("1986-04-08"), born1, 3600 * 24
+        
+          assert_kind_of String, born3
+          assert_match /Invalid Time Format/, born3
+        end
+      
+        should "successfully decorate record objects with new functionality" do
+          moduul = Module.new do
+            def full_name
+              "#{self.fname} #{self.lname}"
+            end
+          
+            def name_last_first
+              "#{self.lname}, #{self.fname}"
+            end
+          end
+        
+          @simple.add_record_methods( moduul )
+        
+          assert @simple[0].respond_to?( :full_name )
+          assert_equal "Mary Moore", @simple[0].full_name
+          assert @simple[0].respond_to?( :name_last_first )
+          assert_equal "Moore, Mary", @simple[0].name_last_first
+        end
+      
+        should "add methods to record objects (block form)" do
+          @simple.add_record_methods do
+            def full_name
+              "#{self.fname} #{self.lname}"
+            end
+          end
+        
+          assert @simple[0].respond_to?( :full_name )
+          assert_equal "Mary Moore", @simple[0].full_name
+        end
+      
+        should "return an array of objects when feeding fetch() an array" do
+          records = @simple.fetch(:id, ["1","2"])
+          assert_equal records.length, records.compact.length
+          assert_equal 2, records.length
+          assert_equal "1", records.first.id
+        end
+      end
+    end
+  
+    context "loading nil spreadsheet" do
+      setup do
+        @nilsheet = CsvMadness.load( "with_nils.csv", index: [:id] )
+      end
+      
+      should "stomp away the nils" do
+        @norris = @nilsheet.fetch(:id, "4")
+        assert_equal nil, @norris.born
+        assert_equal "Chuck", @norris.fname
+      
+        @nilsheet.nils_are_blank_strings  # should turn every nil into a ''
+        assert_equal "", @norris.born
+        assert_equal "Chuck", @norris.fname
+      end
+      
+      should "to_csv properly" do
+        @to_csv = @nilsheet.to_csv( force_quotes: true )
+        assert_match /"Moore"/, @to_csv
+        assert_match /"age","born"/, @to_csv
+      end
+      
+      should "write to an output file properly" do
+        # debugger
+        @outfile = @csv_output_path.join("output_nilfile.csv")
+        @nilsheet.write_to_file( @outfile, force_quotes: true )
+        
+        assert File.exist?( @outfile )
+        @to_csv = File.read( @outfile )
+        assert_match /"Moore"/, @to_csv
+        assert_match /"age","born"/, @to_csv
+      end
+    end
+    
+    context "testing add/remove column transformations" do
+      context "with simple spreadsheet loaded" do
+        setup do
+          load_simple
+        end
+        
+        should "add column" do
+          @simple.add_column( :compound ) do |h, record|
+            v = "#{record.fname} #{record.lname} #{record.id}"
+          end
+          
+          load_mary
+          assert_equal "Mary Moore 1", @mary.compound
+        end
+        
+        should "drop column" do
+          load_mary
+          assert @mary.respond_to?(:lname)
+          assert_equal "Moore", @mary.lname
+          
+          @simple.drop_column( :lname )
+          
+          assert @mary.respond_to?(:age)
+          assert_equal "Mary", @mary.fname
+          assert_equal false, @mary.respond_to?(:lname)
+          assert_equal "27", @mary.age
+        end
+      end
+    end
+  end
+  
+  def load_simple
+    @simple = CsvMadness.load( "simple.csv", index: [:id] )
+  end
+  
+  def load_mary
+    @mary = @simple.fetch( :id, "1" )
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: csv_madness
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Bryce Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: CSV Madness removes what little pain is left from Ruby's CSV class.  Load
+  a CSV file, and get back an array of objects with customizable getter/setter methods.
+email: keeputahweird@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- ./Gemfile
+- ./README.rdoc
+- ./Rakefile
+- ./VERSION
+- ./lib/csv_madness.rb
+- ./lib/csv_madness/record.rb
+- ./lib/csv_madness/sheet.rb
+- ./test/csv/simple.csv
+- ./test/helper.rb
+- ./test/test_csv_madness.rb
+- LICENSE.txt
+- README.rdoc
+homepage: http://github.com/darthschmoo/csv_madness
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 279847321864815987
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: CSV Madness turns your CSV rows into happycrazy objects.
+test_files: []