jr-paperclip 7.3.0

data/RELEASING.md

@@ -0,0 +1,17 @@
+Releasing paperclip
+
+1. Update `lib/paperclip/version.rb` file accordingly.
+2. Update `NEWS` to reflect the changes since last release.
+3. Commit changes. There shouldn’t be code changes, and thus CI doesn’t need to
+   run, you can then add “[ci skip]” to the commit message.
+4. Tag the release: `git tag -m 'vVERSION' vVERSION`
+5. Push changes: `git push --tags`
+6. Build and publish the gem:
+
+   ```bash
+   gem build paperclip.gemspec
+   gem push paperclip-VERSION.gem
+   ```
+
+7. Announce the new release, making sure to say “thank you” to the contributors
+   who helped shape this version.

data/Rakefile

@@ -0,0 +1,52 @@
+require "bundler/gem_tasks"
+require "appraisal"
+require "rspec/core/rake_task"
+require "cucumber/rake/task"
+
+desc "Default: run unit tests."
+task default: [:clean, :all]
+
+desc "Test the paperclip plugin under all supported Rails versions."
+task :all do |_t|
+  if ENV["BUNDLE_GEMFILE"]
+    exec("rake spec && cucumber")
+  else
+    exec("rm -f gemfiles/*.lock")
+    Rake::Task["appraisal:gemfiles"].execute
+    Rake::Task["appraisal:install"].execute
+    exec("rake appraisal")
+  end
+end
+
+desc "Test the paperclip plugin."
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run integration test"
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w{--format progress}
+end
+
+desc "Start an IRB session with all necessary files required."
+task :shell do |_t|
+  chdir File.dirname(__FILE__)
+  exec "bin/console"
+end
+
+desc "Clean up files."
+task :clean do |_t|
+  FileUtils.rm_rf "doc"
+  FileUtils.rm_rf "tmp"
+  FileUtils.rm_rf "pkg"
+  FileUtils.rm_rf "public"
+  begin
+    FileUtils.rm "test/debug.log"
+  rescue StandardError
+    nil
+  end
+  begin
+    FileUtils.rm "test/paperclip.db"
+  rescue StandardError
+    nil
+  end
+  Dir.glob("paperclip-*.gem").each { |f| FileUtils.rm f }
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "logger"
+require "active_record"
+require "tempfile"
+require_relative "../lib/paperclip"
+
+require "irb"
+IRB.start

data/features/basic_integration.feature

@@ -0,0 +1,85 @@
+Feature: Rails integration
+
+  Background:
+    Given I generate a new rails application
+    And I run a rails generator to generate a "User" scaffold with "name:string"
+    And I run a paperclip generator to add a paperclip "attachment" to the "User" model
+    And I run a migration
+    And I update my new user view to include the file upload field
+    And I update my user view to include the attachment
+    And I allow the attachment to be submitted
+    And I replace this snippet to app/views/layouts/application.html.erb:
+      """
+      <%= javascript_tag 'application', 'data-turbolinks-track': 'reload' %>
+      """
+
+  Scenario: Configure defaults for all attachments through Railtie
+    Given I add this snippet to config/application.rb:
+      """
+      config.paperclip_defaults = {
+        :url => "/paperclip/custom/:attachment/:style/:filename",
+        :validate_media_type => false
+      }
+      """
+    And I attach :attachment
+    And I start the rails application
+    When I go to the new user page
+    And I fill in "Name" with "something"
+    And I attach the file "spec/support/fixtures/animated.unknown" to "Attachment"
+    And I press "Submit"
+    Then I should see "Name: something"
+    And I should see an image with a path of "/paperclip/custom/attachments/original/animated.unknown"
+    And the file at "/paperclip/custom/attachments/original/animated.unknown" should be the same as "spec/support/fixtures/animated.unknown"
+
+  Scenario: Add custom processors
+    Given I add a "test" processor in "lib/paperclip"
+    And I add a "cool" processor in "lib/paperclip"
+    And I attach :attachment with:
+      """
+      styles: { original: {} }, processors: [:test, :cool]
+      """
+    And I start the rails application
+    When I go to the new user page
+    And I fill in "Name" with "something"
+    And I attach the file "spec/support/fixtures/5k.png" to "Attachment"
+    And I press "Submit"
+    Then I should see "Name: something"
+    And I should see an image with a path of "/paperclip/custom/attachments/original/5k.png"
+
+  Scenario: Filesystem integration test
+    Given I attach :attachment with:
+      """
+        :url => "/system/:attachment/:style/:filename"
+      """
+    And I start the rails application
+    When I go to the new user page
+    And I fill in "Name" with "something"
+    And I attach the file "spec/support/fixtures/5k.png" to "Attachment"
+    And I press "Submit"
+    Then I should see "Name: something"
+    And I should see an image with a path of "/system/attachments/original/5k.png"
+    And the file at "/system/attachments/original/5k.png" should be the same as "spec/support/fixtures/5k.png"
+
+  Scenario: S3 Integration test
+    Given I attach :attachment with:
+      """
+        :storage => :s3,
+        :path => "/:attachment/:style/:filename",
+        :s3_credentials => Rails.root.join("config/s3.yml"),
+        :styles => { :square => "100x100#" }
+      """
+    And I write to "config/s3.yml" with:
+      """
+      bucket: paperclip
+      access_key_id: access_key
+      secret_access_key: secret_key
+      s3_region: us-west-2
+      """
+    And I start the rails application
+    When I go to the new user page
+    And I fill in "Name" with "something"
+    And I attach the file "spec/support/fixtures/5k.png" to "Attachment" on S3
+    And I press "Submit"
+    Then I should see "Name: something"
+    And I should see an image with a path of "//s3.amazonaws.com/paperclip/attachments/original/5k.png"
+    And the file at "//s3.amazonaws.com/paperclip/attachments/original/5k.png" should be uploaded to S3

data/features/migration.feature

@@ -0,0 +1,29 @@
+Feature: Migration
+
+  Background:
+    Given I generate a new rails application
+    And I generate a "User" model:
+
+  Scenario: Vintage syntax
+    Given I run a paperclip migration to add a paperclip "attach" to the "User" model
+
+    And I run a migration
+    Then I should have attachment columns for "attach"
+
+    When I rollback a migration
+    Then I should not have attachment columns for "attach"
+
+  Scenario: New syntax with create_table
+    Given I run a paperclip migration to add a paperclip "attach" to the "User" model
+
+    And I run a migration
+    Then I should have attachment columns for "attach"
+
+  Scenario: New syntax outside of create_table
+    Given I run a paperclip migration to add a paperclip "attachment_sample" to the "User" model
+
+    And I run a migration
+    Then I should have attachment columns for "attachment_sample"
+
+    When I rollback a migration
+    Then I should not have attachment columns for "attachment_sample"

data/features/rake_tasks.feature

@@ -0,0 +1,62 @@
+Feature: Rake tasks
+
+  Background:
+    Given I generate a new rails application
+    And I run a rails generator to generate a "User" scaffold with "name:string"
+    And I run a paperclip generator to add a paperclip "attachment" to the "User" model
+    And I run a migration
+    And I attach :attachment with:
+      """
+        :path => ":rails_root/public/system/:attachment/:style/:filename"
+      """
+
+  Scenario: Paperclip refresh thumbnails task
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename",
+                                     :styles => { :medium => "200x200#" }
+      """
+    And I upload the fixture "5k.png"
+    Then the attachment "medium/5k.png" should have a dimension of 200x200
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename",
+                                     :styles => { :medium => "100x100#" }
+      """
+    When I successfully run `bundle exec rake paperclip:refresh:thumbnails CLASS=User --trace`
+    Then the attachment "original/5k.png" should exist
+    And the attachment "medium/5k.png" should have a dimension of 100x100
+
+  Scenario: Paperclip refresh metadata task
+    When I upload the fixture "5k.png"
+    And I swap the attachment "original/5k.png" with the fixture "12k.png"
+    And I successfully run `bundle exec rake paperclip:refresh:metadata CLASS=User --trace`
+    Then the attachment should have the same content type as the fixture "12k.png"
+    And the attachment should have the same file size as the fixture "12k.png"
+
+  Scenario: Paperclip refresh missing styles task
+    When I upload the fixture "5k.png"
+    Then the attachment file "original/5k.png" should exist
+    And the attachment file "medium/5k.png" should not exist
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename",
+                                     :styles => { :medium => "200x200#" }
+      """
+    When I successfully run `bundle exec rake paperclip:refresh:missing_styles --trace`
+    Then the attachment file "original/5k.png" should exist
+    And the attachment file "medium/5k.png" should exist
+
+  Scenario: Paperclip clean task
+    When I upload the fixture "5k.png"
+    And I upload the fixture "12k.png"
+    Then the attachment file "original/5k.png" should exist
+    And the attachment file "original/12k.png" should exist
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename"
+      validates_attachment_size :attachment, :less_than => 10.kilobytes
+      """
+    And I successfully run `bundle exec rake paperclip:clean CLASS=User --trace`
+    Then the attachment file "original/5k.png" should exist
+    But the attachment file "original/12k.png" should not exist

data/features/step_definitions/attachment_steps.rb

@@ -0,0 +1,121 @@
+module AttachmentHelpers
+  def fixture_path(filename)
+    File.expand_path("#{PROJECT_ROOT}/spec/support/fixtures/#{filename}")
+  end
+
+  def attachment_path(filename)
+    File.expand_path("public/system/attachments/#{filename}")
+  end
+end
+World(AttachmentHelpers)
+
+When /^I modify my attachment definition to:$/ do |definition|
+  content = cd(".") { File.read("app/models/user.rb") }
+  name = content[/has_attached_file :\w+/][/:\w+/]
+  content.gsub!(/has_attached_file.+end/m, <<-FILE)
+      #{definition}
+      do_not_validate_attachment_file_type #{name}
+    end
+  FILE
+
+  write_file "app/models/user.rb", content
+  cd(".") { FileUtils.rm_rf ".rbx" }
+end
+
+When /^I upload the fixture "([^"]*)"$/ do |filename|
+  aruba_run_simple %(bundle exec rails runner "User.create!(:attachment => File.open('#{fixture_path(filename)}'))")
+end
+
+Then /^the attachment "([^"]*)" should have a dimension of (\d+x\d+)$/ do |filename, dimension|
+  cd(".") do
+    geometry = `identify -format "%wx%h" "#{attachment_path(filename)}"`.strip
+    expect(geometry).to eq(dimension)
+  end
+end
+
+Then /^the attachment "([^"]*)" should exist$/ do |filename|
+  cd(".") do
+    expect(File.exist?(attachment_path(filename))).to be true
+  end
+end
+
+When /^I swap the attachment "([^"]*)" with the fixture "([^"]*)"$/ do |attachment_filename, fixture_filename|
+  cd(".") do
+    require "fileutils"
+    FileUtils.rm_f attachment_path(attachment_filename)
+    FileUtils.cp fixture_path(fixture_filename), attachment_path(attachment_filename)
+  end
+end
+
+Then /^the attachment should have the same content type as the fixture "([^"]*)"$/ do |filename|
+  cd(".") do
+    begin
+      # Use mime/types/columnar if available, for reduced memory usage
+      require "mime/types/columnar"
+    rescue LoadError
+      require "mime/types"
+    end
+
+    attachment_content_type = `bundle exec rails runner "puts User.last.attachment_content_type"`.strip
+    expected = MIME::Types.type_for(filename).first.content_type
+    expect(attachment_content_type).to eq(expected)
+  end
+end
+
+Then /^the attachment should have the same file name as the fixture "([^"]*)"$/ do |filename|
+  cd(".") do
+    attachment_file_name = `bundle exec rails runner "puts User.last.attachment_file_name"`.strip
+    expect(attachment_file_name).to eq(File.name(fixture_path(filename)).to_s)
+  end
+end
+
+Then /^the attachment should have the same file size as the fixture "([^"]*)"$/ do |filename|
+  cd(".") do
+    attachment_file_size = `bundle exec rails runner "puts User.last.attachment_file_size"`.strip
+    expect(attachment_file_size).to eq(File.size(fixture_path(filename)).to_s)
+  end
+end
+
+Then /^the attachment file "([^"]*)" should (not )?exist$/ do |filename, not_exist|
+  cd(".") do
+    if not_exist
+      expect(File.exist?(attachment_path(filename))).to be false
+    else
+      expect(File.exist?(attachment_path(filename))).to be true
+    end
+  end
+end
+
+Then /^I should have attachment columns for "([^"]*)"$/ do |attachment_name|
+  cd(".") do
+    columns = eval(`bundle exec rails runner "puts User.columns.map{ |column| [column.name, column.sql_type] }.inspect"`.strip)
+    expect(columns).to include(["#{attachment_name}_file_name", "varchar"])
+    expect(columns).to include(["#{attachment_name}_content_type", "varchar"])
+    expect(columns).to include(["#{attachment_name}_file_size", "bigint"])
+    # Rails 7+ uses datetime(6) with precision, so match with regex
+    datetime_column = columns.find { |col| col[0] == "#{attachment_name}_updated_at" }
+    expect(datetime_column).to be_present
+    expect(datetime_column[1]).to match(/^datetime/)
+  end
+end
+
+Then /^I should not have attachment columns for "([^"]*)"$/ do |attachment_name|
+  cd(".") do
+    columns = eval(`bundle exec rails runner "puts User.columns.map{ |column| [column.name, column.sql_type] }.inspect"`.strip)
+    column_names = columns.map { |col| col[0] }
+    expect(column_names).not_to include("#{attachment_name}_file_name")
+    expect(column_names).not_to include("#{attachment_name}_content_type")
+    expect(column_names).not_to include("#{attachment_name}_file_size")
+    expect(column_names).not_to include("#{attachment_name}_updated_at")
+  end
+end
+
+# we have to support different versions of aruba, and this method was renamed for 1.0
+# https://github.com/cucumber/aruba/pull/438
+def aruba_run_simple(*args)
+  if respond_to?(:run_simple)
+    run_simple(*args)
+  elsif respond_to?(:run_command_and_stop)
+    run_command_and_stop(*args)
+  end
+end

data/features/step_definitions/html_steps.rb

@@ -0,0 +1,15 @@
+Then %r{I should see an image with a path of "([^"]*)"} do |path|
+  expect(page).to have_css("img[src^='#{path}']")
+end
+
+Then %r{^the file at "([^"]*)" is the same as "([^"]*)"$} do |web_file, path|
+  expected = IO.read(path)
+  actual = if web_file.match %r{^https?://}
+             Net::HTTP.get(URI.parse(web_file))
+           else
+             visit(web_file)
+             page.body
+           end
+  actual.force_encoding("UTF-8") if actual.respond_to?(:force_encoding)
+  expect(actual).to eq(expected)
+end

data/features/step_definitions/rails_steps.rb

@@ -0,0 +1,271 @@
+Given /^I generate a new rails application$/ do
+  steps %{
+    When I successfully run `rails new #{APP_NAME} --skip-bundle --skip-javascript`
+    And I cd to "#{APP_NAME}"
+  }
+
+  FileUtils.chdir("tmp/aruba/testapp/")
+
+  # Remove assets initializer if it exists (causes issues with Rails 8+)
+  FileUtils.rm_f("config/initializers/assets.rb")
+
+  # Determine sqlite3 version based on Rails version
+  sqlite3_version = framework_version.to_f >= 7.2 ? ', "~> 2.0"' : ', "~> 1.4"'
+
+  steps %{
+    And I turn off class caching
+    And I write to "Gemfile" with:
+      """
+      source "https://rubygems.org"
+      gem "rails", "#{framework_version}"
+      gem "sqlite3"#{sqlite3_version}, :platform => [:ruby, :rbx]
+      gem "activerecord-jdbcsqlite3-adapter", :platform => :jruby
+      gem "jruby-openssl", :platform => :jruby
+      gem "capybara"
+      gem "gherkin"
+      gem "aws-sdk-s3"
+      gem "racc", :platform => :rbx
+      gem "rubysl", :platform => :rbx
+      """
+    And I remove turbolinks
+    And I comment out lines that contain "action_mailer" in "config/environments/*.rb"
+    And I empty the application.js file
+    And I configure the application to use "paperclip" from this project
+  }
+
+  FileUtils.chdir("../../..")
+end
+
+Given /^I generate a "([^"]*)" model:$/ do |model_name|
+  step %[I successfully run `rails generate model #{model_name}`]
+end
+
+Given /^I run a paperclip migration to add a paperclip "([^"]*)" to the "([^"]*)" model$/ do |attachment_name, model_name|
+  step %[I successfully run `rails generate paperclip #{model_name} #{attachment_name}`]
+end
+
+Given "I allow the attachment to be submitted" do
+  cd(".") do
+    transform_file("app/controllers/users_controller.rb") do |content|
+      # Handle both Rails 7 style (require/permit) and Rails 8 style (expect)
+      content
+        .gsub("params.require(:user).permit(:name)", "params.require(:user).permit!")
+        .gsub(/params\.expect\(user: \[.*?\]\)/, "params.require(:user).permit!")
+    end
+  end
+end
+
+Given "I remove turbolinks" do
+  cd(".") do
+    # These files may not exist in modern Rails (7+)
+    transform_file("app/assets/javascripts/application.js") do |content|
+      content.gsub("//= require turbolinks", "")
+    end
+    transform_file("app/views/layouts/application.html.erb") do |content|
+      content.gsub(', "data-turbolinks-track" => true', "")
+        .gsub(", 'data-turbolinks-track': 'reload'", "")
+    end
+  end
+end
+
+Given /^I comment out lines that contain "([^"]+)" in "([^"]+)"$/ do |contains, glob|
+  cd(".") do
+    Dir.glob(glob).each do |file|
+      transform_file(file) do |content|
+        content.gsub(/^(.*?#{contains}.*?)$/) { |line| "# #{line}" }
+      end
+    end
+  end
+end
+
+Given /^I attach :attachment$/ do
+  attach_attachment("attachment")
+end
+
+Given /^I attach :attachment with:$/ do |definition|
+  attach_attachment("attachment", definition)
+end
+
+def attach_attachment(name, definition = nil)
+  snippet = "has_attached_file :#{name}"
+  if definition
+    snippet += ", \n"
+    snippet += definition
+  end
+  snippet += "\ndo_not_validate_attachment_file_type :#{name}\n"
+  cd(".") do
+    transform_file("app/models/user.rb") do |content|
+      content.sub(/end\Z/, "#{snippet}\nend")
+    end
+  end
+end
+
+Given "I empty the application.js file" do
+  cd(".") do
+    # This file may not exist in modern Rails (7+) with --skip-asset-pipeline
+    transform_file("app/assets/javascripts/application.js") do |_content|
+      ""
+    end
+  end
+end
+
+Given /^I run a rails generator to generate a "([^"]*)" scaffold with "([^"]*)"$/ do |model_name, attributes|
+  step %[I successfully run `rails generate scaffold #{model_name} #{attributes}`]
+end
+
+Given /^I run a paperclip generator to add a paperclip "([^"]*)" to the "([^"]*)" model$/ do |attachment_name, model_name|
+  step %[I successfully run `rails generate paperclip #{model_name} #{attachment_name}`]
+end
+
+Given /^I run a migration$/ do
+  step %[I successfully run `rake db:migrate --trace`]
+end
+
+When /^I rollback a migration$/ do
+  step %[I successfully run `rake db:rollback STEPS=1 --trace`]
+end
+
+Given /^I update my new user view to include the file upload field$/ do
+  steps %{
+    Given I overwrite "app/views/users/new.html.erb" with:
+      """
+      <%= form_for @user, :html => { :multipart => true } do |f| %>
+        <%= f.label :name %>
+        <%= f.text_field :name %>
+        <%= f.label :attachment %>
+        <%= f.file_field :attachment %>
+        <%= submit_tag "Submit" %>
+      <% end %>
+      """
+  }
+end
+
+Given /^I update my user view to include the attachment$/ do
+  steps %{
+    Given I overwrite "app/views/users/show.html.erb" with:
+      """
+      <p>Name: <%= @user.name %></p>
+      <p>Attachment: <%= image_tag @user.attachment.url %></p>
+      """
+  }
+end
+
+Given /^I add this snippet to the User model:$/ do |snippet|
+  file_name = "app/models/user.rb"
+  cd(".") do
+    content = File.read(file_name)
+    File.open(file_name, "w") { |f| f << content.sub(/end\Z/, "#{snippet}\nend") }
+  end
+end
+
+Given /^I add this snippet to config\/application.rb:$/ do |snippet|
+  file_name = "config/application.rb"
+  cd(".") do
+    content = File.read(file_name)
+    File.open(file_name, "w") do |f|
+      f << content.sub(/class Application < Rails::Application.*$/,
+                       "class Application < Rails::Application\n#{snippet}\n")
+    end
+  end
+end
+
+Given /^I replace this snippet to app\/views\/layouts\/application.html.erb:$/ do |snippet|
+  file_name = "app/views/layouts/application.html.erb"
+  cd(".") do
+    content = File.read(file_name)
+    File.open(file_name, "w") do |f|
+      f << content.sub(/<%= javascript_pack_tag 'application', 'data-turbolinks-track': 'reload' %>$/,
+                       "#{snippet}")
+    end
+  end
+end
+
+Given /^I start the rails application$/ do
+  cd(".") do
+    require "rails"
+    require "./config/environment"
+    require "capybara"
+    Capybara.app = Rails.application
+  end
+end
+
+Given /^I reload my application$/ do
+  Rails::Application.reload!
+end
+
+When /^I turn off class caching$/ do
+  cd(".") do
+    file = "config/environments/test.rb"
+    config = IO.read(file)
+    # Rails 8+ uses enable_reloading instead of cache_classes
+    config.gsub!(%r{^\s*config.cache_classes.*$},
+                 "config.cache_classes = false")
+    config.gsub!(%r{^\s*config.enable_reloading.*$},
+                 "config.enable_reloading = true")
+    File.open(file, "w") { |f| f.write(config) }
+  end
+end
+
+Then /^the file at "([^"]*)" should be the same as "([^"]*)"$/ do |web_file, path|
+  expected = IO.read(path)
+  actual = read_from_web(web_file)
+  expect(actual).to eq(expected)
+end
+
+When /^I configure the application to use "([^\"]+)" from this project$/ do |name|
+  append_to_gemfile "gem '#{name}', :path => '#{PROJECT_ROOT}'"
+  steps %{And I successfully run `bundle install --local`}
+end
+
+When /^I configure the application to use "([^\"]+)"$/ do |gem_name|
+  append_to_gemfile "gem '#{gem_name}'"
+end
+
+When /^I append gems from Appraisal Gemfile$/ do
+  File.read(ENV["BUNDLE_GEMFILE"]).split(/\n/).each do |line|
+    append_to_gemfile line.strip if line =~ /^gem "(?!rails|appraisal)/
+  end
+end
+
+When /^I comment out the gem "([^"]*)" from the Gemfile$/ do |gemname|
+  comment_out_gem_in_gemfile gemname
+end
+
+Given(/^I add a "(.*?)" processor in "(.*?)"$/) do |processor, directory|
+  filename = "#{directory}/#{processor}.rb"
+  cd(".") do
+    FileUtils.mkdir_p directory
+    File.open(filename, "w") do |f|
+      f.write(<<-CLASS)
+        module Paperclip
+          class #{processor.capitalize} < Processor
+            def make
+              basename = File.basename(file.path, File.extname(file.path))
+              dst_format = options[:format] ? ".\#{options[:format]}" : ''
+
+              dst = Tempfile.new([basename, dst_format])
+              dst.binmode
+
+              convert(':src :dst',
+                src: File.expand_path(file.path),
+                dst: File.expand_path(dst.path)
+              )
+
+              dst
+            end
+          end
+        end
+      CLASS
+    end
+  end
+end
+
+def transform_file(filename)
+  if File.exist?(filename)
+    content = File.read(filename)
+    File.open(filename, "w") do |f|
+      content = yield(content)
+      f.write(content)
+    end
+  end
+end