cemeng-paperclip 2.3.6

data/lib/paperclip/matchers/validate_attachment_size_matcher.rb

@@ -0,0 +1,95 @@
+module Paperclip
+  module Shoulda
+    module Matchers
+      # Ensures that the given instance or class validates the size of the
+      # given attachment as specified.
+      #
+      # Examples:
+      #   it { should validate_attachment_size(:avatar).
+      #                 less_than(2.megabytes) }
+      #   it { should validate_attachment_size(:icon).
+      #                 greater_than(1024) }
+      #   it { should validate_attachment_size(:icon).
+      #                 in(0..100) }
+      def validate_attachment_size name
+        ValidateAttachmentSizeMatcher.new(name)
+      end
+
+      class ValidateAttachmentSizeMatcher
+        def initialize attachment_name
+          @attachment_name = attachment_name
+          @low, @high = 0, (1.0/0)
+        end
+
+        def less_than size
+          @high = size
+          self
+        end
+
+        def greater_than size
+          @low = size
+          self
+        end
+
+        def in range
+          @low, @high = range.first, range.last
+          self
+        end
+
+        def matches? subject
+          @subject = subject
+          @subject = @subject.class unless Class === @subject
+          lower_than_low? && higher_than_low? && lower_than_high? && higher_than_high?
+        end
+
+        def failure_message
+          "Attachment #{@attachment_name} must be between #{@low} and #{@high} bytes"
+        end
+
+        def negative_failure_message
+          "Attachment #{@attachment_name} cannot be between #{@low} and #{@high} bytes"
+        end
+
+        def description
+          "validate the size of attachment #{@attachment_name}"
+        end
+
+        protected
+
+        def override_method object, method, &replacement
+          (class << object; self; end).class_eval do
+            define_method(method, &replacement)
+          end
+        end
+
+        def passes_validation_with_size(new_size)
+          file = StringIO.new(".")
+          override_method(file, :size){ new_size }
+          override_method(file, :to_tempfile){ file }
+
+          (subject = @subject.new).send(@attachment_name).assign(file)
+          subject.valid?
+          subject.errors[:"#{@attachment_name}_file_size"].blank?
+        end
+
+        def lower_than_low?
+          not passes_validation_with_size(@low - 1)
+        end
+
+        def higher_than_low?
+          passes_validation_with_size(@low + 1)
+        end
+
+        def lower_than_high?
+          return true if @high == (1.0/0)
+          passes_validation_with_size(@high - 1)
+        end
+
+        def higher_than_high?
+          return true if @high == (1.0/0)
+          not passes_validation_with_size(@high + 1)
+        end
+      end
+    end
+  end
+end

data/lib/paperclip/processor.rb

@@ -0,0 +1,58 @@
+module Paperclip
+  # Paperclip processors allow you to modify attached files when they are
+  # attached in any way you are able. Paperclip itself uses command-line
+  # programs for its included Thumbnail processor, but custom processors
+  # are not required to follow suit.
+  #
+  # Processors are required to be defined inside the Paperclip module and
+  # are also required to be a subclass of Paperclip::Processor. There is
+  # only one method you *must* implement to properly be a subclass:
+  # #make, but #initialize may also be of use. Both methods accept 3
+  # arguments: the file that will be operated on (which is an instance of
+  # File), a hash of options that were defined in has_attached_file's
+  # style hash, and the Paperclip::Attachment itself.
+  #
+  # All #make needs to return is an instance of File (Tempfile is
+  # acceptable) which contains the results of the processing.
+  #
+  # See Paperclip.run for more information about using command-line
+  # utilities from within Processors.
+  class Processor
+    attr_accessor :file, :options, :attachment
+
+    def initialize file, options = {}, attachment = nil
+      @file = file
+      @options = options
+      @attachment = attachment
+    end
+
+    def make
+    end
+
+    def self.make file, options = {}, attachment = nil
+      new(file, options, attachment).make
+    end
+  end
+
+  # Due to how ImageMagick handles its image format conversion and how Tempfile
+  # handles its naming scheme, it is necessary to override how Tempfile makes
+  # its names so as to allow for file extensions. Idea taken from the comments
+  # on this blog post:
+  # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
+  class Tempfile < ::Tempfile
+    # This is Ruby 1.8.7's implementation.
+    if RUBY_VERSION <= "1.8.6"
+      def make_tmpname(basename, n)
+        case basename
+        when Array
+          prefix, suffix = *basename
+        else
+          prefix, suffix = basename, ''
+        end
+
+        t = Time.now.strftime("%y%m%d")
+        path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}-#{n}#{suffix}"
+      end
+    end
+  end
+end

data/lib/paperclip/railtie.rb

@@ -0,0 +1,25 @@
+require 'paperclip'
+
+module Paperclip
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'paperclip.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          Paperclip::Railtie.insert
+        end
+      end
+      rake_tasks do
+        load "tasks/paperclip.rake"
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      ActiveRecord::Base.send(:include, Paperclip::Glue)
+      File.send(:include, Paperclip::Upfile)
+      ActionController::Base.send(:include, Paperclip::Storage::Database::ControllerClassMethods)
+    end
+  end
+end

data/lib/paperclip/storage.rb

@@ -0,0 +1,3 @@
+require "paperclip/storage/filesystem"
+require "paperclip/storage/s3"
+require "paperclip/storage/database"

data/lib/paperclip/storage/database.rb

@@ -0,0 +1,204 @@
+module Paperclip
+  module Storage
+
+    # Store files in a database.
+    # 
+    # Usage is identical to the file system storage version, except:
+    # 
+    # 1. In your model specify the "database" storage option; for example:
+    #   has_attached_file :avatar, :storage => :database
+    # 
+    # 2. The file will be stored in a column called [attachment name]_file (e.g. "avatar_file") by default.
+    # 
+    # To specify a different column name, use :column, like this:
+    #   has_attached_file :avatar, :storage => :database, :column => 'avatar_data'
+    # 
+    # If you have defined different styles, these files will be stored in additional columns called
+    # [attachment name]_[style name]_file (e.g. "avatar_thumb_file") by default.
+    # 
+    # To specify different column names for styles, use :column in the style definition, like this:
+    #   has_attached_file :avatar,
+    #                     :storage => :database,
+    #                     :styles => { 
+    #                       :medium => {:geometry => "300x300>", :column => 'medium_file'},
+    #                       :thumb => {:geometry => "100x100>", :column => 'thumb_file'}
+    #                     }
+    # 
+    # 3. You need to create these new columns in your migrations or you'll get an exception. Example:
+    #   add_column :users, :avatar_file, :binary
+    #   add_column :users, :avatar_medium_file, :binary
+    #   add_column :users, :avatar_thumb_file, :binary
+    # 
+    # Note the "binary" migration will not work for the LONGBLOB type in MySQL for the
+    # file_contents column. You may need to craft a SQL statement for your migration,
+    # depending on which database server you are using. Here's an example migration for MySQL:
+    #   execute 'ALTER TABLE users ADD COLUMN avatar_file LONGBLOB'
+    #   execute 'ALTER TABLE users ADD COLUMN avatar_medium_file LONGBLOB'
+    #   execute 'ALTER TABLE users ADD COLUMN avatar_thumb_file LONGBLOB'
+    # 
+    # 4. To avoid performance problems loading all of the BLOB columns every time you access
+    # your ActiveRecord object, a class method is provided on your model called
+    # “select_without_file_columns_for.” This is set to a :select scope hash that will
+    # instruct ActiveRecord::Base.find to load all of the columns except the BLOB/file data columns.
+    # 
+    # If you’re using Rails 2.3, you can specify this as a default scope:
+    #   default_scope select_without_file_columns_for(:avatar)
+    # 
+    # Or if you’re using Rails 2.1 or 2.2 you can use it to create a named scope:
+    #   named_scope :without_file_data, select_without_file_columns_for(:avatar)
+    # 
+    # 5. By default, URLs will be set to this pattern:
+    #   /:relative_root/:class/:attachment/:id?style=:style
+    # 
+    # Example:
+    #   /app-root-url/users/avatars/23?style=original
+    # 
+    # The idea here is that to retrieve a file from the database storage, you will need some
+    # controller's code to be executed.
+    #     
+    # Once you pick a controller to use for downloading, you can add this line
+    # to generate the download action for the default URL/action (the plural attachment name),
+    # "avatars" in this example:
+    #   downloads_files_for :user, :avatar
+    # 
+    # Or you can write a download method manually if there are security, logging or other
+    # requirements.
+    # 
+    # If you prefer a different URL for downloading files you can specify that in the model; e.g.:
+    #   has_attached_file :avatar, :storage => :database, :url => '/users/show_avatar/:id/:style'
+    # 
+    # 6. Add a route for the download to the controller which will handle downloads, if necessary.
+    # 
+    # The default URL, /:relative_root/:class/:attachment/:id?style=:style, will be matched by
+    # the default route: :controller/:action/:id
+    # 
+    module Database
+      def self.extended base
+        base.instance_eval do
+          @file_columns = @options[:file_columns]
+          if @url == base.class.default_options[:url]
+            @url = "/:class/:attachment/:id?style=:style"
+          end
+        end
+        Paperclip.interpolates(:relative_root) do |attachment, style|
+          begin
+            if ActionController::AbstractRequest.respond_to?(:relative_url_root)
+              relative_url_root = ActionController::AbstractRequest.relative_url_root
+            end
+          rescue NameError
+          end
+          if !relative_url_root && ActionController::Base.respond_to?(:relative_url_root)
+            relative_url_root = ActionController::Base.relative_url_root
+          end
+          relative_url_root
+        end
+        ActiveRecord::Base.logger.info("[paperclip] Database Storage Initalized.")
+      end
+
+      def column_for_style style
+        @file_columns[style.to_sym]
+      end
+        
+      def instance_read_file(style)
+        column = column_for_style(style)
+        responds = instance.respond_to?(column)
+        cached = self.instance_variable_get("@_#{column}")
+        return cached if cached
+        # The blob attribute will not be present if select_without_file_columns_for was used
+        instance.reload :select => column if !instance.attribute_present?(column) && !instance.new_record?
+        instance.send(column) if responds
+      end
+
+      def instance_write_file(style, value)
+        setter = :"#{column_for_style(style)}="
+        responds = instance.respond_to?(setter)
+        self.instance_variable_set("@_#{setter.to_s.chop}", value)
+        instance.send(setter, value) if responds
+      end
+
+      def file_contents(style = default_style)
+        instance_read_file(style)
+      end
+      alias_method :data, :file_contents
+
+      def exists?(style = default_style)
+        !file_contents(style).nil?
+      end
+
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style = default_style
+
+        if @queued_for_write[style]
+          @queued_for_write[style]
+        elsif exists?(style)
+          tempfile = Tempfile.new instance_read(:file_name)
+          tempfile.write file_contents(style)
+          tempfile
+        else
+          nil
+        end
+      end
+      alias_method :to_io, :to_file
+
+      def path style = default_style
+        original_filename.nil? ? nil : column_for_style(style)
+      end
+
+      def assign uploaded_file
+
+        # Assign standard metadata attributes and perform post processing as usual
+        super
+
+        # Save the file contents for all styles in ActiveRecord immediately (before save)
+        @queued_for_write.each do |style, file|
+          file.rewind
+          instance_write_file(style, file.read)
+        end
+
+        # If we are assigning another Paperclip attachment, then fixup the
+        # filename and content type; necessary since Tempfile is used in to_file
+        if uploaded_file.is_a?(Paperclip::Attachment)
+          instance_write(:file_name,       uploaded_file.instance_read(:file_name))
+          instance_write(:content_type,    uploaded_file.instance_read(:content_type))
+        end
+      end
+
+      def queue_existing_for_delete
+        [:original, *@styles.keys].uniq.each do |style|
+          instance_write_file(style, nil)
+        end
+        instance_write(:file_name, nil)
+        instance_write(:content_type, nil)
+        instance_write(:file_size, nil)
+        instance_write(:updated_at, nil)
+      end
+
+      def flush_writes
+        @queued_for_write = {}
+      end
+
+      def flush_deletes
+        @queued_for_delete = []
+      end
+      
+      module ControllerClassMethods
+        def self.included(base)
+          base.extend(self)
+        end
+        def downloads_files_for(model, attachment)
+          define_method("#{attachment.to_s.pluralize}") do
+            user_id = params[:id]
+            user_id ||= params[:user_id]
+            model_record = Object.const_get(model.to_s.camelize.to_sym).find(user_id)
+            style = params[:style] ? params[:style] : 'original'
+            send_data model_record.send(attachment).file_contents(style),
+                      :filename => model_record.send("#{attachment}_file_name".to_sym),
+                      :type => model_record.send("#{attachment}_content_type".to_sym)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/paperclip/storage/filesystem.rb

@@ -0,0 +1,73 @@
+module Paperclip
+  module Storage
+    # The default place to store attachments is in the filesystem. Files on the local
+    # filesystem can be very easily served by Apache without requiring a hit to your app.
+    # They also can be processed more easily after they've been saved, as they're just
+    # normal files. There is one Filesystem-specific option for has_attached_file.
+    # * +path+: The location of the repository of attachments on disk. This can (and, in
+    #   almost all cases, should) be coordinated with the value of the +url+ option to
+    #   allow files to be saved into a place where Apache can serve them without
+    #   hitting your app. Defaults to
+    #   ":rails_root/public/:attachment/:id/:style/:basename.:extension"
+    #   By default this places the files in the app's public directory which can be served
+    #   directly. If you are using capistrano for deployment, a good idea would be to
+    #   make a symlink to the capistrano-created system directory from inside your app's
+    #   public directory.
+    #   See Paperclip::Attachment#interpolate for more information on variable interpolaton.
+    #     :path => "/var/app/attachments/:class/:id/:style/:basename.:extension"
+    module Filesystem
+      def self.extended base
+      end
+
+      def exists?(style_name = default_style)
+        if original_filename
+          File.exist?(path(style_name))
+        else
+          false
+        end
+      end
+
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style_name = default_style
+        @queued_for_write[style_name] || (File.new(path(style_name), 'rb') if exists?(style_name))
+      end
+
+      def flush_writes #:nodoc:
+        @queued_for_write.each do |style_name, file|
+          file.close
+          FileUtils.mkdir_p(File.dirname(path(style_name)))
+          log("saving #{path(style_name)}")
+          FileUtils.mv(file.path, path(style_name))
+          FileUtils.chmod(0644, path(style_name))
+        end
+        @queued_for_write = {}
+      end
+
+      def flush_deletes #:nodoc:
+        @queued_for_delete.each do |path|
+          begin
+            log("deleting #{path}")
+            FileUtils.rm(path) if File.exist?(path)
+          rescue Errno::ENOENT => e
+            # ignore file-not-found, let everything else pass
+          end
+          begin
+            while(true)
+              path = File.dirname(path)
+              FileUtils.rmdir(path)
+              break if File.exists?(path) # Ruby 1.9.2 does not raise if the removal failed.
+            end
+          rescue Errno::EEXIST, Errno::ENOTEMPTY, Errno::ENOENT, Errno::EINVAL, Errno::ENOTDIR
+            # Stop trying to remove parent directories
+          rescue SystemCallError => e
+            log("There was an unexpected error while deleting directories: #{e.class}")
+            # Ignore it
+          end
+        end
+        @queued_for_delete = []
+      end
+    end
+
+  end
+end