spreadsheet_import 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be38eaab1623d6677bc61474eedea9151cda8847
+  data.tar.gz: 1d34a83a16f3d9cc1d666d107d90f558245f6347
+SHA512:
+  metadata.gz: bee3ede308bf899953dd622b06521a15fb52ce5ae3b0a0b537c5b9e9500264242a995501f233ba14ea27c470ff8ef34292536935ef4fcc76b1c7f37e89653699
+  data.tar.gz: 8613dc69e808d506f4a08c849283490cfa558afef73bed0ad368dc826dbd79a9aedb56a2e702aca4b26d2da0d21daad9b6c8dc3e25e4b07626396a826ef53850

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.11.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at rohan.pujari@kiprosh.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Rohan Pujari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,160 @@
+# SpreadsheetImport
+
+SpreadsheetImport gem allows importing data from csv, xls, xls, xlsx and ods file to database.
+SpreadsheetImport contains 3 part (Reader, Processor, Importer). Each part depends on seprate gems and you can replace any part without effecting other part.
+
+- Reader: Reads data from spreadsheet file. Following class are used for this functionality.
+   * SpreadsheetImport::BaseReader: Base class of every Reader class.
+   * SpreadsheetImport::SimpleReader: Inherits from base reader. Provides `each_row(required_columns)` method. This class depends on simple-spreadsheet gem https://github.com/zenkay/simple-spreadsheet.
+
+ - Processor: Processes the data read by Reader. SpreadsheetImport gem defines one processor
+    * SpreadsheetImport::BaseProcessor:  BaseProcessor contains various hooks to process and validate data provided by Reader.
+
+- Importer: Responsible for importing data recieved from data processor to database. SpreadsheetImport gem provides following importor.
+  * SpreadsheetImport::BaseImporter: Base class of all importer
+  * SpreadsheetImport::ActiveRecordImporter::BaseImporter: Supports import using activerecord. Depends on activerecord gem.
+  * SpreadsheetImport::ActiveRecordImporter::BulkImporter: Supports import using activerecord-import gem(https://github.com/zdennis/activerecord-import)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'spreadsheet_import'
+gem 'simple-spreadsheet'  # if want to use SpreadsheetImport::SimpleReader
+gem 'activerecord'        # if want to use any impoter in  SpreadsheetImport::ActiveRecordImporter
+gem 'activerecord-import' # if want to use SpreadsheetImport::ActiveRecordImporter::BulkImporter
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+```ruby
+  SpreadsheetImport.import(file_url, mapping, model, options)
+```
+- file_url: url of csv file
+- mapping: database column name to spreadsheet column number mapping hash.
+
+  Example:
+
+  {city: 1, tax_rate: 3}
+
+  city and tax_rate are column name in database. 1, 3 are column number in spreadsheet file.
+- model: model class for which spreadsheet needs to be imported
+- options: Hash of options
+  * reader: Custom reader class object
+  * data_processor: Custom data processor class object
+  * importer: Custom importer class object
+
+## Details
+- SpreadsheetImport::BaseReader:
+
+  Class inheriting from BaseReader should define `each_row(required_columns)` method. Method should accept column position as array and yield value of those columns as array for each spreadsheet row. It is upto you to implement this functionality anyway you want. BaseReader also accepts start_row(row from where reader should start reading) and end_row(row at which reader should end reading) as option while intiantiating reader. So you can also handle start_row and end_row option in `each_row` method.
+
+- SpreadsheetImport::SimpleReader:
+
+   If you want to use this reader add simple-spreadshee gem to your project. If you dont want to use simple spreadsheet gem or have any alternative gem to read spreadsheet file then you can create your own reader class by inheriting from BaseReader. You can call all simple-spreadsheet gem method on SimpleReader object.
+
+  Example:
+  ```ruby
+    reader = SimpleReader('file/abc.xls', start_row: 2, end_row: 30)
+    reader.cell(1, 2) # this is simple-spreadsheet gem method
+  ```
+
+  Note: SpreadsheetImport::SimpleReader includes Enumerable module. So you can use enumerable functions like each, select etc
+
+- Spreadsheetimport::BaseProcessor:
+
+  If you want to process data before importing it to db then create a new processor class which inherits from BaseProcessor.
+  BaseProcessor constructor accepts following parameters
+     1) reader: Reader class object
+     2) mapping: database column name to spreadsheet column number mapping hash
+     3) options: Following options are supported row_processor, row_validator and only_extract_valid_rows.
+        * row_processor:  Accepts a class which would be responsible for processing rows comming from `each_row` method of reader. Row Processor class should define `process` method. `process` method will called with unprocessed_row and current instance of data processor as arguments. unprocessed_row is in following format
+
+         ```ruby
+            {db_column_name1: value_from_spreadsheet, db_column_name1: value_from_spreadsheet}`.
+         ```
+
+          `process` method should return hash in below format.
+
+          ```ruby
+          {db_column_name1: processed_value, db_column_name1: processed_value}`
+         ```
+
+          There is alternative to process data other then providing row_processor option. You can inherit from BaseProcessor and add `process_row_before_import` method to your class. This method will recieve unprocessed_row and you should return processed row from it.
+        * row_validator: Accepts a class which is responsible for validating a processed row. Row validator class should define `validate` method. This method is called with processed row returned from `process` method of row processor or `process_row_before_import` method and current instance of data processor as second argument. `validate` method should return true or false.
+There is alternative to validate data other then providing row_validatir option. You can inherit from BaseProcessor and add `valid_row_for_import?` method to your class. This method will recieve processed_row and you should return return true or false.
+        * only_extract_valid_rows: If true `spreadsheet_rows` method will yield on rows that are valid otherwise it will yield each row. Row is valid or not is decided either by row_validator class `validate` method or by `valid_row_for_import?` method.
+
+   Example:
+
+   Consider below csv file
+   ```
+     city,county,tax rate,
+     Palm Desert,Some county, 0.2,
+     Marine Corps*,Some county 2,0.9,
+   ```
+
+   ```ruby
+    # Custome data processor
+     class TaxFileProcessor < SpreadsheetImport::BaseProcessor
+       def process_row_before_import(row)
+         city = row[:city]
+         if city.present?
+           city = city.gsub(/[^a-zA-Z0-9\s]/,'').strip # remove special character and remove spaces from start and end
+         end
+         { city: city, tax_rate: row[:tax_rate].to_f * 100 }
+       end
+
+       def valid_row_for_import?(row)
+         row[:city].present?
+       end
+    end
+
+    reader = SimpleReader('file/abc.csv, start_row: 2)
+    data_processor = TaxFileProcessor.new(reader, {city: 1, tax_rate: 3}, only_extract_valid_rows: true)
+    data_processor.spreadsheet_rows {|row| puts row}
+    # o/p
+    # { city: 'Palm Desert', tax_rate:  20.0 }
+    # { city: 'Marine Corps', tax_rate:  90.0 }
+   ```
+  Note: SpreadsheetImport::BaseProcessor includes Enumerable module. So you can use enumerable functions like each, select etc
+
+- SpreadsheetImport::BaseImporter: It does not implement any functionality. It just specifies some hooks that its subclass should implement. SpreadsheetImport::BaseImporter constructor accepts model and options as argument. It accepts only one option i.e data_processor object. It uses data processor `spreadsheet_rows` method which yields processed_row and valid(true or false) to call either handle_valid_row or handle_invalid_row method. By default handle_valid_row calls `create_or_update_record(row)` method. `handle_invalid_row` is blank and you can define it in you subclass if you want to handle_invalid_rows. This may be helpful in case you want to log invalid rows from csv somewhere.
+
+- SpreadsheetImport::ActiveRecordImporter::BaseImporter: Constructor accepts following arguments
+  * model: ActiveRecord model class to which we want to import data
+  * options
+     * data_processor: Data processor object
+     * skip_validations: Skips validation if true. false by default
+     * skip_callbacks: Skips callback if true. false by default
+     * unique_by_attributes: accepts list of attribute which should be unique. If its not unique then new record won't be inserted. Decision to whether update existing record is made by update_existing_record option. For finding already existing record where query is fired which does case sensitive comparision between attribute from spreedsheet and db. If you want to add some custom implementation then create your own importer which inherits from SpreadsheetImport::ActiveRecordImporter::BaseImporter and define `find_duplicate_for_unique_by_attributes(data)` method. find_duplicate_for_unique_by_attributes will be called with data(processed_row). It should return ActiveRecord::Relation object or model object or array of model object. Currently it has following implementation `scoped_model.where(data.slice(*unique_by_attributes))`.
+
+       Note: Always use `scoped_model` method to call any ActiveRecord method
+     * update_existing_record: If true will update the existing record. true by default if unique_by_attributes is present.
+     * scoped_unique: class method or scope name as symbol. This scope is applied for finding record which are already present in database.
+
+  It defines `create_or_update_record` method called by `handle_valid_row`.
+
+- SpreadsheetImport::ActiveRecordImporter::BulkImporter: This importer utilizes activerecord-import gem. Its faster than SpreadsheetImport::ActiveRecordImporter::BaseImporter. It is recomended for large spreedsheet files. ActiveRecord callbacks will not be called when BulkImporter is used. It inherits from SpreadsheetImport::ActiveRecordImporter::BaseImporter, so its constructor supports same argument. Passing skip_callbacks as true or false doesn't have any effect and callbacks will always be skipped. This is a penalty that you have to pay for performance :). It also support addition option of batch_size. It is the number of records that would be inserted at once.
+Default batch size is 100.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/spreadsheet_import. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

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 "spreadsheet_import"
+
+# 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/lib/spreadsheet_import.rb

@@ -0,0 +1,20 @@
+require 'spreadsheet_import/version'
+
+module SpreadsheetImport
+  autoload :BaseProcessor, 'spreadsheet_import/data_processor/base_processor'
+  autoload :BaseReader, 'spreadsheet_import/reader/base_reader'
+  autoload :SimpleReader, 'spreadsheet_import/reader/simple_reader'
+  autoload :BaseImporter, 'spreadsheet_import/importer/base_importer'
+
+  module ActiveRecordImporter
+    autoload :BaseImporter, 'spreadsheet_import/importer/active_record_importer/base_importer'
+    autoload :BulkImporter, 'spreadsheet_import/importer/active_record_importer/bulk_importer'
+  end
+
+  def self.import(file_url, mapping, model, options = {})
+    reader = options[:reader] || SimpleReader.new(file_url, start_row: 2)
+    data_processor = options[:data_processor] || BaseProcessor.new(reader, mapping)
+    (options[:importer] || ActiveRecordImporter::BaseImporter)
+      .new(model, data_processor).import
+  end
+end

data/lib/spreadsheet_import/data_processor/base_processor.rb

@@ -0,0 +1,64 @@
+module SpreadsheetImport
+  class BaseProcessor
+    include Enumerable
+
+    attr_reader :reader, :mapping, :row_processor, :row_validator,
+      :only_extract_valid_rows
+
+    def initialize(reader, mapping, options = {})
+      @reader = reader
+      @mapping = mapping
+      @row_processor = options[:row_processor]
+      @row_validator = options[:row_validator]
+      @only_extract_valid_rows = options[:only_extract_valid_rows]
+    end
+
+    def spreadsheet_rows
+      reader.each_row(mapping.values) do |row|
+        processed_row = process_row(row)
+        valid_row = valid_row?(processed_row)
+        if only_extract_valid_rows
+          valid_row && yield(processed_row, true)
+        else
+          yield(processed_row, valid_row)
+        end
+      end
+    end
+    alias_method :each, :spreadsheet_rows
+
+    protected
+
+    def unprocessed_row(row)
+      {}.tap do |attributes|
+        mapping.keys.each_with_index do |column_name, index|
+          attributes[column_name] = row[index]
+        end
+      end
+    end
+
+    def process_row(row)
+      unprocessed_row = unprocessed_row(row)
+      if row_processor
+        row_processor.process(unprocessed_row, self)
+      else
+        process_row_before_import(unprocessed_row)
+      end
+    end
+
+    def valid_row?(row)
+      if row_validator
+        row_validator.validate(row, self)
+      else
+        valid_row_for_import?(row)
+      end
+    end
+
+    def process_row_before_import(row)
+      row
+    end
+
+    def valid_row_for_import?(_row)
+      true
+    end
+  end
+end

data/lib/spreadsheet_import/hash_extension.rb

@@ -0,0 +1,9 @@
+class Hash
+  unless instance_methods.find { |m| m == :slice }
+    def slice(*keys)
+      keys.each_with_object({}) do |k, hash|
+        hash[k] = self[k] if has_key?(k)
+      end
+    end
+  end
+end

data/lib/spreadsheet_import/importer/active_record_importer/base_importer.rb

@@ -0,0 +1,91 @@
+module SpreadsheetImport
+  module ActiveRecordImporter
+    class BaseImporter < SpreadsheetImport::BaseImporter
+      CALLBACKS_TO_SKIP = [:validation, :save, :create, :update, :commit]
+
+      attr_reader :skip_validations, :skip_callbacks, :unique_by_attributes,
+        :update_existing_record, :scoped_unique
+
+      def initialize(model, data_processor, options ={})
+        super
+        @unique_by_attributes = options[:unique_by_attributes]
+        @update_existing_record = if options[:update_existing_record].nil?
+          !unique_by_attributes.nil?
+        else
+          options[:update_existing_record]
+        end
+        @scoped_unique = options[:scoped_unique]
+        @skip_validations = options[:skip_validations]
+        @skip_callbacks = options[:skip_callbacks]
+      end
+
+      def find_duplicate_for_unique_by_attributes(data)
+        scoped_model.where(data.slice(*unique_by_attributes))
+      end
+
+      def create_or_update_record(data)
+        if unique_by_attributes
+          if update_existing_record
+            duplicate_records = find_duplicate_for_unique_by_attributes(data)
+            duplicate_records.present? ? update_record(duplicate_records, data) : create_record(data)
+          end
+        else
+          create_record(data)
+        end
+      end
+
+      def create_record(data)
+        record = anoymous_model.new(data)
+        unless record.save
+          handle_validation_failure(record, data)
+        end
+        record
+      end
+
+      def update_record(records, data)
+        update_only_if_data_changed(records, data)
+      end
+
+      def update_only_if_data_changed(records, data)
+        records = [records] if records.is_a?(ActiveRecord::Base)
+        records.each do |record|
+          if data.any? { |name, value| record.read_attribute(name) != value }
+            record.update_attributes(data)
+          end
+        end
+      end
+
+      protected
+
+      def handle_validation_failure(record, data); end
+
+      def scoped_model
+        scoped_unique ? anoymous_model.send(scoped_unique) : anoymous_model
+      end
+
+      def anoymous_model
+        @anoymous_model ||= if skip_validations && skip_callbacks
+          table_name = model.table_name
+          Class.new(ActiveRecord::Base) { self.table_name = table_name }
+        elsif skip_validations
+          Class.new(model) do
+            def self.name
+              "#{superclass.name}NoValidation"
+            end
+            reset_callbacks :validate
+            reset_callbacks :validation
+          end
+        elsif skip_callbacks
+          Class.new(model) do
+            def self.name
+              "#{superclass.name}NoCallback"
+            end
+            CALLBACKS_TO_SKIP.each { |name| reset_callbacks(name) }
+          end
+        else
+          model
+        end
+      end
+    end
+  end
+end

data/lib/spreadsheet_import/importer/active_record_importer/bulk_importer.rb

@@ -0,0 +1,41 @@
+require 'activerecord-import'
+
+module SpreadsheetImport
+  module ActiveRecordImporter
+    class BulkImporter < BaseImporter
+      attr_reader :batch_size
+
+      def initialize(model, data_processor, options = {})
+        super(model, data_processor, options.merge!(skip_callbacks: true))
+        @batch_size = options[:batch_size] || 100
+        @batch = []
+      end
+
+      def import
+        super
+        !@batch.length.zero? && execute_batch
+      end
+
+      def create_record(data)
+        if unique_by_attributes.nil? || unique_in_batch?(data)
+          @batch << data
+          batch_size == @batch.length && execute_batch
+        end
+      end
+
+      def unique_in_batch?(data)
+        @batch.find do |batch_record|
+          unique_by_attributes.all? do |attr_name|
+            data[attr_name] == batch_record[attr_name]
+          end
+        end.nil?
+      end
+
+      def execute_batch
+        model.import(data_processor.mapping.keys,
+          @batch.map(&:values), validate: !skip_validations)
+        @batch = []
+      end
+    end
+  end
+end

data/lib/spreadsheet_import/importer/base_importer.rb

@@ -0,0 +1,28 @@
+module SpreadsheetImport
+  class BaseImporter
+    attr_reader :model, :data_processor
+
+    def initialize(model, data_processor, options = {})
+      @model = model
+      @data_processor = data_processor
+    end
+
+    def import
+      data_processor.spreadsheet_rows do |row, valid|
+        if valid
+          handle_valid_row(row)
+        else
+          handle_invalid_row(row)
+        end
+      end
+    end
+
+    protected
+
+    def handle_valid_row(row)
+      create_or_update_record(row)
+    end
+
+    def handle_invalid_row(row); end
+  end
+end

data/lib/spreadsheet_import/reader/base_reader.rb

@@ -0,0 +1,14 @@
+module SpreadsheetImport
+  class BaseReader
+    attr_reader :file_url, :spreadsheet, :start_row, :end_row
+
+    def initialize(file_url, options = {})
+      @file_url = file_url
+      @start_row = options[:start_row] || 1
+    end
+
+    def each_row(_)
+      raise 'each_row method must be implemented by SpreadsheetLoader::Reader subclass'
+    end
+  end
+end

data/lib/spreadsheet_import/reader/simple_reader.rb

@@ -0,0 +1,44 @@
+require 'simple-spreadsheet'
+
+module SpreadsheetImport
+  class SimpleReader < BaseReader
+    include Enumerable
+
+    def initialize(file_url, options = {})
+      super
+      @spreadsheet = SimpleSpreadsheet::Workbook.read(file_url)
+      @end_row = options[:end_row] || spreadsheet.last_row
+    end
+
+    def row_range
+      (start_row..end_row)
+    end
+
+    def default_required_columns
+      spreadsheet.first_column.upto(spreadsheet.last_column)
+    end
+
+    def each_row(required_columns = default_required_columns)
+      row_range.each do |row|
+        entire_row = required_columns.each_with_object([]) do |col, acc|
+          acc << spreadsheet.cell(row, col)
+        end
+        yield entire_row
+      end
+    end
+    alias_method :each, :each_row
+
+    # delegate all methods to SimpleSpreadsheet gem
+    def method_missing(method, *args)
+      if spreadsheet.respond_to?(method)
+        spreadsheet.public_send(method, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      spreadsheet.respond_to?(method_name, include_private) || super
+    end
+  end
+end

data/lib/spreadsheet_import/version.rb

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

data/spreadsheet_import.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spreadsheet_import/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "spreadsheet_import"
+  spec.version       = SpreadsheetImport::VERSION
+  spec.authors       = ["Rohan Pujari"]
+  spec.email         = ["rohanpujaris@gmail.com"]
+  spec.summary       = %q{
+                          Import csv, xls, xls, xlsx and ods file directly to database.
+                          Supports bulk update via activerecord-import gem
+                        }
+  spec.description   = %q{
+                          Import spreadsheet directly to database.
+                          Supports simple import as well as bulk import.
+                          Bulk import used activerecord-import gem.
+                          Options to unique record import, updating of duplicate record,
+                          skipping_callback and skipping validation.
+                        }
+  spec.homepage      = "https://github.com/rohanpujaris/spreadsheet_import"
+  spec.license       = "MIT"
+  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"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "simple-spreadsheet", ">= 0.1"
+  spec.add_development_dependency "activerecord-import", ">= 0.2.3"
+  spec.add_development_dependency "sqlite3"
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: spreadsheet_import
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rohan Pujari
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '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: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simple-spreadsheet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord-import
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n                          Import spreadsheet directly to database.\n
+  \                         Supports simple import as well as bulk import.\n                          Bulk
+  import used activerecord-import gem.\n                          Options to unique
+  record import, updating of duplicate record,\n                          skipping_callback
+  and skipping validation.\n                        "
+email:
+- rohanpujaris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/spreadsheet_import.rb
+- lib/spreadsheet_import/data_processor/base_processor.rb
+- lib/spreadsheet_import/hash_extension.rb
+- lib/spreadsheet_import/importer/active_record_importer/base_importer.rb
+- lib/spreadsheet_import/importer/active_record_importer/bulk_importer.rb
+- lib/spreadsheet_import/importer/base_importer.rb
+- lib/spreadsheet_import/reader/base_reader.rb
+- lib/spreadsheet_import/reader/simple_reader.rb
+- lib/spreadsheet_import/version.rb
+- spreadsheet_import.gemspec
+homepage: https://github.com/rohanpujaris/spreadsheet_import
+licenses:
+- MIT
+metadata: {}
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Import csv, xls, xls, xlsx and ods file directly to database. Supports bulk
+  update via activerecord-import gem
+test_files: []