csv_madness 0.0.6 → 0.0.10

data/lib/csv_madness/column_types/float.rb

@@ -0,0 +1,25 @@
+module CsvMadness
+  module ColumnTypes
+    class FloatType < CsvMadness::ColumnType
+      
+      # I suspect that a blank string and a nil should be treated the same, and that
+      # 0.0 is the wrong choice for a default.  Maybe these should return :default or :error,
+      # and leave it to the individual column definition to handle that.
+      def self.convert( input )
+        if input.fwf_blank?
+          :default
+        elsif input.is_a?( String )
+          Float( input )
+        elsif input.respond_to?( :to_f )
+          input.to_f
+        elsif input.respond_to?( :to_i )
+          input.to_i.to_f
+        else
+          :error
+        end
+      rescue ArgumentError
+        :error
+      end
+    end
+  end
+end

data/lib/csv_madness/column_types/integer.rb

@@ -0,0 +1,17 @@
+module CsvMadness
+  module ColumnTypes
+    class IntegerType < CsvMadness::ColumnType
+      def self.convert( input )
+        if input.fwf_blank?
+          0
+        elsif input.is_a?( String )
+          Float( input ).round
+        elsif input.respond_to?( :to_f )
+          input.to_f.round
+        elsif input.respond_to?( :to_i )
+          input.to_i
+        end
+      end
+    end
+  end
+end

data/lib/csv_madness/column_types/string.rb

@@ -0,0 +1,9 @@
+module CsvMadness
+  module ColumnTypes
+    class StringType < CsvMadness::ColumnType
+      def self.convert( input )
+        input.to_s
+      end
+    end
+  end
+end

data/lib/csv_madness/data_accessor_module.rb

@@ -1,44 +1,79 @@
-class DataAccessorModule < Module
-  def initialize( mapping )
-    @column_accessors = []
-    remap_accessors( mapping )
-  end
-  
-  def install_column_accessors( column, index )
-    @column_accessors << column
-    eval <<-EOF
-      self.send( :define_method, :#{column} ) do
-        self.csv_data[#{index}]
-      end
-      
-      self.send( :define_method, :#{column}= ) do |val|
-        self.csv_data[#{index}] = val
-      end
-    EOF
-  end
-  
-  def remove_column_accessors( column )
-    self.send( :remove_method, column )
-    self.send( :remove_method, :"#{column}=" )
-  end
-  
-  def remove_all_column_accessors
-    @column_accessors ||= []    
-    
-    for sym in @column_accessors
-      remove_column_accessors( sym )
-    end
-    
-    @column_accessors = []    
-  end
-  
-  def remap_accessors( mapping )
-    remove_all_column_accessors
-    
-    @mapping = mapping
-    
-    for column, index in @mapping
-      install_column_accessors( column, index )
-    end
-  end
-end
+# # 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 )
+#     puts "Got mapping #{mapping.inspect}"
+#     @column_accessors_map = mapping
+#     remap_accessors
+#   end
+#
+#   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[ self.column_accessors_map[ :#{column} ] ] = val
+#             end
+#         EOF
+#       end
+#     end
+#   end
+#
+#   # 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
+#     # 2016-11-24 : was this necessary for anything
+#     # @column_accessors ||= []
+#     remove_column_accessors( @column_accessors_map.keys )
+#   end
+#
+#   # Partly obsoleted.
+#   def remap_accessors( *args )
+#     #
+#
+#
+#     remove_all_column_accessors
+#
+#     if args.length == 1
+#       debugger
+#       @column_accessors_map = args.first
+#     end
+#
+#     install_column_accessors( @column_accessors_map.keys )
+#   end
+#
+#   # 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
+#
+#     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

@@ -1,12 +1,21 @@
 module CsvMadness
   module GemAPI
+    # Loads a sheet from a csv file. If given a relative path, will look in
+    # default folders first. 
     def load( csv, opts = {} )
       CsvMadness::Sheet.from( csv, opts )
     end
     
+    
+    def add_search_path( path )
+      CsvMadness::Sheet.add_search_path( path )
+    end
+    
+    # Define a builder using a block, then run
+    # the given objects through it to create a
+    # Sheet.
     def build( objects, &block )
-      builder = CsvMadness::Builder.new(&block)
-      builder.build( objects )
+      CsvMadness::Builder.new(&block).build( objects )
     end
   end
 end

data/lib/csv_madness/index_set.rb

@@ -0,0 +1,36 @@
+module CsvMadness
+  # Used by indexer to store indexing data.  With a regular set, two sets 
+  # are considered equal if they hold the same objects, which is a problem
+  # for the @sets_containing_item data (needed for unindexing)
+  class IndexSet < Set
+    attr_reader :index_key, :index_value
+    
+    def initialize( k, v )
+      super()
+      @index_key = k
+      @index_value = v
+    end
+  end
+end
+
+class Set
+  def inner_hash
+    @hash
+  end
+end
+
+
+class Set2 < Set
+  def eql?( rhs )
+    false
+  end
+end
+
+set = Set.new
+set2 = Set2.new
+set3 = Set2.new
+
+set.add( set2 )
+set.add( set3 )
+set.length
+  

data/lib/csv_madness/indexer.rb

@@ -0,0 +1,105 @@
+module CsvMadness
+  class Indexer
+    # Just columns where every value is unique?  Or fast results when several records have one value?
+    
+    # :indexes => {
+    #               :col1 => {
+    #                          :val1 => Set( Record1 ), 
+    #                          :val2 => Set( Record2 )
+    #                        }
+    #
+    #               :col2 => {
+    #                          :val1 => Set( Record0, Record2 ), 
+    #                          :val2 => Set( Record1, Record3, Record7 ) 
+    #                        }
+    #
+    # But when a cell changes value, (say, R1.col2 switches from :val1 to :val2)
+    # :sets_containing_item => {
+    #                            
+    #                          }
+    # This could be a general-purpose module.  So I'm dropping the restriction
+    # that the index has to be keyed to a symbol.  Should be simple enough to
+    # manage on the caller's end, if that's needed
+    def initialize
+      # Maintaining this information is necessary to remove items
+      # from the indexes quickly.
+      @sets_containing_the_item = {}   # key: a item, value: a set of set sets which live in @indexes
+      @indexes = {}
+    end
+
+
+    # If the item has previously been indexed in this index_name under another
+    # value, it must be removed
+    def index( item, index_key, index_val )
+      @sets_containing_the_item[item] ||= Set.new
+
+      @indexes[index_key] ||= {}
+      @indexes[index_key][index_val] ||= IndexSet.new( index_key, index_val )
+
+      unindex_item_from_one_index( item, index_key )
+
+      added_set = @indexes[index_key][index_val]
+      added_set.add( item )
+      
+      @sets_containing_the_item[item].add( added_set )
+
+      item
+    end
+
+    # remove the item from all
+    def unindex( item )
+      if @sets_containing_the_item.has_key?( item )
+        for item_set in @sets_containing_the_item[item]
+          item_set.delete( item )
+        end
+
+        @sets_containing_the_item.delete( item )
+      end
+
+      item
+    end
+
+    def unindex_item_from_one_index( item, index_key )
+      indx = @indexes[index_key]
+
+      unless indx.fwf_blank?
+
+      end
+    end
+
+    # returns an array of items whose index_val matches the given value
+    def lookup( index_key, index_val )
+      if @indexes.has_key?( index_key ) && @indexes[index_key].has_key?( index_val )
+        @indexes[index_key][index_val].to_a
+      else
+        []
+      end
+    end
+
+    # worrying cases:
+    #
+    # If the old index_name name doesn't exist and new index_name name doesn't exist,
+    # it's a null operation
+    #
+    # If the new_index_name already exists, will raise an error rather than
+    # accidentally discarding the index.
+    def rename_index( old_index_key, new_index_key )
+      raise IndexExistsError.new( "Index exists: #{new_index_key}" ) if @indexes.has_key?( new_index_key )
+
+      @indexes[new_index_key] = @indexes.delete( old_index_key )
+    end
+
+    # deletes all indexing information for the given index
+    def drop_index( index_key )
+      # returns
+      sets_to_remove = @indexes.delete( index_key )
+
+      unless set_to_remove.fwf_blank?
+        # ci => key => a set of items
+        @sets_containing_the_item.each do |item, set|
+          set.delete( set_to_remove )
+        end
+      end
+    end
+  end
+end

data/lib/csv_madness/record.rb

@@ -7,48 +7,58 @@ module CsvMadness
   # future.  I'd like to be able to address by row and by
   # symbol.
   class Record
-    attr_accessor :csv_data
+    include RecordMethods::MethodMethods
     
-    def initialize( data )
-      import_record_data( data )
-    end
+    attr_accessor :data
+    attr_reader   :spreadsheet
     
-    def [] key
-      case key
-      when String, Integer
-        @csv_data[key] 
-      when Symbol
-        @csv_data[key.to_s]
-      end
+    def initialize( _data, sheet ) # , mapping )
+      @spreadsheet = sheet
+      import_record_data( _data )
+      convert_types
     end
     
-    def []= key, val
-      case key
-      when String, Integer
-        @csv_data[key] = val
-      when Symbol
-        @csv_data[key.to_s] = val
-      end
+    # Experimental approach to getter/setter methods.  Seems easier than
+    # constantly rewriting an accessor module every time the columns get 
+    # manipulated.
+    #
+    # Should raise a method_missing if the get/set method isn't in
+    # the index mapping.
+    def method_missing( method, *args )
+      self.spreadsheet.call_record_method( self, method, args )
     end
     
-    def columns
-      self.class.spreadsheet.columns
-    end
     
-    def self.columns
-      self.spreadsheet.columns
+    def [] key
+      self.spreadsheet.get_cell( self, key )
     end
     
-    def self.spreadsheet= sheet
-      @spreadsheet = sheet
+    
+    def []= key, val
+      self.spreadsheet.set_cell( self, key, val )
+      # case key
+      # when String, Integer
+      #   @csv_data[key] = val
+      # when Symbol
+      #   @csv_data[key.to_s] = val
+      # end
     end
     
-    def self.spreadsheet
-      @spreadsheet
+    def columns
+      self.spreadsheet.columns
     end
     
-    def to_csv( opts = {} )
-      self.columns.map{|col| self.send(col) }.to_csv( opts )
+    # def self.spreadsheet= sheet
+    #   @spreadsheet = sheet
+    # end
+    #
+    # def self.spreadsheet
+    #   @spreadsheet
+    # end
+    #
+    def to_csv( hash_opts = {}, **keyword_opts )
+      opts = hash_opts.merge(keyword_opts)
+      self.columns.map{|col| self.send(col) }.to_csv( **opts )
     end
     
     def to_hash
@@ -56,35 +66,53 @@ module CsvMadness
     end
     
     def to_a
-      self.to_hash.to_a
+      self.data
     end
     
     def blank?( col )
       (self.send( col.to_sym ).to_s || "").strip.length == 0
     end
     
+    def convert_types
+      self.spreadsheet.convert_types( self ) if self.spreadsheet
+    end
+    
+    def apply_update_hash( h )
+      for key, val in h
+        self.send( :"#{key}=", val )
+      end
+      
+      self
+    end
+    
+    def inspect
+      cols = self.spreadsheet.columns
+      cols.zip( self.data ).inspect
+    end
+    
+    
+    
     protected
-    def import_record_data( data )
-      case data
+    def import_record_data( _data )
+      case _data
       when Array
-        csv_data = CSV::Row.new( self.columns, data )
+        self.data = _data
       when Hash
         fields = self.columns.map do |col|
-          data[col]
+          _data[col]
         end
         # for col in self.columns
         #   fields << data[col]
         # end
         
-        csv_data = CSV::Row.new( self.columns, fields )
+        self.data = fields # CSV::Row.new( self.columns, fields )
       when CSV::Row
-        csv_data = data
+        self.data = _data.to_a.map(&:last)
+      when Record
+        self.data = _data.data.clone
       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
+        raise "Don't know how to handle this input"
       end
-      
-      @csv_data = csv_data
     end
   end
 end

data/lib/csv_madness/record_filter.rb

@@ -0,0 +1,68 @@
+module CsvMadness
+  class RecordFilter
+    def initialize( &block )
+      @filters = []
+      yield self if block_given?
+    end
+    
+    # if the block returns true, the record passes filters, no subsequent filters will be accepted
+    def accept( &block )
+      @filters << [:accept, block]
+    end
+    
+    # if it returns true, the record fails the filter and is cut from the spreadsheet.  Subsequent filters are ignored
+    def reject( &block )
+      @filters << [:reject, block]
+    end
+    
+    
+    def accept_column( col, val )
+      @filters << [:accept_column, col, val]
+    end
+    
+    def reject_column( col, val )
+      @filters << [:reject_column, col, val]
+    end
+    
+    def filter( records )
+      filtered_records = []
+      
+      for r in records
+        accepted = false
+        rejected = false
+        
+        for filter in @filters
+          next if accepted || rejected
+          
+          case filter.first
+          when :accept, :accept_column
+            accepted = apply_filter( filter, record )
+          when :reject, :reject_column
+            rejected = apply_filter( filter, record ) 
+          end
+        end
+        
+        filtered_records << record if accepted
+      end
+      
+      filtered_records
+    end
+    
+    def apply_filter( filter, record )
+      mode, col, val = filter
+      procedure = col if col.is_a?(Proc)
+      
+      case mode
+      when :accept, :reject
+        procedure.call( record )
+      when :accept_column, :reject_column
+        case val
+        when String, Numeric, Date
+          record.send( col ) == val
+        when Regexp
+          record.send( col ) =~ val
+        end
+      end
+    end
+  end
+end

data/lib/csv_madness/record_methods/method_methods.rb

@@ -0,0 +1,57 @@
+module CsvMadness
+  module RecordMethods
+    module MethodMethods
+      alias :respond_to_naturally? :respond_to?
+      alias :natural_methods :methods
+      
+      def extra_method?( method )
+        self.spreadsheet.extra_methods.keys.include?( method )
+      end
+      
+      def column_method?( method )
+        column_setter_method?( method ) || column_getter_method?( method )
+      end
+      
+      def column_setter_method?( method )
+        if method[-1] == "="
+          self.spreadsheet.has_column?( method[0..-2].to_sym )
+        else
+          false
+        end
+      end
+      
+      def column_getter_method?( method )
+        self.spreadsheet.has_column?( method )
+      end
+  
+      def respond_to?( method )
+        self.methods.include?( method )
+      end
+      
+      def methods
+        self.natural_methods + 
+          self.spreadsheet.extra_methods.keys + 
+          self.spreadsheet.columns +
+          self.spreadsheet.columns.map{ |col| to_setter_method( col ) }
+      end
+      
+      def to_setter_method( method )
+        if method[-1] != "="
+          "#{method}=".to_sym
+        else
+          method.to_sym
+        end
+      end
+      
+      def to_getter_method( method )
+        if method[-1] == "="
+          method[0..-2].to_sym
+        else
+          method.to_sym
+        end
+      end
+    end
+  end
+end
+  
+