act_as_importable 0.0.7 → 0.0.8

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## 0.0.8 (April 7, 2013)
+
+- substantial refactoring
+- moved import functionality into its own class (Importer)
+- changed the return type of the import methods to be an instance of the Importer class

data/README.md

@@ -28,6 +28,8 @@ User.import_csv_file('/path/to/file.csv')
 User.import_csv_text(csv_text)
 # or
 User.import_data(array_of_hashes)
+# or
+User.import_record(hash)
 ```
 
 ## CSV File Format

data/lib/act_as_importable/base.rb

@@ -1,106 +1,45 @@
 require 'active_support'
-require 'csv'
+require 'act_as_importable/importer'
+require 'act_as_importable/csv_importer'
 
 module ActAsImportable
   module Base
     extend ActiveSupport::Concern
 
+    included do
+
+      # This is used to store the data being import when there is an error
+      attr_accessor :import_data
+
+    end
+
     module ClassMethods
 
       def import_csv_file(file, options = {})
-        import_csv_text(read_file(file, options), options)
+        options.reverse_merge!(@default_import_options)
+        importer = ActAsImportable::CSVImporter.new(options)
+        importer.import_csv_file(file)
+        importer
       end
 
       def import_csv_text(text, options = {})
-        csv = ::CSV.parse(text, :headers => true)
-        csv.map do |row|
-          import_record(row.to_hash, options)
-        end
+        options.reverse_merge!(@default_import_options)
+        importer = ActAsImportable::CSVImporter.new(options)
+        importer.import_csv_text(text)
+        importer
       end
 
       def import_data(data, options = {})
-        data.map do |row|
-          import_record(row, options)
-        end
+        options.reverse_merge!(@default_import_options)
+        importer = ActAsImportable::Importer.new(options)
+        importer.import_data(data)
+        importer
       end
 
-      # Creates or updates a model record
-      # Existing records are found by the column(s) specified by the :uid option (default 'id').
-      # If the values for the uid columns are not provided the row will be ignored.
-      # If uid is set to nil it will import the row data as a new record.
       def import_record(row, options = {})
         options.reverse_merge!(@default_import_options)
-        row = row.with_indifferent_access
-        row.reverse_merge!(options[:default_values]) if options[:default_values]
-        convert_key_paths_to_values!(row)
-        row = filter_columns(row, options)
-        record = find_or_create_by_uids(uid_values(row, options))
-        remove_uid_values_from_row(row, options)
-        record.update_attributes(row)
-        unless record.save
-          Rails.logger.error(record.errors.full_messages)
-        end
-        record
-      end
-
-      def filter_columns(row, options = {})
-        except = Array(options[:except]).map { |i| i.to_s }
-        only = Array(options[:only]).map { |i| i.to_s }
-        row = row.reject { |key, value| except.include? key.to_s } if except.present?
-        row = row.select { |key, value| only.include? key.to_s } if only.present?
-        row
-      end
-
-      def uid_values(row, options)
-        Hash[Array(options[:uid]).map { |k| [k, row[k.to_sym]] }]
-      end
-
-      def remove_uid_values_from_row(row, options = {})
-        Array(options[:uid]).each do |field|
-          row.delete(field)
-        end
-      end
-
-      def find_association_value_with_attribute(name, attribute)
-        association = self.reflect_on_association(name.to_sym)
-        association.klass.where(attribute).first
-      end
-
-      def find_or_create_by_uids(attributes, &block)
-        find_by_uids(attributes) || create(attributes, &block)
-      end
-
-      def find_by_uids(attributes)
-        attributes.inject(self.scoped.readonly(false)) { |scope, key_value|
-          add_scope_for_field(scope, key_value[0].to_s, key_value[1])
-        }.first
-      end
-
-      def add_scope_for_field(scope, field, value)
-        return scope unless value
-        if (association = self.reflect_on_association(field.to_sym))
-          field = association.foreign_key
-          value = value.id
-        end
-        scope.where("#{self.table_name}.#{field} = ?", value)
-      end
-
-      # TODO: update this to support finding the association value with multiple columns
-      def convert_key_paths_to_values!(row)
-        key_path_attributes = row.select { |k,v| k.to_s.include? '.' }
-        key_path_attributes.each do |key, value|
-          association_name, uid_field = key.to_s.split('.')
-          row[association_name.to_sym] = find_association_value_with_attribute(association_name, uid_field => value)
-          row.delete(key.to_sym)
-        end
-      end
-
-      def read_file(file, options = {})
-        if options[:encoding]
-          File.read(file, :encoding => options[:encoding])
-        else
-          File.read(file)
-        end
+        importer = ActAsImportable::Importer.new(options)
+        importer.import_record(row)
       end
 
     end

data/lib/act_as_importable/config.rb

@@ -10,6 +10,7 @@ module ActAsImportable::Config
 
       @default_import_options = options
       @default_import_options[:uid] ||= :id
+      @default_import_options[:model_class] ||= self
 
       # create a reader on the class to access the field name
       class << self;

data/lib/act_as_importable/csv_importer.rb

@@ -0,0 +1,18 @@
+require 'csv'
+
+module ActAsImportable
+  class CSVImporter < ActAsImportable::Importer
+
+    def import_csv_file(file)
+      import_csv_text(File.read(file, options))
+    end
+
+    def import_csv_text(text)
+      csv = ::CSV.parse(text, :headers => options[:headers] || true)
+      csv.each do |row|
+        import_record(row.to_hash)
+      end
+    end
+
+  end
+end

data/lib/act_as_importable/importer.rb

@@ -0,0 +1,150 @@
+module ActAsImportable
+  class Importer
+
+    def initialize(options = {})
+      @default_options = options
+      @imported_records = []
+      @errors = []
+    end
+
+    def options
+      @default_options
+    end
+
+    def import_data(data)
+      data.map do |row|
+        import_record(row)
+      end
+    end
+
+    def import_record(row)
+      row = prepare_row_for_import(row)
+      record = find_or_create_record(row)
+      record.update_attributes(row)
+      record.save
+      imported_records << record
+      record
+    rescue Exception => e
+      record = model_class.new
+      # Assign the valid attributes (without saving)
+      record.assign_attributes(row.select { |k,v| record.attributes.keys.include? k })
+      record.errors.add :base, e.message
+      record.import_data = row if record.respond_to? :import_data=
+      imported_records << record
+      record
+    end
+
+    def missing_uid_values(row)
+      uid_values(row).select { |k, v| v.blank? }
+    end
+
+    def imported_records
+      @imported_records ||= []
+    end
+
+    def successful_imports
+      # Note: We don't want to re-validate the objects.
+      imported_records.select { |r| r.errors.empty? }
+    end
+
+    def failed_imports
+      # Note: We don't want to re-validate the objects.
+      imported_records.reject { |r| r.errors.empty? }
+    end
+
+    def model_class
+      options[:model_class]
+    end
+
+    def filter_columns(row)
+      except = Array(options[:except]).map { |i| i.to_s }
+      only = Array(options[:only]).map { |i| i.to_s }
+      row.reject! { |key, value| except.include? key.to_s } if except.present?
+      row.select! { |key, value| only.include? key.to_s } if only.present?
+      row
+    end
+
+    private
+
+    def prepare_row_for_import(row)
+      row = row.with_indifferent_access
+      add_default_values_to_row(row)
+      convert_key_paths_to_values(row)
+      filter_columns(row)
+      row
+    end
+
+    def add_default_values_to_row(row)
+      row.reverse_merge!(options[:default_values]) if options[:default_values]
+    end
+
+    def uid_keys
+      Array(options[:uid])
+    end
+
+    def uid_values(row)
+      uid_keys.each_with_object({}) do |key, result|
+        result[key] = row[key.to_sym]
+      end
+    end
+
+    def remove_uid_values_from_row(row, options = {})
+      Array(options[:uid]).each do |field|
+        row.delete(field)
+      end
+    end
+
+    def find_association_value_with_attribute(name, attribute)
+      association = model_class.reflect_on_association(name.to_sym)
+      association.klass.where(attribute).first
+    end
+
+    def find_or_create_record(row)
+      if missing_uid_values(row).present?
+        raise "Missing the following uids attributes. #{missing_uid_values(row).keys}"
+      end
+
+      record = find_or_create_by_uids(uid_values(row))
+      remove_uid_values_from_row(row)
+      record
+    end
+
+    def find_or_create_by_uids(attributes, &block)
+      find_by_uids(attributes) || model_class.create(attributes, &block)
+    end
+
+    def find_by_uids(attributes)
+      results = attributes.inject(model_class.scoped.readonly(false)) { |scope, key_value|
+        add_scope_for_field(scope, key_value[0].to_s, key_value[1])
+      }
+      if results.count > 1
+        raise "Multiple records found with uid attributes. Attributes: #{attributes}"
+      end
+      results.first
+    end
+
+    def add_scope_for_field(scope, field, value)
+      return scope unless value
+      if (association = model_class.reflect_on_association(field.to_sym))
+        field = association.foreign_key
+        value = value.id
+      end
+      scope.where("#{model_class.table_name}.#{field} = ?", value)
+    end
+
+    # TODO: update this to support finding the association value with multiple columns
+    def convert_key_paths_to_values(row)
+      key_path_attributes = row.select { |k, v| k.to_s.include? '.' }
+      key_path_attributes.each do |key, value|
+        association_name, uid_field = key.to_s.split('.')
+        association_value = find_association_value_with_attribute(association_name, uid_field => value)
+        if association_value.blank?
+          raise "Failed to find #{association_name} with #{uid_field} = #{value}"
+        end
+        row[association_name.to_sym] = association_value
+        row.delete(key.to_sym)
+      end
+    end
+
+  end
+end

data/lib/act_as_importable/version.rb

@@ -1,3 +1,3 @@
 module ActAsImportable
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/spec/act_as_importable/act_as_importable_spec.rb

@@ -1,31 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-# create the tables for the tests
-ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'categories'")
-ActiveRecord::Base.connection.create_table(:categories) do |t|
-  t.string :name
-end
-
-class Category < ActiveRecord::Base
-  has_many :items
-end
-
-ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'items'")
-ActiveRecord::Base.connection.create_table(:items) do |t|
-  t.integer :category_id
-  t.string :name
-  t.float :price
-end
-
-class Item < ActiveRecord::Base
-  # This line isn't needed in a real Rails app.
-  include ActAsImportable::Config
-
-  act_as_importable :uid => 'name'
-
-  belongs_to :category
-end
-
 describe "an act_as_importable model" do
 
   before(:each) do
@@ -45,7 +19,7 @@ describe "an act_as_importable model" do
   it { should respond_to :import_record }
   it { should respond_to :default_import_options }
 
-  let(:default_options) { {:uid => 'name'} }
+  let(:default_options) { {:uid => 'name', :model_class => Item} }
 
   it "should have the correct default import options" do
     Item.default_import_options.should == default_options
@@ -54,11 +28,11 @@ describe "an act_as_importable model" do
   describe "import csv file" do
     let(:file) { 'spec/fixtures/items.csv' }
     it 'should call import_text with contents of file' do
-      Item.should_receive(:import_csv_text).with(File.read(file), {})
+      ActAsImportable::CSVImporter.any_instance.should_receive(:import_csv_text).with(File.read(file))
       Item.import_csv_file(file)
     end
-    it "should return an array of imported records" do
-      Item.import_csv_file(file).should == Item.all.to_a
+    it "should return an importer instance" do
+      Item.import_csv_file(file).should be_a ActAsImportable::Importer
     end
   end
 
@@ -66,13 +40,23 @@ describe "an act_as_importable model" do
     let(:text) { "name,price\nBeer,2.5\nApple,0.5" }
 
     it 'should call import_record with row hashes' do
-      Item.should_receive(:import_record).with({'name' => 'Beer', 'price' => '2.5'}, {}).once
-      Item.should_receive(:import_record).with({'name' => 'Apple', 'price' => '0.5'}, {}).once
+      ActAsImportable::CSVImporter.any_instance.should_receive(:import_record).with({'name' => 'Beer', 'price' => '2.5'}).once
+      ActAsImportable::CSVImporter.any_instance.should_receive(:import_record).with({'name' => 'Apple', 'price' => '0.5'}).once
       Item.import_csv_text(text)
     end
 
-    it "should return an array of imported records" do
-      Item.import_csv_text(text).should == Item.all.to_a
+    it "should return an importer instance" do
+      Item.import_csv_text(text).should be_a ActAsImportable::Importer
+    end
+
+    it "should import 2 records successfully" do
+      result = Item.import_csv_text(text)
+      result.successful_imports.count.should == 2
+    end
+
+    it "should have no errors" do
+      result = Item.import_csv_text(text)
+      result.failed_imports.count.should == 0
     end
   end
 
@@ -82,13 +66,23 @@ describe "an act_as_importable model" do
     let(:data) { [beer, apple] }
 
     it 'should call import_record with row hashes' do
-      Item.should_receive(:import_record).with(beer, {}).once
-      Item.should_receive(:import_record).with(apple, {}).once
+      ActAsImportable::Importer.any_instance.should_receive(:import_record).with(beer).once
+      ActAsImportable::Importer.any_instance.should_receive(:import_record).with(apple).once
       Item.import_data(data)
     end
 
-    it "should return an array of imported records" do
-      Item.import_data(data).should == Item.all.to_a
+    it "should return an importer instance" do
+      Item.import_data(data).should be_a ActAsImportable::Importer
+    end
+
+    it "should import 2 records successfully" do
+      result = Item.import_data(data)
+      result.successful_imports.count.should == 2
+    end
+
+    it "should have no errors" do
+      result = Item.import_data(data)
+      result.failed_imports.count.should == 0
     end
   end
 
@@ -113,7 +107,7 @@ describe "an act_as_importable model" do
           Item.import_record(row, :uid => :name)
           @existing_item.reload.price.should == 2.5
         end
-        it "should not create a new item" do
+        it "should not create a new record" do
           expect { Item.import_record(row, :uid => 'name') }.to change { Item.count }.by(0)
         end
       end
@@ -208,26 +202,5 @@ describe "an act_as_importable model" do
 
   end
 
-  describe "#filter_columns" do
-    let(:row) { {:name => 'Beer', :price => 2.5}.with_indifferent_access }
-
-    it 'should filter columns when importing each record' do
-      Item.should_receive(:filter_columns).with(row, default_options).and_return(row)
-      Item.import_record(row)
-    end
-
-    it "should not modify row if no options provided" do
-      Item.filter_columns(row).should == row
-    end
-
-    it "should remove columns specified by the :except option" do
-      Item.filter_columns(row, :except => :price).should == {'name' => 'Beer'}
-    end
-
-    it "should remove columns not specified by the :only option" do
-      Item.filter_columns(row, :only => :price).should == {'price' => 2.5}
-    end
-  end
-
 end
 

data/spec/act_as_importable/importer_spec.rb

@@ -0,0 +1,38 @@
+describe ActAsImportable::Importer do
+
+  before(:each) do
+    ActiveRecord::Base.connection.increment_open_transactions
+    ActiveRecord::Base.connection.begin_db_transaction
+  end
+
+  after(:each) do
+    ActiveRecord::Base.connection.rollback_db_transaction
+    ActiveRecord::Base.connection.decrement_open_transactions
+  end
+
+  describe "#filter_columns" do
+    let(:row) { {:name => 'Beer', :price => 2.5}.with_indifferent_access }
+
+    it 'should filter columns when importing each record' do
+      importer = ActAsImportable::Importer.new(:uid => :name, :model_class => Item)
+      importer.should_receive(:filter_columns).with(row).and_return(row)
+      importer.import_record(row)
+    end
+
+    it "should not modify row if no options provided" do
+      importer = ActAsImportable::Importer.new
+      importer.filter_columns(row).should == row
+    end
+
+    it "should remove columns specified by the :except option" do
+      importer = ActAsImportable::Importer.new(:except => :price)
+      importer.filter_columns(row).should == {'name' => 'Beer'}
+    end
+
+    it "should remove columns not specified by the :only option" do
+      importer = ActAsImportable::Importer.new(:only => :price)
+      importer.filter_columns(row).should == {'price' => 2.5}
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -18,4 +18,30 @@ ActiveRecord::Base.establish_connection(
 )
 
 RSpec.configure do |config|
+end
+
+# create the tables for the tests
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'categories'")
+ActiveRecord::Base.connection.create_table(:categories) do |t|
+  t.string :name
+end
+
+class Category < ActiveRecord::Base
+  has_many :items
+end
+
+ActiveRecord::Base.connection.execute("DROP TABLE IF EXISTS 'items'")
+ActiveRecord::Base.connection.create_table(:items) do |t|
+  t.integer :category_id
+  t.string :name
+  t.float :price
+end
+
+class Item < ActiveRecord::Base
+  # This line isn't needed in a real Rails app.
+  include ActAsImportable::Config
+
+  act_as_importable :uid => 'name'
+
+  belongs_to :category
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: act_as_importable
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-23 00:00:00.000000000 Z
+date: 2013-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -84,6 +84,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rvmrc
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -93,9 +94,12 @@ files:
 - lib/act_as_importable.rb
 - lib/act_as_importable/base.rb
 - lib/act_as_importable/config.rb
+- lib/act_as_importable/csv_importer.rb
+- lib/act_as_importable/importer.rb
 - lib/act_as_importable/railtie.rb
 - lib/act_as_importable/version.rb
 - spec/act_as_importable/act_as_importable_spec.rb
+- spec/act_as_importable/importer_spec.rb
 - spec/fixtures/items.csv
 - spec/spec_helper.rb
 homepage: https://github.com/Col/act_as_importable
@@ -124,5 +128,6 @@ specification_version: 3
 summary: Helps import records from CSV files.
 test_files:
 - spec/act_as_importable/act_as_importable_spec.rb
+- spec/act_as_importable/importer_spec.rb
 - spec/fixtures/items.csv
 - spec/spec_helper.rb