importance 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc6615b341ca9d538f4e54700b6c4deb6220f235a4b7e8325cffd9358d732178
-  data.tar.gz: a043ef84dea2f19a58ececdd8ddc9fc1b46619128a657f845330f8c1429e5b94
+  metadata.gz: 495f2f10d4834e86a1224ba0368b4642fb136c371dc79f635cd5d2187be756f9
+  data.tar.gz: 9971a1b0c872ab7a4f1b705ff3b105b9217d95a7c1030043053f69a1ae95fc53
 SHA512:
-  metadata.gz: 5c84fc09606e89071f37f12627a4392ebea48e3b5363c48ee3fcaa0ad101b19ffed448f96ab73fe2ad255b83e6da304dc02b44675bbbf259cd5bceedd4fba0a4
-  data.tar.gz: 697a39cbee99aa846b9b36df8b4aaef611d7a5fc27c420ca869bca71bcffa8c19e7b0cc81a8cb6da4e9b752562f8b023b445f5defe3874d6bd6c82d71c9971ce
+  metadata.gz: f73128060f9b98baac9959e8a3f94ba3e061d019b7b2d06df6145afaec892ff4271a4f4b34052c4ac700010f52ef3603da750327e20006e0f40539a4b2dbdc10
+  data.tar.gz: 131100a75c3ea0b074f3a097d759b77bd582b549c7206e469c7a180ce3b716c576bfa25fdaf0183d7b899cdce48c9297af9e71296f41d2af9021bddb65d99d4e

data/app/controllers/importance/imports_controller.rb

@@ -6,125 +6,113 @@ module Importance
     # Form submission target. Persist the file and redirect to the mapping page.
     def submit
       upload = params[:file]
+      session[:redirect_url] = params[:redirect_url]
+      session[:importer] = params[:importer].to_sym
 
-      raise ArgumentError, "Upload cannot be nil" if upload.nil?
+      if upload.nil?
+        flash[:alert] = t("importance.errors.no_file")
+        redirect_to session[:redirect_url] and return
+      end
 
       upload_extension = File.extname(upload.original_filename).downcase
       supported_extensions = [ ".xlsx", ".xls", ".csv" ]
 
-      raise ArgumentError, "Unsupported file format. Please upload Excel (.xlsx, .xls) or CSV (.csv) files." unless supported_extensions.include?(upload_extension)
+      if !supported_extensions.include?(upload_extension)
+        flash[:alert] = t("importance.errors.invalid_file_type", types: supported_extensions.join(", "))
+        redirect_to session[:redirect_url] and return
+      end
 
       system_tmp_dir = Dir.tmpdir
       upload_path = upload.tempfile.path
       persist_filename = "#{SecureRandom.uuid}#{upload_extension}"
 
       persist_path =  File.join(system_tmp_dir, persist_filename)
+      session[:path] = persist_path
 
-      raise ArgumentError, "File does not exist at #{upload_path}" if !File.exist?(upload_path)
+      if !File.exist?(upload_path)
+        flash[:alert] = t("importance.errors.no_file")
+        redirect_to session[:redirect_url] and return
+      end
 
       FileUtils.mv(upload_path, persist_path)
 
-      session[:path] = persist_path
-      session[:importer] = params[:importer].to_sym
-      session[:redirect_url] = params[:redirect_url]
-
       redirect_to map_path
     end
 
     # Mapping page. Load headers and samples, display the form.
     def map
-      importer = Importance.configuration.importers[session[:importer].to_sym]
-
-      raise ArgumentError, "Importer cannot be nil" if importer.nil?
+      @layout = "Importance::#{Importance.configuration.layout.to_s.camelize}Layout".constantize
+      @importer = Importance.configuration.importers[session[:importer].to_sym]
 
-      workbook = Roo::Spreadsheet.open(session[:path], { csv_options: { encoding: "bom|utf-8" } })
-      worksheet = workbook.sheet(0)
-      @file_headers = worksheet.row(1)
-      @samples = worksheet.parse[1..5]
-      @full_count = worksheet.count - 1
+      if @importer.nil?
+        flash[:alert] = t("importance.errors.no_importer")
+        redirect_to session[:redirect_url] and return
+      end
 
-      @importer_attributes = importer.attributes
-      @layout = "Importance::#{Importance.configuration.layout.to_s.camelize}Layout".constantize
+      @importer.add_spreadsheet(session[:path])
     end
 
     # Import page. Load the file according to the mapping and import it.
     # Mappings param is of the form mappings[excel_column_idx] = target_attribute
     # mappings[0] = "first_name", mappings[1] = "", mappings[2] = "last_name" ...
     def import
-      importer = Importance.configuration.importers[session[:importer].to_sym]
-      mappings = params[:mappings]
-
-      raise ArgumentError, "Mapping cannot be nil" if mappings.nil?
+      @layout = "Importance::#{Importance.configuration.layout.to_s.camelize}Layout".constantize
+      @importer = Importance.configuration.importers[session[:importer].to_sym]
 
-      if importer.setup_callback
-        instance_exec(&importer.setup_callback)
+      if @importer.nil?
+        flash[:alert] = t("importance.errors.no_importer")
+        render :map and return
       end
 
-      begin
-        records_to_import = []
+      @importer.add_spreadsheet(session[:path])
 
-        each_processed_row(mappings) do |record|
-          records_to_import << record
-
-          if importer.batch && records_to_import.size >= importer.batch
-            instance_exec(records_to_import, &importer.perform_callback)
-            records_to_import = []
-          end
-        end
+      if params[:mappings].nil?
+        flash[:alert] = t("importance.errors.no_mappings")
+        render :map and return
+      end
 
-        if records_to_import.any?
-          instance_exec(records_to_import, &importer.perform_callback)
-        end
+      @mappings = params[:mappings].permit!.to_h.map { |k, v| [ k.to_i, v ] }.to_h
 
-        if importer.teardown_callback
-          instance_exec(&importer.teardown_callback)
-        else
-          redirect_to (session[:redirect_url] || main_app.root_path), notice: "Import completed."
-        end
+      @importer.importer_attributes.each do |attribute|
+        next if !attribute.options[:required]
+        next if @mappings.values.include?(attribute.key.to_s)
 
-      rescue => e
-        if importer.error_callback
-          instance_exec(e, &importer.error_callback)
-        end
+        flash[:alert] = t("importance.errors.missing_mapping", attribute: attribute.labels.first)
+        render :map and return
       end
-    end
 
-    private
+      @mappings.each do |column_index, attribute_name|
+        next if attribute_name == ""
+        next if @mappings.values.count(attribute_name) <= 1
 
-    def csv_file?
-      File.extname(session[:path]).downcase == ".csv"
-    end
+        flash[:alert] = t("importance.errors.duplicate_mapping", attribute: attribute_name)
+        render :map and return
+      end
 
-    # Yields each processed row (a hash of attribute => value) to the given block.
-    # Skips empty rows (all values nil or empty).
-    def each_processed_row(mappings)
-      workbook = Roo::Spreadsheet.open(session[:path], { csv_options: { encoding: "bom|utf-8" } })
-      worksheet = workbook.sheet(0)
-      worksheet.each_with_index do |row, idx|
-        next if idx == 0 # Skip header row
-        record = process_row(row, mappings)
-        next if record.empty? || record.values.all? { |v| v.nil? || v.to_s.strip.empty? }
-        yield record
+      if @importer.setup_callback
+        instance_exec(&@importer.setup_callback)
       end
-    end
 
-    # Turn a row of the form ["Hans", "Robert", 1970, "male", "Apple Inc.", "hr@apple.com"]
-    # and a mapping of the form {"0"=>"first_name", "1"=>"last_name", "2"=>"", "3"=>"", "4"=>"", "5"=>"email"}
-    # into a record of the form { first_name: "Hans", last_name: "Robert", email: "hr@apple.com" }
-    def process_row(row, mappings)
-      record = {}
+      records_to_import = []
 
-      mappings.each do |column_index, attribute_name|
-        next if attribute_name.nil? || attribute_name == ""
-        value = row[column_index.to_i]
-        record[attribute_name.to_sym] = value
+      @importer.each_processed_row(session[:path], @mappings) do |record|
+        records_to_import << record
+
+        if @importer.batch && records_to_import.size >= @importer.batch
+          instance_exec(records_to_import, &@importer.perform_callback)
+          records_to_import = []
+        end
       end
 
-      record
-    end
+      if records_to_import.any?
+        instance_exec(records_to_import, &@importer.perform_callback)
+      end
 
-    def rails_routes
-      ::Rails.application.routes.url_helpers
+      if @importer.teardown_callback
+        instance_exec(&@importer.teardown_callback)
+      else
+        redirect_to (session[:redirect_url] || main_app.root_path), notice: t("importance.success.import_completed")
+      end
     end
   end
 end

data/app/models/importance/header.rb

@@ -14,8 +14,8 @@ module Importance
               best_similarity = 1.0
               break # No need to check further if an exact match is found
             end
-            distance = DidYouMean::Levenshtein.distance(header, label)
-            percentage = distance / header.length.to_f
+            distance = DidYouMean::Levenshtein.distance(header.to_s, label.to_s)
+            percentage = distance / header.to_s.length.to_f
             similarity = 1 - percentage
             if similarity > best_similarity
               best_similarity = similarity

data/app/views/importance/imports/map.html.erb

@@ -4,32 +4,32 @@
     <table class="importance-table <%= @layout.table_class %>">
       <thead>
         <tr>
-          <% @file_headers.each_with_index do |file_header, file_header_idx| %>
+          <% @importer.file_headers.each_with_index do |file_header, file_header_idx| %>
             <th>
               <%= t('importance.use_column_as') %>
               <%
-                attribute_mappings = Importance::Header.match_attributes_to_headers(@importer_attributes, @file_headers)
-                default_value = Importance::Header.default_value_for_header(file_header, attribute_mappings)
+                attribute_mappings = Importance::Header.match_attributes_to_headers(@importer.importer_attributes, @importer.file_headers)
+                default_value = (@mappings && @mappings[file_header_idx]) || Importance::Header.default_value_for_header(file_header, attribute_mappings)
               %>
               <%= form.select "mappings[#{file_header_idx}]",
                               options_for_select(
                                 [[t('importance.ignore'), ""]] + 
-                                @importer_attributes.map { |attr| [attr.labels.first, attr.key] },
+                                @importer.importer_attributes.map { |attr| [attr.labels.first, attr.key] },
                                 default_value
                               ), {}, class: @layout.select_class %>
             </th>
           <% end %>
         </tr>
         <tr>
-          <% @file_headers.each do |file_header| %>
+          <% @importer.file_headers.each do |file_header| %>
             <th><%= file_header %></th>
           <% end %>
         </tr>
       </thead>
       <tbody>
-        <% @samples.each do |sample| %>
+        <% @importer.samples.each do |sample| %>
           <tr>
-            <% @file_headers.each_with_index do |file_header, file_header_idx| %>
+            <% @importer.file_headers.each_with_index do |file_header, file_header_idx| %>
               <td><%= sample[file_header_idx] %></td>
             <% end %>
           </tr>
@@ -38,7 +38,7 @@
     </table>
   </div>
   <p>
-    <%= t('importance.import_description', count: @samples.count, full_count: @full_count) %>
+    <%= t('importance.import_description', count: @importer.samples.count, full_count: @importer.full_count) %>
   </p>
 <% end %>
 

data/config/locales/de.yml

@@ -3,4 +3,14 @@ de:
     use_column_as: Spalte verwenden als
     ignore: Ignorieren
     import: Importieren
-    import_description: "Es werden %{count} von %{full_count} Beispieldatensätzen angezeigt."
+    import_description: Es werden %{count} von %{full_count} Beispieldatensätzen angezeigt.
+    errors:
+      no_importer: Kein Importer ausgewählt.
+      no_file: Keine Datei hochgeladen.
+      invalid_file_type: Ungültiger Dateityp. Erlaubt sind %{types}.
+      no_mappings: Keine Zuordnungen angegeben.
+      duplicate_mapping: Attribut %{attribute} wird mehrfach verwendet.
+      import_failed: Import fehlgeschlagen. %{error}.
+      missing_mapping: Fehlende Zuordnung für erforderliches Attribut %{attribute}.
+    success:
+      import_completed: Import abgeschlossen.

data/config/locales/en.yml

@@ -3,4 +3,14 @@ en:
     use_column_as: Use column as
     ignore: Ignore
     import: Import
-    import_description: "Showing %{count} of %{full_count} sample records."
+    import_description: Showing %{count} of %{full_count} sample records.
+    errors:
+      no_importer: No importer selected.
+      no_file: No file uploaded.
+      invalid_file_type: Invalid file type. Allowed types are %{types}.
+      no_mappings: No mappings provided.
+      duplicate_mapping: Attribute %{attribute} is used multiple times.
+      import_failed: Import failed. %{error}.
+      missing_mapping: Missing mapping for required attribute %{attribute}.
+    success:
+      import_completed: Import completed.

data/config/locales/fr.yml

@@ -3,4 +3,14 @@ fr:
     use_column_as: Utiliser la colonne comme
     ignore: Ignorer
     import: Importer
-    import_description: "Affichage de %{count} sur %{full_count} exemples d'enregistrements."
+    import_description: Affichage de %{count} sur %{full_count} exemples d'enregistrements.
+    errors:
+      no_importer: Aucun importateur sélectionné.
+      no_file: Aucune fichier téléchargé.
+      invalid_file_type: Type de fichier invalide. Les types autorisés sont %{types}.
+      no_mappings: Aucune correspondance fournie.
+      duplicate_mapping: L'attribut %{attribute} est utilisé plusieurs fois.
+      import_failed: Import échoué. %{error}.
+      missing_mapping: Correspondance manquante pour l'attribut requis %{attribute}.
+    success:
+      import_completed: Import terminé.

data/config/locales/it.yml

@@ -3,4 +3,14 @@ it:
     use_column_as: Utilizzare come
     ignore: Ignora
     import: Importare
-    import_description: "Mostrati %{count} di %{full_count} record di esempio."
+    import_description: Mostrati %{count} di %{full_count} record di esempio.
+    errors:
+      no_importer: Nessun importatore selezionato.
+      no_file: Nessun file caricato.
+      invalid_file_type: Tipo di file non valido. I tipi consentiti sono %{types}.
+      no_mappings: Nessuna mappatura fornita.
+      duplicate_mapping: L'attributo %{attribute} è utilizzato più volte.
+      import_failed: Import fallito. %{error}.
+      missing_mapping: Mappatura mancante per l'attributo obbligatorio %{attribute}.
+    success:
+      import_completed: Import completato.

data/lib/importance/configuration.rb

@@ -29,11 +29,12 @@ module Importance
       @teardown_callback = nil
       @error_callback = nil
       @batch = false
+      @worksheet = nil
       instance_eval(&block) if block_given?
     end
 
-    def attribute(key, labels)
-      @attributes << OpenStruct.new(key: key, labels: labels)
+    def attribute(key, labels, options = {})
+      @attributes << OpenStruct.new(key: key, labels: labels, options: options)
     end
 
     def batch_size(size)
@@ -55,6 +56,49 @@ module Importance
     def error(&block)
       @error_callback = block
     end
+
+    def add_spreadsheet(path)
+      workbook = Roo::Spreadsheet.open(path, { csv_options: { encoding: "bom|utf-8" } })
+      @worksheet = workbook.sheet(0)
+    end
+
+    def file_headers
+      @worksheet.row(1)
+    end
+
+    def samples
+      @worksheet.parse[1..5]
+    end
+
+    def full_count
+      @worksheet.count - 1
+    end
+
+    # Yields each processed row (a hash of attribute => value) to the given block.
+    # Skips empty rows (all values nil or empty).
+    def each_processed_row(path, mappings)
+      @worksheet.each_with_index do |row, idx|
+        next if idx == 0 # Skip header row
+        record = process_row(row, mappings)
+        next if record.empty? || record.values.all? { |v| v.nil? || v.to_s.strip.empty? }
+        yield record
+      end
+    end
+
+    # Turn a row of the form ["Hans", "Robert", 1970, "male", "Apple Inc.", "hr@apple.com"]
+    # and a mapping of the form {"0"=>"first_name", "1"=>"last_name", "2"=>"", "3"=>"", "4"=>"", "5"=>"email"}
+    # into a record of the form { first_name: "Hans", last_name: "Robert", email: "hr@apple.com" }
+    def process_row(row, mappings)
+      record = {}
+
+      mappings.each do |column_index, attribute_name|
+        next if attribute_name.nil? || attribute_name == ""
+        value = row[column_index.to_i]
+        record[attribute_name.to_sym] = value
+      end
+
+      record
+    end
   end
 
   def self.configure

data/lib/importance/version.rb

@@ -1,3 +1,3 @@
 module Importance
-  VERSION = "0.2.4"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: importance
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
 - Lukas_Skywalker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-10-10 00:00:00.000000000 Z
+date: 2025-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails