importance 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3ca5129019f5ae56f87a0f1fdecb67536010d39d93365f1ae46cb5bd41332ab
-  data.tar.gz: eaa6be85de8f2d28a895d5a16a194b45e1bb46f01621a7b6b5a6ccae978ce9c3
+  metadata.gz: e0df06e38c78ddb548f82dd7108a1ff45ac679ad21c8b6549ccba6107cbf37b3
+  data.tar.gz: 1cd461bbaf521ab3d4358faa4accf85553d47fbb9941b8462d7e4342a154b45e
 SHA512:
-  metadata.gz: f4e87f855969ab9da45721363e2b1d7bd17a9685381f10579ffa9de6df5b3b6267c78ac92ac6405d872926b50d87d09be3fa8b6a0419282255595b43ded63d63
-  data.tar.gz: 67c9fe0b5f55256f657ac1e8a4c437a3a84e8412d712f28ee829fcc2b9ab1b937d9920a9817eb28b183e09aa5c61643138f12e10b3bf6560651a136ea5cc92e7
+  metadata.gz: 855023fbe7167ff911683626c1e3f0d2eb0ae058f261f56c7f2e9d96afb01dc40e8a7e192f62fb1f47c79e824a971b8b46dee408d0b68370fc304695a0e66020
+  data.tar.gz: 0b98ee22a71bb61a5cf7a218795eb934b418317dde08ebd22bd267757d7648c531d0ae0e432ec5e4746146ca54562620c2d397c005473fc237aa19cde80f8b23

data/README.md

@@ -1,10 +1,11 @@
 # Importance
-Short description and motivation.
 
-## Usage
-How to use my plugin.
+Importance allows users to select which columns of an Excel or CSV file should be
+imported and which ones should be ignored. This makes it possible to upload
+files with arbitrary headers, as long as all necessary data is contained.
 
 ## Installation
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -21,12 +22,191 @@ Or install it yourself as:
 $ gem install importance
 ```
 
-## Releasing
+Generate the initializer:
+
+```bash
+rails generate importance:install
+```
+
+This will create a configuration file at `config/initializers/importance.rb` and mount
+the engine in `config/routes.rb`.
+
+## Usage
+
+Importance allows you to define one or more `importers`, where each allows you
+to define a different treatment of the data you uploaded.
+
+Define the uploaders in an initializer, for example `config/initializers/importance.rb`.
+You can define as many importers as you want.
+
+Each importer can define callbacks that control what is done before the import, during the import,
+after the import and if any errors occurred.
+
+| Callback | Usage |
+|---|---|
+| `setup` | Code to be run once before the import. Initialization of an error array, loading of required parent records |
+| `perform` | The actual import logic. This block receives a collection of `records` for which you write the logic to import. It may be called multiple times if the dataset is large. |
+| `teardown` | Code to be run one after the import. Cleanup, flushing data to a log. |
+| `error` | Callback if any unhandled exception occurred. Recives the exception as a parameter. |
+
+```ruby
+Importance.configure do |config|
+  config.set_layout :bootstrap
+
+  config.register_importer :students do |importer|
+    importer.attribute :first_name, [ "Vorname", "vorname", "vname", "fname", "l_vorname" ]
+    importer.attribute :last_name, [ "Nachname", "nachname", "nname", "lname", "l_nachname" ]
+    importer.attribute :email, [ "E-Mail", "email", "mail", "l_email" ]
+    
+    importer.batch_size 500
+    
+    # Setup code runs before import
+    importer.setup do
+      @total_count = 0
+      @errors = []
+      @school = School.find(params[:school_id]) # Access to params
+    end
+
+    # Main import logic has access to instance variables from setup
+    importer.perform do |records|
+      @total_count += records.size
+      
+      records.each do |record|
+        begin
+          Student.create(
+            first_name: record[:first_name],
+            last_name: record[:last_name],
+            email: record[:email],
+            created_by: current_user.id,  # Access to current_user
+            school_id: @school.id         # Access to instance var from setup
+          )
+        rescue => e
+          @errors << { record: record, message: e.message }
+        end
+      end
+    end
+    
+    # Teardown code runs after import
+    importer.teardown do
+      # Can access both controller context and setup variables
+      ActivityLog.create(
+        user: current_user,
+        action: "import",
+        details: "Imported #{@total_count} students with #{@errors.size} errors"
+      )
+      
+      # Display errors to the user if any occurred
+      if @errors.any?
+        # Store errors in database to avoid session size limits (4KB)
+        import_log = ImportLog.create!(
+          user: current_user,
+          total_records: @total_count,
+          error_count: @errors.size,
+          errors_data: @errors.to_json
+        )
+        
+        flash[:alert] = "Import completed with #{@errors.size} errors. Please review the details below."
+        redirect_to rails_routes.import_log_path(import_log)
+      else
+        redirect_to rails_routes.students_path, notice: "Successfully imported #{@total_count} students."
+      end
+    end
+
+    # Controller code to run after the import
+    importer.error do |exception|
+      redirect_to rails_routes.root_path, alert: "Import failed: #{exception.message}"
+    end
+  end
+end
+```
+
+Add a file upload form to your application. You can use libraries like
+Dropzone.js to create drag and drop interfaces, and you can style them just
+as you wish. Make sure the path stays, and it is a multipart form.
 
-Run `rake build` to build the gem. Then run `rake release` to push it to rubygems.org.
+The gem supports Excel files (.xlsx, .xls) and CSV files (.csv). For CSV files,
+the first row is automatically treated as the header row.
+
+```erb
+<%= form_with url: importance.submit_path(importer: :students), multipart: true do |form| %>
+  <%= form.file_field :file, accept: ".xlsx,.xls,.csv" %>
+  <%= form.submit "Submit" %>
+<% end %>
+```
+
+### Displaying Import Errors
+
+If you collect errors in the `@errors` variable during import (as shown in the example above), you can display them to users in your views. Since sessions have a 4KB limit, errors are stored in the database:
+
+First, create an ImportLog model to store the errors:
+
+```ruby
+# app/models/import_log.rb
+class ImportLog < ApplicationRecord
+  belongs_to :user
+  
+  def errors_array
+    JSON.parse(errors_data || '[]')
+  end
+end
+```
+
+```ruby
+# Migration
+class CreateImportLogs < ActiveRecord::Migration[7.0]
+  def change
+    create_table :import_logs do |t|
+      t.references :user, null: false, foreign_key: true
+      t.integer :total_records
+      t.integer :error_count
+      t.text :errors_data
+      t.timestamps
+    end
+  end
+end
+```
+
+Then display the errors in your view:
+
+```erb
+<!-- In your import_logs/show.html.erb view -->
+<div class="alert alert-warning">
+  <h4>Import Errors</h4>
+  <p>The following <%= @import_log.error_count %> records could not be imported:</p>
+  
+  <% errors = @import_log.errors_array %>
+  <% if errors.size > 50 %>
+    <p><em>Showing first 50 errors (total: <%= errors.size %>)</em></p>
+    <% errors = errors.first(50) %>
+  <% end %>
+  
+  <ul>
+    <% errors.each do |error| %>
+      <li>
+        <strong>Row data:</strong> <%= error["record"].inspect %><br>
+        <strong>Error:</strong> <%= error["message"] %>
+      </li>
+    <% end %>
+  </ul>
+</div>
+```
+
+## Customization
+
+The following translations can be overriden by the application
+
+```yml
+en:
+  importance:
+    use_column_as: Use column as
+    ignore: Ignore
+    import: Import
+```
 
 ## Contributing
+
 Contribution directions go here.
 
 ## License
+
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/controllers/importance/application_controller.rb

@@ -1,4 +1,6 @@
 module Importance
-  class ApplicationController < ActionController::Base
+  class ApplicationController < ::ApplicationController
+    include Rails.application.routes.url_helpers
+    helper Rails.application.routes.url_helpers
   end
 end

data/app/controllers/importance/imports_controller.rb

@@ -0,0 +1,134 @@
+require "xsv"
+require "csv"
+
+module Importance
+  class ImportsController < ApplicationController
+    # Form submission target. Persist the file and redirect to the mapping page.
+    def submit
+      upload = params[:file]
+
+      raise ArgumentError, "Upload cannot be nil" if upload.nil?
+
+      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)
+
+      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)
+
+      raise ArgumentError, "File does not exist at #{upload_path}" if !File.exist?(upload_path)
+
+      FileUtils.mv(upload_path, persist_path)
+
+      session[:path] = persist_path
+      session[:importer] = params[:importer].to_sym
+
+      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?
+
+      if csv_file?
+        csv_data = CSV.read(session[:path], headers: true)
+        @file_headers = csv_data.headers
+        @samples = csv_data.first(5).map(&:to_h)
+      else
+        workbook = Xsv.open(session[:path], parse_headers: true)
+        worksheet = workbook.first
+        @file_headers = worksheet.first.keys
+        @samples = worksheet.first(5)
+      end
+
+      @importer_attributes = importer.attributes
+      @layout = "Importance::#{Importance.configuration.layout.to_s.camelize}Layout".constantize
+    end
+
+    # Import page. Load the file according to the mapping and import it.
+    def import
+      importer = Importance.configuration.importers[session[:importer].to_sym]
+      mappings = params[:mappings]
+
+      raise ArgumentError, "Mapping cannot be nil" if mappings.nil?
+
+      if importer.setup_callback
+        instance_exec(&importer.setup_callback)
+      end
+
+      begin
+        records_to_import = []
+
+        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 records_to_import.any?
+          instance_exec(records_to_import, &importer.perform_callback)
+        end
+
+        if importer.teardown_callback
+          instance_exec(&importer.teardown_callback)
+        else
+          redirect_to session[:redirect_url] || root_path, notice: "Import completed."
+        end
+
+      rescue => e
+        if importer.error_callback
+          instance_exec(e, &importer.error_callback)
+        end
+      end
+    end
+
+    private
+
+    def csv_file?
+      File.extname(session[:path]).downcase == ".csv"
+    end
+
+    def each_processed_row(mappings)
+      if csv_file?
+        CSV.foreach(session[:path], headers: true) do |row|
+          record = process_row(row.to_h, mappings)
+          next if record.empty? || record.values.all? { |v| v.nil? || v.to_s.strip.empty? }
+          yield record
+        end
+      else
+        workbook = Xsv.open(session[:path], parse_headers: true)
+        worksheet = workbook.first
+        worksheet.each do |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
+    end
+
+    def process_row(row, mappings)
+      record = {}
+      row.each do |row_header, value|
+        attribute = mappings.permit!.to_h.find { |column_name, attribute_name| column_name == row_header }
+        next if attribute.nil?
+        attribute = attribute[1]
+        next if attribute.nil? || attribute == ""
+        record[attribute.to_sym] = value
+      end
+      record
+    end
+
+    def rails_routes
+      ::Rails.application.routes.url_helpers
+    end
+  end
+end

data/app/models/importance/blank_layout.rb

@@ -0,0 +1,19 @@
+module Importance
+  class BlankLayout
+    def self.select_class
+      ""
+    end
+
+    def self.submit_class
+      ""
+    end
+
+    def self.table_class
+      ""
+    end
+
+    def self.wrapper_class
+      ""
+    end
+  end
+end

data/app/models/importance/bootstrap_layout.rb

@@ -0,0 +1,19 @@
+module Importance
+  class BootstrapLayout < BlankLayout
+    def self.select_class
+      "form-select"
+    end
+
+    def self.submit_class
+      "btn btn-primary"
+    end
+
+    def self.table_class
+      "table"
+    end
+
+    def self.wrapper_class
+      "table-responsive"
+    end
+  end
+end

data/app/models/importance/header.rb

@@ -0,0 +1,40 @@
+module Importance
+  class Header
+    def self.match_attributes_to_headers(importer_attributes, file_headers)
+      attribute_mappings = {}
+
+      importer_attributes.each do |attribute|
+        best_header = nil
+        best_similarity = 0
+
+        file_headers.each do |header|
+          attribute.labels.each do |label|
+            if header == label
+              best_header = header
+              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
+            similarity = 1 - percentage
+            if similarity > best_similarity
+              best_similarity = similarity
+              best_header = header
+            end
+          end
+        end
+
+        # Only assign if similarity is reasonable (> 0.5) and header isn't already taken
+        if best_similarity > 0.5 && !attribute_mappings.values.include?(best_header)
+          attribute_mappings[attribute.key] = best_header
+        end
+      end
+
+      attribute_mappings
+    end
+
+    def self.default_value_for_header(file_header, attribute_mappings)
+      attribute_mappings.key(file_header) || ""
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+<%= form_with url: importance.import_path, method: :post do |form| %>
+  <div class="importance-wrapper <%= @layout.wrapper_class %>">
+    <%= form.submit t('importance.import'), class: @layout.submit_class %>
+    <table class="importance-table <%= @layout.table_class %>">
+      <thead>
+        <tr>
+          <% @file_headers.each do |file_header| %>
+            <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)
+              %>
+              <%= form.select "mappings[#{file_header}]",
+                              options_for_select(
+                                [[t('importance.ignore'), ""]] + 
+                                @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| %>
+            <th><%= file_header %></th>
+          <% end %>
+        </tr>
+      </thead>
+      <tbody>
+        <% @samples.each do |sample| %>
+          <tr>
+            <% @file_headers.each do |file_header| %>
+              <td><%= sample[file_header] %></td>
+            <% end %>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+<% end %>
+
+<script>
+  const table = document.querySelector('.importance-table');
+  if (table) {
+    const selects = table.querySelectorAll('thead tr:first-child th select');
+    const dataRows = table.querySelectorAll('tbody tr, thead tr');
+
+    const updateIgnoredColumns = () => {
+      dataRows.forEach(row => {
+        Array.from(row.children).forEach(cell => {
+          if (cell.tagName === 'TD' || cell.tagName == 'TH') {
+            cell.classList.remove('ignored');
+          }
+        });
+      });
+
+      selects.forEach(selectElement => {
+        if (selectElement.value === "") {
+          const headerCell = selectElement.closest('th');
+          if (headerCell && headerCell.parentElement) {
+            const columnIndex = Array.from(headerCell.parentElement.children).indexOf(headerCell);
+
+            if (columnIndex !== -1) {
+              dataRows.forEach(row => {
+                const cell = row.children[columnIndex];
+                if (cell && (cell.tagName === 'TD' || cell.tagName === 'TH')) {
+                  cell.classList.add('ignored');
+                }
+              });
+            }
+          }
+        }
+      });
+    };
+
+    updateIgnoredColumns();
+
+    selects.forEach(selectElement => {
+      selectElement.addEventListener('change', updateIgnoredColumns);
+    });
+  }
+</script>

data/config/locales/de.yml

@@ -0,0 +1,5 @@
+de:
+  importance:
+    use_column_as: Spalte verwenden als
+    ignore: Ignorieren
+    import: Importieren

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  importance:
+    use_column_as: Use column as
+    ignore: Ignore
+    import: Import

data/config/locales/fr.yml

@@ -0,0 +1,5 @@
+fr:
+  importance:
+    use_column_as: Utiliser la colonne comme
+    ignore: Ignorer
+    import: Importer

data/config/locales/it.yml

@@ -0,0 +1,5 @@
+it:
+  importance:
+    use_column_as: Utilizzare come
+    ignore: Ignora
+    import: Importare

data/config/routes.rb

@@ -1,2 +1,5 @@
 Importance::Engine.routes.draw do
+  post "/importance/submit", to: "imports#submit", as: :submit
+  get "/importance/map", to: "imports#map", as: :map
+  post "/importance/import", to: "imports#import", as: :import
 end

data/lib/generators/importance/install/USAGE

@@ -0,0 +1,9 @@
+Description:
+    The importance:install generator creates an initializer file at 
+    config/initializers/importance.rb with a basic configuration.
+
+Examples:
+    rails generate importance:install
+
+    This will create:
+        config/initializers/importance.rb

data/lib/generators/importance/install/install_generator.rb

@@ -0,0 +1,17 @@
+module Importance
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates an Importance initializer for your application"
+
+      def copy_initializer
+        template "importance.rb", "config/initializers/importance.rb"
+      end
+
+      def add_route
+        route 'mount Importance::Engine, at: "/"'
+      end
+    end
+  end
+end

data/lib/generators/importance/install/templates/importance.rb

@@ -0,0 +1,68 @@
+# Importance gem configuration
+# Generated on <%= Date.today.strftime("%Y-%m-%d") %>
+
+Importance.configure do |config|
+  # Set the layout to be used for the form. Can be :default or :bootstrap
+  config.set_layout :bootstrap
+
+  # Example importer configuration:
+  config.register_importer :students do |importer|
+    # Define required attributes with possible column names
+    importer.attribute :first_name, [ "First Name", "FirstName", "fname" ]
+    importer.attribute :last_name, [ "Last Name", "LastName", "lname" ]
+    importer.attribute :email, [ "Email", "E-Mail", "email", "mail" ]
+
+    # Process records in batches of this size
+    importer.batch_size 500
+
+    # Setup runs before the import begins
+    importer.setup do
+      @total_count = 0
+      @errors = []
+
+      # Access controller context and request info
+      @current_user_id = current_user.id
+      @import_source = request.remote_ip
+
+      # Initialize any resources needed for the import
+      @logger = Logger.new(Rails.root.join("log/imports.log"))
+      @logger.info("Starting import by #{current_user.email}")
+    end
+
+    # Main import logic
+    importer.on_complete do |records|
+      @total_count += records.size
+
+      records.each do |record|
+        begin
+          Student.create!(
+            first_name: record[:first_name],
+            last_name: record[:last_name],
+            email: record[:email],
+            created_by: @current_user_id
+          )
+        rescue => e
+          @errors << { record: record, message: e.message }
+          @logger.error("Error importing #{record}: #{e.message}")
+        end
+      end
+    end
+
+    # Teardown runs after the import finishes
+    importer.teardown do
+      # Log import results
+      @logger.info("Import completed: #{@total_count} records processed with #{@errors.size} errors")
+
+      # Create an audit record
+      ImportAudit.create!(
+        user_id: @current_user_id,
+        records_count: @total_count,
+        errors_count: @errors.size,
+        source: @import_source
+      )
+
+      # Clean up resources
+      @logger.close
+    end
+  end
+end

data/lib/importance/configuration.rb

@@ -0,0 +1,67 @@
+require "ostruct"
+
+module Importance
+  class Configuration
+    attr_accessor :importers, :layout
+
+    def initialize
+      @importers = {}
+      @layout = :blank
+    end
+
+    def register_importer(name, &block)
+      @importers[name] = Importer.new(name, &block)
+    end
+
+    def set_layout(name)
+      @layout = name
+    end
+  end
+
+  class Importer
+    attr_reader :name, :attributes, :batch, :setup_callback, :perform_callback, :teardown_callback, :error_callback
+
+    def initialize(name, &block)
+      @name = name
+      @attributes = []
+      @setup_callback = nil
+      @perform_callback = nil
+      @teardown_callback = nil
+      @error_callback = nil
+      @batch = false
+      instance_eval(&block) if block_given?
+    end
+
+    def attribute(key, labels)
+      @attributes << OpenStruct.new(key: key, labels: labels)
+    end
+
+    def batch_size(size)
+      @batch = size
+    end
+
+    def setup(&block)
+      @setup_callback = block
+    end
+
+    def perform(&block)
+      @perform_callback = block
+    end
+
+    def teardown(&block)
+      @teardown_callback = block
+    end
+
+    def error(&block)
+      @error_callback = block
+    end
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+end

data/lib/importance/version.rb

@@ -1,3 +1,3 @@
 module Importance
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/importance.rb

@@ -1,6 +1,25 @@
 require "importance/version"
 require "importance/engine"
+require "importance/configuration"
+require "generators/importance/install/install_generator" if defined?(Rails::Generators)
 
 module Importance
-  # Your code goes here...
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Alias for YourImporterGemName.configuration
+    def config
+      configuration
+    end
+
+    # Yields the singleton configuration object to a block.
+    # Used in the Rails initializer.
+    def configure
+      yield(configuration)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: importance
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Lukas_Skywalker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-23 00:00:00.000000000 Z
+date: 2025-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,18 +16,63 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.1
+        version: 7.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.1
-description: Importance allows users to upload spreadsheets in any format and lets
-  them select how the columns should be imported.
+        version: 7.0.2
+- !ruby/object:Gem::Dependency
+  name: xsv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description: Importance is a Rails engine that allows users to upload Excel and CSV
+  files and interactively map columns to model attributes. It handles files with arbitrary
+  headers by letting users select which columns to import and which to ignore, with
+  support for flexible attribute mapping, batch processing, error handling, and customizable
+  import workflows.
 email:
-- LukasSkywalker@users.noreply.github.com
+- git@lukasdiener.ch
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -35,16 +80,27 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/assets/config/importance_manifest.js
 - app/assets/stylesheets/importance/application.css
 - app/controllers/importance/application_controller.rb
+- app/controllers/importance/imports_controller.rb
 - app/helpers/importance/application_helper.rb
 - app/jobs/importance/application_job.rb
 - app/mailers/importance/application_mailer.rb
 - app/models/importance/application_record.rb
-- app/views/layouts/importance/application.html.erb
+- app/models/importance/blank_layout.rb
+- app/models/importance/bootstrap_layout.rb
+- app/models/importance/header.rb
+- app/views/importance/imports/map.html.erb
+- config/locales/de.yml
+- config/locales/en.yml
+- config/locales/fr.yml
+- config/locales/it.yml
 - config/routes.rb
+- lib/generators/importance/install/USAGE
+- lib/generators/importance/install/install_generator.rb
+- lib/generators/importance/install/templates/importance.rb
 - lib/importance.rb
+- lib/importance/configuration.rb
 - lib/importance/engine.rb
 - lib/importance/version.rb
 - lib/tasks/importance_tasks.rake
@@ -71,8 +127,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.16
 signing_key: 
 specification_version: 4
-summary: Flexible importer for Excel and CSV files.
+summary: Flexible Excel and CSV import engine with column mapping for Rails applications
 test_files: []

data/app/assets/config/importance_manifest.js

@@ -1 +0,0 @@
-//= link_directory ../stylesheets/importance .css

data/app/views/layouts/importance/application.html.erb

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Importance</title>
-  <%= csrf_meta_tags %>
-  <%= csp_meta_tag %>
-
-  <%= stylesheet_link_tag    "importance/application", media: "all" %>
-</head>
-<body>
-
-<%= yield %>
-
-</body>
-</html>