kt-paperclip 6.4.2 → 8.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cff96583dd89dcd0254140d27f4b8043137acd917c804d7710367d719342119
-  data.tar.gz: 27c6a63b58e72a52ec6ea87e82267d0a3ddb87815333295618d8d179c5c52d45
+  metadata.gz: 71b12469bab65eb2861d1170c154ecf1a08f6a0591806096f3d49f598f4ec115
+  data.tar.gz: 12efe7db20633834994b3b1836cc697ff21dbf1bd37851346d1bd5e0961aa045
 SHA512:
-  metadata.gz: c37f46113c6c74e4e862b287174873f58d467adcfaee18766738c87eaa1757deac8363810883b3b0ae604d4cfa8b1223ec7edbe3af9687972c7ba53cc62578ab
-  data.tar.gz: 8cc931814748df871550746bb8798cc06bc018285659f4ddf07632d24d72fa374f867b840a7aa776da957821755cbe869a130abd77ce75636b71a6f5a9df14ed
+  metadata.gz: 6db416b89eaa01127e3b8eb7ac7615a19d840a236ea114be4814675d61765fa53f25e25b351b5d9438badf06ab3a20ec036565a418f47dbbcd97563d96e0f91f
+  data.tar.gz: 8aa390b628e9926d17c9de71e0dfe861fe2197762fff916064e1b61bd18fda5e3d2f6eda291d4e208e36ecb2fa3fc98ca366e5a28c479f7dde00b02736be2765

data/LICENSE

@@ -1,9 +1,9 @@
-
 LICENSE
 
 The MIT License
 
 Copyright (c) 2008-2016 Jon Yurek and thoughtbot, inc.
+Copyright (c) 2019-2025 Kreeti Technologies Pvt Ltd.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -90,76 +90,44 @@ Requirements
 
 ### Ruby and Rails
 
-Paperclip now requires Ruby version **>= 2.2** and Rails version **>= 4.2**
+Paperclip now requires Ruby version **>= 2.7** and Rails version **>= 5.2**
 (only if you're going to use Paperclip with Ruby on Rails).
 
-### Image Processor
+### ImageMagick Image Processor
 
-[ImageMagick](http://www.imagemagick.org) must be installed and Paperclip must have access to it. To ensure
-that it does, on your command line, run `which convert` (one of the ImageMagick
-utilities). This will give you the path where that utility is installed. For
-example, it might return `/usr/local/bin/convert`.
+[ImageMagick](http://www.imagemagick.org) must be installed and Paperclip must have access to it.
+Refer to ImageMagick's [installations instructions](https://imagemagick.org/download/).
+ImageMagick 7 is the latest version. As of April 2026, some package managers such as `apt`
+still install ImageMagick 6.
 
-Then, in your environment config file, let Paperclip know to look there by adding that
-directory to its path.
-
-In development mode, you might add this line to `config/environments/development.rb)`:
+Paperclip supports both ImageMagick versions 6 and 7, and will auto-detect your version.
+You may enforce a specific version in an initializer such as `config/initializers/paperclip.rb`:
 
 ```ruby
-Paperclip.options[:command_path] = "/usr/local/bin/"
+Paperclip.options[:imagemagick_version] = "7"
 ```
 
-If you're on Mac OS X, you'll want to run the following with [Homebrew](http://www.brew.sh):
-
-    brew install imagemagick
-
-If you are dealing with pdf uploads or running the test suite, you'll also need
-to install GhostScript. On Mac OS X, you can also install that using Homebrew:
-
-    brew install gs
-
-If you are on Ubuntu (or any Debian base Linux distribution), you'll want to run
-the following with apt-get:
-
-    sudo apt-get install imagemagick -y
-
-### `file`
-
-The Unix [`file` command](https://en.wikipedia.org/wiki/File_(command)) is required for content-type checking.
-This utility isn't available in Windows, but comes bundled with Ruby [Devkit](https://github.com/oneclick/rubyinstaller/wiki/Development-Kit),
-so Windows users must make sure that the devkit is installed and added to the system `PATH`.
-
-**Manual Installation**
-
-If you're using Windows 7+ as a development environment, you may need to install the `file.exe` application manually. The `file spoofing` system in Paperclip 4+ relies on this; if you don't have it working, you'll receive `Validation failed: Upload file has an extension that does not match its contents.` errors.
-
-To manually install, you should perform the following:
+Please ensure ImageMagick is in your environment path, or alternatively set
+the path manually in an initializer:
 
-> **Download & install `file` from [this URL](http://gnuwin32.sourceforge.net/packages/file.htm)**
-
-To test, you can use the image below:
-![untitled](https://cloud.githubusercontent.com/assets/1104431/4524452/a1f8cce4-4d44-11e4-872e-17adb96f79c9.png)
-
-Next, you need to integrate with your environment - preferably through the `PATH` variable, or by changing your `config/environments/development.rb` file
-
-**PATH**
-
-    1. Click "Start"
-    2. On "Computer", right-click and select "Properties"
-    3. In Properties, select "Advanced System Settings"
-    4. Click the "Environment Variables" button
-    5. Locate the "PATH" var - at the end, add the path to your newly installed `file.exe` (typically `C:\Program Files (x86)\GnuWin32\bin`)
-    6. Restart any CMD shells you have open & see if it works
+```ruby
+Paperclip.options[:imagemagick_path] = "/usr/local/bin/"
+```
 
-OR
+### Optional: Unix `file` Command
 
-**Environment**
+Paperclip uses the [Marcel gem](https://github.com/rails/marcel) to detect file content types.
+If Marcel cannot detect the type, the [Unix `file` command](https://en.wikipedia.org/wiki/File_(command))
+is used as an optional fallback. To use it, ensure `file` is in your environment path,
+or alternatively set its path manually in an initializer:
 
-    1. Open `config/environments/development.rb`
-    2. Add the following line: `Paperclip.options[:command_path] = 'C:\Program Files (x86)\GnuWin32\bin'`
-    3. Restart your Rails server
+```ruby
+Paperclip.options[:file_command_path] = "/usr/local/bin/"
+```
 
-Either of these methods will give your Rails setup access to the `file.exe` functionality, thus providing the ability to check the contents of a file (fixing the spoofing problem)
+Windows users should install the `file` utility via the Ruby Installer for Windows'
+[DevKit](https://github.com/oneclick/rubyinstaller/wiki/Development-Kit), or alternatively,
+by installing [MSYS2](https://www.msys2.org/) which provides Unix utilities for Windows.
 
 ---
 
@@ -171,7 +139,7 @@ Paperclip is distributed as a gem, which is how it should be used in your app.
 Include the gem in your Gemfile:
 
 ```ruby
-gem "kt-paperclip", "~> 6.3"
+gem "kt-paperclip", "~> 8.0"
 ```
 
 Or, if you want to get the latest, you can get master from the main paperclip repository:
@@ -407,8 +375,10 @@ validates_attachment :avatar,
   content_type: ["image/jpeg", "image/gif", "image/png"]
 ```
 
-`Paperclip::ContentTypeDetector` will attempt to match a file's extension to an
-inferred content_type, regardless of the actual contents of the file.
+`Paperclip::ContentTypeDetector` uses the file's extension as a hint when the contents alone are
+ambiguous, so the stored `content_type` is not by itself proof of what a file contains. The check
+that ignores the filename entirely is `validates_media_type_spoof_detection` (see Security
+Validations below); use it alongside your `content_type` validation.
 
 ### Duplicate error messages
 
@@ -476,17 +446,26 @@ being uploaded as JPEGs, but will not prevent GIFs from being uploaded with a
 `.jpg` extension. This validation will only add validation errors to the form. It
 will not cause errors to be raised.
 
+The type is detected from the file's contents only, using magic-number detection plus the Unix
+`file` utility. The filename is never consulted. Where `file` is unavailable the check falls back
+to magic-number detection alone, which cannot identify text-based formats; content it cannot
+identify at all is accepted rather than rejected.
+
 This can sometimes cause false validation errors in applications that use custom
 file extensions. In these cases you may wish to add your custom extension to the
 list of content type mappings by creating `config/initializers/paperclip.rb`:
 
 ```ruby
-# Allow ".foo" as an extension for files with the MIME type "text/plain".
+# Allow ".foo" as an extension for files whose contents are detected as "text/plain".
 Paperclip.options[:content_type_mappings] = {
   foo: %w(text/plain)
 }
 ```
 
+The value is the type the *contents* detect as (what `file -b --mime` reports), not the type you
+would like the extension to mean. Text-based formats such as SVG and CSV are the usual reason to
+need one.
+
 ---
 
 Defaults
@@ -592,9 +571,9 @@ Storage
 
 Paperclip ships with 3 storage adapters:
 
-* File Storage
-* S3 Storage (via `aws-sdk-s3`)
-* Fog Storage
+* File Storage (`storage: :filesystem`)
+* S3 Storage (via `aws-sdk-s3`) (`storage: :s3`)
+* Fog Storage (`storage: :fog`)
 
 If you would like to use Paperclip with another storage, you can install these
 gems along side with Paperclip:
@@ -1070,5 +1049,6 @@ Thank you to all [the contributors](https://github.com/kreeti/kt-paperclip/graph
 License
 -------
 
-Paperclip is Copyright © 2008-2017 thoughtbot, inc. It is free software, and may be
-redistributed under the terms specified in the MIT-LICENSE file.
+Copyright © 2020-2021 Kreeti Technologies Pvt. Ltd.
+Copyright © 2008-2017 thoughtbot, inc.
+It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/lib/generators/paperclip/paperclip_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/generators/active_record"
 
 class PaperclipGenerator < ActiveRecord::Generators::Base
@@ -31,6 +33,6 @@ class PaperclipGenerator < ActiveRecord::Generators::Base
   end
 
   def migration_version
-    "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]" if Rails.version.first.to_i > 4
+    "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
   end
 end

data/lib/kt-paperclip.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "paperclip"

data/lib/paperclip/attachment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "uri"
 require "paperclip/url_generator"
 require "active_support/deprecation"
@@ -10,35 +12,36 @@ module Paperclip
   class Attachment
     def self.default_options
       @default_options ||= {
-        convert_options:                  {},
-        default_style:                    :original,
-        default_url:                      "/:attachment/:style/missing.png",
-        escape_url:                       true,
-        restricted_characters:            /[&$+,\/:;=?@<>\[\]\{\}\|\\\^~%# ]/,
-        filename_cleaner:                 nil,
-        hash_data:                        ":class/:attachment/:id/:style/:updated_at",
-        hash_digest:                      "SHA1",
-        interpolator:                     Paperclip::Interpolations,
-        only_process:                     [],
-        path:                             ":rails_root/public:url",
-        preserve_files:                   false,
-        processors:                       [:thumbnail],
-        source_file_options:              {},
-        storage:                          :filesystem,
-        styles:                           {},
-        url:                              "/system/:class/:attachment/:id_partition/:style/:filename",
-        url_generator:                    Paperclip::UrlGenerator,
-        use_default_time_zone:            true,
-        use_timestamp:                    true,
-        whiny:                            Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails],
-        validate_media_type:              true,
-        adapter_options:                  { hash_digest: Digest::MD5 },
-        check_validity_before_processing: true
+        convert_options:                   {},
+        default_style:                     :original,
+        default_url:                       "/:attachment/:style/missing.png",
+        escape_url:                        true,
+        restricted_characters:             /[&$+,\/:;=?@<>\[\]\{\}\|\\\^~%# ]/,
+        filename_cleaner:                  nil,
+        hash_data:                         ":class/:attachment/:id/:style/:updated_at",
+        hash_digest:                       "SHA1",
+        interpolator:                      Paperclip::Interpolations,
+        only_process:                      [],
+        path:                              ":rails_root/public:url",
+        preserve_files:                    false,
+        processors:                        [:thumbnail],
+        source_file_options:               {},
+        storage:                           :filesystem,
+        styles:                            {},
+        url:                               "/system/:class/:attachment/:id_partition/:style/:filename",
+        url_generator:                     Paperclip::UrlGenerator,
+        use_default_time_zone:             true,
+        use_timestamp:                     true,
+        whiny:                             Paperclip.options[:whiny] || Paperclip.options[:whiny_thumbnails],
+        validate_media_type:               true,
+        adapter_options:                   { hash_digest: Digest::MD5 },
+        check_validity_before_processing:  true,
+        return_file_attributes_on_destroy: false
       }
     end
 
     attr_reader :name, :instance, :default_style, :convert_options, :queued_for_write, :whiny,
-                :options, :interpolator, :source_file_options
+                :options, :interpolator, :source_file_options, :queued_for_delete
     attr_accessor :post_processing
 
     # Creates an Attachment object. +name+ is the name of the attachment,
@@ -69,6 +72,8 @@ module Paperclip
     # +interpolator+ - the object used to interpolate filenames and URLs. Defaults to Paperclip::Interpolations
     # +url_generator+ - the object used to generate URLs, using the interpolator. Defaults to Paperclip::UrlGenerator
     # +escape_url+ - Perform URI escaping to URLs. Defaults to true
+    # +return_file_attributes_on_destroy+ - whether attachment-related attributes should be displayed when
+    #                                       destroying a record. Defaults to false.
     def initialize(name, instance, options = {})
       @name              = name.to_sym
       @name_string       = name.to_s
@@ -563,12 +568,10 @@ module Paperclip
           path(style) if exists?(style)
         end.compact
       end
-      instance_write(:file_name, nil)
-      instance_write(:content_type, nil)
-      instance_write(:file_size, nil)
-      instance_write(:fingerprint, nil)
-      instance_write(:created_at, nil) if has_enabled_but_unset_created_at?
-      instance_write(:updated_at, nil)
+
+      return if show_attrs_and_destroy_callback_triggered?
+
+      clear_all_attachment_attributes
     end
 
     def flush_errors #:nodoc:
@@ -613,5 +616,21 @@ module Paperclip
     def has_enabled_but_unset_created_at?
       able_to_store_created_at? && !instance_read(:created_at)
     end
+
+    # Checks whether the option to show attributes to be destroyed is enabled and whether a destroy callback has been
+    # invoked when deleting the entire record.
+    def show_attrs_and_destroy_callback_triggered?
+      @options[:return_file_attributes_on_destroy] && instance.instance_variable_get(:@_destroy_callback_already_called)
+    end
+
+    # Sets attachment-related attributes to `nil`.
+    def clear_all_attachment_attributes
+      instance_write(:file_name, nil)
+      instance_write(:content_type, nil)
+      instance_write(:file_size, nil)
+      instance_write(:fingerprint, nil)
+      instance_write(:created_at, nil) if has_enabled_but_unset_created_at?
+      instance_write(:updated_at, nil)
+    end
   end
 end

data/lib/paperclip/attachment_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "singleton"
 
 module Paperclip

data/lib/paperclip/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Paperclip
   module Callbacks
     def self.included(base)
@@ -9,14 +11,15 @@ module Paperclip
       def define_paperclip_callbacks(*callbacks)
         define_callbacks(*[callbacks, { terminator: hasta_la_vista_baby }].flatten)
         callbacks.each do |callback|
-          eval <<-end_callbacks
-            def before_#{callback}(*args, &blk)
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+            def self.before_#{callback}(*args, &blk)
               set_callback(:#{callback}, :before, *args, &blk)
             end
-            def after_#{callback}(*args, &blk)
+
+            def self.after_#{callback}(*args, &blk)
               set_callback(:#{callback}, :after, *args, &blk)
             end
-          end_callbacks
+          RUBY
         end
       end
 

data/lib/paperclip/commands/imagemagick/geometry_parser.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Paperclip
+  module Commands
+    module ImageMagick
+      module GeometryParser
+        extend self
+
+        FORMAT = /\b(\d*)x?(\d*)\b(?:,(\d?))?(@>|>@|[><#@%^!])?/i.freeze
+
+        # Runs `magick identify` and returns a Paperclip::Geometry
+        def detect(file)
+          parse(fetch(file))
+        end
+        alias_method :from_file, :detect
+
+        # Parses a "WxH,O" string into a Paperclip::Geometry
+        def parse(string)
+          return unless (match = string&.strip&.match(FORMAT))
+
+          Paperclip::Geometry.new(
+            width: match[1],
+            height: match[2],
+            orientation: match[3],
+            modifier: match[4]
+          )
+        end
+
+        private
+
+        def fetch(file)
+          filepath = path(file)
+          raise_error("Cannot find the geometry of a file with a blank name") if filepath.blank?
+
+          str = Paperclip::Commands::ImageMagick.identify(
+            "-format '%wx%h,#{orientation}' :file",
+            { file: "#{filepath}[0]" },
+            { swallow_stderr: true }
+          ).presence
+
+          raise_error unless str
+
+          str
+        rescue Terrapin::ExitStatusError
+          raise_error
+        end
+
+        def path(file)
+          file.respond_to?(:path) ? file.path : file
+        end
+
+        def orientation
+          Paperclip.options[:use_exif_orientation] ? "%[exif:orientation]" : "1"
+        end
+
+        def raise_error(message = nil)
+          message ||= "Could not identify image size"
+          raise Errors::NotIdentifiedByImageMagickError.new(message)
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/commands/imagemagick/version_detector.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Paperclip
+  module Commands
+    module ImageMagick
+      module VersionDetector
+        extend self
+
+        # Returns 6, 7, or nil (not installed)
+        def detected_version
+          return @detected_version if defined?(@detected_version)
+
+          @detected_version = detect
+        end
+
+        private
+
+        def detect
+          return 7 if valid?("magick")
+          return 6 if valid?("convert")
+
+          nil
+        end
+
+        def valid?(command)
+          run(command).to_s.include?("ImageMagick")
+        end
+
+        def run(command)
+          Paperclip::Commands::Runner.run(command, path, "-version", {}, swallow_stderr: true)
+        rescue Terrapin::CommandLineError
+          nil
+        end
+
+        def path
+          Paperclip::Commands::ImageMagick.imagemagick_path
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/commands/imagemagick.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Paperclip
+  module Commands
+    module ImageMagick
+      extend self
+
+      def convert(arguments = nil, interpolation_values = {}, local_options = {})
+        run(convert_command, imagemagick_path, arguments, interpolation_values, local_options)
+      end
+
+      def identify(arguments = nil, interpolation_values = {}, local_options = {})
+        run(identify_command, imagemagick_path, arguments, interpolation_values, local_options)
+      end
+
+      def imagemagick_path
+        Paperclip.options[:imagemagick_path]
+      end
+
+      private
+
+      def run(command, path = nil, arguments = nil, interpolation_values = {}, local_options = {})
+        Runner.run(command, path || imagemagick_path, arguments, interpolation_values, local_options)
+      rescue Terrapin::CommandNotFoundError
+        raise Errors::CommandNotFoundError.new("Could not run the `#{command}` command. Please install ImageMagick.")
+      end
+
+      # Returns true if ImageMagick 7 is in use (either detected or forced via config)
+      def magick_command?
+        version = Paperclip.options[:imagemagick_version]&.to_i ||
+                  VersionDetector.detected_version
+        !version.nil? && version >= 7
+      end
+
+      def convert_command
+        magick_command? ? "magick" : "convert"
+      end
+
+      def identify_command
+        magick_command? ? "magick identify" : "identify"
+      end
+    end
+  end
+end

data/lib/paperclip/commands/runner.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Paperclip
+  module Commands
+    module Runner
+      extend self
+
+      def run(command, path = nil, arguments = nil, interpolation_values = {}, local_options = {})
+        if Paperclip.logging? && (Paperclip.options[:log_command] || local_options[:log_command])
+          local_options = local_options.merge(logger: Paperclip.logger)
+        end
+
+        binary = resolve_binary(command, path)
+
+        Terrapin::CommandLine.new(binary, arguments, local_options)
+                             .run(interpolation_values)
+      end
+
+      private
+
+      def resolve_binary(command, path)
+        # @deprecated +Paperclip.options[:command_path]+ will be removed in Paperclip 8.0
+        path ||= Paperclip.options[:command_path]
+        return command unless path
+
+        # command may be multi-word (e.g. "magick identify")
+        words = command.split(" ", 2)
+        candidate = File.join(path, words[0])
+        if File.executable?(candidate)
+          words[0] = candidate
+          words.join(" ")
+        else
+          command
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/commands/unix_file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Paperclip
+  module Commands
+    module UnixFile
+      extend self
+
+      # Returns a normalized content type value, otherwise nil.
+      def detect_content_type(file)
+        type = run_file_command(file)
+        return if type.blank? || type.match(/\(.*?\)/)
+
+        type.split(/[:;\s]+/)[0].strip
+      rescue Terrapin::CommandLineError => e
+        Paperclip.log("Error while determining content type: #{e}")
+        nil
+      end
+
+      private
+
+      def run_file_command(file)
+        Runner.run("file", Paperclip.options[:file_command_path], "-b --mime :file", { file: file })
+      rescue Terrapin::CommandLineError
+        nil
+      end
+    end
+  end
+end