map_fields 1.0.1

data/.autotest

@@ -0,0 +1,2 @@
+# -*- ruby -*-
+require 'autotest/redgreen'

data/.gitignore

@@ -0,0 +1,2 @@
+pkg/
+tmp/

data/README.rdoc

@@ -0,0 +1,107 @@
+= map-fields
+
+* http://github.com/internuity/map-fields
+
+== DESCRIPTION:
+
+A Rails plugin which provides a hook to preview and map the fields of an uploaded CSV file to a pre-defined schema
+
+== FEATURES/PROBLEMS:
+
+* Captures the post and provides an intermediate view where a user can map their data to the expected schema
+* Provides a default mapping view that can be customised
+* Allows the import to be part of a larger form (The form fields are remembered through the mapping)
+
+== SYNOPSIS:
+
+===Lists controller
+  class ListsController < AppliactionController
+    map_fields :create, ['Title', 'First name', 'Last name'], :file_field => :file, :params => [:list]
+
+    def index
+      @lists = List.find(:all)
+    end
+
+    def new
+      @list = List.new
+    end
+
+    def create
+      @list = List.new(params[:list])
+      if fields_mapped?
+        mapped_fields.each do |row|
+          @list.contact.create(:title => row[0], 
+                               :first_name => row[1], 
+                               :last_name => row[2])
+        end
+        flash[:notice] = 'Contact list created'
+        redirect_to :action => :index
+      else
+        render
+      end
+    rescue MapFields::InconsistentStateError
+      flash[:error] = 'Please try again'
+      redirect_to :action => :new
+    rescue MapFields::MissingFileContentsError
+      flash[:error] = 'Please upload a file'
+      redirect_to :action => :new
+    end
+  end
+
+===New view (new.html.erb)
+  <h1>Import a new List</h1>
+  <% form_for :list, :html => {:multipart => true} do |form| %>
+    <div class="field">
+      <%= form.label :name %>
+      <%= form.text_field :name %>
+    </div>
+    <div class="field">
+      <label for="file">File</label>
+      <%= file_field_tag 'file' %>
+    </div>
+    <div class="buttons">
+      <%= form.submit 'Import' %>
+    </div>
+  <% end %>
+
+===Create view (create.html.erb)
+  <h1>Import a new List</h1>
+  <p>Please map the details you're importing</p>
+  =render :partial => 'map_fields/map_fields'
+
+== REQUIREMENTS:
+
+* FasterCSV
+
+== INSTALL:
+
+sudo gem install map-fields
+
+or
+
+./script/plugin install git://github.com/internuity/map-fields.git
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009
+
+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,16 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "map_fields"
+    gem.summary = %Q{Rails plugin to allow a user to map the fields of a CSV to an expected list of fields}
+    gem.email = "andrew@andrewtimberlake.com"
+    gem.homepage = "http://github.com/andrewtimberlake/map-fields"
+    gem.authors = ["Andrew Timberlake"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/announcement.txt

@@ -0,0 +1,12 @@
+map-fields version 1.0.0
+    by Andrew Timberlake
+    http://github.com/internuity/map-fields
+
+== DESCRIPTION
+
+A Rails plugin which provides a hook to preview and map the fields of an uploaded CSV file to a pre-defined schema
+
+== CHANGES
+
+* Initial release
+

data/init.rb

@@ -0,0 +1 @@
+require 'map_fields'

data/lib/map_fields.rb

@@ -0,0 +1,197 @@
+require 'fastercsv'
+
+module MapFields
+  VERSION = '1.0.0'
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def map_fields
+    default_options = {
+      :file_field => 'file',
+      :params => []
+    }
+    options = default_options.merge( 
+                self.class.read_inheritable_attribute(:map_fields_options)
+              )
+
+    RAILS_DEFAULT_LOGGER.debug("session[:map_fields]: #{session[:map_fields]}")
+    RAILS_DEFAULT_LOGGER.debug("params[options[:file_field]]: #{params[options[:file_field]]}")
+    if session[:map_fields].nil? || !params[options[:file_field]].blank?
+      session[:map_fields] = {}
+      if params[options[:file_field]].blank?
+        @map_fields_error = MissingFileContentsError
+        return
+      end
+
+      file_field = params[options[:file_field]]
+
+      temp_path = File.join(Dir::tmpdir, "map_fields_#{Time.now.to_i}_#{$$}")
+      File.open(temp_path, 'wb') do |f|
+        f.write file_field.read
+      end
+
+      session[:map_fields][:file] = temp_path
+    else
+      if session[:map_fields][:file].nil? || params[:fields].nil?
+        session[:map_fields] = nil
+        @map_fields_error =  InconsistentStateError
+      else
+        expected_fields = self.class.read_inheritable_attribute(:map_fields_fields)
+        if expected_fields.respond_to?(:call)
+          expected_fields = expected_fields.call(params)
+        end
+        @mapped_fields = MappedFields.new(session[:map_fields][:file], 
+                                          expected_fields,
+                                          params[:fields],
+                                          params[:ignore_first_row])
+      end
+    end
+
+    @rows = []
+    begin
+      FasterCSV.foreach(session[:map_fields][:file]) do |row|
+        @rows << row
+        break if @rows.size == 10
+      end
+    rescue FasterCSV::MalformedCSVError => e
+      @map_fields_error = e
+    end
+    expected_fields = self.class.read_inheritable_attribute(:map_fields_fields)
+    if expected_fields.respond_to?(:call)
+      expected_fields = expected_fields.call(params)
+    end
+    @fields = ([nil] + expected_fields).inject([]){ |o, e| o << [e, o.size]}
+    @parameters = []
+    options[:params].each do |param|
+      @parameters += ParamsParser.parse(params, param)
+    end
+  end
+
+  def mapped_fields
+    @mapped_fields
+  end
+
+  def fields_mapped?
+    raise @map_fields_error if @map_fields_error
+    @mapped_fields
+  end
+
+  def map_field_parameters(&block)
+    
+  end
+
+  def map_fields_cleanup
+    if @mapped_fields
+      if session[:map_fields][:file]
+        File.delete(session[:map_fields][:file]) 
+      end
+      session[:map_fields] = nil
+      @mapped_fields = nil
+      @map_fields_error = nil
+    end
+  end
+
+  module ClassMethods
+    def map_fields(action, fields, options = {})
+      write_inheritable_attribute(:map_fields_fields, fields)
+      write_inheritable_attribute(:map_fields_options, options)
+      before_filter :map_fields, :only => action
+      after_filter :map_fields_cleanup, :only => action
+    end
+  end
+
+  class MappedFields
+    attr_reader :mapping, :ignore_first_row, :file
+
+    def initialize(file, fields, mapping, ignore_first_row)
+      @file = file
+      @fields = fields
+      @mapping = {}
+      @ignore_first_row = ignore_first_row
+
+      mapping.each do |k,v|
+        unless v.to_i == 0
+          #Numeric mapping
+          @mapping[v.to_i - 1] = k.to_i - 1 
+          #Text mapping
+          @mapping[fields[v.to_i-1]] = k.to_i - 1
+          #Symbol mapping
+          sym_key = fields[v.to_i-1].downcase.
+                                      gsub(/[-\s\/]+/, '_').
+                                      gsub(/[^a-zA-Z0-9_]+/, '').
+                                      to_sym
+          @mapping[sym_key] = k.to_i - 1
+        end
+      end
+    end
+
+    def is_mapped?(field)
+      !@mapping[field].nil?
+    end
+
+    def each
+      row_number = 1
+      FasterCSV.foreach(@file) do |csv_row|
+        unless row_number == 1 && @ignore_first_row
+          row = {}
+          @mapping.each do |k,v|
+            row[k] = csv_row[v]
+          end
+          row.class.send(:define_method, :number) { row_number }
+          yield(row)
+        end
+        row_number += 1
+      end
+    end
+  end
+
+  class InconsistentStateError < StandardError
+  end
+
+  class MissingFileContentsError < StandardError
+  end
+
+  class ParamsParser
+    def self.parse(params, field = nil)
+      result = []
+      params.each do |key,value|
+        if field.nil? || field.to_s == key.to_s
+          check_values(value) do |k,v|
+            result << ["#{key.to_s}#{k}", v]
+          end
+        end
+      end
+      result
+    end
+
+    private
+    def self.check_values(value, &block)
+      result = []
+      if value.kind_of?(Hash)
+        value.each do |k,v|
+          check_values(v) do |k2,v2|
+            result << ["[#{k.to_s}]#{k2}", v2]
+          end
+        end
+      elsif value.kind_of?(Array)
+        value.each do |v|
+          check_values(v) do |k2, v2|
+            result << ["[]#{k2}", v2]
+          end
+        end
+      else
+        result << ["", value]
+      end
+      result.each do |arr|
+        yield arr[0], arr[1]
+      end
+    end
+  end
+end
+
+if defined?(Rails) and defined?(ActionController)
+  ActionController::Base.send(:include, MapFields)
+  ActionController::Base.view_paths.push File.expand_path(File.join(File.dirname(__FILE__), '..', 'views'))
+end

data/spec/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/spec/controllers/test_controller_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe TestController do
+
+  context "on upload" do
+    context "with an attached file" do
+      before do
+        test_file  = ActionController::TestUploadedFile.new(File.join(File.dirname(__FILE__), '..', 'test-file.csv'))
+
+        File.should_receive(:open) do |path, flags| 
+          path.should match(Regexp.new(Dir::tmpdir))
+          flags.should == 'wb'
+        end
+        FasterCSV.should_receive(:foreach)
+
+        post :create, :file => test_file, :user => {:first_name => 'Test', :last_name => 'User'}
+      end
+
+      it "should assign to @fields" do
+        assigns[:fields].should_not be_blank
+      end
+
+      it "should store the file location in the session" do
+        session[:map_fields][:file].should_not be_blank
+      end
+
+      it "should assign to @parameters" do 
+        assigns[:parameters].should_not be_blank
+      end
+
+      it "should have the first name parameter" do
+        assigns[:parameters].should include(['user[first_name]', 'Test'])
+      end
+
+      it "should have the last name parameters" do
+        assigns[:parameters].should include(['user[last_name]', 'User'])
+      end
+    end
+
+    context "without an attached file" do
+      it "should raise an error" do
+        lambda { post :create }.should raise_error
+      end
+    end
+  end
+
+  context "on second post" do
+    it "should map the fields" do
+      session[:map_fields] = {:file => '/tmp/test'}
+      FasterCSV.expects(:foreach)
+      File.expects(:delete).with('/tmp/test')
+
+      post :create, :fields => {"1" => "2", "2" => "3", "3" => "1"}
+    end
+  end
+end

data/spec/lib/params_parser_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe MapFields::ParamsParser do
+  context "with no specific field specified" do
+    it "should be able to parse params[:id] = '1'" do
+      params = {:id => '1'}
+
+      MapFields::ParamsParser.parse(params).should == [["id", "1"]]
+    end
+
+    it "should be able to parse params[:user][:id] = '1'" do
+      params = {:user => {:id => '1'}}
+
+      MapFields::ParamsParser.parse(params).should == [["user[id]", "1"]]
+    end
+
+    it "should be able to parse params[:user][] = '1'" do
+      params = {:user => ['1']}
+
+      MapFields::ParamsParser.parse(params).should == [["user[]", "1"]]
+    end
+
+    it "should be able to parse params[:user][] = '1' with multiple entries" do
+      params = {:user => ['1', '2', '3']}
+
+      MapFields::ParamsParser.parse(params).size.should == 3
+      MapFields::ParamsParser.parse(params)[0].should == ["user[]", "1"]
+      MapFields::ParamsParser.parse(params)[1].should == ["user[]", "2"]
+      MapFields::ParamsParser.parse(params)[2].should == ["user[]", "3"]
+    end
+
+    it "should be able to parse params[:user][:sub][:id] = '1'" do
+      params = {:user => {:sub => {:id => '1'}}}
+
+      MapFields::ParamsParser.parse(params).should == [["user[sub][id]", "1"]]
+    end
+
+    it "should be able to parse params[:user][:sub][] = '1'" do
+      params = {:user => {:sub => ['1']}}
+
+      MapFields::ParamsParser.parse(params).should == [["user[sub][]", "1"]]
+    end
+
+    it "should be able to parse params[:user][:sub][] = '1' with multiple entries" do
+      params = {:user => {:sub => ['1', '2', '3']}}
+
+      MapFields::ParamsParser.parse(params).size.should == 3
+      MapFields::ParamsParser.parse(params)[0].should == ["user[sub][]", "1"]
+      MapFields::ParamsParser.parse(params)[1].should == ["user[sub][]", "2"]
+      MapFields::ParamsParser.parse(params)[2].should == ["user[sub][]", "3"]
+    end
+
+    it "should be able to parse params[:user][:sub][:sub2][] = '1'" do
+      params = {:user => {:sub => {:sub2 => ['1']}}}
+
+      MapFields::ParamsParser.parse(params).should == [["user[sub][sub2][]", "1"]]
+    end
+
+    it "should be able to parse a complicated collection of parameters" do
+      params = {:user => {:sub => {:sub2 => ['1']}},
+                :test => '1',
+                :other => ['collection', 'of', 'parameters'],
+                :checking => {:if => ['it', 'can'],
+                              :handle => '1',
+                              :big => {:bunch => {:of => {:rubish => ['thrown', 'at'],
+                                                          :it => 'yes'}}}
+                             }
+               }
+
+      MapFields::ParamsParser.parse(params).should include(["user[sub][sub2][]", "1"])
+      MapFields::ParamsParser.parse(params).should include(["test", "1"])
+      MapFields::ParamsParser.parse(params).should include(["other[]", "collection"])
+      MapFields::ParamsParser.parse(params).should include(["other[]", "of"])
+      MapFields::ParamsParser.parse(params).should include(["other[]", "parameters"])
+      MapFields::ParamsParser.parse(params).should include(["checking[if][]", "it"])
+      MapFields::ParamsParser.parse(params).should include(["checking[if][]", "can"])
+      MapFields::ParamsParser.parse(params).should include(["checking[handle]", "1"])
+      MapFields::ParamsParser.parse(params).should include(["checking[big][bunch][of][rubish][]", "thrown"])
+      MapFields::ParamsParser.parse(params).should include(["checking[big][bunch][of][rubish][]", "at"])
+      MapFields::ParamsParser.parse(params).should include(["checking[big][bunch][of][it]", "yes"])
+    end
+  end
+
+  context "with a specified parameter" do
+    it "should be able to get only the requested field" do
+      params = {:user => {:sub => {:sub2 => ['1']}},
+                :test => ['another', 'parameter']
+               }
+
+      MapFields::ParamsParser.parse(params, :user).should == [["user[sub][sub2][]", "1"]]
+    end
+
+    it "should be able to parse params[:user][:sub][:sub2][] = '1'" do
+      params = {:user => {:sub => {:sub2 => ['1']}}}
+
+      MapFields::ParamsParser.parse(params, :user).should == [["user[sub][sub2][]", "1"]]
+    end
+  end
+end

data/spec/rails_root/app/controllers/application_controller.rb

@@ -0,0 +1,10 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  helper :all # include all helpers, all the time
+  protect_from_forgery # See ActionController::RequestForgeryProtection for details
+
+  # Scrub sensitive parameters from your log
+  # filter_parameter_logging :password
+end

data/spec/rails_root/app/controllers/import_controller.rb

@@ -0,0 +1,30 @@
+class ImportController < ApplicationController
+  map_fields :create, ['Title', 'First name', 'Last name', 'Email'], :file_field => 'file', :params => [:name]
+
+  def new
+    render
+  end
+
+  def create
+    begin
+      if fields_mapped?
+        #Process import
+        
+        render :done
+      else
+        render 
+      end
+    rescue MapFields::InconsistentStateError
+      logger.debug 'catching InconsistentStateError'
+      redirect_to :action => :new, :status => 303
+      return
+    rescue MapFields::MissingFileContentsError
+      logger.debug 'catching MissingFileContentsError'
+      flash[:error] = 'Please upload a file'
+      render :action => :new
+      return
+    end
+
+    logger.debug 'here'
+  end
+end

data/spec/rails_root/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/spec/rails_root/app/helpers/import_helper.rb

@@ -0,0 +1,2 @@
+module ImportHelper
+end

data/spec/rails_root/config/boot.rb

@@ -0,0 +1,110 @@
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?("#{RAILS_ROOT}/vendor/rails")
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+      Rails::GemDependency.add_frozen_gem_path
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.3.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          File.read("#{RAILS_ROOT}/config/environment.rb")
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/spec/rails_root/config/environment.rb

@@ -0,0 +1,41 @@
+# Be sure to restart your server when you modify this file
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+RAILS_GEM_VERSION = '2.3.2' unless defined? RAILS_GEM_VERSION
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  # Settings in config/environments/* take precedence over those specified here.
+  # Application configuration should go into files in config/initializers
+  # -- all .rb files in that directory are automatically loaded.
+
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{RAILS_ROOT}/extras )
+
+  # Specify gems that this application depends on and have them installed with rake gems:install
+  # config.gem "bj"
+  # config.gem "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
+  # config.gem "sqlite3-ruby", :lib => "sqlite3"
+  # config.gem "aws-s3", :lib => "aws/s3"
+
+  # Only load the plugins named here, in the order given (default is alphabetical).
+  # :all can be used as a placeholder for all plugins not explicitly named
+  # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+  # Skip frameworks you're not going to use. To use Rails without a database,
+  # you must remove the Active Record framework.
+  # config.frameworks -= [ :active_record, :active_resource, :action_mailer ]
+
+  # Activate observers that should always be running
+  # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+  # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+  # Run "rake -D time" for a list of tasks for finding time zone names.
+  config.time_zone = 'UTC'
+
+  # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+  # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}')]
+  # config.i18n.default_locale = :de
+end

data/spec/rails_root/config/environments/development.rb

@@ -0,0 +1,17 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# In the development environment your application's code is reloaded on
+# every request.  This slows down response time but is perfect for development
+# since you don't have to restart the webserver when you make code changes.
+config.cache_classes = false
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_view.debug_rjs                         = true
+config.action_controller.perform_caching             = false
+
+# Don't care if the mailer can't send
+config.action_mailer.raise_delivery_errors = false

data/spec/rails_root/config/environments/production.rb

@@ -0,0 +1,28 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The production environment is meant for finished, "live" apps.
+# Code is not reloaded between requests
+config.cache_classes = true
+
+# Full error reports are disabled and caching is turned on
+config.action_controller.consider_all_requests_local = false
+config.action_controller.perform_caching             = true
+config.action_view.cache_template_loading            = true
+
+# See everything in the log (default is :info)
+# config.log_level = :debug
+
+# Use a different logger for distributed setups
+# config.logger = SyslogLogger.new
+
+# Use a different cache store in production
+# config.cache_store = :mem_cache_store
+
+# Enable serving of images, stylesheets, and javascripts from an asset server
+# config.action_controller.asset_host = "http://assets.example.com"
+
+# Disable delivery errors, bad email addresses will be ignored
+# config.action_mailer.raise_delivery_errors = false
+
+# Enable threaded mode
+# config.threadsafe!

data/spec/rails_root/config/environments/test.rb

@@ -0,0 +1,28 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+config.action_view.cache_template_loading            = true
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell Action Mailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test
+
+# Use SQL instead of Active Record's schema dumper when creating the test database.
+# This is necessary if your schema can't be completely dumped by the schema dumper,
+# like if you have constraints or database-specific column types
+# config.active_record.schema_format = :sql

data/spec/rails_root/config/initializers/backtrace_silencers.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying do debug a problem that might steem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!

data/spec/rails_root/config/initializers/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/spec/rails_root/config/initializers/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/spec/rails_root/config/initializers/new_rails_defaults.rb

@@ -0,0 +1,19 @@
+# Be sure to restart your server when you modify this file.
+
+# These settings change the behavior of Rails 2 apps and will be defaults
+# for Rails 3. You can remove this initializer when Rails 3 is released.
+
+if defined?(ActiveRecord)
+  # Include Active Record class name as root for JSON serialized output.
+  ActiveRecord::Base.include_root_in_json = true
+
+  # Store the full class name (including module namespace) in STI type column.
+  ActiveRecord::Base.store_full_sti_class = true
+end
+
+# Use ISO 8601 format for JSON serialized times and dates.
+ActiveSupport.use_standard_json_time_format = true
+
+# Don't escape HTML entities in JSON, leave that for the #json_escape helper.
+# if you're including raw json in an HTML page.
+ActiveSupport.escape_html_entities_in_json = false

data/spec/rails_root/config/initializers/session_store.rb

@@ -0,0 +1,15 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key for verifying cookie session data integrity.
+# If you change this key, all old sessions will become invalid!
+# Make sure the secret is at least 30 characters and all random, 
+# no regular words or you'll be exposed to dictionary attacks.
+ActionController::Base.session = {
+  :key         => '_rails_root_session',
+  :secret      => 'f38f519843de9979c5fe159cd03b57bb30bd8591d9d3f7e9d8e0ad00b477c06c6bf884f0c8095928f57fec7c841225144f1150bab3053a66d84e5b6acdbd56ab'
+}
+
+# Use the database for sessions instead of the cookie-based default,
+# which shouldn't be used to store highly confidential information
+# (create the session table with "rake db:sessions:create")
+# ActionController::Base.session_store = :active_record_store

data/spec/rails_root/config/routes.rb

@@ -0,0 +1,3 @@
+ActionController::Routing::Routes.draw do |map|
+  map.resources :import
+end

data/spec/rails_root/test/functional/import_controller_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class ImportControllerTest < ActionController::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/spec/rails_root/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionController::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/spec/rails_root/test/test_helper.rb

@@ -0,0 +1,38 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+
+class ActiveSupport::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/spec/rails_root/test/unit/helpers/import_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class ImportHelperTest < ActionView::TestCase
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+RAILS_ROOT = File.join(File.dirname(__FILE__), 'rails_root')
+RAILS_ENV = 'test'
+
+#Needed for autospec
+$LOAD_PATH << "spec"
+$LOAD_PATH << "lib"
+
+require 'rubygems'
+#Needed for rspec_rails
+require 'rails/version'
+require 'action_controller'
+require 'action_controller/test_process'
+require 'spec/rails'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'map_fields')
+
+require File.join(File.dirname(__FILE__), '..', 'init')
+
+Spec::Runner.configure do |config|
+  #config.use_transactional_fixtures = true
+end
+
+class TestController < ApplicationController
+  map_fields :create, ['Title', 'First name', 'Last name'], :params => [:user]
+
+  def new
+  end
+
+  def create
+    if fields_mapped?
+      mapped_fields.each do |row|
+        #deal with the data
+        row[0] #=> will be Title
+        row[1] #=> will be First name
+        row[2] #=> will be Last name
+      end
+      render :text => ''
+    else
+      render 'map_fields/_map_fields'
+    end
+  end
+end
+
+ActionController::Routing::Routes.draw do |map|
+  map.resources :test
+end

data/spec/test-file.csv

@@ -0,0 +1,3 @@
+Title,Lastname,Firstname,Email
+Mr,John,Doe,john.doe@example.com
+Mrs,Jane,Doe,jane.doe@example.com

data/views/map_fields/_map_fields.erb

@@ -0,0 +1,31 @@
+<% form_tag nil, :id => 'map_fields_form', :method => :post do -%>
+  <% @parameters.each do |arr| -%>
+    <%= hidden_field_tag arr[0], arr[1] %>
+  <% end -%>
+  <div class="map_fields">
+    <table cellspacing="0">
+      <thead>
+        <tr>
+          <% (1..@rows[0].size).each do |c| -%>
+            <th><%= select_tag "fields[#{c}]", options_for_select(@fields), :include_blank => true, :class => 'field_options' %></th>
+          <% end -%>
+        </tr>
+      </thead>
+      <tbody>
+        <% @rows.each do |row| -%>
+          <tr>
+            <% row.each do |column| -%>
+              <td><%= h(column) %></td>
+            <% end -%>
+          </tr>
+        <% end -%>
+      </tbody>
+    </table>
+  </div>
+  <div class="option">
+    <%= check_box_tag 'ignore_first_row', '1', true, :id => 'ignore_first_row_option' %><label for="ignore_first_row_option">Ignore the first row (headings)</label>
+  </div>
+  <div class="action">
+    <%= submit_tag 'Import' %>
+  </div>
+<% end -%>

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: map_fields
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- Andrew Timberlake
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-12 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: andrew@andrewtimberlake.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .autotest
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION
+- announcement.txt
+- init.rb
+- lib/map_fields.rb
+- spec/application_controller.rb
+- spec/controllers/test_controller_spec.rb
+- spec/lib/params_parser_spec.rb
+- spec/spec_helper.rb
+- spec/test-file.csv
+- views/map_fields/_map_fields.erb
+has_rdoc: true
+homepage: http://github.com/andrewtimberlake/map-fields
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Rails plugin to allow a user to map the fields of a CSV to an expected list of fields
+test_files: 
+- spec/controllers/test_controller_spec.rb
+- spec/lib/params_parser_spec.rb
+- spec/spec_helper.rb
+- spec/rails_root/app/controllers/import_controller.rb
+- spec/rails_root/app/controllers/application_controller.rb
+- spec/rails_root/app/helpers/import_helper.rb
+- spec/rails_root/app/helpers/application_helper.rb
+- spec/rails_root/test/test_helper.rb
+- spec/rails_root/test/unit/helpers/import_helper_test.rb
+- spec/rails_root/test/performance/browsing_test.rb
+- spec/rails_root/test/functional/import_controller_test.rb
+- spec/rails_root/config/environments/test.rb
+- spec/rails_root/config/environments/development.rb
+- spec/rails_root/config/environments/production.rb
+- spec/rails_root/config/boot.rb
+- spec/rails_root/config/routes.rb
+- spec/rails_root/config/initializers/inflections.rb
+- spec/rails_root/config/initializers/backtrace_silencers.rb
+- spec/rails_root/config/initializers/session_store.rb
+- spec/rails_root/config/initializers/new_rails_defaults.rb
+- spec/rails_root/config/initializers/mime_types.rb
+- spec/rails_root/config/environment.rb
+- spec/application_controller.rb