csv-mapper 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-12-05
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,15 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/csv-mapper.rb
+script/console
+script/destroy
+script/generate
+spec/csv-mapper_spec.rb
+spec/csv-mapper_row_map_spec.rb
+spec/csv-mapper_attribute_map_spec.rb
+spec/test.csv
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/README.rdoc

@@ -0,0 +1,82 @@
+= README
+
+by Luke Pillow
+
+== DESCRIPTION:
+
+CsvMapper is a small library intended to simplify the common steps involved with importing CSV files to a usable form in Ruby.
+
+== EXAMPLES:
+
+The following example will import a CSV file to an Array of OpenStruct[http://ruby-doc.org/core/classes/OpenStruct.html] instances.
+
+==== Example CSV File Structure
+
+  First Name,Last Name,Age
+  John,Doe,27
+  Jane,Doe,26
+  Bat,Man,52
+  ...etc...
+
+==== Simple Usage Example
+  include CsvMapper
+
+  results = import('/path/to/file.csv') do
+    start_at_row 1
+    [first_name, last_name, age]
+  end
+
+  results.first.first_name  # John
+  results.first.last_name   # Doe
+  results.first.age         # 27
+
+==== Import to ActiveRecord Example
+Although CsvMapper has no dependency on ActiveRecord; it's easy to import a CSV file to ActiveRecord models and save them.
+
+  # Define an ActiveRecord model
+  class Person < ActiveRecord::Base; end
+
+  include CsvMapper
+  
+  results = import('/path/to/file.csv') do
+    map_to Person # Map to the Person ActiveRecord class (defined above) instead of the default OpenStruct.
+    after_row lambda{|row, person| person.save }  # Call this lambda and save each record after it's parsed.
+		
+    start_at_row 1
+    [first_name, last_name, age]
+  end
+	
+See CsvMapper for a more detailed description
+	
+== REQUIREMENTS:
+
+FasterCSV[http://fastercsv.rubyforge.org/]
+
+== INSTALL:
+
+* sudo gem install csv-mapper
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Luke Pillow
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/csv-mapper'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('csv-mapper', CsvMapper::VERSION) do |p|
+  p.developer('Luke Pillow', 'lpillow@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  # p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  p.extra_deps         = [
+    ['fastercsv','>= 1.4.0'],
+  ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/lib/csv-mapper.rb

@@ -0,0 +1,294 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'ostruct'
+require 'fastercsv'
+
+# This module provides the main interface for importing CSV files & data to mapped Ruby objects.
+# = Usage
+# Including CsvMapper will provide two methods:
+# - +import+
+# - +map_csv+
+#
+# See csv-mapper.rb[link:files/lib/csv-mapper_rb.html] for method docs.
+#
+# === Import From File
+#   results = import('/path/to/file.csv') do
+#     # declare mapping here
+#   end
+#
+# === Import From String or IO
+#   results = import(csv_data, :type => :io) do
+#     # declare mapping here
+#   end
+#
+# === Mapping
+# Mappings are built inside blocks.  All three of CsvMapper's main API methods accept a block containing a mapping.
+# Maps are defined by using +map_to+, +start_at_row+, +before_row+, and +after_row+ (methods on CsvMapper::RowMap) and
+# by defining your own mapping attributes.
+# A mapping block uses an internal cursor to keep track of the order the mapping attributes are declared and use that order to 
+# know the corresponding CSV column index to associate with the attribute.
+# 
+# ===== The Basics
+# * +map_to+ - Override the default OpenStruct target. Accepts a class and an optional hash of default attribute names and values.
+# * +start_at_row+ - Specify what row to begin parsing at.  Use this to skip headers.
+# * +before_row+ - Accepts an Array of method name symbols or lambdas to be invoked before parsing each row.
+# * +after_row+ - Accepts an Array of method name symbols or lambdas to be invoked after parsing each row.
+# * +delimited_by+ - Accepts a character to be used to delimit columns. Use this to specify pipe-delimited files.
+# * <tt>\_SKIP_</tt> - Use as a placehold to skip a CSV column index.
+# * +parser_options+ - Accepts a hash of FasterCSV options.  Can be anything FasterCSV::new()[http://fastercsv.rubyforge.org/classes/FasterCSV.html#M000018] understands
+# 
+# ===== Attribute Mappings
+# Attribute mappings are created by using the name of the attribute to be mapped to.  
+# The order in which attribute mappings are declared determines the index of the corresponding CSV row.  
+# All mappings begin at the 0th index of the CSV row.
+#   foo  # maps the 0th CSV row position value to the value of the 'foo' attribute on the target object.
+#   bar  # maps the 1st row position to 'bar'
+# This could also be a nice one liner for easy CSV format conversion
+#   [foo, bar]  # creates the same attribute maps as above.
+# The mapping index may be specifically declared in two additional ways:
+#   foo(2)     # maps the 2nd CSV row position value to 'foo' and moves the cursor to 3
+#   bar        # maps the 3rd CSV row position to 'bar' due to the current cursor position
+#   baz.at(0)  # maps the 0th CSV row position to 'baz' but only increments the cursor 1 position to 4
+# Each attribute mapping may be configured to parse the record using a lambda or a method name
+#   foo.map lambda{|row| row[2].strip } # maps the 2nd row position value with leading and trailing whitespace removed to 'foo'.
+#   bar.map :clean_bar  # maps the result of the clean_bar method to 'bar'. clean_bar must accept the row as a parameter.
+# Attribute mapping declarations and "modifiers" may be chained
+#   foo.at(4).map :some_transform
+#
+# === Create Reusable Mappings
+# Both +import_csv+ and +import_string+ accept an instance of RowMap as an optional mapping parameter.  
+# The easiest way to create an instance of a RowMap is by using +map_csv+.
+#   a_row_map = map_csv do 
+#     # declare mapping here
+#   end
+# Then you can reuse the mapping
+#   results = import(some_string, :type => :io, :map => a_row_map)
+#   other_results = import('/path/to/file.csv', :map => a_row_map)
+#
+module CsvMapper
+  VERSION = '0.0.1'
+
+  # Create a new RowMap instance from the definition in the given block.
+  def map_csv(&map_block)
+    CsvMapper::RowMap.new(self, &map_block)
+  end
+  
+  # Load CSV data and map the values according to the definition in the given block.
+  # Accepts either a file path, String, or IO as +data+.  Defaults to file path.
+  # 
+  # The following +options+ may be used:
+  # <tt>:type</tt>:: defaults to <tt>:file_path</tt>. Use <tt>:io</tt> to specify data as String or IO.
+  # <tt>:map</tt>:: Specify an instance of a RowMap to take presidence over a given block defintion.
+  #
+  def import(data, options={}, &map_block)
+    config = { :type => :file_path,
+               :map => map_csv(&map_block) }.merge!(options)
+    
+    csv_data = config[:type] == :io ? data : File.new(data, 'r')
+    map = config[:map]
+    
+    results = []
+    FasterCSV.new(csv_data, map.parser_options ).each_with_index do |row, i|
+      results << map.parse(row) if i >= map.start_at_row
+    end
+    
+    results
+  end  
+
+  # CsvMapper::RowMap provides a simple, DSL-like interface for constructing mappings.
+  # A CsvMapper::RowMap provides the main functionality of the library. It will mostly be used indirectly through the CsvMapper API, 
+  # but may be useful to use directly for the dynamic CSV mappings.
+  class RowMap
+    #Start with a 'blank slate'
+    instance_methods.each { |m| undef_method m unless m =~ /^__||instance_eval/ }
+    
+    attr_reader :mapped_attributes
+    
+    # Create a new instance with access to an evaluation context 
+    def initialize(context, &map_block)
+      @context = context
+      @before_filters = []
+      @after_filters = []
+      @parser_options = {}
+      @start_at_row = 0
+      @delimited_by = FasterCSV::DEFAULT_OPTIONS[:col_sep]
+      @mapped_attributes = []
+      
+      self.instance_eval(&map_block) if block_given?
+    end
+    
+    # Each row of a CSV is parsed and mapped to a new instance of a Ruby class; OpenStruct by default.
+    # Use this method to change the what class each row is mapped to.  
+    # The given class must respond to a parameter-less #new and all attribute mappings defined.
+    # Providing a hash of defaults will ensure that each resulting object will have the providing name and attribute values 
+    # unless overridden by a mapping
+    def map_to(klass, defaults={})
+      @map_to_klass = klass
+      
+      defaults.each do |name, value|
+        self.add_attribute(name, -99).map lambda{|row| value}
+      end
+    end
+    
+    # Specify a hash of FasterCSV options to be used for CSV parsing
+    #
+    # Can be anything FasterCSV::new()[http://fastercsv.rubyforge.org/classes/FasterCSV.html#M000018] accepts
+    def parser_options(opts=nil)
+      @parser_options = opts if opts
+      @parser_options.merge :col_sep => @delimited_by 
+    end
+    
+    # Convenience method to 'move' the cursor skipping the current index.
+    def _SKIP_
+      self.move_cursor
+    end
+    
+    # Specify the CSV column delimiter. Defaults to comma.
+    def delimited_by(delimiter=nil)
+      @delimited_by = delimiter if delimiter
+      @delimited_by
+    end
+    
+    # Declare what row to begin parsing the CSV.
+    # This is useful for skipping headers and such.
+    def start_at_row(row_number=nil)
+      @start_at_row = row_number if row_number
+      @start_at_row
+    end
+    
+    # Declare method name symbols and/or lambdas to be executed before each row.
+    # Each method or lambda must accept to parameters: +csv_row+, +target_object+
+    # Methods names should refer to methods available within the RowMap's provided context
+    def before_row(*befores)
+      self.add_filters(@before_filters, *befores)
+    end
+    
+    # Declare method name symbols and/or lambdas to be executed before each row.
+    # Each method or lambda must accept to parameters: +csv_row+, +target_object+
+    # Methods names should refer to methods available within the RowMap's provided context
+    def after_row(*afters)
+      self.add_filters(@after_filters, *afters)
+    end
+    
+    # Add a new attribute to this map.  Mostly used internally, but is useful for dynamic map creation.
+    # returns the newly created CsvMapper::AttributeMap
+    def add_attribute(name, index=nil)
+      attr_mapping = CsvMapper::AttributeMap.new(name.to_sym, index, @context)
+      self.mapped_attributes << attr_mapping
+      attr_mapping
+    end      
+    
+    # The current cursor location
+    def cursor  # :nodoc:
+      @cursor ||= 0
+    end
+    
+    # Move the cursor relative to it's current position
+    def move_cursor(positions=1) # :nodoc:
+      self.cursor += positions
+    end
+    
+    # Given a CSV row return an instance of an object defined by this mapping
+    def parse(csv_row)
+      target = self.map_to_class.new
+      @before_filters.each {|filter| filter.call(csv_row, target) }
+        
+      self.mapped_attributes.inject(target) do |result, attr_map|
+        result.send("#{attr_map.name}=".to_sym, attr_map.parse(csv_row))
+        result
+      end
+      
+      @after_filters.each {|filter| filter.call(csv_row, target) }
+      
+      return target
+    end
+    
+    protected # :nodoc:
+    
+    # The Hacktastic "magic"
+    # Used to dynamically create CsvMapper::AttributeMaps based on unknown method calls that 
+    # should represent the names of mapped attributes.
+    #
+    # An optional first argument is used to move this maps cursor position and as the index of the
+    # new AttributeMap
+    def method_missing(name, *args) # :nodoc:
+      
+      if index = args[0]
+        self.move_cursor(index - self.cursor)
+      else
+        index = self.cursor
+        self.move_cursor
+      end
+      
+      add_attribute(name, index)
+    end
+    
+    def add_filters(to_hook, *filters) # :nodoc:
+      (to_hook << filters.collect do |filter|
+        filter.is_a?(Symbol) ? lambda{|row, target| @context.send(filter, row, target)} : filter
+      end).flatten!
+    end
+            
+    def map_to_class # :nodoc:
+      @map_to_klass || OpenStruct
+    end
+    
+    def cursor=(value) # :nodoc:
+      @cursor=value
+    end
+    
+    
+  end
+  
+  # A CsvMapper::AttributeMap contains the instructions to parse a value from a CSV row and to know the
+  # name of the attribute it is targeting.
+  class AttributeMap
+    attr_reader :name, :index
+    
+    # Creates a new instance using the provided attribute +name+, CSV row +index+, and evaluation +map_context+
+    def initialize(name, index, map_context)
+      @name, @index, @map_context = name, index, map_context
+    end
+    
+    # Set the index that this map is targeting.
+    #
+    # Returns this AttributeMap for chainability
+    def at(index)
+      @index = index
+      self
+    end
+    
+    # Provide a lambda or the symbol name of a method on this map's evaluation context to be used when parsing
+    # the value from a CSV row.  
+    # Both the lambda or the method provided should accept a single +row+ parameter
+    #
+    # Returns this AttributeMap for chainability
+    def map(transform)
+      @transformer = transform
+      self
+    end
+    
+    # Given a CSV row, return the value at this AttributeMap's index using any provided map transforms (see map)
+    def parse(csv_row)
+      @transformer ? parse_transform(csv_row) : csv_row[self.index]
+    end
+    
+    # Access the raw value of the CSV row without any map transforms applied.
+    def raw_value(csv_row)
+      csv_row[self.index]
+    end
+    
+    private
+    
+    def parse_transform(csv_row)
+      if @transformer.is_a? Symbol
+        transform_name = @transformer
+        @transformer = lambda{|row| @map_context.send(transform_name, row) }
+      end
+      
+      @transformer.call(csv_row)
+    end
+    
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/csv-mapper.rb'}"
+puts "Loading csv-mapper gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/csv-mapper_attribute_map_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe CsvMapper::AttributeMap do
+  
+  class TestContext
+    def transform_it(row)
+      :transform_it_success
+    end
+  end
+    
+  before(:each) do
+    @row_attr = CsvMapper::AttributeMap.new('foo', 1, TestContext.new)
+    @csv_row = ['first_name', 'last_name']
+  end
+  
+  it "should map a destination attribute name" do
+    @row_attr.name.should == 'foo'
+  end
+
+  it "should map a CSV column index" do
+    @row_attr.index.should be(1)
+  end
+  
+  it "should map a transformation between the CSV value and destination value and chain method calls" do
+    @row_attr.map(:named_transform).should be(@row_attr)
+  end
+  
+  it "should provide ability to set the index and chain method calls" do
+    @row_attr.at(9).should be(@row_attr)
+    @row_attr.index.should be(9)
+  end
+  
+  it "should parse values" do
+    @row_attr.parse(@csv_row).should == @csv_row[1]
+  end
+
+  it "should parse values using mapped transformer" do
+    @row_attr.map( lambda{|row| :success } )
+    @row_attr.parse(@csv_row).should == :success
+  end
+  
+  it "should parse values using a named method on the context" do
+    @row_attr.map(:transform_it).parse(@csv_row).should == :transform_it_success
+  end
+  
+  it "should provide access to the raw value" do
+    @row_attr.raw_value(@csv_row).should be(@csv_row[@row_attr.index])
+  end
+  
+end

data/spec/csv-mapper_row_map_spec.rb

@@ -0,0 +1,121 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe CsvMapper::RowMap do
+  
+  class TestMapToClass
+    attr_accessor :foo, :bar, :baz
+  end
+  
+  class TestMapContext
+    def transform(row)
+      :transform_success
+    end
+    
+    def change_name(row, target)
+      row[0] = :changed_name
+    end
+  end
+  
+  before(:each) do
+    @row_map = CsvMapper::RowMap.new(TestMapContext.new)
+    @csv_row = ['first_name', 'last_name']
+  end
+
+  it "should parse a CSV row" do
+    @row_map.parse(@csv_row).should_not be_nil
+  end
+
+  it "should map to a OpenStruct by default" do
+    @row_map.parse(@csv_row).should be_instance_of(OpenStruct)
+  end
+  
+  it "should parse a CSV row returning the mapped result" do
+    @row_map.fname
+    @row_map.lname
+    
+    result = @row_map.parse(@csv_row)
+    result.fname.should == @csv_row[0]
+    result.lname.should == @csv_row[1]
+  end
+
+  it "should map to a ruby class with optional default attribute values" do
+    @row_map.map_to TestMapToClass, :baz => :default_baz
+    
+    @row_map.foo
+    @row_map.bar
+    
+    (result = @row_map.parse(@csv_row)).should be_instance_of(TestMapToClass)
+    result.foo.should == @csv_row[0]
+    result.bar.should == @csv_row[1]
+    result.baz.should == :default_baz
+  end
+    
+  it "should start at the specified CSV row" do
+    @row_map.start_at_row.should be(0)
+    @row_map.start_at_row(1)
+    @row_map.start_at_row.should be(1)
+  end
+  
+  it "should allow before row processing" do
+    @row_map.before_row :change_name, lambda{|row, target| row[1] = 'bar'}
+    
+    @row_map.first_name
+    @row_map.foo
+    
+    result = @row_map.parse(@csv_row)
+    result.first_name.should == :changed_name
+    result.foo.should == 'bar'
+  end
+  
+  it "should allow after row processing" do
+    @row_map.after_row lambda{|row, target| target.bam = :woot}
+    
+    @row_map.parse(@csv_row).bam.should == :woot
+  end
+  
+  it "should have a moveable cursor" do
+    @row_map.cursor.should be(0)
+    @row_map.move_cursor
+    @row_map.cursor.should be(1)
+    @row_map.move_cursor 3
+    @row_map.cursor.should be(4)
+  end
+  
+  it "should skip indexes" do
+    pre_cursor = @row_map.cursor
+    @row_map._SKIP_
+    @row_map.cursor.should be(pre_cursor + 1)
+  end
+  
+  it "should accept FasterCSV parser options" do
+    @row_map.parser_options :row_sep => :auto
+    @row_map.parser_options[:row_sep].should == :auto
+  end
+  
+  it "should have a configurable the column delimiter" do
+    @row_map.delimited_by '|'
+    @row_map.delimited_by.should == '|'
+  end
+  
+  it "should maintain a collection of attribute mappings" do
+    @row_map.mapped_attributes.should be_kind_of(Enumerable)
+  end
+  
+  it "should lazy initialize attribute maps and move the cursor" do
+    pre_cursor = @row_map.cursor
+    (attr_map = @row_map.first_name).should be_instance_of(CsvMapper::AttributeMap)
+    attr_map.index.should be(pre_cursor)
+    @row_map.cursor.should be(pre_cursor + 1)
+  end
+  
+  it "should lazy initialize attribute maps with optional cursor position" do
+    pre_cursor = @row_map.cursor
+    @row_map.last_name(1).index.should be(1)
+    @row_map.cursor.should be(1)
+  end
+  
+  it "should share it context with its mappings" do
+    @row_map.first_name.map(:transform)
+    @row_map.parse(@csv_row).first_name.should == :transform_success
+  end
+end

data/spec/csv-mapper_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe CsvMapper do
+    
+  before(:each) do    
+    @mapped_klass = Class.new { include CsvMapper }
+    @mapped = @mapped_klass.new
+  end
+
+  it "should allow the creation of CSV mappings" do
+    mapping = @mapped.map_csv do
+      start_at_row 2      
+    end
+    
+    mapping.should be_instance_of(CsvMapper::RowMap)
+    mapping.start_at_row.should == 2
+  end
+  
+  it "should import a CSV IO" do
+    io = 'foo,bar,00,01'
+    results = @mapped.import(io, :type => :io) do 
+      first
+      second
+    end
+    
+    results.should be_kind_of(Enumerable)
+    results.should have(1).things
+    results[0].first.should == 'foo'
+    results[0].second.should == 'bar'
+  end
+  
+  it "should import a CSV File IO" do
+    results = import(File.dirname(__FILE__) + '/test.csv') do
+      start_at_row 1
+      [first_name, last_name, age]
+    end
+    
+    results.size.should be(3)
+  end 
+  
+  it "should import non-comma delimited files" do
+    piped_io = 'foo|bar|00|01'
+    
+    results = import(piped_io, :type => :io) do
+      delimited_by '|'
+      [first, second]
+    end
+    
+    results.should have(1).things
+    results[0].first.should == 'foo'
+    results[0].second.should == 'bar'
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'csv-mapper'

data/spec/test.csv

@@ -0,0 +1,4 @@
+First Name, Last Name, Age
+John,Doe,27
+Jane,Doe,26
+Bat,Man,52

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: csv-mapper
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Luke Pillow
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-05 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fastercsv
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: CsvMapper is a small library intended to simplify the common steps involved with importing CSV files to a usable form in Ruby.
+email: 
+- lpillow@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/csv-mapper.rb
+- script/console
+- script/destroy
+- script/generate
+- spec/csv-mapper_spec.rb
+- spec/csv-mapper_row_map_spec.rb
+- spec/csv-mapper_attribute_map_spec.rb
+- spec/test.csv
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: true
+homepage: by Luke Pillow
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: csv-mapper
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: CsvMapper is a small library intended to simplify the common steps involved with importing CSV files to a usable form in Ruby.
+test_files: []
+