map_fields 1.0.4 → 2.0.0.beta

data/README.rdoc

@@ -4,48 +4,48 @@
 
 == DESCRIPTION:
 
-A Rails plugin which provides a hook to preview and map the fields of an uploaded CSV file to a pre-defined schema
+A Rails gem 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)
+* Can only handle a single uploaded file at a time
 
-== SYNOPSIS:
+== INSTALLATION:
 
-===Lists controller
-  class ListsController < AppliactionController
-    map_fields :create, ['Title', 'First name', 'Last name'], :file_field => :file, :params => [:list]
+gem install map_fields
 
-    def index
-      @lists = List.find(:all)
-    end
+== EXAMPLE:
+
+===TestController
+  class TestController < AppliactionController
 
     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])
+      map_fields :get_fields, params[:file] do
+        @list = List.create(params[:list])
+        @mapping.rows.each do |row|
+          @list.contact.create(:title => row[:title], 
+                               :first_name => row[:first_name], 
+                               :last_name => row[:last_name])
         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
+    rescue MapFields::MissingFileError
       flash[:error] = 'Please upload a file'
       redirect_to :action => :new
     end
+
+    private
+    def get_fields
+      ['Title', 'First name', 'Last name']
+    end	
   end
 
 ===New view (new.html.erb)
@@ -67,19 +67,12 @@ A Rails plugin which provides a hook to preview and map the fields of an uploade
 ===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'
+  =render :partial => 'map_fields/mapping'
 
 == REQUIREMENTS:
 
-* FasterCSV
-
-== INSTALL:
-
-sudo gem install map-fields
-
-or
-
-./script/plugin install git://github.com/internuity/map-fields.git
+* Rails 3.1
+* Ruby 1.9.3 (Not tested on 1.9.1 or 1.9.2
 
 == LICENSE:
 

data/lib/map_fields/controller.rb

@@ -0,0 +1,15 @@
+require 'map_fields/mapper'
+
+module MapFields
+  module Controller
+    def map_fields(fields, file, &block)
+      @mapper = Mapper.new(self, fields, file)
+      if @mapper.mapped?
+        block.call
+      else
+        append_view_path File.expand_path('../../../views/', __FILE__)
+        render
+      end
+    end
+  end
+end

data/lib/map_fields/mapper.rb

@@ -0,0 +1,108 @@
+require 'csv'
+require 'tempfile'
+require 'map_fields/mapping'
+require 'map_fields/params_parser'
+
+module MapFields
+  class MissingFileError < StandardError; end
+
+  class Mapper
+    def initialize(controller, fields, file)
+      params = controller.params
+      @fields = get_fields(controller, fields)
+      @params = ParamsParser.parse(params)
+
+      if file
+        file = save_file controller, file
+        @rows = parse_first_few_lines file
+      else
+        raise MissingFileError unless controller.session[:map_fields_file] && File.exist?(controller.session[:map_fields_file])
+        @mapped = true
+        @rows = map_fields(controller, params.delete(:mapped_fields), fields)
+      end
+    end
+    attr_reader :rows, :fields, :params
+
+    def mapped?
+      @mapped
+    end
+
+    private
+    def parse_params(params)
+      params = params.except(:controller, :action)
+    end
+
+    def map_fields(controller, mapped_fields, fields)
+      ignore_first_row = mapped_fields.delete(:ignore_first_row)
+      mapping = Mapping.new(mapped_fields, fields)
+      CSVReader.new(controller.session[:map_fields_file], mapping, ignore_first_row)
+    end
+
+    def get_fields(controller, fields)
+      if fields.is_a?(Symbol)
+        controller.send(fields)
+      elsif fields.respond_to?(:call)
+        fields.call
+      else
+        fields
+      end
+    end
+
+    def save_file(controller, file)
+      Tempfile.open(['map_fields', '.csv']) do |tmpfile|
+        tmpfile.write file.read
+        controller.session[:map_fields_file] = tmpfile.path
+        tmpfile.path
+      end
+    end
+
+    def parse_first_few_lines(file)
+      rows = []
+      rowcount = 0
+      CSV.foreach(file) do |row|
+        rows << row
+        break if (rowcount += 1) >= 10
+      end
+      rows
+    end
+  end
+
+  class CSVReader
+    def initialize(file, mapping, ignore_first_row)
+      @mapping = mapping
+      @ignore_first_row = ignore_first_row
+      @csv = CSV.open(file, :headers => ignore_first_row)
+      @rows = nil
+    end
+
+    def [](index)
+      get_row index
+    end
+
+    def each(&block)
+      @csv.each do |row|
+        block.call CSVRow.new(row, @mapping)
+      end
+    end
+
+    private
+    def get_row(index)
+      CSVRow.new((@rows ||= parse_csv)[index], @mapping)
+    end
+
+    def parse_csv
+      @csv.read
+    end
+  end
+
+  class CSVRow
+    def initialize(row, mapping)
+      @row = row
+      @mapping = mapping
+    end
+
+    def [](index)
+      @row[@mapping[index]]
+    end
+  end
+end

data/lib/map_fields/mapping.rb

@@ -0,0 +1,26 @@
+module MapFields
+  class Mapping
+    def initialize(mapping, fields)
+      @mapping = mapping
+      @fields = fields
+
+      @mapping = mapping.each_with_object({}){ |arr, hash|
+        key = arr[0].to_i
+        value = arr[1].to_i
+
+        hash[key] = value
+        hash[@fields[key]] = value
+        hash[field_to_symbol(@fields[key])] = value
+      }
+    end
+
+    def [](index)
+      @mapping[index]
+    end
+
+    private
+    def field_to_symbol(field)
+      field.to_s.downcase.gsub(/[^a-z0-9]+/, '_').to_sym
+    end
+  end
+end

data/lib/map_fields/params_parser.rb

@@ -0,0 +1,39 @@
+module MapFields
+  class ParamsParser
+    def self.parse(params, field = nil)
+      result = []
+      params.each do |key, value|
+        next if [:controller, :action].include?(key.to_sym)
+        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] unless value.respond_to?(:read)
+      end
+      result.each do |arr|
+        yield arr[0], arr[1]
+      end
+    end
+  end
+end

data/lib/map_fields/railtie.rb

@@ -0,0 +1,5 @@
+module MapFields
+  class Railtie < Rails::Railtie
+    AbstractController::Base.send(:include, MapFields::Controller)
+  end
+end

data/lib/map_fields.rb

@@ -1,201 +1,202 @@
-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
-
-    unless @map_fields_error
-      @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
-  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(actions, fields, options = {})
-      write_inheritable_attribute(:map_fields_fields, fields)
-      write_inheritable_attribute(:map_fields_options, options)
-      before_filter :map_fields, :only => actions
-      after_filter :map_fields_cleanup, :only => actions
-    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 == '1'
-
-      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'))
-  #This is a hack but the above code is not enough when using bundler and Rails 2.3.5
-  ActionController::Base.view_paths.push "app/views"
-end
+require 'map_fields/controller'
+require 'map_fields/railtie' if defined?(Rails)
+
+# 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
+
+#     unless @map_fields_error
+#       @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
+#   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(actions, fields, options = {})
+#       write_inheritable_attribute(:map_fields_fields, fields)
+#       write_inheritable_attribute(:map_fields_options, options)
+#       before_filter :map_fields, :only => actions
+#       after_filter :map_fields_cleanup, :only => actions
+#     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 == '1'
+
+#       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'))
+#   #This is a hack but the above code is not enough when using bundler and Rails 2.3.5
+#   ActionController::Base.view_paths.push "app/views"
+# end

data/spec/spec_helper.rb

@@ -1,45 +1,13 @@
-RAILS_ROOT = File.join(File.dirname(__FILE__), 'rails_root')
-RAILS_ENV = 'test'
+ENV['RAILS_ENV'] = 'test'
 
-#Needed for autospec
-$LOAD_PATH << "spec"
-$LOAD_PATH << "lib"
+$:.unshift File.expand_path('../../lib', __FILE__)
 
-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 'bundler'
+require File.expand_path('../../rails_app/config/environment.rb', __FILE__)
+require 'rails/test_help'
+require 'rspec/rails'
+require '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
+RailsApp::Application.routes.draw do
+  resources :test
 end

metadata

@@ -1,71 +1,55 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: map_fields
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 1.0.4
+version: !ruby/object:Gem::Version
+  version: 2.0.0.beta
+  prerelease: 6
 platform: ruby
-authors: 
+authors:
 - Andrew Timberlake
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-13 00:00:00 +02:00
-default_executable: 
+date: 2011-06-13 00:00:00.000000000 Z
 dependencies: []
-
 description: 
 email: andrew@andrewtimberlake.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
-- .autotest
+files:
 - README.rdoc
-- Rakefile
-- VERSION
-- announcement.txt
-- init.rb
+- lib/map_fields/controller.rb
+- lib/map_fields/mapper.rb
+- lib/map_fields/mapping.rb
+- lib/map_fields/params_parser.rb
+- lib/map_fields/railtie.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/internuity/map-fields
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.2
+rubygems_version: 1.8.10
 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/application_controller.rb
-- spec/controllers/test_controller_spec.rb
-- spec/lib/params_parser_spec.rb
+summary: Rails gem to allow a user to map the fields of a CSV to an expected list
+  of fields
+test_files:
 - spec/spec_helper.rb

data/.autotest

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

data/Rakefile

@@ -1,16 +0,0 @@
-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/internuity/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

@@ -1 +0,0 @@
-1.0.4

data/announcement.txt

@@ -1,12 +0,0 @@
-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

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

data/spec/application_controller.rb

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

data/spec/controllers/test_controller_spec.rb

@@ -1,56 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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/test-file.csv

@@ -1,3 +0,0 @@
-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

@@ -1,31 +0,0 @@
-<% 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 -%>