csv_madness 0.0.6 → 0.0.10

data/lib/csv_madness/sheet_methods/base.rb

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

data/lib/csv_madness/sheet_methods/class_methods.rb

@@ -0,0 +1,84 @@
+module CsvMadness
+  module SheetMethods
+    module ClassMethods
+      # Used to make getter/setter names out of the original header strings.
+      # " hello;: world! " => :hello_world
+      def getter_name( name )
+        # replace any run of non-word characters with a single "_"
+        return nil if name.nil?
+        
+        name = name.downcase.to_s.gsub( /(\W|_|\s)+/, "_" )
+      
+        # snip trailing and leading "_"
+        name = name.gsub( /(^_+|_+$)/, "" )
+      
+        # add leading "_" when we'd otherwise have a method name starting with a digit
+        name = "_#{name}" if name.match( /^\d/ )
+      
+        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.
+      def 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
+    
+      attr_reader :search_paths
+    
+      def 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 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
+    
+      # opts are passed to underlying CSV (:row_sep, :encoding, :force_quotes)
+      def 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 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
+    end
+  end
+end

data/lib/csv_madness/sheet_methods/column_methods.rb

@@ -0,0 +1,175 @@
+module CsvMadness
+  module SheetMethods
+    module ColumnMethods    
+      FORBIDDEN_COLUMN_NAMES = [:to_s]  # breaks things hard when you use them.  Probably not comprehensive, sadly.
+      
+      
+      # 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 )
+        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)
+        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 (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( col, &block )
+        raise_on_forbidden_column_names( col )
+        raise_on_columns_present( col )
+
+        @columns << col
+      
+        # add empty column to each row
+        @records.map{ |r| r.data << "" }
+        
+        set_column_mapping
+        alter_column( col, &block ) if block_given?
+      end
+    
+      
+      def drop_column( col )
+        index = index_of_column( col )
+        @columns.delete( col.to_sym )
+      
+        @records.map(&:data).map do |dat|
+          dat.delete_at( index )
+        end
+      
+        remove_column_from_mapping( col )
+      end
+    
+      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 )
+        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
+
+    
+      # 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
+      
+      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]}: 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 )
+        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,44 @@
+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
+          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
+      end
+      
+    
+      def reload_spreadsheet( opts = @opts )
+        load_csv if @spreadsheet_file
+        set_columns( opts[:columns] )
+        package_each_csv_row
+      
+        if indexing_enabled?
+          set_index_columns( opts[:index] )
+          reindex
+        end
+      end
+    end
+  end
+end

data/lib/csv_madness/sheet_methods/indexing.rb

@@ -0,0 +1,133 @@
+module CsvMadness
+  module SheetMethods
+    module Indexing
+      attr_accessor :index_columns
+      
+      def set_index_columns( 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_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 index_records( records )
+        if records.is_a?( Array )
+          for record in records
+            index_records( record )
+          end
+        else
+          record = records
+          for col in @index_columns
+            add_to_index( col, record.send(col), record )
+          end
+        end
+      end
+
+      def has_index_column?( col )
+        @index_columns.include?( col.to_sym )
+      end
+    
+      # Reindexes the record lookup tables.
+      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( 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
+end

data/lib/csv_madness/sheet_methods/record_methods.rb

@@ -0,0 +1,175 @@
+module CsvMadness
+  module SheetMethods
+    module RecordMethods
+      def add_record( record, &block )
+        case record
+        when Array
+          # do nothing
+        when Hash
+          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
+        when CSV::Row
+          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.new( record, self )
+        
+        @records << 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( [], &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
+      #
+      # returns the record that was removed.  
+      def remove_record( record )
+        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
+      
+      def remove_record_at_index( index )
+        self.records.delete_at( index )
+      end
+    
+      # 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 )
+        [].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
+      
+      # 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 indexing_enabled?
+          if key.is_a?(Array)
+            key.map{ |k| @indexes[index_col][k] }
+          else
+            @indexes[index_col][key]
+          end
+        else
+          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( 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
+        
+        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!( 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