csv_importable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 468b8461398702b643ac57db4fe9aa28309e5abe
+  data.tar.gz: b31a2f2189637a5889d27e846239c06231b3df05
+SHA512:
+  metadata.gz: 37fdcd78cc1b9518d89c8be76167e348ae61f60688e021647589ce273965c65c3cbf734a42ec7bfb10d0d1f9b39c06c358abb7f1e7316e8b5b5f170e3d5c6c23
+  data.tar.gz: 8d95e02da61b4823eb94b3b5bd4723052f35b758d869dc950ffe5b4a43e9c91a2b96b68996e3a66bf44dce94a9b3127d6c1e387b396225fb01ad835d2eac3dd0

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in csv_importable.gemspec
+gemspec

data/README.md

@@ -0,0 +1,104 @@
+# CSV Importable
+
+Intelligently parse CSVs and display errors to your users.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'csv_importable'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+High level steps:
+
+1. Create an `Import` model: this model handles and stores the file, status, and results of the import for the user to see.
+2. Create a `RowImporter` class: this class handles the logic surrounding how one row in the CSV should be added to the database.
+
+Please note, it is also possible to implement an `Importer` class, which handles the logic surrounding how the entire file is imported. This is not usually needed though.
+
+
+### Create Import Model
+
+This model handles and stores the file, status, and results of the import for the user to see. By storing the file and results, we can process the import in the background when the file is too large to process real-time, and then email the user when the import is finished.
+
+Note: if you're not using Paperclip, you can modify `file` to be a string or some other data type that helps you find the file for the `read_file` method, which is really the only required field as it relates to the uploaded file.
+
+    $ rails g model Import status:string results:text type:string file:attachment should_replace:boolean
+    $ bundle exec rake db:migrate
+
+Change the Import class to look something like below:
+
+```ruby
+class Import < ActiveRecord::Base
+  include CSVImportable::Importable
+
+  def row_importer_class
+    # e.g. UserRowImporter (see next section)
+  end
+
+  def read_file
+    # needs to return StringIO of file
+    # for paperclip, use:
+    # Paperclip.io_adapters.for(file).read
+  end
+
+  def after_async_complete
+    # this is an optional hook for when an async import finishes
+    # e.g. SiteMailer.import_completed(import).deliver_later
+  end
+
+  def save_to_db
+    save
+  end
+
+  def big_file_threshold
+    # max number of rows before processing with a background job
+    # super returns the default of 10
+    super
+  end
+end
+```
+
+### Create RowImporter Class
+
+this class handles the logic surrounding how one row in the CSV should be added to the database. You need only (1) inherit from `CSVImportable::CSVImporter` and (2) implement the `import_row` method.
+
+```ruby
+class UserRowImporter < CSVImportable::CSVImporter
+  def import_row
+    user = User.new
+    user.email = pull_string('email', required: true)
+    user.first_name = pull_string('first_name', required: true)
+    user.last_name = pull_string('last_name', required: true)
+    user.birthdate = pull_date('birthdate') # format: YYYYMMDD    
+    user.salary = pull_float('salary')
+  end
+end
+```
+
+#### Parsers
+
+To assist you in getting data out of your CSV, we've implemented some basic parsers. These parsers will grab the raw data for the particular row/column and attempt to coerce it into the correct type (e.g. take string from CSV and convert to float).
+
+If the parser fails to coerce the data properly, it will add an error message to the array of errors that your user receives after the import runs. These errors help the user fix the import file in order to try again.
+
+- pull_string
+- pull_boolean
+- pull_date
+- pull_float
+- pull_integer
+- pull_select
+
+Basic syntax: `pull_string(column_key, args)` where `column_key` is the CSV header string for the column and `args` is a hash with the following defaults: `{ required: false }`
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/launchpadlab/csv_importable
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "csv_importable"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/csv_importable.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'csv_importable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "csv_importable"
+  spec.version       = CsvImportable::VERSION
+  spec.authors       = ["Ryan Francis"]
+  spec.email         = ["ryan@launchpadlab.com"]
+
+  spec.summary       = %q{Import CSV files from users}
+  spec.description   = %q{Equipped with intelligent parsing rules and excellent error handling, this gem is all you need for importing CSVs in Ruby.}
+  spec.homepage      = "https://github.com/LaunchPadLab/csv_importable"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "asyncable"
+end

data/lib/csv_importable.rb

@@ -0,0 +1,10 @@
+require "csv_importable/version"
+
+module CsvImportable
+end
+
+require_relative './csv_importable/type_parser'
+require_relative './csv_importable/csv_coercion'
+require_relative './csv_importable/row_importer'
+require_relative './csv_importable/csv_importer'
+require_relative './csv_importable/importable'

data/lib/csv_importable/csv_coercion.rb

@@ -0,0 +1,40 @@
+module CSVImportable
+  module CSVCoercion
+    def string_type_class
+      CSVImportable::TypeParser::StringTypeParser
+    end
+
+    def date_type_class
+      CSVImportable::TypeParser::DateTypeParser
+    end
+
+    def boolean_type_class
+      CSVImportable::TypeParser::BooleanTypeParser
+    end
+
+    def integer_type_class
+      CSVImportable::TypeParser::IntegerTypeParser
+    end
+
+    def float_type_class
+      CSVImportable::TypeParser::FloatTypeParser
+    end
+
+    def percent_type_class
+      CSVImportable::TypeParser::PercentTypeParser
+    end
+
+    def select_type_class
+      CSVImportable::TypeParser::SelectTypeParser
+    end
+
+    [:string, :date, :boolean, :integer, :float, :percent, :select].each do |parser_type|
+      define_method("pull_#{parser_type}") do |key, options={}|
+        csv_row = options.fetch(:row, @row)
+        options = options.merge(row: csv_row)
+        parser = send("#{parser_type}_type_class").new(key, options)
+        parser.parse
+      end
+    end
+  end
+end

data/lib/csv_importable/csv_importer.rb

@@ -0,0 +1,192 @@
+require 'csv'
+
+module CSVImportable
+  class CSVImporter
+    include CSVImportable::CSVCoercion
+    attr_reader :file_string, :should_replace, :out, :results,
+                :importable_class, :import_obj, :row_importer_class,
+                :big_file_threshold
+
+    module Statuses
+      SUCCESS = :success
+      ERROR = :error
+    end
+
+    def initialize(args = {})
+      @file_string = args[:file_string]
+      import_id = args[:import_id]
+      @importable_class = args[:importable_class]
+      @big_file_threshold = args[:big_file_threshold]
+      @import_obj = importable_class.find(import_id) if import_id
+      # because we can't pass file_string to delayed job
+      @file_string = @import_obj.read_file if @import_obj
+      @should_replace = args.fetch(:should_replace, false)
+      @row_importer_class = args[:row_importer_class]
+      after_init(args)
+      require_args
+    end
+
+    def out
+      @out ||= StringIO.new
+    end
+
+    def import
+      @results = guard_against_errors do
+        destroy_records if should_replace?
+        print(starting_message)
+        before_rows
+        @results = parse_csv_string(file_string) do |row, headers|
+          process_row(row, headers)
+        end
+        after_rows(@results.map { |result| result[:value] })
+        print(finished_message)
+        @results
+      end
+      @results
+    end
+
+    def big_file?
+      parse_csv_string(file_string).count > big_file_threshold
+    end
+
+    def succeeded?
+      results[:status] == Statuses::SUCCESS
+    end
+
+    def number_imported
+      results.fetch(:results).length
+    end
+
+    private
+
+      def after_init(args = {})
+        # hook for subclasses
+      end
+
+      def require_args
+        required_args.each do |required_arg|
+          fail "#{required_arg} is required for #{self.class.name}" unless send(required_arg)
+        end
+      end
+
+      def before_rows
+        # hook for subclasses
+      end
+
+      def after_rows(values)
+        # hook for subclasses
+      end
+
+      def required_args
+        [:file_string] + subclass_required_args
+      end
+
+      def subclass_required_args
+        # hook for subclasses
+        []
+      end
+
+      def should_replace?
+        @should_replace
+      end
+
+      def destroy_records
+        # hook for subclasses
+      end
+
+      def process_row(row, headers)
+        row_importer_class.new(row: row, headers: headers).import_row if row_importer_class
+      end
+
+      def starting_message
+        "Importing with #{self.class.name}...\n\n"
+      end
+
+      def finished_message
+        "Finished importing."
+      end
+
+      def print(message)
+        out.print message
+      end
+
+      def guard_against_errors(&block)
+
+        results = {}
+
+        begin
+          ActiveRecord::Base.transaction do
+            import_results = yield
+            status = import_results.any? { |result| result[:status] == Statuses::ERROR } ? Statuses::ERROR : Statuses::SUCCESS
+
+            results = {
+              status: status,
+              results: import_results
+            }
+
+            # need to rollback if errors
+            raise ActiveRecord::Rollback if status == Statuses::ERROR
+          end
+        rescue Exception => e
+          results = {
+            status: Statuses::ERROR,
+            error: e.message
+          }
+        end
+
+        print_results(results)
+
+        results
+      end
+
+      def print_results(results)
+        case results[:status]
+        when Statuses::SUCCESS
+          print("Imported completed successfully!".green)
+        when Statuses::ERROR
+          print("\nImported failed, all changes have been rolled back.\n\n".red)
+          if results[Statuses::ERROR]
+            print("  #{results[Statuses::ERROR]}\n\n".red)
+          else
+            results[:results].each { |result| print(" #{result}\n") }
+          end
+        end
+      end
+
+      def load_csv_from_file(str)
+        csv = CSV.parse(str, headers: true)
+        raise(IOError.new('There is no data to import')) if csv.length == 0
+        headers = csv.headers.compact
+        [csv, headers]
+      end
+
+      def parse_csv_string(csv_str, previous_results=[], &block)
+
+        csv, headers = load_csv_from_file(csv_str)
+
+        idx = 1
+        csv.each.map do |row|
+          errors = []
+          return_value = nil
+          begin
+            return_value = yield row, headers
+          rescue Exception => e
+            errors << e.message
+          end
+
+          result = previous_results.detect(lambda { {} }) { |result| result[:row] == idx+1 }
+
+          {
+            row:    idx += 1,
+            status: errors.any? ? Statuses::ERROR : result.fetch(:status, Statuses::SUCCESS),
+            errors: result.fetch(:errors, []) + errors,
+            value: return_value
+          }
+        end
+      end
+
+      def has_errors?
+        results.any? { |result| result[:status] == :error }
+      end
+  end
+end

data/lib/csv_importable/importable.rb

@@ -0,0 +1,148 @@
+require "asyncable"
+
+module CSVImportable
+  module Importable
+    # columns: results (text), file (attachment),
+    #          should_replace (boolean), type (string),
+    #          status (string)
+
+    include Asyncable
+    extend ActiveSupport::Concern
+
+    included do
+      serialize :results, Hash
+
+      has_attached_file :file
+      validates_attachment :file, content_type: { content_type: ['text/csv']} , message: "is not in CSV format"
+    end
+
+    DEFAULT_BIG_FILE_THRESHOLD = 10
+
+    # === PUBLIC INTERFACE METHODS ===
+    def read_file
+      # returns CSV StringIO data
+      # e.g. Paperclip.io_adapters.for(file).read
+      fail "read_file method is required by #{self.class.name}"
+    end
+
+
+    def save_to_db
+      return save if respond_to?(:save)
+      fail "please implement the save_to_db method on #{self.class.name}"
+    end
+    # === END INTERFACE METHODS ===
+
+    def import!
+      # start_async provided by Asyncable module
+      return start_async if run_async?
+      process_now
+    end
+
+    def run_async?
+      big_file?
+    end
+
+    def not_async?
+      !run_async?
+    end
+
+    def formatted_errors
+      @formatted_errors ||= (
+        errors = []
+        error_key = CSVImportable::CSVImporter::Statuses::ERROR
+        errors << results.fetch(error_key) if results.has_key?(error_key)
+        errors + results.fetch(:results, [])
+          .select { |result| result.fetch(:status) == error_key }
+          .map    { |error| "Line #{error.fetch(:row)}: #{error.fetch(:errors).join(', ')}" }
+      )
+    end
+
+    def display_status
+      case status
+      when Statuses::SUCCEEDED
+        'Import Succeeded'
+      when Statuses::FAILED
+        'Import Failed with Errors'
+      else
+        'Processing'
+      end
+    end
+
+    def number_of_records_imported
+      return 0 unless results && results.is_a?(Hash)
+      results[:results].try(:count) || 0
+    end
+
+    private
+
+      # === PRIVATE INTERFACE METHODS ===
+      def importer_class
+        # hook for subclasses
+        CSVImportable::CSVImporter
+      end
+
+      def row_importer_class
+        fail "row_importer_class class method is required by #{self.class.name}"
+      end
+
+      def importable_class
+        self.class
+      end
+
+      def importer_options
+        # hook for additional options
+        {}
+      end
+      # === END INTERFACE METHODS ===
+
+      def async_operation
+        run_importer
+      end
+
+      def process_now
+        run_importer
+        complete!
+      end
+
+      def async_complete!
+        # async_complete! is a hook from Asyncable module
+        complete!
+      end
+
+      def complete!
+        return success! if importer.succeeded?
+        failed!(results[:error])
+      end
+
+      def big_file?
+        importer.big_file?
+      end
+
+      def big_file_threshold
+        DEFAULT_BIG_FILE_THRESHOLD
+      end
+
+      def importer
+        return @importer if @importer
+
+        args = {
+          should_replace: should_replace?,
+          row_importer_class: row_importer_class,
+          big_file_threshold: big_file_threshold
+        }.merge(importer_options)
+
+        if new_record? && !processing? # e.g. new record that's not async
+          args = args.merge(file_string: read_file)
+        else
+          args = args.merge(import_id: id, importable_class: importable_class)
+        end
+
+        @importer ||= importer_class.new(args)
+      end
+
+      def run_importer
+        importer.import
+        self.results = importer.results
+      end
+  end
+end

data/lib/csv_importable/row_importer.rb

@@ -0,0 +1,22 @@
+module CSVImportable
+  class RowImporter
+    include CSVImportable::CSVCoercion
+    attr_reader :row, :headers
+
+    def initialize(args = {})
+      @row = args[:row]
+      @headers = args[:headers]
+      after_init(args)
+    end
+
+    def import_row
+      # hook for subclasses
+    end
+
+    private
+
+      def after_init(args)
+        # hook for subclasses
+      end
+  end
+end

data/lib/csv_importable/type_parser.rb

@@ -0,0 +1,77 @@
+module CSVImportable
+  class TypeParser
+    attr_reader :row, :key, :value, :required
+
+    def initialize(key, args = {})
+      @key = key
+      @row = args[:row]
+      @required = args.fetch(:required, false)
+      @value = args.fetch(:value, pull_value_from_row)
+      after_init(args)
+    end
+
+    def parse
+      if value.blank?
+        check_required
+        return nil
+      end
+      parsed_val = nil
+      begin
+        parsed_val = parse_val
+      rescue
+        raise_parsing_error
+      end
+      raise_parsing_error if parsed_val.nil?
+      parsed_val
+    end
+
+    private
+
+      def after_init(args)
+        # hook for subclasses
+      end
+
+      def pull_value_from_row
+        return nil unless row
+        # handle both caps and lowercase
+        row.field(key.upcase) || row.field(key.downcase)
+      end
+
+      def parse_val
+        # hook for subclasses
+        fail 'parse_val is a required method for subclass'
+      end
+
+      def raise_parsing_error
+        raise error_message
+      end
+
+      def error_message
+        fail 'error_message is a requird method for subclass'
+      end
+
+      def raise_required_error
+        raise required_error_message
+      end
+
+      def required_error_message
+        "#{key} is blank"
+      end
+
+      def required?
+        required
+      end
+
+      def check_required
+        return raise_required_error if required?
+      end
+  end
+end
+
+require_relative './type_parser/boolean_type_parser'
+require_relative './type_parser/date_type_parser'
+require_relative './type_parser/float_type_parser'
+require_relative './type_parser/integer_type_parser'
+require_relative './type_parser/percent_type_parser'
+require_relative './type_parser/select_type_parser'
+require_relative './type_parser/string_type_parser'

data/lib/csv_importable/type_parser/boolean_type_parser.rb

@@ -0,0 +1,13 @@
+module CSVImportable
+  class TypeParser::BooleanTypeParser < TypeParser
+    def parse_val
+      val = true if ["yes", "y", true, "true"].include?(value.downcase)
+      val = false if ["no", "n", false, "false"].include?(value.downcase)
+      val
+    end
+
+    def error_message
+      "Invalid boolean for column: #{key}"
+    end
+  end
+end

data/lib/csv_importable/type_parser/date_type_parser.rb

@@ -0,0 +1,23 @@
+module CSVImportable
+  class TypeParser::DateTypeParser < TypeParser
+    def parse_val
+      Date.new(year, month, day)
+    end
+
+    def year
+      value[0..3].try(:to_i)
+    end
+
+    def month
+      value[4..5].try(:to_i)
+    end
+
+    def day
+      value[6..7].try(:to_i)
+    end
+
+    def error_message
+      "Invalid date for column: #{key}"
+    end
+  end
+end

data/lib/csv_importable/type_parser/float_type_parser.rb

@@ -0,0 +1,11 @@
+module CSVImportable
+  class TypeParser::FloatTypeParser < TypeParser
+    def parse_val
+      Float(value)
+    end
+
+    def error_message
+      "Invalid decimal for column: #{key}"
+    end
+  end
+end

data/lib/csv_importable/type_parser/integer_type_parser.rb

@@ -0,0 +1,11 @@
+module CSVImportable
+  class TypeParser::IntegerTypeParser < TypeParser
+    def parse_val
+      Integer(value)
+    end
+
+    def error_message
+      "Invalid integer for column: #{key}"
+    end
+  end
+end

data/lib/csv_importable/type_parser/percent_type_parser.rb

@@ -0,0 +1,22 @@
+module CSVImportable
+  class TypeParser::PercentTypeParser < TypeParser
+    def parse_val
+      val = parse_percentage_sign if value.to_s.include?("%")
+      val = val.present? ? val : Float(value)
+      outside_range if val < 0 || val > 1
+      val
+    end
+
+    def error_message
+      "Invalid percent for column: #{key}. It should be a decimal between 0 and 1."
+    end
+
+    def outside_range
+      raise
+    end
+
+    def parse_percentage_sign
+      value.to_f / 100.0
+    end
+  end
+end

data/lib/csv_importable/type_parser/select_type_parser.rb

@@ -0,0 +1,19 @@
+module CSVImportable
+  class TypeParser::SelectTypeParser < TypeParser
+    attr_reader :options
+
+    def after_init(args = {})
+      @options = args.fetch(:options, [])
+    end
+
+    def parse_val
+      val = value.downcase
+      raise unless options.include?(val)
+      val
+    end
+
+    def error_message
+      "Invalid value for column: #{key}. Must be one of the following: #{options.join(', ')}"
+    end
+  end
+end

data/lib/csv_importable/type_parser/string_type_parser.rb

@@ -0,0 +1,11 @@
+module CSVImportable
+  class TypeParser::StringTypeParser < TypeParser
+    def parse_val
+      value
+    end
+
+    def error_message
+      "Invalid string for column: #{key}"
+    end
+  end
+end

data/lib/csv_importable/version.rb

@@ -0,0 +1,3 @@
+module CsvImportable
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: csv_importable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Francis
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: asyncable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Equipped with intelligent parsing rules and excellent error handling,
+  this gem is all you need for importing CSVs in Ruby.
+email:
+- ryan@launchpadlab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- csv_importable.gemspec
+- lib/csv_importable.rb
+- lib/csv_importable/csv_coercion.rb
+- lib/csv_importable/csv_importer.rb
+- lib/csv_importable/importable.rb
+- lib/csv_importable/row_importer.rb
+- lib/csv_importable/type_parser.rb
+- lib/csv_importable/type_parser/boolean_type_parser.rb
+- lib/csv_importable/type_parser/date_type_parser.rb
+- lib/csv_importable/type_parser/float_type_parser.rb
+- lib/csv_importable/type_parser/integer_type_parser.rb
+- lib/csv_importable/type_parser/percent_type_parser.rb
+- lib/csv_importable/type_parser/select_type_parser.rb
+- lib/csv_importable/type_parser/string_type_parser.rb
+- lib/csv_importable/version.rb
+homepage: https://github.com/LaunchPadLab/csv_importable
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Import CSV files from users
+test_files: []