csv_madness 0.0.4 → 0.0.9

data/lib/csv_madness/sheet_methods/class_methods.rb

@@ -0,0 +1,77 @@
+module CsvMadness
+  module SheetMethods
+    module ClassMethods
+      # Used to make getter/setter names out of the original header strings.
+      # " hello;: world! " => :hello_world
+      def getter_name( name )
+        # replace any run of non-word characters with a single "_"
+        name = name.downcase.gsub( /(\W|_|\s)+/, "_" )
+      
+        # snip trailing and leading "_"
+        name = name.gsub( /(^_+|_+$)/, "" )
+      
+        # add leading "_" when we'd otherwise have a method name starting with a digit
+        name = "_#{name}" if name.match( /^\d/ )
+      
+        name.to_sym
+      end
+    
+    
+      # Paths to be searched when CsvMadness.load( "filename.csv" ) is called.
+      def add_search_path( path )
+        @search_paths ||= []
+        path = Pathname.new( path ).expand_path
+        unless path.directory?
+          raise "The given path does not exist"
+        end
+      
+        @search_paths << path unless @search_paths.include?( path )
+      end
+    
+      def search_paths
+        @search_paths
+      end
+    
+      def 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 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 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 write_to_file( spreadsheet, file, opts = {} )
+        file = file.fwf_filepath.expand_path
+        file.write( spreadsheet.to_csv( opts ) )
+      end
+    end
+  end
+end

data/lib/csv_madness/sheet_methods/column_methods.rb

@@ -0,0 +1,187 @@
+module CsvMadness
+  module SheetMethods
+    module ColumnMethods
+    
+      COLUMN_TYPES = {
+        number: Proc.new do |cell, record|
+          rval = cell
+        
+          unless cell.nil? || (cell.is_a?(String) && cell.length == 0)
+        
+            begin
+              rval = Integer(cell)
+            rescue
+              # do nothing
+            end
+        
+            unless rval.is_a?(Integer)
+              begin
+                rval = Float(cell)
+              rescue
+                # do nothing
+              end
+            end
+          end
+        
+          rval
+        end,
+      
+        integer: Proc.new do |cell, record|
+          begin
+            Integer(cell)
+          rescue
+            cell
+          end
+        end,
+      
+        float:   Proc.new do |cell, record|
+          begin
+            Float(cell)
+          rescue
+            cell
+          end
+        end,
+      
+        date:    Proc.new do |cell, record|
+          begin
+            parse = Time.parse( cell || "" )
+          rescue ArgumentError
+            if cell =~ /^Invalid Time Format: /
+              parse = cell
+            else
+              parse = "Invalid Time Format: <#{cell}>"
+            end
+          end
+        
+          parse
+        end
+      }
+    
+      FORBIDDEN_COLUMN_NAMES = [:to_s]  # breaks things hard when you use them.  Probably not comprehensive, sadly.
+      
+      
+      def column col
+        @records.map(&col)
+      end
+    
+      def has_column?( col )
+        self.columns.include?( col.to_sym )
+      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
+      
+      def alter_column( column, blank = :undefined, &block )
+        raise_on_missing_columns( column )
+      
+        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
+    
+      # If no block given, adds an empty column.
+      # If block given, fills the new column cells when the block is run on each record
+      # TODO: Should be able to specify the index of the column
+      def add_column( column, &block )
+        raise_on_forbidden_column_names( column )
+        raise ColumnExistsError.new( "Column already exists: #{column}" ) 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_on_missing_columns( column )
+      
+        @columns.delete( column )
+      
+        key = column.to_s
+      
+        @records.map{ |r|
+          r.csv_data.delete( key )
+        }
+      
+        update_data_accessor_module
+      end
+    
+      def rename_column( column, new_name )
+        @columns[@columns.index(column)] = new_name
+        rename_index_column( column, new_name ) if @index_columns.include?( column )
+        update_data_accessor_module
+      end
+    
+      def set_column_type( column, type, blank = :undefined )
+        alter_column( column, blank, &COLUMN_TYPES[type] )
+      end
+
+    
+      # If :reverse_merge is true, then the dest column is only overwritten for records where :dest is blank
+      def merge_columns( source, dest, opts = {} )
+        opts = { :drop_source => true, :reverse_merge => false, :default => "" }.merge( opts )
+        raise_on_missing_columns( source, dest )
+      
+        self.records.each do |record|
+          if opts[:reverse_merge] == false || record.blank?( dest )
+            record[dest] = record.blank?(source) ? opts[:default] : record[source]
+          end
+        end
+      
+        self.drop_column( source ) if opts[:drop_source]
+      end
+    
+      # By default, the
+      def concat_columns( col1, col2, opts = {} )
+        opts =  {:separator => '', :out => col1}.merge( opts )
+      
+        raise_on_missing_columns( col1, col2 )
+        self.add_column( opts[:out] ) unless self.columns.include?( opts[:out] )
+      
+        for record in self.records
+          record[ opts[:out] ] = "#{record[col1]}#{opts[:separator]}#{record[col2]}"
+        end
+      end
+    
+      alias :concatenate :concat_columns
+      
+      protected
+      def raise_on_missing_columns( *cols )
+        missing_columns = cols.flatten.reject{ |col| self.has_column?( col ) }
+      
+        raise MissingColumnError.new( "#{caller[0]}: required_column(s) :#{missing_columns.inspect} not found." ) unless missing_columns.fwf_blank?
+      end
+    
+      def forbidden_column_name?( col )
+        FORBIDDEN_COLUMN_NAMES.include?( col )
+      end
+      
+      def raise_on_forbidden_column_names( *cols )
+        forbidden_columns = cols.flatten.select{ |col| self.forbidden_column_name?( col ) }
+        raise ForbiddenColumnNameError.new( "forbidden names: #{forbidden_columns.inspect}" ) unless forbidden_columns.fwf_blank?
+      end
+    end
+  end
+end

data/lib/csv_madness/sheet_methods/file_methods.rb

@@ -0,0 +1,41 @@
+module CsvMadness
+  module SheetMethods
+    module FileMethods
+      def write_to_file( file, opts = {} )
+        self.class.write_to_file( self, file, opts )
+      end
+    
+      # pass an arbitrary filepath to save sheet to that filepath
+      # call save() with no arguments to overwrite the current spreadsheet file
+      # call save(:timestamp) to make a timestamped copy of the spreadsheet file
+      #
+      # Obviously, the last two require self.spreadsheet_file to exist and be writable
+      def save( file = self.spreadsheet_file )
+        if file == :timestamp
+          if self.spreadsheet_file
+            file = self.spreadsheet_file.fwf_filepath.timestamp
+          else
+            raise ArgumentError.new( "CsvMadness.save(:timestamp) - Spreadsheet must be specified by @spreadsheet_file" )
+          end
+        end
+      
+        if file
+          self.write_to_file( self.spreadsheet_file, @opts || {} )
+        else
+          raise "CsvMadness.save(:timestamp) - Spreadsheet must be specified by spreadsheet_file"
+        end
+      end
+      
+    
+      def reload_spreadsheet( opts = @opts )
+        load_csv if @spreadsheet_file
+        set_initial_columns( opts[:columns] )
+        create_record_class
+        package
+      
+        set_index_columns( opts[:index] )
+        reindex
+      end
+    end
+  end
+end

data/lib/csv_madness/sheet_methods/indexing.rb

@@ -0,0 +1,52 @@
+module CsvMadness
+  module SheetMethods
+    module Indexing
+      def set_index_columns( index_columns )
+        @index_columns = case index_columns
+        when NilClass
+          []
+        when Symbol
+          [ index_columns ]
+        when Array
+          index_columns
+        end
+      end
+      
+      def add_to_index( col, key, record )
+        (@indexes[col] ||= {})[key] = record
+      end
+    
+      def add_to_indexes( records )
+        if records.is_a?( Array )
+          for record in records
+            add_to_indexes( record )
+          end
+        else
+          record = records
+          for col in @index_columns
+            add_to_index( col, record.send(col), record )
+          end
+        end
+      end
+    
+      def remove_from_index( record )
+        for col in @index_columns
+          @indexes[col].delete( record.send(col) )
+        end
+      end
+    
+      # Reindexes the record lookup tables.
+      def reindex
+        @indexes = {}
+        add_to_indexes( @records )
+      end
+    
+      # shouldn't require reindex
+      def rename_index_column( column, new_name )
+        @index_columns[ @index_columns.index( column ) ] = new_name
+        @indexes[new_name] = @indexes[column]
+        @indexes.delete(column)
+      end
+    end
+  end
+end

data/lib/csv_madness/sheet_methods/record_methods.rb

@@ -0,0 +1,99 @@
+module CsvMadness
+  module SheetMethods
+    module RecordMethods
+      def add_record( record )
+        case record
+        when Array
+          # CSV::Row.new( column names, column_entries ) (in same order as columns, natch) 
+          record = CSV::Row.new( self.columns, record )
+        when Hash
+          header = []
+          fields = []
+        
+          for col in self.columns
+            header << col
+            fields << record[col]
+          end
+        
+          record = CSV::Row.new( header, fields )
+        when CSV::Row
+          # do nothing
+        else
+          raise "sheet.add_record() doesn't take objects of type #{record.inspect}" unless record.respond_to?(:csv_data)
+          record = record.csv_data
+        end
+      
+        record = @record_class.new( record, self.column_accessors_map )
+        @records << record
+        add_to_indexes( record )
+      end
+    
+      alias :<< :add_record
+      
+      def add_blank_record( &block )
+        self.add_record( {} )
+        if block_given?
+          yield self.records.last
+        else
+          self.records.last
+        end
+      end
+    
+      # record can be the row number (integer from 0...@records.length)
+      # record can be the record itself (anonymous class)
+      def remove_record( record )
+        record = @records[record] if record.is_a?(Integer)
+        return if record.nil?
+      
+        self.remove_from_index( record )
+        @records.delete( record )
+      end
+    
+      # Here's the deal: you hand us a block, and we'll remove the records for which
+      # it yields _true_.
+      def remove_records( records = nil, &block )
+        if block_given?
+          for record in @records
+            remove_record( record ) if yield( record ) == true
+          end
+        else # records should be an array
+          for record in records
+            self.remove_record( record )
+          end
+        end
+      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{ |k| @indexes[index_col][k] }
+        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.
+      # TODO!  Should be returning self rather than the records.a
+      def filter!( &block )
+        @records = self.filter( &block )
+        reindex
+        @records
+      end
+    end
+  end
+end

data/lib/csv_madness.rb

@@ -1,17 +1,7 @@
 require 'csv'
-require 'fun_with_files'
+require 'fun_with_gems'
+# require 'fun_with_version_strings'
 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'
+FunWith::Gems.make_gem_fun( "CsvMadness" )
 
-
-FunWith::Files::RootPath.rootify( CsvMadness, __FILE__.fwf_filepath.dirname.up )
-
-CsvMadness.class_eval do
-  def self.load( csv, opts = {} )
-    CsvMadness::Sheet.from( csv, opts )
-  end
-end

data/test/csv/forbidden_column.csv

@@ -0,0 +1,2 @@
+"to_s"
+"string!"

data/test/csv/splitter.csv

@@ -0,0 +1,11 @@
+"id","fname","lname","party"
+"1","Mary","Moore","D"
+"2","Bill","Paxton","R"
+"3","Charles","Darwin","I"
+"4","Chuck","Norris","D"
+"5","Annabelle","Lecter","R"
+"6","Mortimer","Bradford","D"
+"7","Wilford","Brimley","I"
+"8","Cala","Wilcox","R"
+"9","Horace","Wilcox","R"
+"10","Jacob","Buford","D"

data/test/csv/test_column_types.csv

@@ -0,0 +1,3 @@
+"id","number","integer","float","date"
+,,,,
+12,134.2,100,123.4,2013-01-13

data/test/csv/with_nils.csv

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

data/test/helper.rb

@@ -1,30 +1,41 @@
-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'
+# 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 'fun_with_testing'
 require 'csv_madness'
 
-class Test::Unit::TestCase
-end
+# class Test::Unit::TestCase
+# end
 
-class MadTestCase < Test::Unit::TestCase
+class MadTestCase < FunWith::Testing::TestCase # Test::Unit::TestCase
+  include FunWith::Testing::Assertions::Basics
+  
   MARY_ID = "1"
   BILL_ID = "2"
   DARWIN_ID = "3"
   CHUCK_ID = "4"
+
+  def setup
+    set_spreadsheet_paths
+  end
+  
+  def load_sheet( *args )
+    @sheet = CsvMadness.load( *args )
+  end
   
   def load_mary
     id = @simple.index_columns.first
@@ -54,6 +65,7 @@ class MadTestCase < Test::Unit::TestCase
   end
   
   def muck_up_spreadsheet
+    debugger
     @simple.add_column(:scrambled_name) do |val, record|
       record.fname.chars.map(&:to_s).zip( record.lname.chars.map(&:to_s) ).flatten.compact.join
     end
@@ -78,9 +90,9 @@ class MadTestCase < Test::Unit::TestCase
   end
    
   def set_spreadsheet_paths
-    @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 )
+    @csv_load_path = CsvMadness.root( "test", "csv" )
+    @csv_output_path = CsvMadness.root( "test", "csv", "out" )
+    CsvMadness::Sheet.add_search_path( @csv_load_path )
     CsvMadness::Sheet.add_search_path( @csv_output_path )
   end
   

data/test/test_builder.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+class TestBuilder < MadTestCase
+  context "testing simple cases" do
+    should "spreadsheetize integers" do
+      integers = [65, 66, 67, 68, 69, 70]
+      
+      sb = CsvMadness::Builder.new do |s|
+        s.column( :even, "even?" )          # calls the .even?() method on each object
+        s.column( :odd, "odd?" )
+        s.column( :hashh, "hash" )
+        s.column( :hashhash, "hash.hash" )  # calls .hash(), then calls .hash() on result
+        s.column( :chr )
+        s.column( :not_a_valid_method )
+        s.column( :square ) do |i|          # Stores the block as a proc, runs on each object.
+          i * i
+        end
+      end
+      
+      ss = sb.build( integers )
+      
+      for record in ss.records
+        assert_kind_of( CsvMadness::Record, ss.records.first )
+        for col in [:even, :odd, :hashh, :hashhash, :chr]
+          assert_respond_to record, col
+        end
+      end
+      
+      assert_matches ss.records.first.not_a_valid_method, /^ERROR: undefined method `not_a_valid_method'/
+      
+      ss = sb.build( integers, :on_error => :ignore )
+      
+      assert_equal "", ss.records.first.not_a_valid_method
+      assert_equal 4225, ss.records.first.square
+    end
+  end
+end

data/test/test_csv_madness.rb

@@ -3,7 +3,6 @@ require 'helper'
 class TestCsvMadness < MadTestCase
   context "all:" do
     setup do
-      set_spreadsheet_paths
       load_simple_spreadsheet
     end
 
@@ -14,12 +13,12 @@ class TestCsvMadness < MadTestCase
     context "testing sheet basics" do
       should "not accept duplicate search paths" do
         @path_count = CsvMadness::Sheet.search_paths.length
-        CsvMadness::Sheet.add_search_path( Pathname.new( __FILE__ ).dirname.join("csv") )
+        CsvMadness::Sheet.add_search_path( @csv_load_path )
         assert_equal @path_count, CsvMadness::Sheet.search_paths.length
       end
     
       should "load a simple spreadsheet" do
-        simple = CsvMadness::Sheet.from("simple.csv")
+        simple = CsvMadness::Sheet.from( "simple.csv" )
         assert_equal "Mary", simple[0].fname
         assert_equal "Paxton", simple[1].lname
         assert_equal "72", simple[2].age
@@ -111,7 +110,7 @@ class TestCsvMadness < MadTestCase
           assert_in_delta Time.parse("1986-04-08"), born1, 3600 * 24
         
           assert_kind_of String, born3
-          assert_match /Invalid Time Format/, born3
+          assert_match( /Invalid Time Format/, born3 )
         end
       
         should "successfully decorate record objects with new functionality" do
@@ -213,19 +212,18 @@ class TestCsvMadness < MadTestCase
       
       should "to_csv properly" do
         @to_csv = @nilsheet.to_csv( force_quotes: true )
-        assert_match /"Moore"/, @to_csv
-        assert_match /"age","born"/, @to_csv
+        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
+        assert_match( /"Moore"/, @to_csv )
+        assert_match( /"age","born"/, @to_csv )
       end
     end
     
@@ -237,7 +235,7 @@ class TestCsvMadness < MadTestCase
         
         should "add column" do
           @simple.add_column( :compound ) do |h, record|
-            v = "#{record.fname} #{record.lname} #{record.id}"
+            "#{record.fname} #{record.lname} #{record.id}"
           end
           
           load_mary