csv_madness 0.0.9 → 0.0.10

data/lib/csv_madness/sheet_methods/indexing.rb

@@ -1,25 +1,69 @@
 module CsvMadness
   module SheetMethods
     module Indexing
+      attr_accessor :index_columns
+      
       def set_index_columns( index_columns )
-        @index_columns = case index_columns
-        when NilClass
-          []
-        when Symbol
-          [ index_columns ]
-        when Array
-          index_columns
+        cols =  case index_columns
+                when NilClass
+                  []
+                when Symbol
+                  [ index_columns ]
+                when Array
+                  index_columns.map{|col| add_index_column( col ) }
+                end
+        for col in cols.map(&:to_sym)
+          remove_index_column( col ) if self.has_index_column?( col )
+          add_index_column( col )
         end
       end
       
-      def add_to_index( col, key, record )
-        (@indexes[col] ||= {})[key] = record
+      def add_index_column( col )
+        raise_if_index_columns( col )
+        
+        col = col.to_sym
+        
+        @index_columns << col
+        @indexes[col] = {}
+        
+        reindex( col )
+      end
+      
+      # TODO:  Suddenly seeing a huge problem with the indexes.  
+      #        What if the index values aren't unique?
+      # Add a single record to a single index. Index value calculated by caller.
+      def add_to_index( col, index_value, record )
+        raise_unless_index_columns( col )
+        
+        remove_from_index( col, record )   # first remove in case it's been indexed previously with a different value... gah, this is getting ugly.
+        
+        index_hash = (@indexes[col.to_sym] ||= {})
+        index_hash_records = (index_hash[index_value] ||= Set.new)
+        
+        index_hash_records << record
+      end
+      
+      def unindex_record( record )
+        for index_col in @index_columns
+          remove_from_index( index_col, record )
+        end
       end
+      
+      def remove_from_index( col, record )
+        raise_unless_index_columns( col )
+        
+        @indexes[col.to_sym].each do |index_value, indexed_records| 
+          indexed_records.delete( record )
+        end
+      end
+      
+      
+      
     
-      def add_to_indexes( records )
+      def index_records( records )
         if records.is_a?( Array )
           for record in records
-            add_to_indexes( record )
+            index_records( record )
           end
         else
           record = records
@@ -28,24 +72,61 @@ module CsvMadness
           end
         end
       end
-    
-      def remove_from_index( record )
-        for col in @index_columns
-          @indexes[col].delete( record.send(col) )
-        end
+
+      def has_index_column?( col )
+        @index_columns.include?( col.to_sym )
       end
     
       # Reindexes the record lookup tables.
-      def reindex
-        @indexes = {}
-        add_to_indexes( @records )
+      def reindex( *cols  )
+        # for column in (columns )
+        #
+        # @indexes = {}
+        # index_records( @records )
       end
+      
+      def empty_indexes( *cols )
+        raise_unless_index_columns( cols )
+        
+        icols = @index_columns if cols.fwf_blank?
+        
+        for icol in icols
+          @indexes[icol.to_sym] = {}
+        end
+      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)
+      def rename_index_column( old_name, new_name )
+        @index_columns[ @index_columns.index( old_name ) ] = new_name
+        @indexes[new_name] = @indexes.delete( old_name )  
+      end
+      
+      def remove_index_column( column_name )
+        raise_unless_index_columns( column_name )
+        
+        @indexes.delete( column_name.sym )
+        @index_columns.delete( column_name.sym )
+      end
+      
+      protected
+      # def each_index_column( cols = @index_columns, &block )
+      #   raise_unless_index_columns( cols )
+      #
+      #   for col in cols
+      #     yield col.to_sym
+      #   end
+      # end
+      
+      def raise_unless_index_columns( *cols )
+        absent_columns = cols.reject{ |col| self.has_index_column?( col ) }
+        
+        raise MissingColumnError.new( "Not an index column(s): #{absent_columns.inspect}" ) unless absent_columns.fwf_blank?
+      end
+
+      def raise_if_index_columns( *cols )
+        present_columns = cols.detect{ |col| self.has_index_column?( col ) }
+        
+        raise MissingColumnError.new( "Index column(s) already exist: #{present_columns.inspect}" ) unless present_columns.fwf_blank?
       end
     end
   end

data/lib/csv_madness/sheet_methods/record_methods.rb

@@ -1,64 +1,101 @@
 module CsvMadness
   module SheetMethods
     module RecordMethods
-      def add_record( record )
+      def add_record( record, &block )
         case record
         when Array
-          # CSV::Row.new( column names, column_entries ) (in same order as columns, natch) 
-          record = CSV::Row.new( self.columns, record )
+          # do nothing
         when Hash
-          header = []
-          fields = []
-        
-          for col in self.columns
-            header << col
-            fields << record[col]
+          record = @column_mapping.inject( [] ) do |memo, col_and_index|
+            col, index = col_and_index
+            
+            if record.has_key?( col )
+              val = record[col]
+            elsif record.has_key?( col.to_s )
+              val = record[col.to_s]
+            else
+              val = nil
+            end
+
+            if index >= memo.length
+              memo.insert( index, val )
+            else
+              memo[index] = val
+            end
+            
+            memo
           end
-        
-          record = CSV::Row.new( header, fields )
         when CSV::Row
-          # do nothing
+          record = record.to_a.map( &:last )
+        when CsvMadness::Record
+          # TODO: But what if the two records aren't from the same kinds of sheet
+          # IOW, different columns or columns in different orders, etc.
+          record = record.data
         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 )
+        
+        record = Record.new( record, self )
+        
         @records << record
-        add_to_indexes( record )
+        
+        yield record if block_given?
+        
+        index_records( record ) if indexing_enabled?
+        
+        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
+        self.add_record( [], &block )
+        #
+        # 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)
+      # record can be the record itself
+      #
+      # returns the record that was removed.  
       def remove_record( record )
-        record = @records[record] if record.is_a?(Integer)
-        return if record.nil?
+        if record.is_a?(Integer)
+          record = remove_record_at_index( record )
+        else
+          record = self.records.delete( record )
+        end
+        
+        self.unindex_record( record ) if indexing_enabled?
+        record
+      end
       
-        self.remove_from_index( record )
-        @records.delete( record )
+      def remove_record_at_index( index )
+        self.records.delete_at( index )
       end
     
-      # Here's the deal: you hand us a block, and we'll remove the records for which
-      # it yields _true_.
+      # Here's the deal: you hand it an array of records (or indexes, or a mix of the two),
+      # and it will remove the records (or the index... may want to test the indexing thing).
+      # If you give it a block, and it'll remove all the records for which
+      # the block yields _true_.
+      #
+      # returns an array of the removed records, in case you want them for anything.
       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 )
+        [].tap do |removed|
+          if block_given?
+            for record in @records
+              removed << self.remove_record( record ) if yield( record ) == true
+            end
+          else # records should be an array
+            records = records.map{ |r| r.is_a?( Integer ) ? self[r] : r }   # turn indexes into records
+            
+            for record in records
+              removed << self.remove_record( record )
+            end
           end
         end
       end
@@ -68,32 +105,71 @@ module CsvMadness
       # 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] }
+        if indexing_enabled?
+          if key.is_a?(Array)
+            key.map{ |k| @indexes[index_col][k] }
+          else
+            @indexes[index_col][key]
+          end
         else
-          @indexes[index_col][key]
+          if key.is_a?(Array)
+            key.map{ |k| self.fetch( index_col, k ) }
+          else
+            index = index_of_column( index_col )
+            @records.detect{ |r| r.data[index] == key }
+          end
         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 )
+      def filter( record_filter = nil, &block )
+        if block_given?
+          filtered_records = []
+        
+          @records.each do |record|
+            filtered_records << record if ( yield record )
+          end
+        elsif record_filter
+          filtered_records = record_filter.apply( @records )
+        else
+          warn "#{self.class}.filter called without block or RecordFilter.. "
+          filtered_records = @records
         end
-    
-        rval
+        
+        return filtered_records
       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
+      def filter!( record_filter = nil, &block )
+        @records = self.filter( record_filter, &block )
+        reindex if indexing_enabled?
         @records
       end
+      
+      def extra_method?( m )
+        @extra_methods.keys.include?( m )
+      end
+      
+      # The method given should take a record, return... well, anything.
+      def add_extra_method( method, &block )
+        @extra_methods[method.to_sym] = block
+      end
+      
+      def remove_extra_method( method )
+        @extra_methods.delete( method.to_sym )
+      end
+      
+      def call_extra_method( method, *args )
+        @extra_methods[method.to_sym].call( *args )
+      end
+      
+      
+      def convert_types( record )
+        
+      end
     end
   end
 end

data/lib/csv_madness/sheet_methods/sorting_methods.rb

@@ -0,0 +1,10 @@
+module CsvMadness
+  module SheetMethods
+    module SortingMethods
+      # Changes the order that the records appear in the sheet
+      def sort( *columns, &block )
+        
+      end
+    end
+  end
+end

data/lib/csv_madness/utils/const_proc.rb

@@ -0,0 +1,19 @@
+module CsvMadness
+  module Utils
+    class ConstProc < Proc
+      def initialize( val, &block )
+        @rval = val
+      end
+
+      def call(*args,&block)
+        @rval
+      end
+  
+      def self.proc_for( val )
+        ConstProc.new( val ) do
+          :does_nothing
+        end
+      end
+    end
+  end
+end

data/lib/csv_madness/utils/counter.rb

@@ -0,0 +1,24 @@
+module CsvMadness
+  module Utils
+    class Counter
+      attr_reader :value
+      
+      def initialize( initial_value = 0 )
+        @initial_value = initial_value
+        self.reset
+      end
+      
+      def click
+        @value += 1
+      end
+      
+      def reset
+        @value = resets_to()
+      end
+      
+      def resets_to
+        @initial_value
+      end
+    end
+  end
+end

data/lib/csv_madness/utils/counter_proc.rb

@@ -0,0 +1,31 @@
+module CsvMadness
+  module Utils
+    class CounterProc < Proc
+      def initialize( initial_value, &block )
+        @counter = Counter.new( initial_value )
+      end
+
+      # Each call return the value of the internal counter at the time the call mas made.
+      # Which is one lower than the number of times called.  Hence the existence of the times_called method
+      def call(*args,&block)
+        rval = @counter.value
+        @counter.click
+        rval
+      end
+      
+      def reset
+        @counter.reset
+      end
+      
+      def times_called
+        @counter.value - @counter.resets_to
+      end
+  
+      def self.counter( initial_value = 0 )
+        self.new( initial_value ) do
+          :proc_does_nothing
+        end
+      end
+    end
+  end
+end

data/lib/csv_madness/utils/looker_upper.rb

@@ -0,0 +1,36 @@
+module CsvMadness
+  module Utils
+    # Fast insert/remove/lookup indexing utility.  
+    # 
+    # For example, if you're keeping an index of a spreadsheet column, and you want to be able at any moment to get the records
+    # containing that value (id = 7124) or (name = 'Mary'), 
+    #
+    # Is it a hash?  Two hashes?
+    # It's like a hash because...
+    #
+    # It's like an array because order needs to be preserved.
+    # 
+    # - insert( key, val )
+    #    - add_to_result_index
+    #    - add_position_in_result_index_to removal index
+    #    - 
+    # - update( key, val )
+    #
+    # - remove( val )
+    #
+    # - fetch_results( key )
+    #
+    # Is the order important?  Definitely.  But that means re-indexing whenever the record order changes?
+    #
+    # results_data
+    # removal_data
+    # ordering_data ... shared by multiple 
+    
+    # lu = LookerUpper.new
+    # lu.keep( )
+    
+    class LookerUpper
+      
+    end
+  end
+end

data/lib/csv_madness.rb

@@ -2,6 +2,7 @@ require 'csv'
 require 'fun_with_gems'
 # require 'fun_with_version_strings'
 require 'time'        # to use Time.parse to parse cells to get the date
+require 'set'
 
 FunWith::Gems.make_gem_fun( "CsvMadness" )
 

data/test/csv/nil_headers.csv

@@ -0,0 +1,5 @@
+,fname,,,
+"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/csv/pokemon.csv

@@ -0,0 +1,9 @@
+ID,PokemonType,CP,HP
+1,Jigglypuff,392,54
+2,Pikachu,408,29
+3,Charmander,392,35
+4,Tentacool,376,35
+5,Haunter,338,27
+6,Meowth,401,55
+7,Geodude,338,48
+8,Haunter,301,55

data/test/csv/test_column_types.csv

@@ -1,3 +1,3 @@
-"id","number","integer","float","date"
+"id","number","integer","float","date","string"
 ,,,,
-12,134.2,100,123.4,2013-01-13
+12,134.2,100,123.4,2013-01-13,"I am the very model of a coding individual"

data/test/helper.rb

@@ -38,22 +38,22 @@ class MadTestCase < FunWith::Testing::TestCase # Test::Unit::TestCase
   end
   
   def load_mary
-    id = @simple.index_columns.first
+    id = @simple.columns.first
     @mary = @simple.fetch( id, MARY_ID )
   end
   
   def load_bill
-    id = @simple.index_columns.first
+    id = @simple.columns.first
     @bill = @simple.fetch( id, BILL_ID )
   end
   
   def load_darwin
-    id = @simple.index_columns.first
+    id = @simple.columns.first
     @darwin = @simple.fetch( id, DARWIN_ID )
   end
   
   def load_chuck
-    id = @simple.index_columns.first
+    id = @simple.columns.first
     @chuck = @simple.fetch( id, CHUCK_ID )
   end
      
@@ -65,7 +65,6 @@ 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
@@ -80,8 +79,12 @@ class MadTestCase < FunWith::Testing::TestCase # Test::Unit::TestCase
     @simple.alter_column(:born) do |val|
       if val.is_a?(String)
         -1.0
-      else
+      elsif val.is_a?(Date)
+        val.wday
+      elsif val.is_a?(Time)
         (Time.now - val).to_f
+      else
+        57.3
       end
     end
 

data/test/test_builder.rb

@@ -34,4 +34,40 @@ class TestBuilder < MadTestCase
       assert_equal 4225, ss.records.first.square
     end
   end
+  
+  context "testing convenience column methods" do
+    setup do
+      @builder = CsvMadness::Builder.new do |s|
+        s.constant_column :string, "String"
+        s.constant_column :int,    5
+        s.constant_column :sym,    :sym
+        s.blank_column    :blank 
+        s.counter_column  :line,   1 
+      end
+      
+      @sheet = @builder.build( [nil, nil, nil] )
+    end
+    
+    should "calculate the resulting sheet accurately" do
+      assert_equal [nil,nil,nil], @sheet.column( :blank )
+      assert_equal ["String", "String", "String"], @sheet.column( :string )
+      assert_equal 3, @sheet.records.last.line
+      assert_equal :sym, @sheet.records[0].sym
+      assert_equal 5, @sheet.records[1].int
+      assert_equal 5, @sheet.records[0][1]
+    end
+    
+    should "add a record without a dumpster fire ensuing" do
+      data = [7] * @builder.column_names.length
+      
+      @sheet.add_record( data )
+      
+      
+      r = @sheet.records.last
+
+      for sym in @builder.column_names
+        assert_equal 7, r.send( sym )
+      end
+    end
+  end
 end