rails-importer 0.0.7 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6281fb4ece61433a46c9365db6929dc23b479d6c
-  data.tar.gz: 6e6c0730bfb4a252fe827b7116cd521e6f76cb0f
+SHA256:
+  metadata.gz: 21fedbfaf0623b35213ec6e37dafab5d3a11040ffaae8add9613e726743b441c
+  data.tar.gz: 3ba9d86e6cdd1b2cd4217c52b9718ebc2e654ac128d1d14551165891c3501282
 SHA512:
-  metadata.gz: 4940a022355897d904c48cd390c3ba94c0b2f5317685dc023733b6324128f034f553a51604e9c478ac2230e0e1272186c45dda2038829ee864410ad13ddc09fd
-  data.tar.gz: 750a1b7411b6f88559ad04671e36761b70c1701aecf93d887aef08985400b357fa466f0d78f075ba407f64243db48e9d3777c8c1716ca5589381eb99bf55ef06
+  metadata.gz: dddecdf677d03410d18c8df7977be529c5b571ee550263f40aff43544face6b4ef8a9227ae6c5e3f940db62640f49b6f0f6a098707bea9afeb3f7fbd1cb32f76
+  data.tar.gz: d20d9a502f0943fe733b655af1c42342565ed04461a3e5c2a4c9d4c86048786e41a16e849aea12c85c6f5a20135afd0efcd4489d320bb771b3e40f9c05d9c5f2

data/README.md

@@ -30,12 +30,17 @@ 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
   
   # importer :simple do
+  #   csv_params col_sep: ';'
   #   xml_structure :root, :row
   #   fields :name, :email, :age
   #   each_record do |record, params|
@@ -49,14 +54,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/generators/templates/generic_importer.erb

@@ -8,6 +8,7 @@ class <%= @importer_name %>Importer < RailsImporter::Base
   end
 
   # importer :simple do
+  #   csv_params col_sep: ';'
   #   xml_structure :root, :row
   #   fields :name, :email, :age
   #   each_record do |record, params|

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,8 +42,13 @@ module RailsImporter
       #   end
       # end
 
-      def importer(name=:default, &block)
-        (self.importers ||= {})[name] ||= {fields: [], xml_structure: [:records, :record], each_record: nil}
+      def importer(name = :default, &block)
+        (self.importers ||= {})[name] ||= {
+          fields: [],
+          csv_params: {headers: false, col_sep: ',', force_quotes: true},
+          xml_structure: %i[records record],
+          each_record: nil
+        }
         @importer_name = name
         block.call if block_given?
         self.importers[name]
@@ -52,24 +62,34 @@ module RailsImporter
         importer_value(:xml_structure, attributes)
       end
 
+      def csv_params(*attributes)
+        options = importer_value(:csv_params)
+        params = attributes.first
+        options = options.merge(params) if params.is_a?(Hash)
+        importer_value(:csv_params, options)
+      end
+
       def each_record(&block)
         importer_value(:each_record, block)
       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)
+        first_line = nil
+        options = self.importers[context][:csv_params]
+        CSV.foreach(file.path, options.merge(headers: false)) do |row|
+          # Skip headers
+          if first_line.nil?
+            first_line = row
+            next
           end
-          line+=1
+          records << object_values(row, context, custom_fields) unless array_blank?(row)
         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 +97,79 @@ 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=nil)
+        return self.importers[@importer_name][key] if attributes.nil?
+        attributes = normalize_fields(attributes) if key == :fields
+        self.importers[@importer_name][key] = attributes
       end
 
-      def importer_value(key, attributes)
-        if attributes.present?
-          self.importers[@importer_name][key] = (attributes.first.is_a?(Hash) ? attributes.inject(:merge) : attributes)
+      def normalize_fields(attributes)
+        if attributes.first.is_a?(Hash)
+          attributes.inject(:merge)
+        elsif attributes.first.is_a?(Array)
+          attributes.flatten
         else
-          self.importers[@importer_name][key]
+          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.7"
+  VERSION = "0.0.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-importer
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.12
 platform: ruby
 authors:
 - Bruno Porto
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-02-14 00:00:00.000000000 Z
+date: 2021-05-19 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.6.8
-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