scottmotte-csvmapper 0.4.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 scottmotte
+
+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/README.rdoc

@@ -0,0 +1,36 @@
+= CsvMapper
+
+Taken from Luke Pillow (pillowfactory's) gem and adjusted for my own needs very very slightly.
+
+== INSTALL:
+
+  sudo gem install scottmotte-csvmapper
+
+== 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
+
+==== Simple Usage Example
+  include CsvMapper
+
+  results = CsvMapper.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
+
+

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "csvmapper"
+    gem.summary = %Q{Stolen from pillowfactory's csv-mapper and adjusted slightly}
+    gem.email = "scott@scottmotte.com"
+    gem.homepage = "http://github.com/scottmotte/csvmapper"
+    gem.authors = ["scottmotte"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    
+    gem.add_dependency('right_aws')
+    gem.add_dependency('mini_magick')
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "csvmapper #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/lib/csvmapper.rb

@@ -0,0 +1,237 @@
+require 'ostruct'
+require 'fastercsv'
+
+# this is stolen from csv-mapper gem with slight modifcations by me and a cleaner module name
+module CsvMapper
+  # Create a new RowMap instance from the definition in the given block.
+  def self.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 self.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 && i <= map.stop_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/ }
+    
+    Infinity = 1.0/0
+    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
+      @stop_at_row = Infinity
+      @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 the last row to be parsed in a CSV.
+    def stop_at_row(row_number=nil)
+      @stop_at_row = row_number if row_number
+      @stop_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/spec/csvmapper_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Csvmapper" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'csvmapper'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: scottmotte-csvmapper
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- scottmotte
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: right_aws
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mini_magick
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: scott@scottmotte.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/csvmapper.rb
+- spec/csvmapper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/scottmotte/csvmapper
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Stolen from pillowfactory's csv-mapper and adjusted slightly
+test_files: 
+- spec/csvmapper_spec.rb
+- spec/spec_helper.rb