paperclip
Version 6.1.0
El clip está en desuso .
Para nuevos proyectos, recomendamos el propio ActiveStorage de Rails.
Para proyectos existentes, consulte y contribuya a la guía de migración, disponible en inglés, en español y como video grabado en RailsConf 2019. También puede preferir un tutorial de migración alternativo utilizado por Doorkeeper.
Alternativamente, para proyectos existentes, Kreeti mantiene kt-paperclip, una bifurcación en curso de Paperclip.
Dejaremos los Temas abiertos únicamente como foro de discusión. No garantizamos una respuesta nuestra en las Cuestiones. Todos los informes de errores deben ir a kt-paperclip.
Ya no aceptamos solicitudes de extracción, excepto solicitudes de extracción basadas en la guía de migración. Todas las demás solicitudes de extracción se cerrarán sin fusionarse.
master .Consulte la documentación de la versión de clip que está utilizando: https://github.com/thinkbot/paperclip/releases
Requisitos
Rubí y rieles
Procesador de imagen
file
Instalación
Inicio rápido
Modelos
Migraciones
Editar y nuevas vistas
Editar y nuevas vistas con formulario simple
Controlador
Ver ayudantes
Comprobar que existe un archivo
Eliminar un archivo adjunto
Uso
Validaciones
Internacionalización (I18n)
Validaciones de seguridad
Valores predeterminados
Migraciones
Agregar columna adjunta a una tabla
Definición de esquema
Sintaxis antigua
Almacenamiento
Comprender el almacenamiento
Adaptadores E/S
Postprocesamiento
Procesadores de archivos adjuntos personalizados
Eventos
Ofuscación de URI
Suma de comprobación/huella digital
Preservación de archivos para eliminación temporal
Configuración dinámica
Estilos dinámicos:
Procesadores dinámicos:
Explotación florestal
Despliegue
Estilos de archivos adjuntos
Pruebas
Contribuyendo
Licencia
Acerca del robot de pensamiento
Paperclip está pensado como una biblioteca de archivos adjuntos sencilla para ActiveRecord. La intención detrás de esto era mantener la configuración lo más fácil posible y tratar los archivos lo más parecido posible a otros atributos. Esto significa que no se guardan en sus ubicaciones finales en el disco, ni se eliminan si se configuran en nil, hasta que se llame a ActiveRecord::Base#save. Gestiona validaciones en función del tamaño y presencia, si es necesario. Puede transformar su imagen asignada en miniaturas si es necesario, y los requisitos previos son tan simples como instalar ImageMagick (que, para la mayoría de los sistemas modernos basados en Unix, es tan fácil como instalar los paquetes correctos). Los archivos adjuntos se guardan en el sistema de archivos y se hace referencia a ellos en el navegador mediante una especificación fácilmente comprensible, que tiene valores predeterminados sensatos y útiles.
Consulte la documentación de has_attached_file en Paperclip::ClassMethods para obtener opciones más detalladas.
El RDoc completo está en línea.
Paperclip ahora requiere la versión de Ruby >= 2.1 y la versión de Rails >= 4.2 (solo si vas a utilizar Paperclip con Ruby on Rails).
ImageMagick debe estar instalado y Paperclip debe tener acceso a él. Para asegurarse de que así sea, en su línea de comando, ejecute which convert (una de las utilidades ImageMagick). Esto le dará la ruta donde está instalada esa utilidad. Por ejemplo, podría devolver /usr/local/bin/convert .
Luego, en el archivo de configuración de su entorno, informe a Paperclip que busque allí agregando ese directorio a su ruta.
En modo de desarrollo, puede agregar esta línea a config/environments/development.rb) :
Paperclip.options[:command_path] = "/usr/local/bin/"
Si estás en Mac OS X, querrás ejecutar lo siguiente con Homebrew:
brew install imagemagick
Si está cargando archivos PDF o ejecutando el conjunto de pruebas, también necesitará instalar GhostScript. En Mac OS X, también puedes instalarlo usando Homebrew:
brew install gs
Si está en Ubuntu (o cualquier distribución de Linux basada en Debian), querrá ejecutar lo siguiente con apt-get:
sudo apt-get install imagemagick -y
file El comando file Unix es necesario para comprobar el tipo de contenido. Esta utilidad no está disponible en Windows, pero viene incluida con Ruby Devkit, por lo que los usuarios de Windows deben asegurarse de que el devkit esté instalado y agregado a la PATH del sistema.
Instalación manual
Si está utilizando Windows 7+ como entorno de desarrollo, es posible que deba instalar la aplicación file.exe manualmente. El sistema file spoofing de Paperclip 4+ se basa en esto; si no lo tienes funcionando, recibirás Validation failed: Upload file has an extension that does not match its contents. errores.
Para instalar manualmente, debe realizar lo siguiente:
Descargue e instale
filedesde esta URL
Para probar, puedes usar la imagen a continuación:
A continuación, debe realizar la integración con su entorno, preferiblemente a través de la variable PATH o cambiando su archivo config/environments/development.rb
CAMINO
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)GnuWin32bin`) 6. Restart any CMD shells you have open & see if it works
O
Ambiente
1. Open `config/environments/development.rb` 2. Add the following line: `Paperclip.options[:command_path] = 'C:Program Files (x86)GnuWin32bin'` 3. Restart your Rails server
Cualquiera de estos métodos le dará a su configuración de Rails acceso a la funcionalidad file.exe , brindando así la capacidad de verificar el contenido de un archivo (solucionando el problema de suplantación de identidad)
Paperclip se distribuye como una joya, que es como debe usarse en su aplicación.
Incluye la gema en tu Gemfile:
gema "clip", "~> 6.0.0"
O, si desea obtener la última versión, puede obtener el master desde el repositorio principal de clips:
gema "clip", git: "git://github.com/thinkbot/paperclip.git"
Si está intentando utilizar funciones que no parecen estar en la última gema lanzada, pero que se mencionan en este README, entonces probablemente necesite especificar la rama master si desea usarlas. Este archivo README probablemente esté por delante de la última versión publicada si lo estás leyendo en GitHub.
Para uso sin rieles:
clase Nombre del Módulo < ActiveRecord::Base incluir Paperclip::Pegamento ...fin
clase Usuario < ActiveRecord::Base has_attached_file :avatar, estilos: { medio: "300x300>", pulgar: "100x100>" }, default_url: "/images/:style/missing.png" valida_attachment_content_type :avatar, content_type: / Imagen/.*z/end Suponiendo que tiene una tabla users , agregue una columna avatar a la tabla de users :
clase AddAvatarColumnsToUsers < ActiveRecord::Migration def up add_attachment :users, :avatar end def down remove_attachment :users, :avatar endend
(O puede utilizar el generador de migración de Rails: rails generate paperclip user avatar )
Asegúrese de tener los métodos correspondientes en su controlador:
<%= form_for @usuario, url: ruta_usuarios, html: { multiparte: verdadero } hacer |formulario| %> <%= form.file_field :avatar %> <%= form.submit %><% end %><%= formulario_simple_para @usuario, url: ruta_usuarios hacer |formulario| %> <%= formulario.entrada :avatar, como: :archivo %> <%= formulario.enviar %><% fin %>
def create @user = User.create(user_params)endprivate# Utilice strong_parameters para la lista blanca de atributos# Asegúrese de actualizar sus métodos de controlador create() y update().def user_params params.require(:user).permit(:avatar)end
Agregue estos a la vista donde desea que se muestren sus imágenes:
<%= etiqueta_imagen @user.avatar.url %><%= etiqueta_imagen @user.avatar.url(:medium) %><%= etiqueta_imagen @user.avatar.url(:thumb) %>
Hay dos métodos para comprobar si existe un archivo:
file? y present? comprueba si el campo _file_name está completo
exists? comprueba si el archivo existe (realizará una conexión TCP si se almacena en la nube)
Tenga esto en cuenta si está comprobando si los archivos están presentes en un bucle. La primera versión tiene un rendimiento significativamente mayor, pero tiene una semántica diferente.
Establezca el atributo en nil y guárdelo.
@usuario.avatar = [email protected]
Los conceptos básicos de Paperclip son bastante simples: declara que tu modelo tiene un archivo adjunto con el método has_attached_file y dale un nombre.
Paperclip envolverá hasta cuatro atributos (todos con el prefijo del nombre de ese archivo adjunto, por lo que puede tener varios archivos adjuntos por modelo si lo desea) y les brindará una interfaz amigable. Estos atributos son:
De forma predeterminada, sólo se requiere
Más información sobre las opciones pasadas a has_attached_file está disponible en la documentación de Paperclip::ClassMethods .
Para las validaciones, Paperclip presenta varios validadores para validar su archivo adjunto:
AttachmentContentTypeValidator
AttachmentPresenceValidator
AttachmentSizeValidator
Uso de ejemplo:
valida :avatar, adjunto_presencia: truevalidates_con AnexoPresenceValidator, atributos: :avatarvalidates_con AnexoTamañoValidator, atributos: :avatar, menos_que: 1.megabytes
Los validadores también se pueden definir usando el antiguo estilo de ayuda:
validates_attachment_presence
validates_attachment_content_type
validates_attachment_size
Uso de ejemplo:
valida_attachment_presence: avatar
Por último, también puedes definir múltiples validaciones en un solo archivo adjunto usando validates_attachment :
valida_attachment: avatar, presencia: verdadero, tipo de contenido: "imagen/jpeg", tamaño: {en: 0..10.kilobytes}NOTA: El posprocesamiento ni siquiera comenzará si el archivo adjunto no es válido según las validaciones. Sus devoluciones de llamada y procesadores solo serán llamados con archivos adjuntos válidos.
mensaje de clase < ActiveRecord::Base has_attached_file :asset, estilos: { pulgar: "100x100#" } before_post_process :skip_for_audio def skip_for_audio
! %w(audio/aplicación ogg/ogg).include?(asset_content_type) endendSi tiene otras validaciones que dependen del orden de asignación, el curso de acción recomendado es evitar la asignación del archivo adjunto hasta después y luego asignarlo manualmente:
class Libro < ActiveRecord::Base has_attached_file :document, estilos: { miniatura: "60x60#" } valida_attachment :document, content_type: "application/pdf" valida_algo_else # Otras validaciones que entran en conflicto con Paperclip'sendclass BooksController < ApplicationController def create @book = Libro.nuevo(libro_params) @libro.documento = params[:libro][:documento] @book.save respond_with @book end private def book_params params.require(:book).permit(:title, :author) endendUna nota sobre validaciones y seguridad de content_type
Debe asegurarse de validar los archivos para que sean solo aquellos tipos MIME que desea admitir explícitamente. Si no lo hace, podría estar expuesto a ataques XSS si un usuario carga un archivo con una carga útil HTML maliciosa.
Si solo está interesado en imágenes, restrinja los tipos de contenido permitidos a los de imágenes:
adjunto_validaciones :avatar, tipo_contenido: ["imagen/jpeg", "imagen/gif", "imagen/png"]
Paperclip::ContentTypeDetector intentará hacer coincidir la extensión de un archivo con un tipo de contenido inferido, independientemente del contenido real del archivo.
Para usar o agregar archivos locales en diferentes idiomas, consulte el proyecto https://github.com/thinkbot/paperclip-i18n.
Gracias a un informe de Egor Homakov, hemos tomado medidas para evitar que las personas falsifiquen tipos de contenido y obtengan datos inesperados en su servidor.
NOTA: A partir de la versión 4.0.0, todos los archivos adjuntos deben incluir una validación de tipo de contenido, una validación de nombre de archivo o indicar explícitamente que no tendrán ninguna de las dos. Paperclip generará un error si no hace esto.
class ActiveRecord::Base has_attached_file :avatar # Validar tipo de contenido valida_attachment_content_type :avatar, content_type: /Aimage/ # Valida nombre de archivo valida_attachment_file_name :avatar, coincidencias: [/pngz/, /jpe?gz/] # Explícitamente no validar do_not_validate_attachment_file_type: avatarend
Esto mantiene a Paperclip seguro de forma predeterminada y evitará que las personas intenten alterar su sistema de archivos.
NOTA: También a partir de la versión 4.0.0, Paperclip tiene otra validación que no se puede desactivar. Esta validación evitará la suplantación de tipo de contenido. Es decir, subir un documento PHP (por ejemplo) como parte de las etiquetas EXIF de un JPEG bien formado. Esta verificación se limita al tipo de medio (la primera parte del tipo MIME, es decir, 'texto' en text/plain ). Esto evitará que los documentos HTML se carguen como JPEG, pero no evitará que se carguen GIF con una extensión .jpg . Esta validación solo agregará errores de validación al formulario. No provocará que se generen errores.
A veces, esto puede provocar errores de validación falsos en aplicaciones que utilizan extensiones de archivo personalizadas. En estos casos, es posible que desee agregar su extensión personalizada a la lista de asignaciones de tipos de contenido creando config/initializers/paperclip.rb :
# Permitir ".foo" como extensión para archivos con el tipo MIME "text/plain".Paperclip.options[:content_type_mappings] = { foo: %w(text/plain)} Los valores predeterminados globales para todos los archivos adjuntos de Paperclip se pueden definir cambiando el hash Paperclip::Attachment.default_options. Esto puede ser útil para establecer la configuración de almacenamiento predeterminada, por ejemplo, para que no tenga que definirla en cada definición de has_attached_file .
Si está utilizando Rails, puede definir un Hash con opciones predeterminadas en config/application.rb o en cualquiera de los archivos config/environments/*.rb en config.paperclip_defaults. Estos se fusionarán en Paperclip::Attachment.default_options cuando se inicie la aplicación Rails. Un ejemplo:
módulo YourApp clase Aplicación < Rails::Aplicación # Otro código... config.paperclip_defaults = { almacenamiento: :fog, fog_credentials: { proveedor: "Local", local_root: "#{Rails.root}/public"}, fog_directory: "", fog_host: "localhost"} fin Otra opción es modificar directamente el Hash Paperclip::Attachment.default_options ; este método funciona para aplicaciones que no son Rails o es una opción si prefiere colocar la configuración predeterminada de Paperclip en un inicializador.
Un ejemplo de inicializador de Rails se vería así:
Paperclip::Attachment.default_options[:storage] = :fogPaperclip::Attachment.default_options[:fog_credentials] = { proveedor: "Local", local_root: "#{Rails.root}/public"}Paperclip::Attachment.default_options[ :directorio_niebla] = ""Paperclip::Attachment.default_options[:fog_host] = "http://localhost:3000"Paperclip define varios métodos de migración que se pueden utilizar para crear las columnas necesarias en su modelo. Hay dos tipos de métodos auxiliares para ayudar en esto, como se muestra a continuación:
El asistente attachment se puede utilizar al crear una tabla:
clase CreateUsersWithAttachments < ActiveRecord::Migration def up create_table :los usuarios hacen |t| t.attachment :avatar end end # Esto supone que solo está utilizando la tabla de usuarios para el archivo adjunto Paperclip. ¡Baja con cuidado! def abajo drop_table: usuarios finales
También puede utilizar el método change , en lugar de la combinación up / down anterior, como se muestra a continuación:
clase CreateUsersWithAttachments < ActiveRecord::Migration def cambiar create_table :los usuarios hacen |t| t.attachment: final del avatar final del final
Alternativamente, los métodos add_attachment y remove_attachment se pueden usar para agregar nuevas columnas Paperclip a una tabla existente:
clase AddAttachmentColumnsToUsers < ActiveRecord::Migration def arriba add_attachment :usuarios, :avatar fin def abajo remove_attachment :usuarios, :avatar final
O puedes hacer esto con el método change :
clase AddAttachmentColumnsToUsers < ActiveRecord::Migration def cambiar add_attachment :usuarios, :avatar endend
La sintaxis antigua (como t.has_attached_file y drop_attached_file ) todavía es compatible con Paperclip 3.x, pero se recomienda actualizar esos archivos de migración para usar esta nueva sintaxis.
Paperclip se envía con 3 adaptadores de almacenamiento:
Almacenamiento de archivos
Almacenamiento S3 (a través de aws-sdk-s3 )
Almacenamiento de niebla
Si desea utilizar Paperclip con otro almacenamiento, puede instalar estas gemas junto con Paperclip:
clip-azul
almacenamiento-de-clip-azure
buzón de clip
Los archivos que se asignan como archivos adjuntos se colocan, de forma predeterminada, en el directorio especificado por la opción :path para has_attached_file . De forma predeterminada, esta ubicación es :rails_root/public/system/:class/:attachment/:id_partition/:style/:filename . Se eligió esta ubicación porque, en las implementaciones estándar de Capistrano, el directorio public/system se puede vincular simbólicamente al directorio compartido de la aplicación, lo que significa que sobrevive entre implementaciones. Por ejemplo, usando ese :path , es posible que tenga un archivo en
/data/myapp/releases/20081229172410/public/system/users/avatar/000/000/013/small/my_pic.png
NOTA : Este es un cambio con respecto a las versiones anteriores de Paperclip, pero en general es una opción más segura para el almacén de archivos predeterminado.
También puede optar por almacenar sus archivos utilizando el servicio S3 de Amazon. Para hacerlo, incluya la gema aws-sdk-s3 en su Gemfile:
gema 'aws-sdk-s3'
Y luego puede especificar el uso de S3 desde has_attached_file . Puede encontrar más información sobre la configuración y el uso del almacenamiento S3 en la documentación Paperclip::Storage::S3 .
Los archivos en el sistema de archivos local (y en el directorio público de la aplicación Rails) estarán disponibles en Internet en general. Si necesita control de acceso, es posible colocar sus archivos en una ubicación diferente. Deberá cambiar las opciones :path y :url para asegurarse de que los archivos no estén disponibles para el público. Tanto :path como :url permiten el mismo conjunto de variables interpoladas.
Cuando se carga o adjunta un archivo, puede estar en una de varias formas de entrada diferentes, desde el objeto UploadedFile de Rails hasta un StringIO, un Tempfile o incluso una cadena simple que es una URL que apunta a una imagen.
Paperclip aceptará, de forma predeterminada, muchas de estas fuentes. También es capaz de manejar aún más con una pequeña configuración. Los adaptadores IO que manejan imágenes de fuentes no locales no están habilitados de forma predeterminada. Se pueden habilitar agregando una línea similar a la siguiente en config/initializers/paperclip.rb :
Clip::DataUriAdapter.register
Es mejor habilitar solo un adaptador de carga remota si lo necesita. De lo contrario, existe la posibilidad de que alguien pueda obtener información sobre la estructura de su red interna usándola como vector.
Los siguientes adaptadores no están cargados de forma predeterminada:
Paperclip::UriAdapter - que acepta una instancia URI .
Paperclip::HttpUrlProxyAdapter - que acepta una cadena http .
Paperclip::DataUriAdapter - que acepta data: cadena.
Paperclip admite una selección ampliable de postprocesadores. Cuando define un conjunto de estilos para un archivo adjunto, de forma predeterminada se espera que esos "estilos" sean en realidad "miniaturas". Estos son procesados por Paperclip::Thumbnail . Por razones de compatibilidad con versiones anteriores, puede pasar una única cadena de geometría o una matriz que contenga una geometría y un formato al que se convertirá el archivo, así:
has_attached_file :avatar, estilos: { pulgar: ["32x32#", :png] } Esto convertirá el estilo "pulgar" a un cuadrado de 32x32 en formato PNG, independientemente de lo que se haya subido. Si no se especifica el formato, se mantiene igual (por ejemplo, los JPG seguirán siendo JPG). Paperclip::Thumbnail usa ImageMagick para procesar imágenes; La documentación de geometría de ImageMagick tiene más información sobre los formatos de estilo aceptados.
Para un control más detallado del proceso de conversión, se pueden usar source_file_options y convert_options para pasar indicadores y configuraciones directamente a la poderosa herramienta Convertir de ImageMagick, documentada aquí. Por ejemplo:
has_attached_file: imagen, estilos: {regular: ['800x800>',: png]},
source_file_options: {regular: "-densidad 96 -profundidad 8 -calidad 85" }, convert_options: {regular: "-posterize 3"}ImageMagick admite una serie de variables de entorno para controlar sus límites de recursos. Por ejemplo, puede imponer límites de memoria o de tiempo de ejecución configurando las siguientes variables en el entorno de proceso de su aplicación:
MAGICK_MEMORY_LIMIT=128MiB
MAGICK_MAP_LIMIT=64MiB
MAGICK_TIME_LIMIT=30
Para obtener una lista completa de variables y descripciones, consulte la documentación de recursos de ImageMagick.
Puede escribir sus propios procesadores de archivos adjuntos personalizados para realizar tareas como agregar marcas de agua, comprimir imágenes o cifrar archivos. Los procesadores personalizados deben definirse dentro del módulo Paperclip , heredar de Paperclip::Processor (consulte lib/paperclip/processor.rb ) e implementar un método make que devuelva un File . Paperclip cargará automáticamente todos los archivos en los directorios lib/paperclip y lib/paperclip_processors de su aplicación Rails. Los procesadores se especifican usando la opción :processors para has_attached_file :
has_attached_file: escanear, estilos: {texto: {calidad:: mejor}}, procesadores: [:ocr] Esto cargaría la clase hipotética Paperclip::Ocr y le pasaría el hash de opciones { quality: :better } , junto con el archivo cargado.
Se pueden especificar varios procesadores y se invocarán en el orden en que están definidos en la matriz :processors . A cada procesador sucesivo se le da el resultado del procesador anterior. Todos los procesadores reciben los mismos parámetros, que se definen en el hash :styles . Por ejemplo, suponiendo que tuviéramos esta definición:
has_attached_file: escanear, estilos: {texto: {calidad:: mejor}}, procesadores: [: rotador,: ocr] Tanto el procesador :rotator como el procesador :ocr recibirían las opciones { quality: :better } . Si un procesador recibe una opción que no reconoce, se espera que la ignore.
NOTA: Debido a que los procesadores funcionan convirtiendo el archivo adjunto original en estilos, no se ejecutará ningún procesador si no hay estilos definidos.
Si está interesado en almacenar en caché el ancho, alto y tamaño de su miniatura en la base de datos, eche un vistazo a la meta gema paperclip.
Además, si está interesado en generar la miniatura sobre la marcha, es posible que desee consultar la gema adjunto_on_the_fly.
El generador de miniaturas de Paperclip (consulte lib/paperclip/thumbnail.rb ) se implementa como un procesador y puede ser una buena referencia para escribir sus propios procesadores.
Antes y después del paso de posprocesamiento, Paperclip vuelve a llamar al modelo con algunas devoluciones de llamada, lo que permite que el modelo cambie o cancele el paso de procesamiento. Las devoluciones de llamada son before_post_process y after_post_process (que se llaman antes y después del procesamiento de cada archivo adjunto), y las específicas del archivo adjunto before_ y after_ . Las devoluciones de llamada están destinadas a ser lo más parecidas posible a las devoluciones de llamada normales de ActiveRecord, por lo que si devuelve false (específicamente, devolver nil no es lo mismo) en before_filter , el paso de procesamiento posterior se detendrá. Devolver false en after_filter no detendrá nada, pero podrá acceder al modelo y al archivo adjunto si es necesario.
NOTA: El posprocesamiento ni siquiera comenzará si el archivo adjunto no es válido según las validaciones. Sus devoluciones de llamada y procesadores solo serán llamados con archivos adjuntos válidos.
mensaje de clase < ActiveRecord::Base has_attached_file :asset, estilos: { pulgar: "100x100#" } before_post_process :skip_for_audio def skip_for_audio
! %w(audio/aplicación ogg/ogg).include?(asset_content_type) endend Paperclip tiene una interpolación llamada :hash para ofuscar los nombres de los archivos disponibles públicamente.
Uso de ejemplo:
has_attached_file :avatar, { url: "/system/:hash.:extension", hash_secret: "longSecretString"} La interpolación :hash se reemplazará con un hash único compuesto por lo que se especifica en :hash_data . El valor predeterminado para :hash_data es ":class/:attachment/:id/:style/:updated_at" .
:hash_secret es obligatorio; se generará una excepción si :hash se utiliza sin :hash_secret presente.
Para obtener más información sobre esta función, lea la explicación del propio autor.
Se colocará una suma de verificación del archivo original asignado en el modelo si tiene un atributo denominado huella digital. Siguiendo el ejemplo de migración del modelo de usuario anterior, la migración tendría el siguiente aspecto:
clase AddAvatarFingerprintColumnToUser < ActiveRecord::Migration def arriba add_column :usuarios, :avatar_fingerprint, :string end def abajo remove_column :usuarios, :avatar_fingerprint endend
El algoritmo se puede especificar mediante una opción de configuración; su valor predeterminado es MD5 para compatibilidad con Paperclip 5 y versiones anteriores.
has_attached_file: some_attachment, adapt_options: {hash_digest: Digest::SHA256} Ejecute CLASS=User ATTACHMENT=avatar rake paperclip:refresh:fingerprints después de cambiar el resumen de los archivos adjuntos existentes para actualizar las huellas digitales en la base de datos.
Hay una opción disponible para conservar los archivos adjuntos para que funcionen bien con los modelos eliminados temporalmente. (actúa_como_paranoico, paranoia, etc.)
has_attached_file: algún_archivo adjunto, {preservar_files: verdadero,} Esto evitará que some_attachment se borre cuando se destruya el modelo, por lo que seguirá existiendo cuando el objeto se restaure más adelante.
Los objetos invocables (lambdas, Procs) se pueden usar en varios lugares para la configuración dinámica en Paperclip. Esta estrategia existe en varios componentes de la biblioteca, pero es más importante en las posibilidades de permitir que se apliquen estilos y procesadores personalizados para instancias de modelo específicas, en lugar de aplicar estilos y procesadores definidos en todas las instancias.
Imagine un modelo de usuario que tuviera diferentes estilos según el rol del usuario. Quizás algunos usuarios sean jefes (por ejemplo, una instancia de modelo de usuario responde a #boss? ) y merezcan una miniatura de avatar más grande que los usuarios normales. La configuración para determinar qué parámetros de estilo se utilizarán según la función del usuario podría verse de la siguiente manera: un jefe recibirá una miniatura 300x300 de lo contrario, se creará una miniatura 100x100 .
clase Usuario < ActiveRecord::Base has_attached_file :avatar, estilos: lambda { |adjunto| { pulgar: (archivo adjunto.instancia.boss? ? "300x300>" : "100x100>") } }fin Otro ejemplo artificial es un modelo de usuario que sabe qué procesadores de archivos se le deben aplicar (más allá del procesador thumbnail implícito que se invoca cuando se definen :styles ). Quizás tengamos disponible un procesador de marcas de agua y solo se use en los avatares de determinados modelos. La configuración para esto podría ser donde se consulta la instancia para saber qué procesadores se le deben aplicar. Es de suponer que algunos usuarios podrían devolver [:thumbnail, :watermark] para sus procesadores, donde se invoca un procesador watermark definido después del procesador thumbnail ya definido por Paperclip.
clase Usuario < ActiveRecord::Base has_attached_file :avatar, procesadores: lambda { |instancia| instancia.procesadores } attr_accessor:procesadorenviarDe forma predeterminada, Paperclip genera el registro según su nivel de registrador. Si desea deshabilitar el registro (por ejemplo, durante las pruebas), agregue esto a la configuración de su entorno:
Su::Aplicación.configure hacer... Paperclip.options[:log] = false...end
Más información en los rdocs
Para hacer que Capistrano enlace simbólicamente el directorio public/system para que los archivos adjuntos sobrevivan a nuevas implementaciones, configure la opción linked_dirs en su archivo config/deploy.rb :
establecer :linked_dirs, fetch(:linked_dirs, []).push('público/sistema') Paperclip reconoce los nuevos estilos de archivos adjuntos que ha agregado en implementaciones anteriores. Lo único que debe hacer después de cada implementación es llamar rake paperclip:refresh:missing_styles . Almacenará los estilos de archivos adjuntos actuales en RAILS_ROOT/public/system/paperclip_attachments.yml de forma predeterminada. Puedes cambiarlo por:
Paperclip.registered_attachments_styles_path = '/tmp/config/paperclip_attachments.yml'
Aquí hay un ejemplo para Capistrano:
espacio de nombres :paperclip hacer desc tarea "construir estilos de clip que faltan" :build_missing_styles hacer en roles(:app) hacer dentro de release_path hacer con rails_env: fetch(:rails_env) ejecutar :rake, "paperclip:refresh:missing_styles" end end endendafter( "deploy:compile_assets", "paperclip:build_missing_styles")
Ahora no es necesario que recuerdes actualizar las miniaturas en producción cada vez que agregas un nuevo estilo. Desafortunadamente, no funciona con estilos dinámicos, simplemente los ignora.
Si ya tiene una aplicación que funciona y no desea rake paperclip:refresh:missing_styles actualice las imágenes antiguas, debe informar a Paperclip sobre los estilos existentes. Simplemente cree un archivo paperclip_attachments.yml a mano. Por ejemplo:
clase Usuario < ActiveRecord::Base has_attached_file :avatar, estilos: { pulgar: 'x100', recortable: '600x600>', grande: '1000x1000>' }endclass Libro < ActiveRecord::Base has_attached_file :portada, estilos: { pequeño: 'x100', grande: '1000x1000>' } has_attached_file: muestra, estilos: {pulgar: 'x100'} fin Luego en RAILS_ROOT/public/system/paperclip_attachments.yml :
---:Usuario: :avatar: - :pulgar - :recortable - :grande:Libro: :portada: - :pequeño - :grande :muestra: - :pulgar
Paperclip proporciona comparadores compatibles con rspec para probar archivos adjuntos. Consulte la documentación en Paperclip::Shoulda::Matchers para obtener más información.
Pruebas paralelas
Debido a la path predeterminada para el almacenamiento de Paperclip, si intenta ejecutar pruebas en paralelo, es posible que los archivos se sobrescriban porque se calcula la misma ruta para ellos en cada proceso de prueba. Si bien esta solución funciona para pruebas_paralelas, se debe utilizar un concepto similar para cualquier otro mecanismo para ejecutar pruebas al mismo tiempo.
if ENV['PARALLEL_TEST_GROUPS'] Paperclip::Attachment.default_options[:path] = ":rails_root/public/system/:rails_env/#{ENV['TEST_ENV_NUMBER'].to_i}/:class/:attachment/:id_partition/ :nombre de archivo"else Paperclip::Attachment.default_options[:ruta] = ":rails_root/public/system/:rails_env/:class/:attachment/:id_partition/:filename"end La parte importante aquí es la inclusión de ENV['TEST_ENV_NUMBER'] , o un mecanismo similar para cualquier biblioteca de pruebas paralela que utilice.
Pruebas de integración
El uso de pruebas de integración con FactoryBot puede guardar varias copias de sus archivos de prueba dentro de la aplicación. Para evitar esto, especifique una ruta personalizada en config/environments/test.rb así:
Paperclip::Attachment.default_options[:path] = "#{Rails.root}/spec/test_files/:class/:id_partition/:style.:extension" Luego, asegúrese de eliminar ese directorio después de que se ejecute el conjunto de pruebas agregando esto a spec_helper.rb .
config.after(:suite) hacer FileUtils.rm_rf(Dir["#{Rails.root}/spec/test_files/"])endEjemplo de configuración de prueba con Factory Bot
FactoryBot.define hacer fábrica :usuario hacer avatar { File.new("#{Rails.root}/spec/support/fixtures/image.jpg") } finSi desea contribuir con una característica o corrección de errores: ¡Gracias! Para asegurarse de que su solución/función tenga una alta probabilidad de incluirse, lea las siguientes pautas:
Publicar una solicitud de extracción.
¡Asegúrate de que haya pruebas! No aceptaremos ningún parche que no esté probado. Es raro que no se necesiten pruebas explícitas. Si tiene preguntas sobre cómo escribir pruebas para clip, abra una edición de GitHub.
Consulte CONTRIBUTING.md para obtener más detalles sobre cómo contribuir y ejecutar pruebas.
¡Gracias a todos los contribuyentes!
Paperclip tiene Copyright © 2008-2017 thinkbot, inc. Es software gratuito y puede redistribuirse según los términos especificados en el archivo MIT-LICENSE.
Paperclip es mantenido y financiado por thinkbot. Los nombres y logotipos de thinkbot son marcas comerciales de thinkbot, inc.
¡Nos encanta el software de código abierto! Vea nuestros otros proyectos o contratenos para diseñar, desarrollar y hacer crecer su producto.
