eluvia-base 3.40.0 → 3.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcf7c769d60f4347beee0d63aff1e1e8944e5fb2412985f531465dd833cfe58e
-  data.tar.gz: dc7491fcac983ef84e9f33396139370ce94fb65ce8718742acc4806d4e35e0b6
+  metadata.gz: 69890341f7733c2669578108d2e8dec34c753a9cd9dcfc2ff1125d1ca710492a
+  data.tar.gz: f59a4a2012c88fa70479feb651857458b8ad9f9580904d340478fa26c51c429b
 SHA512:
-  metadata.gz: 1a8eff124c578195160772b542e7ece4419b76ada79214f3b7d7ba3cb5c24768249b8d8c24ea207e37a33e6dc5d4d3b7196f83d369df428ae9724b36702af1e4
-  data.tar.gz: 2df71bbb4195fde554b62bc8052d02894be13b14c652325f08af43b94d4b23385499bf0dbe5847ae16786519e59de04be8b6d8a65f4e734f8202bc99f793a55a
+  metadata.gz: c7f8f95b0d3b6948862cb21080001e1f35e891a4cb01dfa92c847b33145054de9cbc7f67be561f3ffd450e6e51d40b14568949f5e2dc7c1bcc860d52ded15135
+  data.tar.gz: 263c3e8f9a6769695aebade49c3bea01562571b6ea6e104ef6fddb9812d9c6f7b188b82a863f453a4a3bc44e00545a19e64f42ca23d1ad5f656a9cab32b9d4f9

data/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.42.0] — 2026-10-28
+
+### Fixed
+- `Eluvia::PaginationHandler#set_pagination`: `fallback_order_by` no longer overrides the
+  direction of a field that the client's `order_by` (or `default_order_by`) already orders by; it
+  only appends the fields not ordered by yet. This changes behavior: with the default
+  `fallback_order_by: 'created_at:asc'`, `?order_by=created_at:desc` now really sorts descending
+  (before it was silently turned into ascending), and `?order_by=id:desc` with
+  `fallback_order_by: 'id:asc'` keeps `id` descending (HAB-1064).
+
+## [3.41.0] — 2026-10-27
+
+### Added
+- `Eluvia::ActiveRecord::FileArrayAttribute` registers each `file_array_attr` like `file_attr`
+  does: `file_array_attrs`, `file_array_attr_names`, `has_file_array_attr?` and
+  `find_file_array_attr` return its `underlying_attachments`, `underlying_filter`, `nature` and
+  `append_only` (HAB-991).
+- `append_only:` option on `file_array_attr`: the setter takes a list of flat
+  `{filename, content}` files, attaches each one with content, never removes an existing
+  attachment, and ignores `nil`. Requires `underlying_attachments` (HAB-991).
+
 ## [3.40.0] — 2026-09-23
 
 ### Added

data/README.md

@@ -1,10 +1,9 @@
 # Eluvia Base
 
-This library provides a set of Ruby on Rails customizations and other helpers in order to meet common Eluvia standards 
-for API communication (https://sparktech.myjetbrains.com/youtrack/articles/BASE-A-4/Communication-interface-FE-BE) and 
-Eluvia requirements for backend application behavior. 
+Ruby on Rails customizations and helpers implementing the Eluvia
+[API communication standard](https://sparktech.myjetbrains.com/youtrack/articles/BASE-A-4/Communication-interface-FE-BE)
+and common backend behavior:
 
-It applies to both client and server sides:
 - Pagination and ordering is handled for the API requests (server side).
 - Extended params parsing is implemented for the API requests (server side).
 - Extended filtering is handled for the API requests (server side).
@@ -45,8 +44,7 @@ For full list of configuration options, see `lib/eluvia/base/config.rb` file.
 
 ### 2.1. Application controller setup
 
-In order to use all the implemented functionality, you should integrate all defined handlers to your 
-main `ApplicationController`:
+Include the handlers in your `ApplicationController`:
 
 ```ruby
 
@@ -61,78 +59,39 @@ end
 
 ### 2.2. Pagination
 
-In order to interpret `limit`, `offset` and `order_by` parameters, you can user `set_pagination` decorator. It will
-transform the input parameters into the `@order_by`, `@page`, `@limit` and `@padding` instance variables which can be 
-easily used in Active Record and Kaminari interfaces. 
+`set_pagination` reads the `limit`, `offset` and `order_by` query params and sets `@limit`, `@page`, `@padding` and
+`@order_by` for Active Record and Kaminari:
 
 ```ruby
-
 class TestRecordsController < ApplicationController
-  # ...
-
-  before_action -> { set_pagination(20, 0, 'created_at:desc') }, only: [:index]
-
-  # ...
+  before_action -> { set_pagination(default_order_by: 'created_at:desc', fallback_order_by: 'id:asc') }, only: [:index]
 
   def index
     @test_records = TestRecord.all.order(@order_by).page(@page).per(@limit).padding(@padding)
   end
-
-  # ...
-end
-```
-
-**BREAKING CHANGE:** the `limit` param is now capped. Requests with a `limit` above the configured ceiling are
-rejected with a `422 Unprocessable Entity` (error detail on the `limit` field) instead of being silently accepted.
-A negative or non-numeric `limit` no longer falls through to Kaminari — it now also raises the same `422`. Only a
-missing or blank `limit` param still falls back to `default_limit`, unchanged. `limit=0` is treated as a deliberate
-meta-only request (see below) rather than an error, mirroring `ListPagination` in eluvia-base-django.
-
-The ceiling defaults to `Eluvia::Base::Config.max_page_limit` (`1000` by default, `nil` disables the check):
-
-```ruby
-Eluvia::Base::Config.max_page_limit = 500
-```
-
-It can be overridden per controller by overriding `pagination_max_limit`, or per call via the `max_limit:` keyword
-(an explicit `max_limit: nil` removes the ceiling for that call only, regardless of `pagination_max_limit`):
-
-```ruby
-class TestRecordsController < ApplicationController
-  def pagination_max_limit
-    50
-  end
 end
 ```
 
-```ruby
-before_action -> { set_pagination(default_limit: 20, default_offset: 0, max_limit: 50) }, only: [:index]
-```
-
-To restore the pre-validation behavior (invalid or above-ceiling `limit` silently falls back to `default_limit`
-instead of raising `422`), enable `disable_errors` — globally via `Eluvia::Base::Config.disable_pagination_errors =
-true` (default: `false`), or per call via the `disable_errors:` keyword, which takes precedence over the global
-setting:
-
-```ruby
-before_action -> { set_pagination(default_limit: 20, default_offset: 0, disable_errors: true) }, only: [:index]
-```
-
-`limit=0` is accepted by default as a way to request only pagination metadata without fetching any records — check
-`@limit.zero?` in the action and skip the query:
-
-```ruby
-def index
-  @test_records = @limit.zero? ? TestRecord.none : TestRecord.all.order(@order_by).page(@page).per(@limit).padding(@padding)
-end
-```
-
-Pass `allow_meta_only_limit: false` (e.g. for a search-backed resource, mirroring
-`AnySearchCursorBasedPagination` in eluvia-base-django) to reject `limit=0` like any other invalid value instead:
-
-```ruby
-before_action -> { set_pagination(default_limit: 20, default_offset: 0, allow_meta_only_limit: false) }, only: [:index]
-```
+| Keyword                 | Default                            | Meaning                                                       |
+|-------------------------|------------------------------------|---------------------------------------------------------------|
+| `default_limit`         | `20`                               | `limit` when the param is missing or blank                    |
+| `default_offset`        | `0`                                | `offset` when the param is missing                            |
+| `max_limit`             | `pagination_max_limit`             | upper bound for `limit`, `nil` for none                       |
+| `allow_meta_only_limit` | `true`                             | accept `limit=0`                                              |
+| `disable_errors`        | `Config.disable_pagination_errors` | use `default_limit` instead of raising 422 on invalid `limit` |
+| `default_order_by`      | `'created_at:asc'`                 | ordering when `order_by` is missing or blank                  |
+| `force_order_by`        | `false`                            | ignore the `order_by` param, always use `default_order_by`    |
+| `fallback_order_by`     | `'created_at:asc'`                 | tiebreaker appended to the ordering                           |
+
+**Limit.** `limit` must be a non-negative integer not above the ceiling, otherwise the request fails with
+`422 Unprocessable Entity` on `limit`. The ceiling is `Eluvia::Base::Config.max_page_limit` (default `1000`, `nil`
+for none); a controller can override the `pagination_max_limit` method to set its own. `limit=0` returns only the
+pagination metadata, so skip the query when `@limit.zero?`.
+
+**Ordering.** `order_by` is a comma-separated list of `field:asc` or `field:desc` entries; anything else fails with
+`422`. `fallback_order_by` only appends fields the ordering does not contain yet, so it never changes the requested
+direction; set it to the primary key to keep pages stable when ordered values are equal. For example,
+`?order_by=name:asc,id:desc` with `fallback_order_by: 'id:asc'` yields `{ 'name' => :asc, 'id' => :desc }`.
 
 ### 2.3. Params parser
 
@@ -195,8 +154,7 @@ For the full list of features, see `Eluvia::EluviaIntegration` interface.
 
 ### 2.5. Raising error
 
-You can raise en exception `Eluvia::Errors::XXX` anywhere in the code and this exception will be automatically 
-formatted as standardized error response.
+An `Eluvia::Errors::XXX` exception raised anywhere in the code is rendered as a standardized error response.
 
 For example, this exception:
 
@@ -256,12 +214,10 @@ For the full list of available exceptions, see content of `lib/eluvia/errors` fo
 
 ### 2.6. Chunked/direct upload finalization
 
-`Eluvia::File` carries an `upload_key` attribute, an alternative to `content` (base64 encoded file data)
-for `file_attr` fields backed by an underlying ActiveStorage attachment. When `upload_key` is present,
-the setter no longer base64-decodes `content` — instead it delegates to `Eluvia::Uploads.finalizer`, a
-registrable extension point that finalizes a previously uploaded (chunked/direct) temp object into the
-ActiveStorage attachment. This lets a separate library (e.g. a chunked upload provider) implement the
-actual storage logic (S3 `copy_object`, tus, ...) without eluvia-base depending on it.
+An `Eluvia::File` assigned to a `file_attr` field may carry an `upload_key` instead of base64 `content`. The key
+identifies an already uploaded (chunked/direct) temp object, and the setter passes it to `Eluvia::Uploads.finalizer`,
+which attaches it to the ActiveStorage record. The storage logic (S3 `copy_object`, tus, ...) thus lives in the
+application or another library, not in this gem. `file_array_attr` fields reject `upload_key` with `400 Bad Request`.
 
 Register a finalizer, typically from an initializer:
 
@@ -273,8 +229,7 @@ Eluvia::Uploads.finalizer = ->(attachment_record, upload_key, filename) do
 end
 ```
 
-If `upload_key` is present on the assigned `Eluvia::File` but no finalizer is registered, a
-`Eluvia::Errors::StandardError` is raised.
+Assigning a file with `upload_key` while no finalizer is registered raises `Eluvia::Errors::StandardError`.
 
 ### 2.7. ENV-driven scope restriction
 
@@ -324,13 +279,10 @@ are NULL-safe: a row whose value is `NULL` is kept.
 
 ### 2.8. Translations
 
-All validation error messages raised by this gem (ordering, filtering, fieldset and pagination errors) go through
-`I18n.t` with an English `default:`, so the gem works out of the box without any locale setup. In addition,
-`lib/eluvia/locales/*.yml` ships ready-made translations — under the `eluvia.errors.*` key namespace — for the
-same set of languages supported by `habarico`: `cs`, `de`, `en`, `es`, `fr`, `it`, `ja`, `nl`, `pl`, `pt`, `ro`,
-`sk`, `uk`. These are appended to `I18n.load_path` automatically when the gem loads; a host application only
-needs to add the relevant locale to its own `I18n.available_locales` and set `I18n.locale` as usual. A host app's
-own `config/locales/*.yml` takes precedence over these if it defines the same key.
+Validation error messages of this gem go through `I18n.t` with an English default, so no locale setup is needed.
+Translations for `cs`, `de`, `en`, `es`, `fr`, `it`, `ja`, `nl`, `pl`, `pt`, `ro`, `sk` and `uk` (under
+`eluvia.errors.*`) are added to `I18n.load_path` when the gem loads. The application's own `config/locales/*.yml`
+takes precedence for the same key.
 
 ## 3. Development
 

data/lib/eluvia/active_record/file_array_attribute.rb

@@ -6,6 +6,30 @@ module Eluvia
 
       class_methods do
 
+        # *********************************************************************
+        # Attribute store methods
+        # *********************************************************************
+
+        def _file_array_attrs
+          @file_array_attrs ||= {}
+        end
+
+        def file_array_attrs
+          _file_array_attrs.values
+        end
+
+        def file_array_attr_names
+          file_array_attrs.map { |a| a[:attr_name] }
+        end
+
+        def has_file_array_attr?(attr_name)
+          _file_array_attrs.key?(attr_name.to_sym)
+        end
+
+        def find_file_array_attr(attr_name)
+          _file_array_attrs.fetch(attr_name.to_sym, nil)
+        end
+
         # *********************************************************************
         # Attribute definition methods for file array
         # *********************************************************************
@@ -16,78 +40,101 @@ module Eluvia
         # @param underlying_attachments [Symbol, nil] Name of the attribute holding underlying Active Storage attachments
         # @param underlying_filter [Proc, nil] Optional filter to be applied to scope underlying attachments
         # @param nature [Symbol] Nature of file attribute (:file, :image, etc.)
+        # @param append_only [Boolean] Whether the setter only attaches new `{filename, content}` files and never removes existing ones
         # @param declare [Boolean] Whether to declare the underlying attribute
-        def file_array_attr(attr_name, underlying_attachments: nil, underlying_filter: nil, nature: :file, declare: false)
+        def file_array_attr(attr_name, underlying_attachments: nil, underlying_filter: nil, nature: :file, append_only: false, declare: false)
           attr_name = attr_name.to_sym
           nature = nature.to_sym
 
+          raise ArgumentError, "`append_only` file array attribute `#{attr_name}` requires `underlying_attachments`." if append_only && !underlying_attachments
+
           # Define it using "has many" attribute
           if declare
             has_many_attr(attr_name, nature == :image ? 'Eluvia::ImageWrapper' : 'Eluvia::FileWrapper')
           end
 
+          # Register metadata
+          self._file_array_attrs[attr_name] = {
+            attr_name: attr_name,
+            underlying_attachments: underlying_attachments,
+            underlying_filter: underlying_filter,
+            nature: nature,
+            append_only: append_only
+          }
+
           # *******************************************************************
           # Dynamically defined instance methods for file array
           # *******************************************************************
 
           if underlying_attachments
 
-            # Set method
-            define_method(:"#{attr_name}=") do |new_values|
-
-              # Check input
-              raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}`, expecting Array.") unless new_values.is_a?(::Array)
-
-              # Current values
-              current_values = self.send(attr_name)
-              current_ids = current_values.map(&:id)
-              new_ids = []
-
-              # Create missing attachments
-              new_values.each do |value|
-                # Normalize and check value
-                if value.is_a?(::Hash)
-                  if nature == :image
-                    value = Eluvia::ImageWrapper.map(value)
-                  else
-                    value = Eluvia::FileWrapper.map(value)
+            if append_only
+
+              # Set method - attaches each new file, leaves the existing attachments untouched
+              define_method(:"#{attr_name}=") do |new_values|
+                append_file_array_uploads(attr_name, underlying_attachments, new_values)
+              end
+
+            else
+
+              # Set method
+              define_method(:"#{attr_name}=") do |new_values|
+
+                # Check input
+                raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}`, expecting Array.") unless new_values.is_a?(::Array)
+
+                # Current values
+                current_values = self.send(attr_name)
+                current_ids = current_values.map(&:id)
+                new_ids = []
+
+                # Create missing attachments
+                new_values.each do |value|
+                  # Normalize and check value
+                  if value.is_a?(::Hash)
+                    if nature == :image
+                      value = Eluvia::ImageWrapper.map(value)
+                    else
+                      value = Eluvia::FileWrapper.map(value)
+                    end
                   end
-                end
-                raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[]`, expecting Eluvia::FileWrapper or Eluvia::ImageWrapper.") unless value.is_a?(Eluvia::FileWrapper) || value.is_a?(Eluvia::ImageWrapper)
-                raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[].file`, can't be blank.") if value.file.blank?
+                  raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[]`, expecting Eluvia::FileWrapper or Eluvia::ImageWrapper.") unless value.is_a?(Eluvia::FileWrapper) || value.is_a?(Eluvia::ImageWrapper)
+                  raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[].file`, can't be blank.") if value.file.blank?
 
-                # Keep track of new ids
-                new_ids << value.id if value.id
+                  # Keep track of new ids
+                  new_ids << value.id if value.id
 
-                # Retrieve filename and content
-                filename = value.file&.filename
-                content = value.file&.content
+                  # Retrieve filename and content
+                  filename = value.file&.filename
+                  content = value.file&.content
 
-                # Sanitize filename
-                filename = ActiveStorage::Filename.new(filename).sanitized
+                  # Sanitize filename
+                  filename = ActiveStorage::Filename.new(filename).sanitized
 
-                # Create or update attachment only if both filename and content are passed (this means that user uploaded a new file)
-                if !filename.blank? && !content.blank?
+                  # Create or update attachment only if both filename and content are passed (this means that user uploaded a new file)
+                  if !filename.blank? && !content.blank?
 
-                  # Delete the existing attachment
-                  if value.id && current_ids.include?(value.id)
-                    attachment_record = self.send("#{underlying_attachments}_attachments").find(value.id)
-                    attachment_record.purge_later
+                    # Delete the existing attachment
+                    if value.id && current_ids.include?(value.id)
+                      attachment_record = self.send("#{underlying_attachments}_attachments").find(value.id)
+                      attachment_record.purge_later
+                    end
+
+                    # Create a new attachment
+                    self.send(underlying_attachments).attach(io: StringIO.new(Base64.decode64(content)), filename: filename)
                   end
 
-                  # Create a new attachment
-                  self.send(underlying_attachments).attach(io: StringIO.new(Base64.decode64(content)), filename: filename)
                 end
 
-              end
-
-              # Delete no longer wanted attachments
-              current_values.each do |value|
-                unless new_ids.include?(value.id)
-                  attachment_record = self.send("#{underlying_attachments}_attachments").find(value.id)
-                  attachment_record.purge_later
+                # Delete no longer wanted attachments
+                current_values.each do |value|
+                  unless new_ids.include?(value.id)
+                    attachment_record = self.send("#{underlying_attachments}_attachments").find(value.id)
+                    attachment_record.purge_later
+                  end
                 end
               end
+
             end
 
             # Get method
@@ -111,6 +158,32 @@ module Eluvia
         end
 
       end
+
+      private
+
+      # Attaches each `{filename, content}` upload of an append-only file array attribute
+      def append_file_array_uploads(attr_name, underlying_attachments, new_values)
+        return if new_values.nil?
+
+        # Check input
+        raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}`, expecting Array.") unless new_values.is_a?(::Array)
+
+        new_values.each do |value|
+          # Normalize and check value
+          value = Eluvia::File.map(value) if value.is_a?(::Hash)
+          raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[]`, expecting Eluvia::File.") unless value.is_a?(Eluvia::File)
+          raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[]`, `upload_key` is not supported.") if value.upload_key.present?
+
+          # An item without content carries no new file
+          next if value.content.blank?
+
+          filename = ActiveStorage::Filename.new(value.filename.to_s).sanitized
+          raise Eluvia::Errors::BadRequest.new("Invalid value for attribute `#{attr_name}[].filename`, can't be blank.") if filename.blank?
+
+          self.send(underlying_attachments).attach(io: StringIO.new(Base64.decode64(value.content)), filename: filename)
+        end
+      end
+
     end
   end
 end

data/lib/eluvia/active_record/file_attribute.rb

@@ -75,11 +75,8 @@ module Eluvia
               value = Eluvia::File.map(value) if value.is_a?(::Hash)
               raise Eluvia::Errors::BadRequest.new("Invalid value for file attribute `#{attr_name}`, expecting Eluvia::File.") unless value.is_a?(Eluvia::File)
 
-              # Retrieve and check filename - for a chunked/direct upload the frontend only sends
-              # `upload_key` (see habarico's `uploadFileChunked`), not a separate filename; the key
-              # itself already encodes the original filename as its last path segment (providers
-              # build it as `<tmp_prefix><uuid>/<filename>`), so fall back to that instead of
-              # requiring it to be sent twice.
+              # Retrieve and check filename - a chunked/direct upload may send only `upload_key`,
+              # whose last path segment is the original filename (`<tmp_prefix><uuid>/<filename>`)
               filename = value.filename
               filename = ::File.basename(value.upload_key) if filename.blank? && value.upload_key.present?
               raise Eluvia::Errors::BadRequest.new("Expected `filename` in the attribute `#{attr_name}`.") if filename.blank?

data/lib/eluvia/base/config.rb

@@ -40,16 +40,14 @@ module Eluvia
       mattr_accessor :search_use_unaccent
       @@search_use_unaccent = true
 
-      # Upper bound for the `limit` pagination param on `set_pagination`. Requests with a
-      # higher `limit` are rejected with 422 instead of being silently truncated. `nil`
-      # disables the check. Mirrors `MAX_PAGE_LIMIT` in eluvia-base-django. (default: 1000)
+      # Upper bound for the `limit` param of `set_pagination`; a higher `limit` is rejected with 422.
+      # `nil` disables the check. (default: 1000)
       mattr_accessor :max_page_limit
       @@max_page_limit = 1000
 
-      # Whether an invalid `limit` param (non-numeric, negative, above `max_page_limit`, or zero
-      # without `allow_meta_only_limit:`) on `set_pagination` silently falls back to
-      # `default_limit` instead of being rejected with 422. Mirrors `disable_errors` on
-      # `LimitResolutionMixin` in eluvia-base-django. (default: false)
+      # Whether `set_pagination` uses `default_limit` for an invalid `limit` param (non-numeric,
+      # negative, above `max_page_limit`, or zero without `allow_meta_only_limit:`) instead of
+      # rejecting it with 422. (default: false)
       mattr_accessor :disable_pagination_errors
       @@disable_pagination_errors = false
 

data/lib/eluvia/handlers/pagination_handler.rb

@@ -44,10 +44,18 @@ module Eluvia
       # A blank `order_by` is treated as "not supplied" (falls through to defaults/fallback)
       # rather than as a literal empty ordering, since a Kaminari scope always needs some order.
       order_by = !force_order_by && user_order_by.present? ? user_order_by : default_order_by
-      order_by = "#{order_by},#{fallback_order_by}"
 
+      # Within `order_by` a repeated field takes its last direction; `fallback_order_by` only
+      # appends fields not already ordered by, so it never overrides the requested direction.
       @order_by = {}
-      order_by.split(',').each do |entry|
+      parse_order_by(order_by) { |field_name, direction| @order_by[field_name] = direction }
+      parse_order_by(fallback_order_by) { |field_name, direction| @order_by[field_name] ||= direction }
+    end
+
+    private
+
+    def parse_order_by(order_by)
+      order_by.to_s.split(',').each do |entry|
         entry = entry.strip
         # `-1` keeps a trailing empty segment (e.g. `name:`) instead of Ruby's default of
         # dropping it, so it is caught below as an invalid direction rather than as a bare field.
@@ -68,13 +76,10 @@ module Eluvia
           })
         end
 
-        @order_by[field_name] = direction.to_sym
+        yield field_name, direction.to_sym
       end
-
     end
 
-    private
-
     def resolve_pagination_limit(default_limit:, max_limit:, disable_errors:, allow_meta_only_limit:)
       return default_limit unless params[:limit].present?
 

data/lib/eluvia/uploads.rb

@@ -2,8 +2,8 @@ module Eluvia
   module Uploads
 
     # Extension point for finalizing chunked/direct uploads (identified by `Eluvia::File#upload_key`)
-    # into the underlying ActiveStorage attachment. Left unset by default so that eluvia-base has no
-    # dependency on any specific storage provider (e.g. aws-sdk-s3) or on habarico.
+    # into the underlying ActiveStorage attachment. Unset by default, so the gem does not depend on
+    # any storage provider (e.g. aws-sdk-s3).
     #
     # Consumers register a callable of the form:
     #   ->(attachment_record, upload_key, filename) { ... }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eluvia-base
 version: !ruby/object:Gem::Version
-  version: 3.40.0
+  version: 3.42.0
 platform: ruby
 authors:
 - Matěj Outlý
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-23 00:00:00.000000000 Z
+date: 2026-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client