csv_madness 0.0.4 → 0.0.9

data/lib/csv_madness/data_accessor_module.rb

@@ -1,44 +1,79 @@
+# Each record within the spreadsheet is extended by a module with accessor functions
+# which allow the user to treat column names as methods.  When columns are added, dropped, or re-ordered,
+# the accessor module needs to be updated to reflect the change.
 class DataAccessorModule < Module
+  # mapping : keys = column symbol
+  #           values = column index
+  attr_accessor :column_accessors_map
+  
   def initialize( mapping )
-    @column_accessors = []
-    remap_accessors( mapping )
+    puts "Got mapping #{mapping.inspect}"
+    @column_accessors_map = mapping
+    remap_accessors
   end
   
-  def install_column_accessors( column, index )
-    @column_accessors << column
-    eval <<-EOF
-      self.send( :define_method, :#{column} ) do
-        self.csv_data[#{index}]
+  def install_column_accessors( *columns )
+    for column in columns.flatten
+      unless is_valid_ruby_method?( column )
+        warn( "#{column.inspect} is not a valid ruby method" )
+        require "data_accessor_module"    # TODO:  WTF?
+        column = "csv_column_#{index}"
+        warn( "   ----> renaming to #{column.inspect}" )
       end
+    
+      if self.respond_to?( column )
+        puts "Column already has accessors"
+      else
+        eval <<-EOF
+            self.send( :define_method, :#{column} ) do
+              self.csv_data[ self.column_accessors_map[ :#{column} ] ]
+            end
       
-      self.send( :define_method, :#{column}= ) do |val|
-        self.csv_data[#{index}] = val
+            self.send( :define_method, :#{column}= ) do |val|
+              self.csv_data[ self.column_accessors_map[ :#{column} ] ] = val
+            end
+        EOF
       end
-    EOF
+    end
   end
   
-  def remove_column_accessors( column )
-    self.send( :remove_method, column )
-    self.send( :remove_method, :"#{column}=" )
+  # But if instead of hardcoding the index, the index was pulled from the spreadsheet mapping...
+  # a titch slower to look up?  But a change to the mapping automatically updates the method
+  def remove_column_accessors( *columns )
+    for column in columns.flatten
+      for method_sym in [column, :"#{column}="]
+        self.send( :remove_method, method_sym ) if self.respond_to?( method_sym )
+      end
+    end
   end
   
   def remove_all_column_accessors
-    @column_accessors ||= []    
+    # 2016-11-24 : was this necessary for anything
+    # @column_accessors ||= []
+    remove_column_accessors( @column_accessors_map.keys )
+  end
+  
+  # Partly obsoleted.  
+  def remap_accessors( *args )
+    # 
     
-    for sym in @column_accessors
-      remove_column_accessors( sym )
+    
+    remove_all_column_accessors
+    
+    if args.length == 1
+      debugger
+      @column_accessors_map = args.first
     end
     
-    @column_accessors = []    
+    install_column_accessors( @column_accessors_map.keys )
   end
   
-  def remap_accessors( mapping )
-    remove_all_column_accessors
-    
-    @mapping = mapping
+  # Symbol.inspect doesn't output " quotes when given a sym 
+  # that expresses a valid method name or a valid identifier.
+  def is_valid_ruby_method?( str_or_sym )
+    sym = str_or_sym.to_sym
+    test_string = sym.inspect
     
-    for column, index in @mapping
-      install_column_accessors( column, index )
-    end
+    test_string.match( /^:[@"]/ ).nil?   
   end
 end

data/lib/csv_madness/exceptions.rb

@@ -0,0 +1,16 @@
+module CsvMadness
+  class LoadError < RuntimeError
+  end
+  
+  class ColumnError < ArgumentError
+  end
+  
+  class ForbiddenColumnNameError < ColumnError
+  end
+  
+  class MissingColumnError < ColumnError
+  end
+  
+  class ColumnExistsError < ColumnError
+  end
+end

data/lib/csv_madness/gem_api.rb

@@ -0,0 +1,12 @@
+module CsvMadness
+  module GemAPI
+    def load( csv, opts = {} )
+      CsvMadness::Sheet.from( csv, opts )
+    end
+    
+    def build( objects, &block )
+      builder = CsvMadness::Builder.new(&block)
+      builder.build( objects )
+    end
+  end
+end

data/lib/csv_madness/record.rb

@@ -8,8 +8,11 @@ module CsvMadness
   # symbol.
   class Record
     attr_accessor :csv_data
-    def initialize( data )
-      @csv_data = data
+    attr_reader   :column_accessors_map
+    
+    def initialize( data, mapping )
+      @column_accessors_map = mapping            # holds a reference to its spreadsheet's overall mapping
+      import_record_data( data )
     end
     
     def [] key
@@ -34,6 +37,10 @@ module CsvMadness
       self.class.spreadsheet.columns
     end
     
+    def self.columns
+      self.spreadsheet.columns
+    end
+    
     def self.spreadsheet= sheet
       @spreadsheet = sheet
     end
@@ -46,8 +53,40 @@ module CsvMadness
       self.columns.map{|col| self.send(col) }.to_csv( opts )
     end
     
+    def to_hash
+      self.columns.inject({}){ |hash, col| hash[col] = self.send( col ); hash }
+    end
+    
+    def to_a
+      self.to_hash.to_a
+    end
+    
     def blank?( col )
       (self.send( col.to_sym ).to_s || "").strip.length == 0
     end
+    
+    protected
+    def import_record_data( data )
+      case data
+      when Array
+        csv_data = CSV::Row.new( self.columns, data )
+      when Hash
+        fields = self.columns.map do |col|
+          data[col]
+        end
+        # for col in self.columns
+        #   fields << data[col]
+        # end
+        
+        csv_data = CSV::Row.new( self.columns, fields )
+      when CSV::Row
+        csv_data = data
+      else
+        raise "record.import_record_data() doesn't take objects of type #{data.inspect}" unless data.respond_to?(:csv_data)
+        csv_data = data.csv_data.clone
+      end
+      
+      @csv_data = csv_data
+    end
   end
 end

data/lib/csv_madness/sheet.rb

@@ -1,114 +1,16 @@
 module CsvMadness
   class Sheet
-    COLUMN_TYPES = {
-      number: Proc.new do |cell, record|
-        if (cell || "").strip.match(/^\d*$/)
-          cell.to_i
-        else
-          cell.to_f
-        end
-      end,
-      
-      integer: Proc.new do |cell, record|
-        cell.to_i
-      end,
-      
-      float:   Proc.new do |cell, record|
-        cell.to_f
-      end,
-      
-      date:    Proc.new do |cell, record|
-        begin
-          parse = Time.parse( cell )
-        rescue ArgumentError
-          parse = "Invalid Time Format: <#{cell}>"
-        end
-        parse
-      end
-    }
-    
-    # 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
+    include SheetMethods::FileMethods
+    include SheetMethods::ColumnMethods
+    include SheetMethods::RecordMethods
     
-    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
-    end
+    attr_reader :columns, :index_columns, :record_class, :opts
+    attr_accessor :spreadsheet_file
     
-    # 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
-    
-    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: 
     #   index: ( [:id, :id2 ] )
     #       columns you want mapped for quick 
@@ -123,88 +25,90 @@ module CsvMadness
     #   
     #   header:   false       
     #       anything else, we assume the csv file has a header row
-    def initialize( spreadsheet, opts = {} )
-      if spreadsheet.is_a?(Array)
-        @spreadsheet_file = nil
-        
+    def initialize( *args )
+      @csv = nil
+      
+      if args.last.is_a?(Hash)
+        @opts = args.pop
       else
-        @spreadsheet_file = self.class.find_spreadsheet_in_filesystem( spreadsheet )
+        @opts = {}
       end
-      @opts = opts
+      
+      firstarg = args.shift
+      
+      case firstarg
+      when NilClass
+        @spreadsheet_file = nil
+        @opts[:columns] ||= []
+      when String, FunWith::Files::FilePath, Pathname
+        @spreadsheet_file = self.class.find_spreadsheet_in_filesystem( firstarg )
+      when Array
+        @spreadsheet_file = nil
+        @opts[:columns] ||= firstarg
+      end
+      
       @opts[:header] = (@opts[:header] == false ? false : true)  # true unless already explicitly set to false
       
       reload_spreadsheet
     end
     
-    def reload_spreadsheet( opts = @opts )
-      load_csv
-      set_initial_columns( opts[:columns] )
-      create_record_class
-      package
-      
-      set_index_columns( opts[:index] )
-      reindex
-    end
+    
 
-    def set_index_columns( index_columns )
-      @index_columns = case index_columns
-      when NilClass
-        []
-      when Symbol
-        [ index_columns ]
-      when Array
-        index_columns
+    def to_csv( opts = {} )
+      self.records.inject( self.columns.to_csv( opts ) ) do |output, record|
+        output << record.to_csv( opts )
       end
     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]
-      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.
-    def filter!( &block )
-      @records = self.filter( &block )
-      reindex
-      @records
+    def records
+      @records ||= []
     end
   
-    def column col
-      @records.map(&col)
+    
+    # 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.records = []
+      sheet.spreadsheet_file = nil
+      sheet.create_data_accessor_module
+      sheet.create_record_class
+      sheet.opts = @opts.clone
+      sheet.reindex
+      
+      sheet
     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
-      }
+    # 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
+      
+      for record in @records
+        result_key = yield record
+        ( sheets[result_key] ||= self.blanked() ) << record
+      end
+
+      sheets
+      # sheet_args = self.blanked
+      # for key, record_set in records
+      #   sheet = self.clone
+      #   sheet.records = 
+      #   
+      #   records[key] = sheet
+      # end
+      # 
+      # records
     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
     # default
@@ -214,91 +118,6 @@ module CsvMadness
       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 )
-      @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 )
@@ -316,36 +135,20 @@ module CsvMadness
       end
     end
     
+    def length
+      self.records.length
+    end
+    
     protected
+    attr_writer :columns, :index_columns, :records, :record_class, :opts    
+    
     def load_csv
+      
       # 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
-      
-    def add_to_index( col, key, record )
-      @indexes[col][key] = record
-    end
-    
-    # Reindexes the record lookup tables.
-    def reindex
-      @indexes = {}
-      for col in @index_columns
-        @indexes[col] = {}
-
-        for record in @records
-          add_to_index( col, record.send(col), record )
-        end
-      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)
-    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.
@@ -381,18 +184,22 @@ module CsvMadness
     # prints a warning and a comparison of the columns to the headers.
     def set_initial_columns( columns = nil )
       if columns.nil?
-        if @opts[:header] == false    #
-          @columns = (0...csv_column_count).map{ |i| :"col#{i}" }
+        if @opts[:header] == false
+          columns = (0...csv_column_count).map{ |i| :"col#{i}" }
         else
-          @columns = fetch_csv_headers.map{ |name| self.class.getter_name( name ) }
+          columns = fetch_csv_headers.map{ |name| self.class.getter_name( name ) }
         end
       else
-        @columns = columns
-        unless @columns.length == csv_column_count
-          puts "Warning <#{@spreadsheet_file}>: columns array does not match the number of columns in the spreadsheet." 
+        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
+
+      raise_on_forbidden_column_names( columns )
+
+      @columns = columns
     end
     
     # Printout so the user can see which CSV columns are being matched to which
@@ -400,9 +207,10 @@ module CsvMadness
     # column list.
     def compare_columns_to_headers
       headers = fetch_csv_headers
-
-      for i in 0...([@columns, headers].map(&:length).max)
-        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
     
@@ -410,8 +218,8 @@ module CsvMadness
     # Create objects that respond to the recipe-named methods
     def package
       @records = []
-      @csv.each do |row|
-        @records << @record_class.new( row )
+      (@csv || []).each do |row|
+        @records << @record_class.new( row, self.column_accessors_map )
       end
     end
   
@@ -420,6 +228,8 @@ 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
@@ -434,13 +244,12 @@ module CsvMadness
     end
     
     def update_data_accessor_module
+      debugger
       @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
+    
+    def column_accessors_map
+      @module.column_accessors_map
     end
   end
 end

data/lib/csv_madness/sheet_methods/base.rb

@@ -0,0 +1,6 @@
+module CsvMadness
+  module SheetMethods
+    module Base
+    end
+  end
+end