active_record_importer 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79df869df341582d9485f48a0798f878ab6047ef
-  data.tar.gz: 9dd7ced4d90dda9744410144012ece81b8ee4f01
+  metadata.gz: 0b0c2019e863558605d2703fb80890c8ba209192
+  data.tar.gz: 480be20d7fc0440427e4107f7b50e7e19572ad81
 SHA512:
-  metadata.gz: ef41b94191496fd7b9dc37366f87a42ef9f8646a4724d1ce53fa996b11c1337753bad72059152816936961863061c340b05bf114c7e78e97064fd88cbae1c652
-  data.tar.gz: dd3ffa7d4bedc5b2bcd4b1f33659f07ae9d560b6bf2835b1e9d7e3377943770f24cc5c56490ac804bcb7991f98789fef0c30983da67b03f363f30206aecf7793
+  metadata.gz: f9191b603ceb3e77bff828ac70ad0a9301b854a1956cc1ef218e00177c2f8d5b20b0722e98bcc99cb9f99663126e29e53d3b57eebe60d14c88eb248008092441
+  data.tar.gz: 4be44dcf15fcd9a9981ff0942c63a1a1e6d21691cf27832cb3d3755a78636f4fe79193fbe26eb5bb4ccc437cbd0e6c0ab5583d73e37f25e67e78b1a8d7d53265

data/README.md

@@ -25,8 +25,32 @@ Or install it yourself as:
     $ gem install active_record_importer
 
 ## Usage
+### For version 0.3.0
 
-Simple usage for now:
+For the newest version (0.3.0), you don't have to create Import table/model and controller.
+You just need to add the `acts_as_importable` in your model you want to be importable, and you may now run:
+
+```ruby
+User.import!(file: File.open(PATH_TO_FILE))
+```
+
+`insert` will be the default insert method for this
+If you want to use `upsert` or `error_duplicate`, define it in your importer options:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_importable insert_method: 'upsert',
+                     find_options: [:email]
+end
+```
+
+Or you may use in your console:
+
+```ruby
+User.acts_as_importable insert_method: 'error_duplicate', find_options: ['email']
+```
+
+### If you don't want to record the status of your import, you don't have to do the remaining steps
 
 ### Create Import table/model
 I'll add a generator on my next release
@@ -76,15 +100,27 @@ class Import < ActiveRecord::Base
 
   # I'll add import options in the next major release
   # accepts_nested_attributes_for :import_options, allow_destroy: true
-
+  ### THIS IS VERSION 0.2.1 and below
   def execute
     resource_class.import!(self, execute_on_create)
   end
 
+  ### THIS IS VERSION 0.2.1 and below
+  def execute
+    resource_class.import!(object: self, execute: execute_on_create)
+  end
+
+
+  ### THIS IS VERSION 0.2.1 and below
   def execute!
     resource_class.import!(self, true)
   end
 
+  ### THIS IS VERSION 0.3.0
+  def execute!
+    resource_class.import!(object: self, execute: true)
+  end
+
   def resource_class
     resource.safe_constantize
   end
@@ -226,6 +262,9 @@ end
 @import.execute!
 ```
 
+###REMINDER:
+Headers of your csv file should be formatted/transformed to column names of your IMPORTABLE model
+
 
 ## Development
 

data/lib/active_record_importer/attribute/find_options_builder.rb

@@ -4,7 +4,7 @@ module ActiveRecordImporter
       include Virtus.model
       include Helpers
 
-      attribute :resource, String
+      attribute :importable
       attribute :attrs, Hash, default: {}
       attribute :find_options, String
       attribute :prefix, String
@@ -16,18 +16,8 @@ module ActiveRecordImporter
 
       private
 
-      def klass
-        resource.safe_constantize
-      end
-
-      delegate :importer_options, to: :klass
-
-      delegate :required_attributes, to: :importer_options
-
       def get_find_opts
         @options = strip_and_symbolize
-        @options ||= importer_options.find_options || required_attributes
-        @options
       end
 
       def slice_attributes

data/lib/active_record_importer/batch_importer.rb

@@ -1,19 +1,18 @@
 module ActiveRecordImporter
   class BatchImporter
+    include Virtus.model
 
-    attr_reader :data, :import, :failed_file, :processor
-
-    def initialize(import, data)
-      @import = import
-      @data = data
-      @failed_file = FailedFileBuilder.new(import)
-    end
+    attribute :import, Import
+    attribute :importable
+    attribute :data, Array, default: []
+    attribute :failed_file, FailedFileBuilder, default: :initialize_failed_file
 
     def process!
       @imported_count, @failed_count = 0, 0
-      data.each do |row|
-        next if row.blank?
-        process_row(row.symbolize_keys!)
+
+      data.each do |row_attrs|
+        next if row_attrs.blank?
+        process_row(row_attrs.symbolize_keys!)
       end
 
       set_import_count
@@ -22,25 +21,39 @@ module ActiveRecordImporter
 
     private
 
-    def process_row(row)
-      processor = DataProcessor.new(import, row)
+    def initialize_failed_file
+      return unless import
+      FailedFileBuilder.new(import)
+    end
+
+    def process_row(row_attrs)
+      processor =
+        DataProcessor.new(
+          import: import,
+          importable: importable,
+          row_attrs: row_attrs
+        )
       return @imported_count += 1 if processor.process
 
-      @failed_file.failed_rows << row.merge(import_errors: processor.row_errors)
+      collect_failed_rows(row_attrs, processor.row_errors)
       @failed_count += 1
     end
 
     def set_import_count
+      return unless import
+
       Import.update_counters(import.id, imported_rows: @imported_count)
       Import.update_counters(import.id, failed_rows: @failed_count)
     end
 
-    def finalize_batch_import
-      @failed_file.build
+    def collect_failed_rows(row_attrs, errors)
+      return puts errors.inspect unless failed_file
+      @failed_file.failed_rows << row_attrs.merge(import_errors: errors)
     end
 
-    def importable
-      import.resource.safe_constantize
+    def finalize_batch_import
+      return unless failed_file
+      @failed_file.build
     end
 
     delegate :importer_options, to: :importable

data/lib/active_record_importer/data_processor.rb

@@ -1,16 +1,16 @@
 module ActiveRecordImporter
   class DataProcessor
-    attr_reader :importable, :import, :instance, :attributes,
-                :row_errors, :row_attrs, :find_attributes
-
-    delegate :importer_options,
-             to: :importable
-
-    def initialize(import, row_attrs)
-      @import = import
-      @importable = import.resource.safe_constantize
-      @row_attrs = row_attrs
-    end
+    include Virtus.model
+
+    attribute :import, Import
+    attribute :importable, Class
+    attribute :insert_method, String, default: :set_insert_method
+    attribute :row_attrs, Hash
+    attribute :instance_attrs, Hash
+    attribute :find_options, String, default: :set_find_options
+    attribute :find_attributes, Hash
+    attribute :row_errors, Array
+    attribute :instance
 
     def process
       fetch_instance_attributes
@@ -24,10 +24,12 @@ module ActiveRecordImporter
       ActiveRecord::Base.transaction do
         begin
           @instance =
-              InstanceBuilder.new(
-                import, find_attributes,
-                attributes_without_state_machine_attrs
-              ).build
+            InstanceBuilder.new(
+              importable: importable,
+              insert_method: insert_method,
+              find_attributes: find_attributes,
+              instance_attrs: attributes_without_state_machine_attrs
+            ).build
 
           methods_after_upsert
           true
@@ -38,18 +40,18 @@ module ActiveRecordImporter
     end
 
     def fetch_instance_attributes
-      @attributes = Attribute::AttributesBuilder.new(
-                      importable, row_attrs
-                    ).build
+      @instance_attrs = Attribute::AttributesBuilder.new(
+        importable, row_attrs
+      ).build
     rescue => exception
       append_errors(exception)
     end
 
     def fetch_find_attributes
       @find_attributes = Attribute::FindOptionsBuilder.new(
-        resource: import.resource,
-        find_options: import.find_options,
-        attrs: attributes
+        importable: importable,
+        find_options: find_options,
+        attrs: instance_attrs
       ).build
     rescue => exception
       append_errors(exception)
@@ -62,8 +64,10 @@ module ActiveRecordImporter
       run_after_save_callbacks
     end
 
-    delegate :after_save,
-             :state_machine_attr,
+    delegate :importer_options,
+             to: :importable
+
+    delegate :after_save, :state_machine_attr,
              to: :importer_options
 
     def state_transitions
@@ -77,7 +81,7 @@ module ActiveRecordImporter
     end
 
     def attributes_without_state_machine_attrs
-      attributes.except(*state_machine_attr)
+      instance_attrs.except(*state_machine_attr)
     end
 
     def skip_callbacks?
@@ -97,5 +101,15 @@ module ActiveRecordImporter
       @row_errors = message
       fail ActiveRecord::Rollback if rollback
     end
+
+    def set_insert_method
+      @insert_method = import.try(:insert_method)
+      @insert_method ||= importer_options.insert_method
+      @insert_method ||= 'insert'
+    end
+
+    def set_find_options
+      import.try(:find_options) || importer_options.find_options.join(',')
+    end
   end
 end

data/lib/active_record_importer/dispatcher.rb

@@ -1,11 +1,11 @@
 module ActiveRecordImporter
   class Dispatcher
-    attr_reader :import, :execute
+    include Virtus.model
 
-    def initialize(import_id, execute = true)
-      @import = Import.find(import_id)
-      @execute = execute
-    end
+    attribute :import, Import
+    attribute :importable, Class
+    attribute :execute, Boolean, default: true
+    attribute :import_file
 
     def call
       divide_and_conquer
@@ -14,22 +14,22 @@ module ActiveRecordImporter
     private
 
     def divide_and_conquer
-      File.open(import.import_file, 'r:bom|utf-8') do |file|
+      File.open(import_file, 'r:bom|utf-8') do |file|
         SmarterCSV.process(file, csv_options) do |collection|
           queue_or_execute(collection)
         end
       end
+      true
     end
 
     def csv_options
-      klass = import.resource.safe_constantize
-      opts = klass_csv_opts(klass)
-      return opts if import.batch_size.blank? || import.batch_size < 1
+      opts = klass_csv_opts
+      return opts if import.nil? || import.batch_size.blank?
       opts.merge(chunk_size: import.batch_size)
     end
 
-    def klass_csv_opts(klass)
-      klass.importer_options.csv_opts.to_hash
+    def klass_csv_opts
+      importable.importer_options.csv_opts.to_hash
     end
 
     def queue_or_execute(collection)
@@ -38,7 +38,11 @@ module ActiveRecordImporter
     end
 
     def process_import(collection)
-      BatchImporter.new(import, collection).process!
+      BatchImporter.new(
+        import: import,
+        importable: importable,
+        data: collection
+      ).process!
     end
 
     def queue(collection)

data/lib/active_record_importer/errors.rb

@@ -17,5 +17,11 @@ module ActiveRecordImporter
         super 'Duplicate record found!'
       end
     end
+
+    class MissingImportFile < StandardError
+      def initialize
+        super 'File is missing for import'
+      end
+    end
   end
 end

data/lib/active_record_importer/importable.rb

@@ -6,6 +6,8 @@ module ActiveRecordImporter
 
     module ClassMethods
       ##
+      # #acts_as_importable
+      #
       # Make a model importable
       # This will allow a model to use the importer
       #
@@ -29,13 +31,60 @@ module ActiveRecordImporter
         @@importer_options
       end
 
-      def import!(import_object, execute = true)
-        ActiveRecordImporter::Dispatcher.new(
-          import_object.id, execute).call
+      def importable?
+        ::IMPORTABLES.include?(self.name)
+      end
+
+      ##
+      # #import!
+      #
+      # This method is called in the Import instance during execution of import
+      # You may also call this method without any import instance
+      # e.g.
+      #
+      # User.import!(file: File.open(PATH_TO_FILE))
+      #
+      # "insert" will be the default insert method for this
+      # If you want to use "upsert" or "error_duplicate",
+      # define it in your importer options:
+      #
+      #   class User < ActiveRecord::Base
+      #     acts_as_importable insert_method: 'upsert',
+      #                        find_options: ['email']
+      #   end
+      #
+      #  Or you may use:
+      #  User.acts_as_importable insert_method: 'error_duplicate', find_options: ['email']
+      #
+      ##
+      def import!(options = {})
+        fail "#{self.name} is not importable" unless importable?
+
+        import_object = options.fetch(:object, nil)
+        execute = options.fetch(:execute, true)
+        import_file = get_import_file(import_object, options)
+
+        call_dispatcher(import_object, execute, import_file)
       end
 
       private
 
+      def call_dispatcher(import_object = nil, execute = true, file = nil)
+        ActiveRecordImporter::Dispatcher.new(
+          importable: self,
+          import: import_object,
+          execute: execute,
+          import_file: file
+        ).call
+      end
+
+      def get_import_file(import, options = {})
+        file = options.fetch(:file, nil) || import.try(:import_file)
+        fail Errors::MissingImportFile.new unless file
+        file
+      end
+
+
       def allowed_columns_hash(options = {})
         {
           importable_columns: allowed_columns(options)

data/lib/active_record_importer/instance_builder.rb

@@ -1,12 +1,11 @@
 module ActiveRecordImporter
   class InstanceBuilder
-    attr_reader :attributes, :find_attributes, :import
+    include Virtus.model
 
-    def initialize(import, find_attributes, attributes)
-      @import = import
-      @find_attributes = find_attributes
-      @attributes = attributes
-    end
+    attribute :importable, ActiveRecord::Base
+    attribute :insert_method, String, default: 'insert'
+    attribute :instance_attrs, Hash, default: {}
+    attribute :find_attributes, Hash, default: {}
 
     def build
       instance = initialize_instance
@@ -15,20 +14,16 @@ module ActiveRecordImporter
 
     private
 
-    delegate :insert_method, to: :import
+    delegate :error_duplicate, :insert?, to: :insert_method_inquiry
 
     def initialize_instance
-      return klass.new if insert_method.insert?
+      return importable.new if insert?
 
       fail Errors::MissingFindByOption if find_attributes.blank?
-      klass.find_or_initialize_by(find_attributes)
-    end
-
-    def klass
-      import.resource.safe_constantize
+      importable.find_or_initialize_by(find_attributes)
     end
 
-    delegate :importer_options, to: :klass
+    delegate :importer_options, to: :importable
     delegate :before_save, to: :importer_options
 
     def process_data(instance)
@@ -44,13 +39,17 @@ module ActiveRecordImporter
     end
 
     def assign_attrs_and_save!(instance)
-      instance.attributes = attributes
+      instance.attributes = instance_attrs
       instance.save!
       instance
     end
 
+    def insert_method_inquiry
+      insert_method.inquiry
+    end
+
     def error_duplicate?(instance)
-      instance.persisted? && insert_method.error_duplicate?
+      instance.persisted? && error_duplicate?
     end
   end
 end

data/lib/active_record_importer/options_builder.rb

@@ -31,9 +31,10 @@ module ActiveRecordImporter
   class ImporterOptions
     include Virtus.model
 
-    attribute :find_options, Array
+    attribute :find_options, Array, default: []
     attribute :exclude_from_find_options, Array
     attribute :scope, Symbol
+    attribute :insert_method, String
     attribute :importable_columns, Array
     attribute :default_attributes, Hash
     attribute :csv_opts, CsvOptions, default: CsvOptions.new

data/lib/active_record_importer/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordImporter
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/lib/app/models/import.rb

@@ -28,11 +28,11 @@ module ActiveRecordImporter
     # accepts_nested_attributes_for :import_options, allow_destroy: true
 
     def execute
-      resource_class.import!(self, execute_on_create)
+      resource_class.import!(object: self, execute: execute_on_create)
     end
 
     def execute!
-      resource_class.import!(self, true)
+      resource_class.import!(object: self, execute: true)
     end
 
     def resource_class

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_importer
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Michael Nera