rails-importer 0.0.6 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0ee6bdad79ed8a4d980a915735461df003bca4d5
-  data.tar.gz: 2105757e2d2515fdcb8f4e1483df2f85bc683f07
+SHA256:
+  metadata.gz: 573081d673ea028ad52dedeb5b6492358a0e7e1e909b1f867e064bb01112ca9c
+  data.tar.gz: 83d313fdbd28f692b740e84c0ee2563f43f8ae2670489de0190da2db4e19bd5e
 SHA512:
-  metadata.gz: 046fc96c808dfcce475bd1ada1e0c5467ec78b4d6ccee48a46d9a5029ca25d1d573d252f4f94a02249eaf96e896db33c28d64c63dc7eefa46d831cd1ee5bf996
-  data.tar.gz: 1ff316fc036a83d9a93c82ceb5404441e3cb6a8413e42fff0b9a3969b1b9bf61147589e0321634debb76c14ff6df6f1fcd4cf2f987372e38f7d7378709607f05
+  metadata.gz: 3a5f67741c4dd49bde921f88451fac6cc275b2270d7137380915c0c7fcb2ce2b93528b70b5029048a6dffa2b5ba6787b17a7258f8f6f8b22a4fc6cf28f1ac157
+  data.tar.gz: f6cf858f4b81136dd9af761a00a882548f42d25658143cc522811ecdc1439918c9f47ec0d41adc31a62d887b55538b0c77a9b225e3ac0145aa77dcfd73e1a3b8

data/README.md

@@ -30,8 +30,12 @@ class ExampleImporter < RailsImporter::Base
 
   importer do
     fields :name, :email, :age
+    #or fields({:name => "Name", :email => "E-mail", :age => "Idade"})
     each_record do |record, params|
+    
       MyModel.find_or_create_by(name: record[:name], email: record[:email], age: record[:age])
+      
+      return record # or return wherever
     end
   end
   
@@ -49,14 +53,68 @@ end
 ### How to use
 
 You can call `import` from **Importers** objects: 
-```erb
+**file param** must be an object that responds to `.path` method
+```ruby
     file = params[:import][:file]
-    records = ExampleImporter.import(file, extra_param: 'Extra')
+    records = ExampleImporter.import(file)
 ```
 
 Or with context:
+```ruby
+    file = params[:import][:file]
+    records = ExampleImporter.import(file, context: :simple)
+```
+
+Overwrite default fields (called in the block `importer do`):
+```ruby
+    file = params[:import][:file]
+    records = ExampleImporter.import(file, fields: [:name, :email, :age])
+```
 
-```erb
+With extra params:
+```ruby
     file = params[:import][:file]
-    records = ExampleImporter.import(file, context: :simple, extra_param: 'Extra')
-```
+    records = ExampleImporter.import(file, {user: 'john@mail.com'})
+```
+Then inside each record you can get params:
+```ruby
+class ExampleImporter < RailsImporter::Base
+  importer do
+    # ...
+    each_record do |record, params|
+      # ...
+      params[:user]
+      # ...
+    end
+    # ...
+  end
+end
+```
+
+With full options:
+```ruby
+    file = params[:import][:file]
+    records = ExampleImporter.import(file,
+      context: :simple,
+      fields: [:name, :email, :age],
+      {user: 'john@mail.com', account: '1'})
+```
+
+To return imported values, you need to return values inside of `each_record`:
+```ruby
+class ExampleImporter < RailsImporter::Base
+  importer do
+    # ...
+    each_record do |record, params|
+      # ...
+      u = Model.new(record)
+      u.created_by = params[:user]
+      ok = !!u.save
+      return {record: u, success: ok}
+    end
+    # ...
+  end
+end
+records = ExampleImporter.import(file, {user: 'john@mail.com'})
+# [{record: ..., success: true}, {record: ..., success: false}]
+```

data/config/locales/importers.en.yml

@@ -1,4 +1,7 @@
 en:
   importer:
     error:
-      invalid_file_type: "Invalid file type allowed: %{file_types}"
+      invalid_file: "Invalid File instance."
+      invalid_file_type: "Invalid file type allowed: %{file_types}"
+      convert_number_to_text: "Error when convert number to text"
+      

data/lib/rails_importer/base.rb

@@ -8,18 +8,23 @@ module RailsImporter
     class << self
       def import(file, *args)
         context = args.try(:context) || :default
+        custom_fields = args.try(:fields) || nil
         result = []
         begin
-          ext = (File.extname(file.path)[1..-1] rescue nil)
-          if file.respond_to?(:path) and self.file_types.include?(ext.to_sym)
-            rows = self.send("import_from_#{ext}", file)
-            if rows.present? and rows.is_a?(Array)
-              result = rows.map do |record|
-                self.importers[context][:each_record].call(record, *args) if self.importers[context][:each_record].is_a?(Proc)
-              end.compact
+          if file.respond_to?(:path)
+            ext = (File.extname(file.path)[1..-1] rescue '')
+            if self.file_types.include?(ext.to_sym)
+              rows = self.send('import_from_%s' % ext, file, context, custom_fields)
+              if rows.present? && rows.is_a?(Array)
+                result = rows.map do |record|
+                  self.importers[context][:each_record].call(record, *args) if self.importers[context][:each_record].is_a?(Proc)
+                end.compact
+              end
+            else
+              result = I18n.t(:invalid_file_type, file_types: self.file_types.join(', '), scope: [:importer, :error])
             end
           else
-            I18n.t(:invalid_file_type, file_types: self.file_types.join(', '), scope: [:importer, :error])
+            result = I18n.t(:invalid_file, scope: [:importer, :error])
           end
         rescue Exception => e
           result = e.message
@@ -37,7 +42,7 @@ module RailsImporter
       #   end
       # end
 
-      def importer(name=:default, &block)
+      def importer(name = :default, &block)
         (self.importers ||= {})[name] ||= {fields: [], xml_structure: [:records, :record], each_record: nil}
         @importer_name = name
         block.call if block_given?
@@ -57,19 +62,19 @@ module RailsImporter
       end
 
       private
-      def import_from_csv(file, context=:default)
+      def import_from_csv(file, context = :default, custom_fields = :nil)
         records = []
         line = 0
         CSV.foreach(file.path, {:headers => false, :col_sep => ';', :force_quotes => true}) do |row|
-          if line>0
-            records << object_values(row, context) unless array_blank?(row)
+          if line > 0
+            records << object_values(row, context, custom_fields) unless array_blank?(row)
           end
-          line+=1
+          line += 1
         end
         records
       end
 
-      def import_from_xml(file, context=:default)
+      def import_from_xml(file, context = :default, custom_fields = :nil)
         records = []
         xml_structure = self.importers[context][:xml_structure]
         xml = Hash.from_xml(file.read)
@@ -77,59 +82,85 @@ module RailsImporter
           xml = xml[node.to_s]
         end
         xml.each do |elem|
-          records << object_values(elem.values, context) unless array_blank?(elem.values)
+          records << object_values(elem.values, context, custom_fields) unless array_blank?(elem.values)
         end
         records
       end
 
-      def import_from_xls(file, context=:default)
+      def import_from_xls(file, context = :default, custom_fields = :nil)
         records = []
         Spreadsheet.client_encoding = 'UTF-8'
         document = Spreadsheet.open(file.path)
         spreadsheet = document.worksheet 0
         spreadsheet.each_with_index do |row, i|
-          next unless i>0
-          records << object_values(row, context) unless array_blank?(row)
+          next if i.zero?
+          records << object_values(row, context, custom_fields) unless array_blank?(row)
         end
         records
       end
 
-      def object_values(array, context=:default)
-        attributes = self.importers[context][:fields]
+      def object_values(array, context = :default, custom_fields = nil)
+        attributes = custom_fields || self.importers[context][:fields]
         attributes = attributes.keys if attributes.is_a?(Hash)
-        args = array[0...attributes.size]
-        hValues = Hash[attributes.zip(args)]
+        values = equalize_columns_of_values(attributes, array)
+        hash_values = Hash[attributes.zip(values)]
         attributes.each do |attr|
-          if hValues[attr].present?
-            if hValues[attr].is_a?(Numeric)
-              hValues[attr] = hValues[attr].to_i if hValues[attr].modulo(1).zero?
-              hValues[attr] = (hValues[attr].to_s.strip rescue '#ERRO AO CONVERTER NUMERO PARA TEXTO')
-            elsif hValues[attr].is_a?(Date)
-              hValues[attr] = (I18n.l(hValues[attr], format: '%d/%m/%Y') rescue hValues[attr]).to_s
-            elsif hValues[attr].is_a?(DateTime)
-              hValues[attr] = (I18n.l(hValues[attr], format: '%d/%m/%Y %H:%i:%s') rescue hValues[attr]).to_s
+          if hash_values[attr].present?
+            if hash_values[attr].is_a?(Numeric)
+              hash_values[attr] = hash_values[attr].to_i if hash_values[attr].modulo(1).zero?
+              hash_values[attr] = (hash_values[attr].to_s.strip rescue I18n.t(:convert_number_to_text, scope: [:importer, :error]))
+            elsif hash_values[attr].is_a?(Date)
+              hash_values[attr] = (I18n.l(hash_values[attr], format: '%d/%m/%Y') rescue hash_values[attr]).to_s
+            elsif hash_values[attr].is_a?(DateTime)
+              hash_values[attr] = (I18n.l(hash_values[attr], format: '%d/%m/%Y %H:%i:%s') rescue hash_values[attr]).to_s
             else
               #PARA QUALQUER OUTRO VALOR, FORÇA CONVERTER PARA STRING
-              hValues[attr] = (hValues[attr].to_s.strip rescue '')
+              hash_values[attr] = (hash_values[attr].to_s.strip rescue '')
             end
           else
-            hValues[attr] = ''
+            hash_values[attr] = ''
           end
         end
-        OpenStruct.new(hValues)
+        OpenStruct.new(hash_values)
       end
 
       def array_blank?(array)
-        array.all? {|i|i.nil? or i==''}
+        array.all?(&:blank?)
       end
 
       def importer_value(key, attributes)
         if attributes.present?
-          self.importers[@importer_name][key] = attributes
+          if key == :fields
+            self.importers[@importer_name][key] = normalize_fields(attributes)
+          else
+            self.importers[@importer_name][key] = attributes
+          end
         else
           self.importers[@importer_name][key]
         end
       end
+
+      def normalize_fields(attributes)
+        if attributes.first.is_a?(Hash)
+          attributes.inject(:merge)
+        elsif attributes.first.is_a?(Array)
+          attributes.flatten
+        else
+          attributes
+        end
+      end
+
+      def equalize_columns_of_values(attributes, values=[])
+        if attributes.size > values.size
+          diff_size = (attributes.size - values.size).abs
+          values + Array.new(diff_size, nil)
+        elsif attributes.size < values.size
+          values[0...attributes.size]
+        else
+          values
+        end
+      end
+
     end
 
   end

data/lib/rails_importer/version.rb

@@ -1,3 +1,3 @@
 module RailsImporter
-  VERSION = "0.0.6"
+  VERSION = "0.0.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-importer
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.11
 platform: ruby
 authors:
 - Bruno Porto
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-02-13 00:00:00.000000000 Z
+date: 2021-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: '4'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: spreadsheet
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +67,6 @@ files:
 - lib/generators/templates/generic_importer.erb
 - lib/rails-importer.rb
 - lib/rails_importer.rb
-- lib/rails_importer/_importer.rb
 - lib/rails_importer/base.rb
 - lib/rails_importer/engine.rb
 - lib/rails_importer/version.rb
@@ -75,7 +74,7 @@ homepage: https://github.com/brunoporto/rails-importer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,9 +89,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Rails Importer
 test_files: []

data/lib/rails_importer/_importer.rb

@@ -1,138 +0,0 @@
-require 'ostruct'
-
-module RailsImporter
-
-  def self.included(base)
-    base.extend ClassMethods
-
-    base.define_singleton_method 'colunas' do |*args|
-      @importacao_colunas = nil unless @importacao_colunas.present?
-      if args.present?
-        @importacao_colunas = (args.first.is_a?(Hash) ? args.inject(:merge) : args)
-      else
-        @importacao_colunas
-      end
-    end
-
-    base.define_singleton_method 'estrutura_xml' do |*args|
-      @importacao_estrutura_xml = nil unless @importacao_estrutura_xml.present?
-      if args.present?
-        @importacao_estrutura_xml = args
-      else
-        @importacao_estrutura_xml
-      end
-    end
-
-    base.define_singleton_method 'para_cada_linha' do |&block|
-      define_singleton_method('importar_registro') do |registro, *args|
-        block.call(registro, *args)
-      end
-    end
-
-  end
-
-  def self.tipos_de_arquivos
-    [:csv, :xls, :xml]
-  end
-
-  module ClassMethods
-
-    def importacao(&block)
-      block.call if block_given?
-      self.class.class_eval do
-        define_method :importar do |arquivo, *args|
-          retorno = []
-          begin
-            ext = (File.extname(arquivo.path)[1..-1] rescue nil)
-            if arquivo.respond_to?(:path) and RailsImporter.tipos_de_arquivos.include?(ext.to_sym)
-              registros = self.send("#{ext}_para_array", arquivo)
-              if registros.present? and registros.is_a?(Array)
-                retorno = registros.map do |registro|
-                  importar_registro(registro, *args)
-                end
-              end
-            else
-              raise "Tipo de arquivo inválido. Arquivos permitidos: #{RailsImporter.tipos_de_arquivos.join(', ')}"
-            end
-          rescue Exception => e
-            retorno = e.message
-          end
-          retorno
-        end
-      end
-    end
-
-    private
-    def csv_para_array(arquivo)
-      registros = []
-      linha=0
-      CSV.foreach(arquivo.path, {:headers => false, :col_sep => ';', :force_quotes => true}) do |row|
-        if linha>0
-          registros << object_values(row) unless array_blank?(row)
-        end
-        linha+=1
-      end
-      registros
-    end
-
-    def xml_para_array(arquivo)
-      registros = []
-      estrutura_xml = self.send(:estrutura_xml)
-      if estrutura_xml.present? and estrutura_xml.is_a?(Array) and estrutura_xml.count > 0
-        xml = Hash.from_xml(arquivo.read)
-        estrutura_xml.each do |node|
-          xml = xml[node.to_s]
-        end
-        xml.each do |elem|
-          registros << object_values(elem.values) unless array_blank?(elem.values)
-        end
-      else
-        raise 'Você precisa informar a estrutura_xml no seu Model'
-      end
-      registros
-    end
-
-    def xls_para_array(arquivo)
-      registros = []
-      Spreadsheet.client_encoding = 'UTF-8'
-      documento = Spreadsheet.open(arquivo.path)
-      planilha = documento.worksheet 0
-      planilha.each_with_index do |row, i|
-        next unless i>0
-        registros << object_values(row) unless array_blank?(row)
-      end
-      registros
-    end
-
-    def object_values(array)
-      atributos = self.send(:colunas)
-      atributos = atributos.keys if atributos.is_a?(Hash)
-      args = array[0...atributos.size]
-      hValores = Hash[atributos.zip(args)]
-      #Ajustando valores inválidos
-      atributos.each do |atributo|
-        if hValores[atributo].present?
-          if hValores[atributo].is_a?(Numeric)
-            hValores[atributo] = hValores[atributo].to_i if hValores[atributo].modulo(1).zero?
-            hValores[atributo] = (hValores[atributo].to_s.strip rescue '#ERRO AO CONVERTER NUMERO PARA TEXTO')
-          elsif hValores[atributo].is_a?(Date)
-            hValores[atributo] = (I18n.l(hValores[atributo], format: '%d/%m/%Y') rescue hValores[atributo]).to_s
-          elsif hValores[atributo].is_a?(DateTime)
-            hValores[atributo] = (I18n.l(hValores[atributo], format: '%d/%m/%Y %H:%i:%s') rescue hValores[atributo]).to_s
-          else
-            #PARA QUALQUER OUTRO VALOR, FORÇA CONVERTER PARA STRING
-            hValores[atributo] = (hValores[atributo].to_s.strip rescue '')
-          end
-        else
-          hValores[atributo] = ''
-        end
-      end
-      OpenStruct.new(hValores)
-    end
-
-    def array_blank?(array)
-      array.all? {|i|i.nil? or i==''}
-    end
-
-  end
-end