csv_madness 0.0.6 → 0.0.10

data/lib/csv_madness/sheet.rb

@@ -1,144 +1,29 @@
 module CsvMadness
   class Sheet
-    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.
-    
-    # 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
-      name = name.gsub( /_+$/, "" )
-      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
-      unless path.directory?
-        raise "The given path does not exist"
-      end
-      
-      @search_paths << path unless @search_paths.include?( path )
-    end
-    
-    def self.search_paths
-      @search_paths
-    end
+    extend  SheetMethods::ClassMethods 
+    include SheetMethods::Base
+    # include SheetMethods::Indexing    # TODO: May never re-implement
+    include SheetMethods::FileMethods
+    include SheetMethods::ColumnMethods
+    include SheetMethods::RecordMethods
+    include SheetMethods::SortingMethods
     
-    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
+    def indexing_enabled?
+      false
     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
+    attr_reader :columns, :column_mapping, :opts, :extra_methods
+    attr_accessor :spreadsheet_file
     
-    def self.write_to_file( spreadsheet, file, opts = {} )
-      file = file.fwf_filepath.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, :index_columns, :records, :spreadsheet_file, :record_class, :opts
+    # new( <optional non-hash first argument>, <optional hash of options> )
+    # firstarg:
+    #   nil or no first argument given: this Spreadsheet object isn't associated with a .csv file
+    #
+    #  string or path: create Spreadsheet by reading contents of a CSV file
+    #  
+    #  array: sets the columns.  Overlaps with opts[:columns], and should likely be removed.
+    #    
+    #   
     # opts: 
     #   index: ( [:id, :id2 ] )
     #       columns you want mapped for quick 
@@ -154,16 +39,25 @@ module CsvMadness
     #   header:   false       
     #       anything else, we assume the csv file has a header row
     def initialize( *args )
+      @csv = nil
+      @extra_methods = {}  # key = method name as symbol, val: a proc that takes a record as an argument, and possibly a block
+      if indexing_enabled?
+        @index_columns = []
+        @indexes = {}
+      end
+      
       if args.last.is_a?(Hash)
         @opts = args.pop
       else
         @opts = {}
       end
       
+      @column_types = {}
+      
       firstarg = args.shift
       
       case firstarg
-      when NilClass
+      when NilClass               # Blank sheet, no affiliation with an existing csv file
         @spreadsheet_file = nil
         @opts[:columns] ||= []
       when String, FunWith::Files::FilePath, Pathname
@@ -178,146 +72,102 @@ module CsvMadness
       reload_spreadsheet
     end
     
-    def <<( record )
-      self.add_record( record )
-    end
     
-    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
+    def call_record_method( record, method, args )
+      if extra_method?( method )
+        # call the decorated method
+        call_extra_method( method, record, *args )
       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 )
-      @records << record
-      add_to_indexes( record )
-    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 )
+        if method[-1] == '='
+          key = method[0..-2]
+          set_cell( record, key, args.first )
+        else
+          get_cell( record, method )
         end
       end
     end
-    
-    def reload_spreadsheet( opts = @opts )
-      load_csv if @spreadsheet_file
-      set_initial_columns( opts[:columns] )
-      create_record_class
-      package
+  
+    def get_cell( record, key )
+      record = self[record] if record.is_a?( Integer )  
+
+      index = if key.is_a?( Integer )
+                key
+              elsif has_column?( key )
+                index_of_column( key )
+              else
+                nil
+              end
       
-      set_index_columns( opts[:index] )
-      reindex
+      raise ColumnError.new( "Column #{key} does not exist. Column mapping: #{self.column_mapping.inspect}" ) if index.nil?
+      
+      record.data[ index ]
     end
+  
+  
+    # TODO:  Also update the index if necessary
+    def set_cell( record, key, val )
+      record = self[record] if record.is_a?( Integer )  
 
-    def set_index_columns( index_columns )
-      @index_columns = case index_columns
-      when NilClass
-        []
-      when Symbol
-        [ index_columns ]
-      when Array
-        index_columns
-      end
+      record.data[ index_of_column( key ) ] = val
     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]
+    def to_csv( hash_opts = {}, **keyword_opts )
+      opts = hash_opts.merge( keyword_opts )
+      self.records.inject( self.columns.to_csv( ** opts ) ) do |output, record|
+        output << record.to_csv( ** opts )
       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
+
+    def [] offset
+      @records[offset]
     end
     
-    # removes rows which fail the given test from the spreadsheet.
-    def filter!( &block )
-      @records = self.filter( &block )
-      reindex
-      @records
+    def records
+      @records ||= []
     end
-    
+  
     
     # give a copy of the current spreadsheet, but with no records
     def blanked()
       sheet = self.class.new
       sheet.columns = @columns.clone
-      sheet.index_columns = @index_columns.clone
+      sheet.set_column_mapping
+      
+      sheet.index_columns = @index_columns.clone   if indexing_enabled?
+      
       sheet.records = []
       sheet.spreadsheet_file = nil
-      sheet.create_data_accessor_module
-      sheet.create_record_class
+      # sheet.create_data_accessor_module
+      # sheet.create_record_class
       sheet.opts = @opts.clone
-      sheet.reindex
+      sheet.reindex if indexing_enabled?
       
       sheet
     end
     
-    # give a block, and get back a hash.  
-    # The hash keys are the results of the block.
-    # The hash values are copies of the spreadsheets, with only the records
-    # which caused the block to return the key.
-    def split( &block )
-      sheets = Hash.new
+    # block form:
+    #   give a block, and get back a hash.  
+    #   The hash keys are the results of the block.
+    #   The hash values are copies of the spreadsheets, with only the records
+    #   which caused the block to return the key.
+    #
+    # arg form:
+    #   assumes the given arg is a column name
+    def split( col = nil, &block )
+      if block_given?
+        sheets = Hash.new
       
-      for record in @records
-        result_key = yield record
-        ( sheets[result_key] ||= self.blanked() ) << record
-      end
+        for record in @records
+          result_key = yield record
+          ( sheets[result_key] ||= self.blanked() ) << record
+        end
 
-      sheets
+        sheets
+      elsif has_column?( col )
+        self.split(&col)
+      else
+        raise ColumnError.new( "No block given and column doesn't exist: #{col.inspect}" )
+      end
       # sheet_args = self.blanked
       # for key, record_set in records
       #   sheet = self.clone
@@ -329,18 +179,6 @@ module CsvMadness
       # 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
@@ -350,102 +188,6 @@ module CsvMadness
         alter_column( column, blank, &block )
       end
     end
-
-    def alter_column( column, blank = :undefined, &block )
-      raise "Column does not exist: #{column}" unless @columns.include?( 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
-    def add_column( column, &block )
-      raise "Column already exists: #{column}" if @columns.include?( column )
-      raise "#{column} is in the list FORBIDDEN_COLUMN_NAMES" if FORBIDDEN_COLUMN_NAMES.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 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 )
-      column_must_exist( 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 )
-      
-      column_must_exist( 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
-    
-    # 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
@@ -459,74 +201,50 @@ module CsvMadness
     end
     
     protected
-    attr_writer :columns, :index_columns, :records, :spreadsheet_file, :record_class, :opts    
+    attr_writer :columns, :records, :record_class, :opts    
     
     def load_csv
+      puts "Options: #{@opts.inspect}"
       
       # 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
+      data = File.read(@spreadsheet_file).force_encoding("ISO-8859-1").encode("UTF-8")
       
-    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
-    
-    # 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 )
+      header_flag = @opts[:header] ? :first_row : false
+      @csv = CSV.new( data, write_headers: true, headers: header_flag )   # , { write_headers: true, headers: header_flag } )   API changed with CSV 3.x
     end
+
+    # No longer needed.
+    # # 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.
+    #
+    # 
+    # I think that somewhere between v2 and v3 of CSV, they changed the way headers get loaded.
+    # For whatever reason, something's broken here.
     def fetch_csv_headers
       if @csv && @opts[:header]
-        if @csv.headers == true
-          @csv.shift
-          headers = @csv.headers
+        if @csv.headers.is_a?(Array)
+          headers = @csv.headers      # already loaded
+        elsif @csv.header_row?
+          # WARNING: This is probably a really expensive way to get the headers... 
+          headers = @csv.read.headers.map(&:to_sym)
           @csv.rewind   # shift/rewind, else @csv.headers only returns 'true'
         else
-          headers = @csv.headers
+          warn( "NO HEADERS in CSV" )
+          headers = @csv.headers || []
         end
+          
         headers
       else
+        warn( "THE ELSE HAPPENED")
         []
       end
     end
@@ -537,25 +255,35 @@ module CsvMadness
     #   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 )
+    def set_columns( columns = nil )
       if columns.nil?
         if @opts[:header] == false
-          columns = (0...csv_column_count).map{ |i| :"col#{i}" }
+          columns = (0...csv_column_count).map{ |i| self.class.default_column_name(i) }
         else
-          columns = fetch_csv_headers.map{ |name| self.class.getter_name( name ) }
+          header_list = fetch_csv_headers
+          columns = header_list.each_with_index.map do |name, index|
+            self.class.getter_name( name || self.class.default_column_name( index ) )
+          end
         end
       else
         unless !@csv || columns.length == csv_column_count
           $stderr.puts "Warning <#{@spreadsheet_file}>: columns array does not match the number of columns in the spreadsheet." 
+          @columns = columns
           compare_columns_to_headers
         end
       end
-      
-      for column in columns
-        raise "#{column} is in the list FORBIDDEN_COLUMN_NAMES" if FORBIDDEN_COLUMN_NAMES.include?(column)
-      end
-      
+
+      raise_on_forbidden_column_names( columns )
+
       @columns = columns
+      set_column_mapping
+    end
+    
+    def set_column_mapping
+      @column_mapping = @columns.each_with_index.inject( {} ) do |memo, col_with_index|
+        memo[col_with_index.first.to_sym] = col_with_index.last
+        memo
+      end
     end
     
     # Printout so the user can see which CSV columns are being matched to which
@@ -563,18 +291,19 @@ module CsvMadness
     # column list.
     def compare_columns_to_headers
       headers = fetch_csv_headers
-
-      for i in 0...([@columns, headers].map(&:length).max)
-        $stdout.puts "\t#{i}:  #{@columns[i]} ==> #{headers[i]}"
+      max_index = ([@columns, headers].map(&:length).max)
+      
+      for i in 0 ... max_index
+        $stdout.puts "\t#{i}:  #{@columns[i].inspect} ==> #{headers[i].inspect}"
       end
     end
     
     
     # Create objects that respond to the recipe-named methods
-    def package
+    def package_each_csv_row
       @records = []
       (@csv || []).each do |row|
-        @records << @record_class.new( row )
+        @records << Record.new( row, self )
       end
     end
   
@@ -583,27 +312,28 @@ module CsvMadness
       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
-  
-    def column_must_exist( *cols )
-      for col in cols
-        raise ArgumentError.new( "#{caller[0]}: column :#{col} does not exist.") unless self.columns.include?(col)
-      end
-    end
+    # # returns a mapping based off the current ordered list of columns.
+    # # A hash where the first column
+    # 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
+    #   debugger
+    #   @module.remap_accessors( columns_to_mapping )
+    # end
+    #
+    # def column_accessors_map
+    #   @module.column_accessors_map
+    # end
   end
 end