ss-attachment_fu 3.2.17

data/CHANGELOG

@@ -0,0 +1,99 @@
+* Jan 27, 2015 *
+* Pull in changes from bacrossland to fix test suite *
+
+* Sep 23, 2014 *
+* Pull in changes from corlissc to Refactor DbFileBackend for Rails 4 AREL conformity *
+
+* May 13, 2014 *
+* Pull in changes from bacrossland to fix thumbnails for S3 storage
+
+* Apr 17, 2014 *
+* Pull in changes from jasonbuehler to fix Rails 4 errors
+
+* Jan 7, 2014 *
+* Pull in changes from twelvelabs to fix gem use in Rails 2
+
+* Aug 22, 2013 *
+* Added cache-control header option and Ruby 1.9 fix for S3 from tricycle
+
+* Aug 21, 2013 *
+* Added S3 :encrypted_storage option support from cschulte22
+
+* Jul 5, 2013
+* Pull in changes from lchimonji10 to reformat README to RDoc format
+
+* Apr 10, 2013 *
+* Ruby 2 compatibility fix
+* Removed some lingering occurrences of RAILS_ROOT and RAILS_ENV
+* clean up of gemspec file
+* no longer package unnecessary files like the test files
+
+* Mar 12, 2013 *
+* Pull in changes from https://github.com/aalong/attachment_fu to use Ruby 1.9.2 Tempfile naming strategy to fix conflicts with Sprockets (see https://github.com/aalong/attachment_fu/commit/938ec3b8597fbf82b1de8c98de12c4688463450a)
+
+* Feb 19, 2013 *
+* Pull in changes from https://github.com/itkin/attachment_fu fork to fix mini magick
+
+* Nov 15, 2012 *
+* Removed 'crop:' option as already included when prefixing geometry with a 'c'.  Add note to docs.
+* Added option to sharpen resized images ':sharpen_on_resize'
+
+* Oct 26, 2012 *
+* Merged with https://github.com/tdd/attachment_fu fork to include GEM support for use in Rails 3.2, and bumped version to 3.2.x to indicate Rails 3.2 support.
+
+* Oct 25, 2012 *
+* Fix to support Ruby 1.9.3
+* Image cropping support (append 'crop:' to desired file size when resizing)
+
+* Mar 15, 2010 *
+* Added a symbol syntax for parent-type-based size spec: calls the corresponding method on the current asset instance to
+  get a Hash of required thumbnails.  Lets us dynamically specify what would otherwise be hard-coded, which is useful
+  when the set of thumbnails for a given parent type varies depending on the usage context.
+
+* Aug 6, 2009 *
+* JPEG quality control finalized across processors (although CoreImage applies it in a rather fuzzy-logic way), with tests.
+
+* Aug 4, 2009 *
+* Supports the :aspect/'!' geometry flag in all processors
+  (thanks to http://www.deepcalm.com/writing/cropped-thumbnails-in-attachment_fu-using-imagescience)
+* JPEG quality control on thumbnailing/resizing (still buggy on Rmagick/MiniMagick though).
+* Moves from GIF to PNG regardless of the source file extension's case (used to require lowercase)
+* Auto-orients image (if EXIF suggests it) prior to processing with RMagickProcessor
+* Fixes non-image upload tests (both regular files and Merb files)
+* Fixes obsolete failures on RMagick tests (aspect_ratio tested but not initialized anymore due to new callback architecture
+
+* Apr 17 2008 *
+* amazon_s3.yml is now passed through ERB before being passed to AWS::S3 [François Beausoleil]
+
+* Mar 22 2008 *
+* Some tweaks to support Rails 2.0 and Rails 2.1 due to ActiveSupport::Callback changes.  
+  Thanks to http://blog.methodmissing.com/2008/1/19/edge-callback-refactorings-attachment_fu/
+
+* Feb. 26, 2008 *
+* remove breakpoint from test_helper, makes test suite crazy (at least Rails 2+) [Rob Sanheim]
+* make S3 test really optional [Rob Sanheim]
+
+* Nov 27, 2007 *
+* Handle properly ImageScience thumbnails resized from a gif file [Matt Aimonetti]
+* Save thumbnails file size properly when using ImageScience [Matt Aimonetti]
+* fixed s3 config file loading with latest versions of Rails [Matt Aimonetti]
+
+* April 2, 2007 *
+
+* don't copy the #full_filename to the default #temp_paths array if it doesn't exist
+* add default ID partitioning for attachments
+* add #binmode call to Tempfile (note: ruby should be doing this!) [Eric Beland]
+* Check for current type of :thumbnails option.
+* allow customization of the S3 configuration file path with the :s3_config_path option.
+* Don't try to remove thumbnails if there aren't any.  Closes #3 [ben stiglitz]
+
+* BC * (before changelog)
+
+* add default #temp_paths entry [mattly]
+* add MiniMagick support to attachment_fu [Isacc]
+* update #destroy_file to clear out any empty directories too [carlivar]
+* fix references to S3Backend module [Hunter Hillegas]
+* make #current_data public with db_file and s3 backends [ebryn]
+* oops, actually svn add the files for s3 backend. [Jeffrey Hardy]
+* experimental s3 support, egad, no tests.... [Jeffrey Hardy]
+* doh, fix a few bad references to ActsAsAttachment [sixty4bit]

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 rick olson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE 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/README.rdoc

@@ -0,0 +1,358 @@
+= attachment-fu
+
+{<img src="https://badge.fury.io/rb/pothoven-attachment_fu.svg" alt="Gem Version" />}[http://badge.fury.io/rb/pothoven-attachment_fu]
+
+attachment_fu is a plugin by Rick Olson (aka technoweenie
+http://techno-weenie.net) and is the successor to acts_as_attachment. To get a
+basic run-through of its capabilities, check out {Mike Clark's
+tutorial}[https://github.com/pothoven/attachment_fu/blob/master/TUTORIAL.rdoc].
+
+= patch
+* Directly save to AWS S3 based on Zoo configuration
+* Parameter resize_to can receive a symbol which is can be an instance method of class
+
+= attachment_fu functionality
+
+attachment_fu facilitates file uploads in Ruby on Rails. There are a few
+storage options for the actual file data, but the plugin always at a minimum
+stores metadata for each file in the database.
+
+There are four storage options for files uploaded through attachment_fu:
+
+* File system
+* Database file
+* Amazon S3
+* Rackspace (Mosso) Cloud Files
+
+Each method of storage many options associated with it that will be covered in
+the following section. Something to note, however, is that the Amazon S3 storage
+requires you to modify +config/amazon_s3.yml+, the Rackspace Cloud Files storage
+requires you to modify +config/rackspace_cloudfiles.yml+, and the Database file
+storage requires an extra table.
+
+= attachment_fu models
+
+For all three of these storage options a table of metadata is required. This
+table will contain information about the file (hence the 'meta') and its
+location. This table has no restrictions on naming, unlike the extra table
+required for database storage, which must have a table name of +db_files+ (and
+by convention a model of +DbFile+).
+
+Two methods are available to models: +has_attachment+ and
++validates_as_attachment+.
+
+== has_attachment(options = {})
+
+This method accepts the options in a hash:
+
+[:content_type]
+    Allowed content types.
+
+    By default, all content types are allowed. Use +:image+ to allow all
+    standard image types.
+
+[:min_size]
+    Minimum file size.
+
+    By default, set to +1.byte+.
+
+[:max_size]
+    Maximum file size.
+
+    By default, set to +1.megabyte+.
+
+[:size]
+    Minimum and maximum file size.
+
+    By default, set to +1..1.megabyte+. Overrides +:min_size+ and
+    +:max_size+.
+
+[:resize_to]
+    Used by RMagick.
+
+    Tells RMagick how to resize images. Pass either an array specifying
+    width and height or a geometry string.  Prefixing the geometry string
+    with a 'c' will crop the image to the specified size.
+
+[:sharpen_on_resize]
+    Used by RMagick.
+
+    If set to true, images are sharpened after being resized.
+
+[:thumbnails]
+    A set of thumbnails to generate.
+
+    This accepts a hash of filename suffixes and RMagick resizing options. This
+    option need only be included if you want thumbnailing.
+
+    If you have a polymorphic parent relationship, you can provide
+    parent-type-specific thumbnail settings by using a pair with the type string
+    as key and a Hash of thumbnail definitions, or a method symbol, as value.
+    The method symbol will call the named method in order to get a
+    dynamically-built Hash of thumbnail definitions, which gives you full
+    flexibility. AttachmentFu automatically detects your first polymorphic
+    +belongs_to+ relationship.
+
+[:thumbnail_class]
+    Which model class to use for thumbnails.
+
+    By default, the current attachment class is used.
+
+[:jpeg_quality]
+    JPEG quality settings for thumbnail resizes.
+
+    Arguments can be in multiple formats:
+
+    * Integer from 0 (basically crap) to 100 (basically lossless, fat files).
+
+    * When relying on tdd-image_science, you can also use one of its +JPEG_xxx+
+      constants for predefined ratios/settings.
+
+    * You can also use a Hash, with keys being either  thumbnail symbols (I
+      repeat: _symbols_) or surface boundaries.  A surface boundary is a string
+      starting with either '<' or '>=', followed by a number of pixels.  This
+      lets you specify per-thumbnail or per-general-thumbnail-"size" JPEG
+      qualities. (which can be useful when you have a _lot_ of thumbnail
+      options). Surface example: <code>{'<2000' => 90, '>=2000' => 75}</code>.
+
+    Defaults vary depending on the processor (ImageScience: 100%,
+    Rmagick/MiniMagick/Gd2: 75%, CoreImage: auto-adjust). Note that only
+    tdd-image_science (available from GitHub) currently supports explicit JPEG
+    quality; the default image_science currently forces 100%.
+
+[:path_prefix]
+    Path to store the uploaded files in. Uses <code>public/#{table_name}</code>
+    by default for the filesystem, and just <code>#{table_name}</code> for the
+    S3 and Cloud Files backend. Setting this sets the +:storage+ to
+    +:file_system+.
+
+[:partition]
+    Whether to partiton files in directories like +/0000/0001/image.jpg+.
+    Default is true. Only applicable to the +:file_system+ backend.
+
+[:storage]
+    Specifies the storage system to use. Defaults to +:db_file+. Options are
+    +:file_system+, +:db_file+, +:s3+, and +:cloud_files+.
+
+[:cloudfront]
+    If using S3 for storage, this option allows for serving the files via Amazon
+    CloudFront. Defaults to false.
+
+[:processor]
+    Sets the image processor to use for resizing of the attached image. Options
+    include ImageScience, Rmagick, MiniMagick, Gd2 and CoreImage. Default is
+    whatever is installed.
+
+[:uuid_primary_key]
+    If your model's primary key is a 128-bit UUID in hexadecimal format, then
+    set this to true.
+
+[:association_options]
+    attachment_fu automatically defines associations with thumbnails with
+    +has_many+ and +belongs_to+. If there are any additional options that you
+    want to pass to these methods, then specify them here.
+
+Examples:
+
+    has_attachment(content_type: 'application/pdf')
+    has_attachment(
+        content_type: ['application/pdf', 'application/msword', 'text/plain']
+    )
+    has_attachment(content_type: ['application/pdf', :image], resize_to: 'x50')
+    has_attachment(content_type: :image, resize_to: [50,50])
+    has_attachment(max_size: 1.kilobyte)
+    has_attachment(size: 1.megabyte..2.megabytes)
+    has_attachment(storage: :cloud_files)
+    has_attachment(storage: :file_system, path_prefix: 'public/files')
+    has_attachment(
+        storage: :file_system,
+        path_prefix: 'public/files',
+        content_type: :image,
+        resize_to: [50, 50],
+        partition: false
+    )
+    has_attachment(
+        storage: :file_system,
+        path_prefix: 'public/files',
+        thumbnails: {thumb: [50, 50], geometry: 'x50'}
+    )
+    has_attachment(storage: :s3)
+    has_attachment(store: :s3, cloudfront: true)
+    has_attachment(thumbnails: {thumb: [50, 50], geometry: 'x50'})
+
+    # Let's say we have a polymorphic belongs_to, e.g. called 'imageable', where
+    # imageable_type (or whatever the :foreign_type option was set to) can be,
+    # among other things, 'Product', 'User' or 'Editorial', each of which should
+    # have extra thumbnails:
+
+    has_attachment(thumbnails: {
+        editorials: {fullsize: '150x100>'},
+        geometry: 'x50',
+        products: {large_thumb: '169x169!', zoomed: '500x500>'},
+        thumb: [50, 50],
+        users: {avatar: '64x64!'}
+    })
+
+    # JPEG qualities…
+
+    has_attachment(jpeg_quality: 75)
+    has_attachment(jpeg_quality: 80 | ImageScience::JPEG_PROGRESSIVE)
+    has_attachment(
+        thumbnails: {thumb: [50, 50], geometry: 'x50'},
+        jpeg_quality: {'<2000' => 90, '>=2000' => 75}
+    )
+    has_attachment(
+        thumbnails: {thumb: [50, 50], geometry: 'x50'},
+        jpeg_quality: {nil => 75, thumb: 90, geometry: 90}
+    )
+
+== validates_as_attachment
+
+This method prevents files outside of the valid range (+:min_size+ to
++:max_size+, or the +:size+ range) from being saved. It does not however, halt
+the upload of such files. They will be uploaded into memory regardless of size
+before validation.
+
+To perform this validation, simply add +validates_as_attachment+ to your model.
+
+= attachment_fu migrations
+
+Fields for attachment_fu metadata tables…
+
+In general:
+
+    size,         :integer # file size in bytes
+    content_type, :string  # mime type, ex: application/mp3
+    filename,     :string  # sanitized filename
+
+That reference images:
+
+    height,       :integer # in pixels
+    width,        :integer # in pixels
+
+That reference images that will be thumbnailed:
+
+    parent_id,    :integer  # id of parent image (on the same table, a
+                            # self-referencing foreign-key). Only populated if
+                            # the current object is a thumbnail.
+    thumbnail,    :string   # The type of thumbnail this attachment record
+                            # describes. Only populated if the current object is
+                            # a thumbnail. Example:
+                            #
+                            # (In Model 'Avatar')
+                            # has_attachment(
+                            #     :content_type => :image,
+                            #     :storage => :file_system,
+                            #     :max_size => 500.kilobytes,
+                            #     :resize_to => '320x200>',
+                            #     :thumbnails => {
+                            #         :small => '10x10>',
+                            #         :thumb => '100x100>'
+                            #     }
+                            # )
+                            #
+                            # (Elsewhere)
+                            # @user.avatar.thumbnails.first.thumbnail # => 'small'
+                            #
+    db_file_id,   :integer  # ID of the file in the database (foreign key) that
+                            # reference files stored in the database (:db_file).
+
+Field for attachment_fu +db_files+ table:
+
+    data, :binary # binary file data, for use in database file storage
+
+= attachment_fu views
+
+There are two main views tasks that will be directly affected by attachment_fu:
+upload forms and displaying uploaded images.
+
+There are two parts of the upload form that differ from typical usage.
+
+1. Include <code>multipart: true</code> in the html options of the +form_for+
+   tag. Example:
+
+        <%=
+        form_for(
+            :attachment_metadata,
+            url: {action: "create"},
+            html: {multipart: true}
+        ) do |form|
+        %>
+
+2. Use the +file_field+ helper with +:uploaded_data+ as the field name. Example:
+
+       <%= form.file_field(:uploaded_data) %>
+
+Displaying uploaded images is made easy by the +public_filename+ method of the
+ActiveRecord attachment objects using file system, s3, and Cloud Files storage.
+
+== public_filename(thumbnail = nil)
+
+Returns the public path to the file.  If a thumbnail prefix is specified it will
+return the public file path to the corresponding thumbnail.  Examples:
+
+    attachment_obj.public_filename         #=> /attachments/2/file.jpg
+    attachment_obj.public_filename(:thumb) #=> /attachments/2/file_thumb.jpg
+    attachment_obj.public_filename(:small) #=> /attachments/2/file_small.jpg
+
+When serving files from database storage, doing more than simply downloading the
+file is beyond the scope of this document.
+
+= attachment_fu controllers
+
+There are two considerations to take into account when using attachment_fu in
+controllers.
+
+The first is when the files have no publicly accessible path and need to be
+downloaded through an action. Example:
+
+    def readme
+        send_file(
+            '/path/to/readme.txt',
+            type: 'plain/text',
+            disposition: 'inline'
+        )
+    end
+
+See the possible values for +send_file+ for reference.
+
+The second is when saving the file when submitted from a form. Example:
+
+In a view:
+
+    <%= form.file_field(:attachable, :uploaded_data) %>
+
+In a controller:
+
+    def create
+        @attachable_file = AttachmentMetadataModel.new(params[:attachable])
+        if @attachable_file.save
+            flash[:notice] = 'Attachment was successfully created.'
+            redirect_to(attachable_url(@attachable_file))
+        else
+            redirect_to(action: 'new')
+        end
+    end
+
+= attachment_fu scripting
+
+You may wish to import a large number of images or attachments. The following
+example shows how to upload a file from a script.
+
+    #!/usr/bin/env ./script/runner
+
+    # required to use ActionController::TestUploadedFile
+    require 'action_controller'
+    require 'action_controller/test_process.rb'
+
+    path = "./public/images/x.jpg"
+
+    # `mimetype` is a string like "image/jpeg". One way to get the mimetype for
+    # a given file on a UNIX system: mimetype = `file -ib #{path}`.gsub(/\n/,"")
+    mimetype = "image/jpeg"
+
+    # This will "upload" the file at path and create the new model.
+    @attachable = AttachmentMetadataModel.new(
+        uploaded_data: ActionController::TestUploadedFile.new(path, mimetype)
+    )
+    @attachable.save

data/amazon_s3.yml.tpl

@@ -0,0 +1,17 @@
+development:
+  bucket_name: appname_development
+  access_key_id: 
+  secret_access_key: 
+  distribution_domain: XXXX.cloudfront.net
+
+test:
+  bucket_name: appname_test
+  access_key_id: 
+  secret_access_key: 
+  distribution_domain: XXXX.cloudfront.net
+
+production:
+  bucket_name: appname
+  access_key_id: 
+  secret_access_key: 
+  distribution_domain: XXXX.cloudfront.net

data/lib/geometry.rb

@@ -0,0 +1,96 @@
+# This Geometry class was yanked from RMagick.  However, it lets ImageMagick handle the actual change_geometry.
+# Use #new_dimensions_for to get new dimensions
+# Used so I can use spiffy RMagick geometry strings with ImageScience
+class Geometry
+  # @ is removed until support for them is added
+  FLAGS = ['', '%', '<', '>', '!']#, '@']
+  RFLAGS = { '%' => :percent,
+             '!' => :aspect,
+             '<' => :>,
+             '>' => :<,
+             '@' => :area }
+
+  attr_accessor :width, :height, :x, :y, :flag
+
+  def initialize(width=nil, height=nil, x=nil, y=nil, flag=nil)
+    # Support floating-point width and height arguments so Geometry
+    # objects can be used to specify Image#density= arguments.
+    raise ArgumentError, "width must be >= 0: #{width}"   if width < 0
+    raise ArgumentError, "height must be >= 0: #{height}" if height < 0
+    @width  = width.to_f
+    @height = height.to_f
+    @x      = x.to_i
+    @y      = y.to_i
+    @flag   = flag
+  end
+
+  # Construct an object from a geometry string
+  RE = /\A(\d*)(?:x(\d+)?)?([-+]\d+)?([-+]\d+)?([%!<>@]?)\Z/
+
+  def self.from_s(str)
+    raise(ArgumentError, "no geometry string specified") unless str
+  
+    if m = RE.match(str)
+      new(m[1].to_i, m[2].to_i, m[3].to_i, m[4].to_i, RFLAGS[m[5]])
+    else
+      raise ArgumentError, "invalid geometry format"
+    end
+  end
+
+  # Convert object to a geometry string
+  def to_s
+    str = ''
+    str << "%g" % @width if @width > 0
+    str << 'x' if (@width > 0 || @height > 0)
+    str << "%g" % @height if @height > 0
+    str << "%+d%+d" % [@x, @y] if (@x != 0 || @y != 0)
+    str << FLAGS[@flag.to_i]
+  end
+  
+  # attempts to get new dimensions for the current geometry string given these old dimensions.
+  # This doesn't implement the aspect flag (!) or the area flag (@).  PDI
+  def new_dimensions_for(orig_width, orig_height)
+    new_width  = orig_width
+    new_height = orig_height
+
+    case @flag
+      when :percent
+        scale_x = @width.zero?  ? 100 : @width
+        scale_y = @height.zero? ? @width : @height
+        new_width    = scale_x.to_f * (orig_width.to_f  / 100.0)
+        new_height   = scale_y.to_f * (orig_height.to_f / 100.0)
+      when :aspect
+        new_width = @width unless @width.nil?
+        new_height = @height unless @height.nil?
+      when :<, :>, nil
+        scale_factor =
+          if new_width.zero? || new_height.zero?
+            1.0
+          else
+            if @width.nonzero? && @height.nonzero?
+              [@width.to_f / new_width.to_f, @height.to_f / new_height.to_f].min
+            else
+              @width.nonzero? ? (@width.to_f / new_width.to_f) : (@height.to_f / new_height.to_f)
+            end
+          end
+        new_width  = scale_factor * new_width.to_f
+        new_height = scale_factor * new_height.to_f
+        new_width  = orig_width  if @flag && orig_width.send(@flag,  new_width)
+        new_height = orig_height if @flag && orig_height.send(@flag, new_height)
+    end
+
+    [new_width, new_height].collect! { |v| [v.round, 1].max }
+  end
+end
+
+class Array
+  # allows you to get new dimensions for the current array of dimensions with a given geometry string
+  #
+  #   [50, 64] / '40>' # => [40, 51]
+  def /(geometry)
+    raise ArgumentError, "Only works with a [width, height] pair" if size != 2
+    raise ArgumentError, "Must pass a valid geometry string or object" unless geometry.is_a?(String) || geometry.is_a?(Geometry)
+    geometry = Geometry.from_s(geometry) if geometry.is_a?(String)
+    geometry.new_dimensions_for first, last
+  end
+end

data/lib/pothoven-attachment_fu.rb

@@ -0,0 +1,27 @@
+
+if defined?(Rails::Engine)
+  # Rails >= 3
+  class Engine < Rails::Engine
+    # Mimic old vendored plugin behavior, attachment_fu/lib is autoloaded.
+    config.autoload_paths << File.expand_path("..", __FILE__)
+
+    initializer "attachment_fu" do
+      require 'geometry'
+
+      ActiveRecord::Base.send(:extend, Technoweenie::AttachmentFu::ActMethods)
+      Technoweenie::AttachmentFu.tempfile_path = ATTACHMENT_FU_TEMPFILE_PATH if Object.const_defined?(:ATTACHMENT_FU_TEMPFILE_PATH)
+      FileUtils.mkdir_p Technoweenie::AttachmentFu.tempfile_path
+    end
+  end
+else
+  # Rails <= 2
+  require 'geometry'
+
+  ActiveSupport::Dependencies.autoload_paths << File.expand_path("..", __FILE__)
+
+  ActiveRecord::Base.send(:extend, Technoweenie::AttachmentFu::ActMethods)
+  Technoweenie::AttachmentFu.tempfile_path = ATTACHMENT_FU_TEMPFILE_PATH if Object.const_defined?(:ATTACHMENT_FU_TEMPFILE_PATH)
+  FileUtils.mkdir_p Technoweenie::AttachmentFu.tempfile_path
+
+  $:.unshift(File.expand_path("../vendor", __FILE__))
+end