paperclip 3.5.4 → 6.1.0

data/.rubocop.yml

@@ -0,0 +1 @@
+inherit_from: .hound.yml

data/.travis.yml

@@ -1,28 +1,25 @@
+language: ruby
+sudo: false
+
 rvm:
-  - 1.9.2
-  - 1.9.3
-  - jruby-19mode
-  - rbx-19mode
-  - 2.0.0
-  - 2.1.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
 
-install:
-  - "bundle install"
+script: "bundle exec rake clean spec cucumber"
 
-before_script: "sudo ntpdate -ub ntp.ubuntu.com pool.ntp.org; true"
-script: "bundle exec rake clean test cucumber"
+addons:
+  apt:
+    packages:
+    - ghostscript
 
 gemfile:
-  - gemfiles/3.0.gemfile
-  - gemfiles/3.1.gemfile
-  - gemfiles/3.2.gemfile
-  - gemfiles/4.0.gemfile
+  - gemfiles/4.2.gemfile
+  - gemfiles/5.0.gemfile
 
 matrix:
-  allow_failures:
-    - rvm: jruby-19mode
-    - rvm: rbx-19mode
-
+  fast_finish: true
   exclude:
-      - rvm: 1.9.2
-        gemfile: gemfiles/4.0.gemfile
+    - gemfile: gemfiles/5.0.gemfile
+      rvm: 2.1

data/Appraisals

@@ -1,19 +1,7 @@
-appraise "3.0" do
-  gem "rails", "~> 3.0.20"
-  gem "paperclip", :path => "../"
+appraise "4.2" do
+  gem "rails", "~> 4.2.0"
 end
 
-appraise "3.1" do
-  gem "rails", "~> 3.1.12"
-  gem "paperclip", :path => "../"
-end
-
-appraise "3.2" do
-  gem "rails", "~> 3.2.15"
-  gem "paperclip", :path => "../"
-end
-
-appraise "4.0" do
-  gem "rails", "~> 4.0.0"
-  gem "paperclip", :path => "../"
+appraise "5.0" do
+  gem "rails", "~> 5.0.0"
 end

data/CONTRIBUTING.md

@@ -1,24 +1,36 @@
 Contributing
 ============
 
-We love pull requests. Here's a quick guide:
+We love pull requests from everyone. By participating in this project, you agree
+to abide by the thoughtbot [code of conduct].
+
+[code of conduct]: https://thoughtbot.com/open-source-code-of-conduct
+
+Here's a quick guide for contributing:
 
 1. Fork the repo.
 
-2. Run the tests. We only take pull requests with passing tests, and it's great
-to know that you have a clean slate: `bundle && rake`
+1. Make sure you have ImageMagick and Ghostscript installed. See [this section]
+(./README.md#image-processor) of the README.
+
+1. Run the tests. We only take pull requests with passing tests, and it's great
+to know that you have a clean slate: `bundle && bundle exec rake`
 
-3. Add a test for your change. Only refactoring and documentation changes
+1. Add a test for your change. Only refactoring and documentation changes
 require no new tests. If you are adding functionality or fixing a bug, we need
 a test!
 
-4. Make the test pass.
+1. Make the test pass.
 
-5. Push to your fork and submit a pull request.
+1. Mention how your changes affect the project to other developers and users in
+   the `NEWS.md` file.
+
+1. Push to your fork and submit a pull request.
 
 At this point you're waiting on us. We like to at least comment on, if not
-accept, pull requests within three business days (and, typically, one business
-day). We may suggest some changes or improvements or alternatives.
+accept, pull requests within seven business days (most of the work on Paperclip
+gets done on Fridays). We may suggest some changes or improvements or
+alternatives.
 
 Some things that will increase the chance that your pull request is accepted,
 taken straight from the Ruby on Rails guide:
@@ -35,27 +47,31 @@ Paperclip uses [Appraisal](https://github.com/thoughtbot/appraisal) to aid
 testing against multiple version of Ruby on Rails. This helps us to make sure
 that Paperclip performs correctly with them.
 
+Paperclip also uses [RSpec](http://rspec.info) for its unit tests. If you submit
+tests that are not written for Cucumber or RSpec without a very good reason, you
+will be asked to rewrite them before we'll accept.
+
 ### Bootstrapping your test suite:
 
     bundle install
-    bundle exec rake appraisal:install
+    bundle exec appraisal install
 
 This will install all the required gems that requires to test against each
 version of Rails, which defined in `gemfiles/*.gemfile`.
 
 ### To run a full test suite:
 
-    bundle exec rake
+    bundle exec appraisal rake
 
-This will run Test::Unit and Cucumber against all version of Rails
+This will run RSpec and Cucumber against all version of Rails
 
 ### To run single Test::Unit or Cucumber test
 
 You need to specify a `BUNDLE_GEMFILE` pointing to the gemfile before running
 the normal test command:
 
-    BUNDLE_GEMFILE=gemfiles/3.2.gemfile ruby -Itest test/schema_test.rb
-    BUNDLE_GEMFILE=gemfiles/3.2.gemfile cucumber features/basic_integration.feature
+    BUNDLE_GEMFILE=gemfiles/4.1.gemfile rspec spec/paperclip/attachment_spec.rb
+    BUNDLE_GEMFILE=gemfiles/4.1.gemfile cucumber features/basic_integration.feature
 
 Syntax
 ------

data/Gemfile

@@ -2,7 +2,15 @@ source "https://rubygems.org"
 
 gemspec
 
-gem 'jruby-openssl', :platform => :jruby
-gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
+gem 'sqlite3', '~> 1.3.8', :platforms => :ruby
+gem 'pry'
 
-gem 'pry', :platform => :ruby
+# Hinting at development dependencies
+# Prevents bundler from taking a long-time to resolve
+group :development, :test do
+  gem 'activerecord-import'
+  gem 'mime-types'
+  gem 'builder'
+  gem 'rubocop', require: false
+  gem 'rspec'
+end

data/LICENSE

@@ -3,7 +3,7 @@ LICENSE
 
 The MIT License
 
-Copyright (c) 2008-2013 Jon Yurek and thoughtbot, inc.
+Copyright (c) 2008-2016 Jon Yurek and thoughtbot, inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -22,5 +22,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
-
-

data/MIGRATING-ES.md

@@ -0,0 +1,317 @@
+# Migrando de Paperclip a ActiveStorage
+
+Paperclip y ActiveStorage resuelven problemas similares con soluciones
+similares, por lo que pasar de uno a otro es simple.
+
+El proceso de ir desde Paperclip hacia ActiveStorage es como sigue:
+
+1. Implementa las migraciones a la base de datos de ActiveStorage.
+2. Configura el almacenamiento.
+3. Copia la base de datos.
+4. Copia los archivos.
+5. Actualiza tus pruebas.
+6. Actualiza tus vistas.
+7. Actualiza tus controladores.
+8. Actualiza tus modelos.
+
+## Implementa las migraciones a la base de datos de ActiveStorage
+
+Sigue [las instrucciones para instalar ActiveStorage]. Muy probablemente vas a
+querer agregar la gema `mini_magick` a tu Gemfile.
+
+
+```sh
+rails active_storage:install
+```
+
+[las instrucciones para instalar ActiveStorage]: https://github.com/rails/rails/blob/master/activestorage/README.md#installation
+
+## Configura el almacenamiento
+
+De nuevo, sigue [las instrucciones para configurar ActiveStorage].
+
+[las instrucciones para configurar ActiveStorage]: http://edgeguides.rubyonrails.org/active_storage_overview.html#setup
+
+## Copia la base de datos.
+
+Las tablas `active_storage_blobs` y`active_storage_attachments` son en donde
+ActiveStorage espera encontrar los metadatos del archivo. Paperclip almacena los
+metadatos del archivo directamente en en la tabla del objeto asociado.
+
+Vas a necesitar escribir una migración para esta conversión. Proveer un script
+simple, es complicado porque están involucrados tus modelos. ¡Pero lo
+intentaremos!
+
+Así sería para un `User` con un `avatar` en Paperclip:
+
+```ruby
+class User < ApplicationRecord
+  has_attached_file :avatar
+end
+```
+
+Tus migraciones de Paperclip producirán una tabla como la siguiente:
+
+```ruby
+create_table "users", force: :cascade do |t|
+  t.string "avatar_file_name"
+  t.string "avatar_content_type"
+  t.integer "avatar_file_size"
+  t.datetime "avatar_updated_at"
+end
+```
+
+Y tu la convertirás en estas tablas:
+
+```ruby
+create_table "active_storage_attachments", force: :cascade do |t|
+  t.string "name", null: false
+  t.string "record_type", null: false
+  t.integer "record_id", null: false
+  t.integer "blob_id", null: false
+  t.datetime "created_at", null: false
+  t.index ["blob_id"], name: "index_active_storage_attachments_on_blob_id"
+  t.index ["record_type", "record_id", "name", "blob_id"], name: "index_active_storage_attachments_uniqueness", unique: true
+end
+```
+
+```ruby
+create_table "active_storage_blobs", force: :cascade do |t|
+  t.string "key", null: false
+  t.string "filename", null: false
+  t.string "content_type"
+  t.text "metadata"
+  t.bigint "byte_size", null: false
+  t.string "checksum", null: false
+  t.datetime "created_at", null: false
+  t.index ["key"], name: "index_active_storage_blobs_on_key", unique: true
+end
+```
+
+Así que asumiendo que quieres dejar los archivos en el mismo lugar, _esta es tu
+migración_. De otra forma, ve la siguiente sección primero y modifica la
+migración como corresponda.
+
+```ruby
+Dir[Rails.root.join("app/models/**/*.rb")].sort.each { |file| require file }
+
+class ConvertToActiveStorage < ActiveRecord::Migration[5.2]
+  require 'open-uri'
+
+  def up
+    # postgres
+    get_blob_id = 'LASTVAL()'
+    # mariadb
+    # get_blob_id = 'LAST_INSERT_ID()'
+    # sqlite
+    # get_blob_id = 'LAST_INSERT_ROWID()'
+
+    active_storage_blob_statement = ActiveRecord::Base.connection.raw_connection.prepare(<<-SQL)
+      INSERT INTO active_storage_blobs (
+        key, filename, content_type, metadata, byte_size,
+        checksum, created_at
+      ) VALUES (?, ?, ?, '{}', ?, ?, ?)
+    SQL
+
+    active_storage_attachment_statement = ActiveRecord::Base.connection.raw_connection.prepare(<<-SQL)
+      INSERT INTO active_storage_attachments (
+        name, record_type, record_id, blob_id, created_at
+      ) VALUES (?, ?, ?, #{get_blob_id}, ?)
+    SQL
+
+    models = ActiveRecord::Base.descendants.reject(&:abstract_class?)
+
+    transaction do
+      models.each do |model|
+        attachments = model.column_names.map do |c|
+          if c =~ /(.+)_file_name$/
+            $1
+          end
+        end.compact
+
+        model.find_each.each do |instance|
+          attachments.each do |attachment|
+            active_storage_blob_statement.execute(
+              key(instance, attachment),
+              instance.send("#{attachment}_file_name"),
+              instance.send("#{attachment}_content_type"),
+              instance.send("#{attachment}_file_size"),
+              checksum(instance.send(attachment)),
+              instance.updated_at.iso8601
+            )
+
+            active_storage_attachment_statement.
+              execute(attachment, model.name, instance.id, instance.updated_at.iso8601)
+          end
+        end
+      end
+    end
+
+    active_storage_attachment_statement.close
+    active_storage_blob_statement.close
+  end
+
+  def down
+    raise ActiveRecord::IrreversibleMigration
+  end
+
+  private
+
+  def key(instance, attachment)
+    SecureRandom.uuid
+    # Alternativamente:
+    # instance.send("#{attachment}_file_name")
+  end
+
+  def checksum(attachment)
+    # archivos locales almacenados en disco:
+    url = attachment.path
+    Digest::MD5.base64digest(File.read(url))
+
+    # archivos remotos almacenados en la computadora de alguién más:
+    # url = attachment.url
+    # Digest::MD5.base64digest(Net::HTTP.get(URI(url)))
+  end
+end
+```
+
+## Copia los archivos
+
+La migración de arriba deja los archivos como estaban. Sin embargo,
+los servicios de Paperclip y ActiveStorage utilizan diferentes ubicaciones.
+
+Por defecto, Paperclip se ve así:
+
+```
+public/system/users/avatars/000/000/004/original/the-mystery-of-life.png
+```
+
+Y ActiveStorage se ve así:
+
+```
+storage/xM/RX/xMRXuT6nqpoiConJFQJFt6c9
+```
+
+Ese `xMRXuT6nqpoiConJFQJFt6c9` es el valor de `active_storage_blobs.key`. En la
+migración de arriba usamos simplemente el nombre del archivo, pero tal vez
+quieras usar un UUID.
+
+Migrando los archivos en un hospedaje externo (S3, Azure Storage, GCS, etc.)
+está fuera del alcance de este documento inicial. Así es como se vería para un
+almacenamiento local:
+
+```ruby
+#!bin/rails runner
+
+class ActiveStorageBlob < ActiveRecord::Base
+end
+
+class ActiveStorageAttachment < ActiveRecord::Base
+  belongs_to :blob, class_name: 'ActiveStorageBlob'
+  belongs_to :record, polymorphic: true
+end
+
+ActiveStorageAttachment.find_each do |attachment|
+  name = attachment.name
+
+  source = attachment.record.send(name).path
+  dest_dir = File.join(
+    "storage",
+    attachment.blob.key.first(2),
+    attachment.blob.key.first(4).last(2))
+  dest = File.join(dest_dir, attachment.blob.key)
+
+  FileUtils.mkdir_p(dest_dir)
+  puts "Moving #{source} to #{dest}"
+  FileUtils.cp(source, dest)
+end
+```
+
+## Actualiza tus pruebas
+
+En lugar de utilizar `have_attached_file`, será necesario que escribas tu propio
+matcher. Aquí hay un matcher similar _en espíritu_ al que Paperclip provee:
+
+
+```ruby
+RSpec::Matchers.define :have_attached_file do |name|
+  matches do |record|
+    file = record.send(name)
+    file.respond_to?(:variant) && file.respond_to?(:attach)
+  end
+end
+```
+
+## Actualiza tus vistas
+
+En Paperclip se ven así:
+
+```ruby
+image_tag @user.avatar.url(:medium)
+```
+
+En ActiveStorage se ven así:
+
+```ruby
+image_tag @user.avatar.variant(resize: "250x250")
+```
+
+## Actualiza tus controladores
+
+Esto no debería _requerir_ ningúna actualización. Sin embargo, si te fijas en
+el schema de tu base de datos, notaras un join.
+
+Por ejemplo si tu controlador tiene:
+
+```ruby
+def index
+  @users = User.all.order(:name)
+end
+```
+
+Y tu vista tiene:
+
+```
+<ul>
+  <% @users.each do |user| %>
+    <li><%= image_tag user.avatar.variant(resize: "10x10"), alt: user.name %></li>
+  <% end %>
+</ul>
+```
+
+Vas a terminar con un n+1, ya que descargas cada archivo adjunto dentro del
+bucle.
+
+Así que mientras que el controlador y el modelo funcionarán sin ningún cambio,
+tal vez quieras revisar dos veces tus bucles y agregar `includes` en dónde haga
+falta.
+
+ActiveStorage agrega `avatar_attachment` y `avatar_blob` a las relaciones del
+tipo `has-one`, así como `avatar_attachments` y `avatar_blobs` a las relaciones
+de tipo `has-many`:
+
+```ruby
+def index
+  @users = User.all.order(:name).includes(:avatar_attachment)
+end
+```
+
+## Actualiza tus modelos
+
+Sigue [la guía sobre cómo adjuntar archivos a los registros]. Por ejemplo, un
+`User` con un `avatar` se representa como:
+
+```ruby
+class User < ApplicationRecord
+  has_one_attached :avatar
+end
+```
+
+Cualquier cambio de tamaño se hace en la vista como un `variant`.
+
+[la guía sobre cómo adjuntar archivos a los registros]: http://edgeguides.rubyonrails.org/active_storage_overview.html#attaching-files-to-records
+
+## Quita Paperclip
+
+Quita la gema de tu `Gemfile` y corre `bundle`. Corre tus pruebas porque ya
+terminaste!