shrine-zip-guard 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08688c20b1b8190ce44c95079e5d71a302b42f18f635876f1f8265381650e086'
-  data.tar.gz: 3c5fa541d7cfe9620b405e33ce7457ede9df3f37503583492a0e0089e7ee0f35
+  metadata.gz: 77f0c1a42fe262acd41c72ef110fd74cadf993c0b180624ddd1d47d4a76dd1e7
+  data.tar.gz: 60996e76aa76030fabf52f525be6e6048009c2d8dc063495935d23c2b730ce4e
 SHA512:
-  metadata.gz: d5571ca6c940dc80e911a826bc4231aa6fbb712841d5038a355a4fa8ed0664caf0fa6e506e27d90e73784e77ee690f60d44e5e0904560c7a3ff1d8d8a8fa0252
-  data.tar.gz: 3228249ed0d1246cc04976fd2a7fb7b600bdfe3b20ca5ea343c8c60bda85a540ea1b42808445c2cc4b7a663e8e4908aa91ef3d579128f827f13314888bd0c1e0
+  metadata.gz: 217ee96460de7fea169f1ce225812866a54608f98e4e4af5935a328bcc092b19450561fb9c3b314d298b3b682c31d28749eb963414594656073be3c2fe87d7cc
+  data.tar.gz: 16a011fbd591b0224420807290a1dadf694f79706107b0cc029c108d13fc46ab2c9ba23b929cbed664055fae0e85f9879e36b5ba9b3e04cf9dbef049620fa986

data/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Changelog
 
-## [Unreleased]
+## [0.3.0] - 2026-08-11
+
+### Fixed
+- All rescue branches in `create_derivatives` now explicitly return `{}` instead of the error messages array.
+
+### Changed
+- `rescue ZipGuard::Error` broadened to `rescue StandardError` — catches corrupt ZIP archives, other unexpected errors, and custom error subclasses like `NestedFileError`.
+- Fallback callback (`shrine_class.opts[:zip_guard][:fallback]`) is now invoked for all rescued errors, not just `ZipGuard::Error` subclasses.
+- Renamed internal method `handle_zip_guard_error` to `handle_error`.
+- Renamed internal method `report_fallback` to `report_error`.
+
+## [0.2.0] - 2026-08-06
+
+### Added
+- Per-uploader custom I18n messages via `shrine.zip_guard.errors.<uploader_name>`.
+- Custom messages are supported for `password_protected`, `missing_file`, and `processing_failed` keys.
+- `error_message_key` helper that resolves a custom key based on the uploader class name.
+
+### Changed
+- Custom message lookup no longer depends on ActiveSupport `String#underscore`.
 
 ## [0.1.0] - 2026-08-06
 

data/README.md

@@ -30,18 +30,28 @@ the plugin with `required_files`:
 ```ruby
 class XmlUploader < Shrine
   plugin :derivatives
-  plugin :zip_guard, required_files: ["**/*.xml"]
+  plugin :zip_guard, required_files: ["*.xml"]
 end
 ```
 
-This will automatically check that the ZIP is not password-protected and that it
-contains at least one file matching each glob pattern.
+This checks that the ZIP is not password-protected and that it contains at least
+one file matching each glob pattern. Patterns are matched against the root of the
+archive only. If you want to allow nested files, use a recursive pattern:
+
+```ruby
+plugin :zip_guard, required_files: ["**/*.xml"]
+```
+
+For a specific subdirectory, include the path in the pattern:
+
+```ruby
+plugin :zip_guard, required_files: ["data/*.xml"]
+```
 
 ### Custom processing with `with_zip`
 
-If you need to run your own logic (for example extracting files, checking
-specific paths, or adding custom error rules), use the `with_zip` helper inside
-your `Attacher.derivatives` block:
+If you need to run your own logic (for example extracting files or checking
+specific paths), use the `with_zip` helper inside your `Attacher.derivatives` block:
 
 ```ruby
 class XmlUploader < Shrine
@@ -49,12 +59,9 @@ class XmlUploader < Shrine
   plugin :zip_guard
 
   Attacher.derivatives do |original|
-    Shrine::Plugins::ZipGuard.with_zip(original, required_files: ["**/*.xml"]) do |zip_file|
+    Shrine::Plugins::ZipGuard.with_zip(original, required_files: ["*.xml"]) do |zip_file|
       xmls = zip_file.glob("*.xml")
 
-      # Your custom rule — for example requiring the file to be at the root level
-      raise ZipUploadErrors::NestedFileError if xmls.empty? && zip_file.glob("**/*.xml").any?
-
       if xmls.size == 1
         extracted = Tempfile.new(["extracted", ".xml"], binmode: true)
         extracted.write(xmls.first.get_input_stream.read)
@@ -68,10 +75,14 @@ class XmlUploader < Shrine
 end
 ```
 
+`with_zip` checks for encryption and optional required file patterns before
+yielding the opened ZIP file. You do not need to pass `required_files` to both
+the plugin and `with_zip`.
+
 ## Error messages
 
 All user-facing errors are translated via I18n. The gem ships with English
-defaults. Add your own translations under the `shrine.zip_guard` key:
+defaults under the `shrine.zip_guard` key:
 
 ```yaml
 en:
@@ -82,21 +93,49 @@ en:
       processing_failed: "File could not be processed. Please try again or contact support."
 ```
 
+### Per-uploader custom messages
+
+You can override any message for a specific uploader by adding a key under
+`shrine.zip_guard.errors.<uploader_name>`:
+
+```yaml
+en:
+  shrine:
+    zip_guard:
+      missing_file: "Archive does not contain required file matching '%{pattern}'."
+      errors:
+        digital_box_rd_uploader:
+          missing_file: "XML file must be at the root level of the ZIP archive."
+          password_protected: "This ZIP is password protected."
+          processing_failed: "Could not process this XML ZIP."
+```
+
+If the per-uploader key exists, it is used; otherwise the default key is used.
+The class name is converted with `underscore`, so `MyUploaders::XmlUploader`
+would become `my_uploaders/xml_uploader`.
+
 ## Custom fallback for unexpected errors
 
-By default, unexpected `ZipGuard::Error` subclasses are reported to the Rails error
+By default, any unhandled error (including corrupt ZIP archives, `StandardError`
+subclasses not explicitly caught by the plugin) is reported to the Rails error
 reporter (if available) and a generic `processing_failed` message is added to
-`attacher.errors`. You can override this with your own handler:
+`attacher.errors`.
+
+You can override this with your own handler:
 
 ```ruby
 plugin :zip_guard,
-       required_files: ["**/*.xml"],
+       required_files: ["*.xml"],
        fallback: lambda { |error, attacher|
          Sentry.capture_exception(error)
          attacher.errors << "Custom processing error: #{error.message}"
        }
 ```
 
+The fallback is called for any rescued error that is not a specific
+`EncryptedZipError` or `MissingFileError`. This includes corrupt ZIPs, custom
+application error classes, and other unexpected errors.
+
 ## Supported versions
 
 - Ruby >= 3.1

data/lib/shrine/plugins/zip_guard.rb

@@ -48,30 +48,47 @@ class Shrine
         def create_derivatives(*args, **options, &)
           super
         rescue ZipGuard::EncryptedZipError
-          errors << I18n.t("shrine.zip_guard.password_protected")
+          errors << I18n.t(error_message_key("password_protected"))
           {}
         rescue ZipGuard::MissingFileError => e
-          errors << I18n.t("shrine.zip_guard.missing_file", pattern: e.pattern)
+          errors << I18n.t(error_message_key("missing_file"), pattern: e.pattern)
           {}
-        rescue ZipGuard::Error => e
-          handle_zip_guard_error(e)
+        rescue StandardError => e
+          handle_error(e)
           {}
         end
 
         private
 
-        def handle_zip_guard_error(error)
+        def error_message_key(base_key)
+          uploader_name = shrine_class.name
+          return "shrine.zip_guard.#{base_key}" unless uploader_name
+
+          custom_key = "shrine.zip_guard.errors.#{underscore(uploader_name)}.#{base_key}"
+          I18n.t(custom_key, default: nil) ? custom_key : "shrine.zip_guard.#{base_key}"
+        end
+
+        def underscore(class_name)
+          class_name
+            .gsub("::", "/")
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr("-", "_")
+            .downcase
+        end
+
+        def handle_error(error)
           fallback = shrine_class.opts[:zip_guard][:fallback]
 
           if fallback
             fallback.call(error, self)
           else
-            report_fallback(error)
-            errors << I18n.t("shrine.zip_guard.processing_failed")
+            report_error(error)
+            errors << I18n.t(error_message_key("processing_failed"))
           end
         end
 
-        def report_fallback(error)
+        def report_error(error)
           return unless defined?(Rails) && Rails.respond_to?(:error) && Rails.error.respond_to?(:report)
 
           Rails.error.report(error)

data/lib/shrine-zip-guard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ShrineZipGuard
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shrine-zip-guard
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Martin Dobrovodský
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-06 00:00:00.000000000 Z
+date: 2026-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n