csv_madness 0.0.9 → 0.0.10

data/lib/csv_madness/sheet.rb

@@ -2,15 +2,28 @@ module CsvMadness
   class Sheet
     extend  SheetMethods::ClassMethods 
     include SheetMethods::Base
-    include SheetMethods::Indexing
+    # include SheetMethods::Indexing    # TODO: May never re-implement
     include SheetMethods::FileMethods
     include SheetMethods::ColumnMethods
     include SheetMethods::RecordMethods
+    include SheetMethods::SortingMethods
     
+    def indexing_enabled?
+      false
+    end
     
-    attr_reader :columns, :index_columns, :record_class, :opts
+    attr_reader :columns, :column_mapping, :opts, :extra_methods
     attr_accessor :spreadsheet_file
     
+    # 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 
@@ -27,6 +40,11 @@ module CsvMadness
     #       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
@@ -34,10 +52,12 @@ module CsvMadness
         @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
@@ -53,10 +73,48 @@ module CsvMadness
     end
     
     
+    def call_record_method( record, method, args )
+      if extra_method?( method )
+        # call the decorated method
+        call_extra_method( method, record, *args )
+      else
+        if method[-1] == '='
+          key = method[0..-2]
+          set_cell( record, key, args.first )
+        else
+          get_cell( record, method )
+        end
+      end
+    end
+  
+    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
+      
+      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 to_csv( opts = {} )
-      self.records.inject( self.columns.to_csv( opts ) ) do |output, record|
-        output << record.to_csv( opts )
+      record.data[ index_of_column( key ) ] = val
+    end
+    
+    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
 
@@ -73,30 +131,43 @@ module CsvMadness
     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
@@ -117,16 +188,6 @@ module CsvMadness
         alter_column( column, blank, &block )
       end
     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
@@ -140,38 +201,50 @@ module CsvMadness
     end
     
     protected
-    attr_writer :columns, :index_columns, :records, :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
-    
-    # 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 )
+      data = File.read(@spreadsheet_file).force_encoding("ISO-8859-1").encode("UTF-8")
+      
+      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
@@ -182,12 +255,15 @@ 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
@@ -200,6 +276,14 @@ module CsvMadness
       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
@@ -216,10 +300,10 @@ module CsvMadness
     
     
     # 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, self.column_accessors_map )
+        @records << Record.new( row, self )
       end
     end
   
@@ -228,28 +312,28 @@ module CsvMadness
       fetch_csv_headers.length
     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
+    # # 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

data/lib/csv_madness/sheet_methods/class_methods.rb

@@ -5,7 +5,9 @@ module CsvMadness
       # " hello;: world! " => :hello_world
       def getter_name( name )
         # replace any run of non-word characters with a single "_"
-        name = name.downcase.gsub( /(\W|_|\s)+/, "_" )
+        return nil if name.nil?
+        
+        name = name.downcase.to_s.gsub( /(\W|_|\s)+/, "_" )
       
         # snip trailing and leading "_"
         name = name.gsub( /(^_+|_+$)/, "" )
@@ -15,6 +17,10 @@ module CsvMadness
       
         name.to_sym
       end
+      
+      def default_column_name( index )
+        "col#{index}".to_sym
+      end
     
     
       # Paths to be searched when CsvMadness.load( "filename.csv" ) is called.
@@ -28,9 +34,7 @@ module CsvMadness
         @search_paths << path unless @search_paths.include?( path )
       end
     
-      def search_paths
-        @search_paths
-      end
+      attr_reader :search_paths
     
       def from( csv_file, opts = {} )
         if f = find_spreadsheet_in_filesystem( csv_file )
@@ -69,6 +73,9 @@ module CsvMadness
       end
     
       def write_to_file( spreadsheet, file, opts = {} )
+        opts = opts.clone
+        opts.delete( :columns )      # CSV library chokes on this option
+        
         file = file.fwf_filepath.expand_path
         file.write( spreadsheet.to_csv( opts ) )
       end

data/lib/csv_madness/sheet_methods/column_methods.rb

@@ -1,67 +1,15 @@
 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
-      }
-    
+    module ColumnMethods    
       FORBIDDEN_COLUMN_NAMES = [:to_s]  # breaks things hard when you use them.  Probably not comprehensive, sadly.
       
       
-      def column col
-        @records.map(&col)
+      # can only be called with proper column names (not extra methods)
+      def column( col )
+        index = index_of_column( col )
+      
+        # Should be faster...
+        @records.map(&:data).map{ |dat| dat[index] }
       end
     
       def has_column?( col )
@@ -71,71 +19,81 @@ module CsvMadness
       # 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
+        column_results = args.map do |col| 
+          index_of_column( col ) 
+        end
+        
+        column_results.first.zip( *(column_results[1..-1] ) )
+      end
+      
+      def alter_column( col, blank = :undefined, &block )
+        cindex = index_of_column( col )
+
+        for record in @records
+          if record.blank?( col ) && blank != :undefined
+            record[cindex] = blank
+          else
+            record[cindex] = yield( record[cindex], record )
           end
         end
       end
     
-      # If no block given, adds an empty column.
+      # If no block given, adds an empty column (blank string).
       # 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 )
+      def add_column( col, &block )
+        raise_on_forbidden_column_names( col )
+        raise_on_columns_present( col )
 
-        @columns << column
+        @columns << col
       
         # 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
+        @records.map{ |r| r.data << "" }
+        
+        set_column_mapping
+        alter_column( col, &block ) if block_given?
       end
     
-      def drop_column( column )
-        raise_on_missing_columns( column )
-      
-        @columns.delete( column )
       
-        key = column.to_s
+      def drop_column( col )
+        index = index_of_column( col )
+        @columns.delete( col.to_sym )
       
-        @records.map{ |r|
-          r.csv_data.delete( key )
-        }
+        @records.map(&:data).map do |dat|
+          dat.delete_at( index )
+        end
       
-        update_data_accessor_module
+        remove_column_from_mapping( col )
       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
+      def rename_column( old_column_name, new_name )
+        raise_on_missing_columns( old_column_name )
+        raise_on_forbidden_column_names( new_name )
+        
+        # - rename the column itself
+        # - rename the column in the index
+        # - rename the column in the column mapping
+        column_index = index_of_column( old_column_name )
+        
+        @columns[column_index] = new_name
+        
+        if indexing_enabled? && has_index_column?( old_column_name )
+          rename_index_column( column, new_name )
+        end
+        
+        rename_column_mapping_key( old_column_name, new_name )
       end
-    
+      
       def set_column_type( column, type, blank = :undefined )
-        alter_column( column, blank, &COLUMN_TYPES[type] )
+        type = ColumnType::COLUMN_TYPE_LOOKUP[type]
+        
+        alter_column( column, blank ) do |cell|
+          begin
+            type.convert( cell )
+          rescue StandardError => e
+            "ERROR: #{cell} (#{e.message})"
+          end
+        end
       end
 
     
@@ -167,11 +125,41 @@ module CsvMadness
     
       alias :concatenate :concat_columns
       
+      def index_of_column( col )
+        case col
+        when Integer
+          col
+        when Symbol, String
+          raise_on_missing_columns( col )
+          @column_mapping[ col.to_sym ]
+        end
+      end
+      
       protected
+      def rename_column_mapping_key( old_column_name, new_name )
+        @column_mapping[new_name] = @column_mapping.delete( old_column_name )
+      end
+      
+      def remove_column_from_mapping( col )
+        index = @column_mapping.delete( col.to_sym )
+        
+        @column_mapping.each do |_col, i|
+          @column_mapping[_col] = i - 1  if i > index
+        end
+      end
+      
+      
+      
       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?
+        raise MissingColumnError.new( "#{caller[0]}: requested column(s) :#{missing_columns.inspect} not found." ) unless missing_columns.fwf_blank?
+      end
+      
+      def raise_on_columns_present( *cols )
+        present_columns = cols.flatten.select{ |col| self.has_column?( col ) }
+        
+        raise ColumnExistsError.new( "#{caller[0]}: requested column(s) already present: #{present_columns.inspect}" ) unless present_columns.fwf_blank?
       end
     
       def forbidden_column_name?( col )

data/lib/csv_madness/sheet_methods/file_methods.rb

@@ -20,7 +20,9 @@ module CsvMadness
         end
       
         if file
-          self.write_to_file( self.spreadsheet_file, @opts || {} )
+          opts = (@opts || {}).clone
+          opts.delete(:header)
+          self.write_to_file( file, opts)
         else
           raise "CsvMadness.save(:timestamp) - Spreadsheet must be specified by spreadsheet_file"
         end
@@ -29,12 +31,13 @@ module CsvMadness
     
       def reload_spreadsheet( opts = @opts )
         load_csv if @spreadsheet_file
-        set_initial_columns( opts[:columns] )
-        create_record_class
-        package
+        set_columns( opts[:columns] )
+        package_each_csv_row
       
-        set_index_columns( opts[:index] )
-        reindex
+        if indexing_enabled?
+          set_index_columns( opts[:index] )
+          reindex
+        end
       end
     end
   end