csv_madness 0.0.6 → 0.0.9

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

@@ -3,6 +3,5 @@ require 'fun_with_gems'
 # require 'fun_with_version_strings'
 require 'time'        # to use Time.parse to parse cells to get the date
 
-lib_dir = __FILE__.fwf_filepath.dirname
-FunWith::Gems.make_gem_fun( "CsvMadness", :require => lib_dir.join( "csv_madness" ) )
+FunWith::Gems.make_gem_fun( "CsvMadness" )
 

data/test/helper.rb

@@ -33,6 +33,10 @@ class MadTestCase < FunWith::Testing::TestCase # Test::Unit::TestCase
     set_spreadsheet_paths
   end
   
+  def load_sheet( *args )
+    @sheet = CsvMadness.load( *args )
+  end
+  
   def load_mary
     id = @simple.index_columns.first
     @mary = @simple.fetch( id, MARY_ID )
@@ -61,6 +65,7 @@ class MadTestCase < FunWith::Testing::TestCase # 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

data/test/test_builder.rb

@@ -4,15 +4,19 @@ 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?" )
+        s.column( :even, "even?" )          # calls the .even?() method on each object
         s.column( :odd, "odd?" )
         s.column( :hashh, "hash" )
-        s.column( :hashhash, "hash.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
@@ -27,7 +31,7 @@ class TestBuilder < MadTestCase
       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

@@ -110,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
@@ -212,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
     
@@ -236,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

data/test/test_reloading_spreadsheet.rb

@@ -12,7 +12,8 @@ class TestCsvMadness < MadTestCase
       assert @mary.respond_to?(:lname)
       assert @darwin.respond_to?(:fname)
       assert @mary.born.is_a?(String)
-
+      
+      debugger
       muck_up_spreadsheet
       set_person_records
       

data/test/test_sheet.rb

@@ -3,39 +3,46 @@ require 'helper'
 class TestSheet < MadTestCase
   context "testing getter_name()" do
     should "return proper function names" do
-      assert_equal :hello_world, CsvMadness::Sheet.getter_name( "  heLLo __ world " )
-      assert_equal :_0_hello_world, CsvMadness::Sheet.getter_name( "0  heLLo __ worlD!!! " )
+      test_data = [
+        ["  heLLo __ world ", :hello_world],
+        ["0  heLLo __ worlD!!! ", :_0_hello_world],
+        ["9ess 🐙 bsv++=", :_9ess_bsv ]
+      ]
+      
+      for input, expected in test_data
+        assert_equal expected, CsvMadness::Sheet.getter_name( input )
+      end
     end
   end
   
   context "testing default spreadsheet paths" do
-    should "only load existing paths" do
-      assert_raises(RuntimeError) do
+    should "raise error if a path does not exist" do
+      assert_raises( RuntimeError ) do
         CsvMadness::Sheet.add_search_path( CsvMadness.root.join("rocaganthor") )
       end
     end
     
     should "check a search path for files to load" do
-      sheet = CsvMadness.load( "with_nils.csv" )
-      assert sheet.is_a?(CsvMadness::Sheet)
+      load_sheet( "with_nils.csv" )
+      assert @sheet.is_a?( CsvMadness::Sheet )
     end
   end
   
   context "testing column_types" do
     should "gracefully handle empty strings for all column_types" do
-      sheet = CsvMadness.load("test_column_types.csv")
+      load_sheet("test_column_types.csv")
       
       for type, ignore_proc in CsvMadness::Sheet::COLUMN_TYPES
-        sheet.set_column_type( type, type )
+        @sheet.set_column_type( type, type )
       end
       
-      record = sheet.records[0]
+      record = @sheet.records[0]
       
       assert_kind_of String, record.date
       assert_equal nil, record.number
       assert_equal nil, record.float
       
-      record = sheet.records[1]
+      record = @sheet.records[1]
       assert_equal "12", record.id
       assert_equal 134.2, record.number
       assert_equal 100, record.integer
@@ -45,7 +52,7 @@ class TestSheet < MadTestCase
   
   context "testing add/remove records" do
     setup do
-      @sheet = CsvMadness.load( "simple.csv", :index => :id )
+      load_sheet( "simple.csv", :index => :id )
     end
     
     should "add record" do
@@ -95,17 +102,20 @@ class TestSheet < MadTestCase
     end
 
     should "deliver me a properly blanked spreadsheet (index)" do
-      sheet = CsvMadness.load( "splitter.csv", :index => [:id] )
-      blank_sheet = sheet.blanked
+      load_sheet( "splitter.csv", :index => [:id] )
+      blank_sheet = @sheet.blanked
+      
+      assert_zero blank_sheet.length
+      assert_includes blank_sheet.index_columns, :id 
     end
     
     should "split splitter" do
-      sheet = CsvMadness.load( "splitter.csv", :index => [:id, :party] )
+      load_sheet( "splitter.csv", :index => [:id, :party] )
       
-      sheets = sheet.split(&:party)
+      sheets = @sheet.split(&:party)
       
       for party in %w(D I R)
-        assert_equal_length sheets[party], sheet.records.select{|r| r.party == party }
+        assert_equal_length sheets[party], @sheet.records.select{|r| r.party == party }
       end
       
       assert_includes sheets["D"].index_columns, :id
@@ -115,8 +125,8 @@ class TestSheet < MadTestCase
   
   context "testing hilarious spreadsheet fails" do
     should "raise error on forbidden column name" do
-      assert_raises(RuntimeError) do
-        sheet = CsvMadness.load( "forbidden_column.csv" )
+      assert_raises( CsvMadness::ForbiddenColumnNameError ) do
+        CsvMadness.load( "forbidden_column.csv" )
       end
     end
   end