attachment_magic 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in attachment_magic.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/attachment_magic.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "attachment_magic/version"
+
+Gem::Specification.new do |s|
+  s.name        = "attachment_magic"
+  s.version     = AttachmentMagic::VERSION
+  s.authors     = ["Thomas von Deyen"]
+  s.email       = ["tvdeyen@gmail.com"]
+  s.homepage    = "https://github.com/magiclabs/attachment_magic"
+  s.summary     = %q{A simple file attachment gem for Rails 3}
+  s.description = %q{A Rails 3 Gem based on attachment_fu, but without the image processing fudge and multiple backend crap! Just simple file attachments with a little mime type magic ;)}
+
+  s.rubyforge_project = "attachment_magic"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_runtime_dependency(%q<rails>, ["< 3.1", ">= 3.0.7"])
+  s.add_runtime_dependency(%q<mimetype-fu>, ["~> 0.1.2"])
+end

data/lib/attachment_magic.rb

@@ -0,0 +1,299 @@
+require "fileutils"
+require 'mimetype_fu'
+require "attachment_magic/version"
+require "attachment_magic/backends/file_system_backend"
+
+module AttachmentMagic
+  @@content_types      = [
+    'image/jpeg',
+    'image/pjpeg',
+    'image/jpg',
+    'image/gif',
+    'image/png',
+    'image/x-png',
+    'image/jpg',
+    'image/x-ms-bmp',
+    'image/bmp',
+    'image/x-bmp',
+    'image/x-bitmap',
+    'image/x-xbitmap',
+    'image/x-win-bitmap',
+    'image/x-windows-bmp',
+    'image/ms-bmp',
+    'application/bmp',
+    'application/x-bmp',
+    'application/x-win-bitmap',
+    'application/preview',
+    'image/jp_',
+    'application/jpg',
+    'application/x-jpg',
+    'image/pipeg',
+    'image/vnd.swiftview-jpeg',
+    'image/x-xbitmap',
+    'application/png',
+    'application/x-png',
+    'image/gi_',
+    'image/x-citrix-pjpeg'
+  ]
+  mattr_reader :content_types, :tempfile_path
+  mattr_writer :tempfile_path
+
+  class ThumbnailError < StandardError;  end
+  class AttachmentError < StandardError; end
+
+  def self.tempfile_path
+    @@tempfile_path ||= Rails.root.join('tmp', 'attachment_magic')
+  end
+
+  module ActMethods
+    # Options:
+    # *  <tt>:content_type</tt> - Allowed content types.  Allows all by default.  Use :image to allow all standard image types.
+    # *  <tt>:min_size</tt> - Minimum size allowed.  1 byte is the default.
+    # *  <tt>:max_size</tt> - Maximum size allowed.  1.megabyte is the default.
+    # *  <tt>:size</tt> - Range of sizes allowed.  (1..1.megabyte) is the default.  This overrides the :min_size and :max_size options.
+    # *  <tt>:path_prefix</tt> - path to store the uploaded files.  Uses public/#{table_name} by default.
+    # *  <tt>:storage</tt> - Use :file_system to specify the attachment data is stored with the file system.  Defaults to :file_system.
+    #
+    # Examples:
+    #   has_attachment :max_size => 1.kilobyte
+    #   has_attachment :size => 1.megabyte..2.megabytes
+    #   has_attachment :content_type => 'application/pdf'
+    #   has_attachment :content_type => ['application/pdf', 'application/msword', 'text/plain']
+    def has_attachment(options = {})
+      # this allows you to redefine the acts' options for each subclass, however
+      options[:min_size]         ||= 1
+      options[:max_size]         ||= 1.megabyte
+      options[:size]             ||= (options[:min_size]..options[:max_size])
+      options[:content_type] = [options[:content_type]].flatten.collect! { |t| t == :image ? AttachmentMagic.content_types : t }.flatten unless options[:content_type].nil?
+
+      extend ClassMethods unless (class << self; included_modules; end).include?(ClassMethods)
+      include InstanceMethods unless included_modules.include?(InstanceMethods)
+
+      parent_options = attachment_options || {}
+      # doing these shenanigans so that #attachment_options is available to processors and backends
+      self.attachment_options = options
+
+      attachment_options[:storage]     ||= :file_system
+      attachment_options[:storage]     ||= parent_options[:storage]
+      attachment_options[:path_prefix] ||= attachment_options[:file_system_path]
+      if attachment_options[:path_prefix].nil?
+        File.join("public", table_name)
+      end
+      attachment_options[:path_prefix]   = attachment_options[:path_prefix][1..-1] if options[:path_prefix].first == '/'
+
+      unless File.directory?(AttachmentMagic.tempfile_path)
+        FileUtils.mkdir_p(AttachmentMagic.tempfile_path)
+      end
+
+      storage_mod = AttachmentMagic::Backends.const_get("#{options[:storage].to_s.classify}Backend")
+      include storage_mod unless included_modules.include?(storage_mod)
+
+    end
+
+    def load_related_exception?(e) #:nodoc: implementation specific
+      case
+      when e.kind_of?(LoadError), e.kind_of?(MissingSourceFile), $!.class.name == "CompilationError"
+        # We can't rescue CompilationError directly, as it is part of the RubyInline library.
+        # We must instead rescue RuntimeError, and check the class' name.
+        true
+      else
+        false
+      end
+    end
+    private :load_related_exception?
+  end
+
+  module ClassMethods
+    delegate :content_types, :to => AttachmentMagic
+
+    # Performs common validations for attachment models.
+    def validates_as_attachment
+      validates_presence_of :size, :content_type, :filename
+      validate              :attachment_attributes_valid?
+    end
+
+    # Returns true or false if the given content type is recognized as an image.
+    def image?(content_type)
+      content_types.include?(content_type)
+    end
+
+    def self.extended(base)
+      base.class_inheritable_accessor :attachment_options
+      base.before_validation :set_size_from_temp_path
+      base.after_save :after_process_attachment
+      base.after_destroy :destroy_file
+      base.after_validation :process_attachment
+    end
+
+    # Copies the given file path to a new tempfile, returning the closed tempfile.
+    def copy_to_temp_file(file, temp_base_name)
+      Tempfile.new(temp_base_name, AttachmentMagic.tempfile_path).tap do |tmp|
+        tmp.close
+        FileUtils.cp file, tmp.path
+      end
+    end
+
+    # Writes the given data to a new tempfile, returning the closed tempfile.
+    def write_to_temp_file(data, temp_base_name)
+      Tempfile.new(temp_base_name, AttachmentMagic.tempfile_path).tap do |tmp|
+        tmp.binmode
+        tmp.write data
+        tmp.close
+      end
+    end
+  end
+
+  module InstanceMethods
+    def self.included(base)
+      base.define_callbacks *[:after_attachment_saved] if base.respond_to?(:define_callbacks)
+    end
+
+    # Sets the content type.
+    def content_type=(new_type)
+      write_attribute :content_type, new_type.to_s.strip
+    end
+    
+    # Detects the mime-type if content_type is 'application/octet-stream'
+    def detect_mimetype(file_data)
+      if file_data.content_type.strip == "application/octet-stream"
+        return File.mime_type?(file_data.original_filename)
+      else
+        return file_data.content_type
+      end
+    end
+
+    # Sanitizes a filename.
+    def filename=(new_name)
+      write_attribute :filename, sanitize_filename(new_name)
+    end
+
+    # Returns true if the attachment data will be written to the storage system on the next save
+    def save_attachment?
+      File.file?(temp_path.class == String ? temp_path : temp_path.to_filename)
+    end
+
+    # nil placeholder in case this field is used in a form.
+    def uploaded_data() nil; end
+
+    # This method handles the uploaded file object.  If you set the field name to uploaded_data, you don't need
+    # any special code in your controller.
+    #
+    #   <% form_for :attachment, :html => { :multipart => true } do |f| -%>
+    #     <p><%= f.file_field :uploaded_data %></p>
+    #     <p><%= submit_tag :Save %>
+    #   <% end -%>
+    #
+    #   @attachment = Attachment.create! params[:attachment]
+    #
+    # TODO: Allow it to work with Merb tempfiles too.
+    def uploaded_data=(file_data)
+      if file_data.respond_to?(:content_type)
+        return nil if file_data.size == 0
+        self.content_type = detect_mimetype(file_data)
+        self.filename     = file_data.original_filename if respond_to?(:filename)
+      else
+        return nil if file_data.blank? || file_data['size'] == 0
+        self.content_type = file_data['content_type']
+        self.filename =  file_data['filename']
+        file_data = file_data['tempfile']
+      end
+      if file_data.is_a?(StringIO)
+        file_data.rewind
+        set_temp_data file_data.read
+      else
+        self.temp_paths.unshift file_data.tempfile.path
+      end
+    end
+
+    # Gets the latest temp path from the collection of temp paths.  While working with an attachment,
+    # multiple Tempfile objects may be created for various processing purposes (resizing, for example).
+    # An array of all the tempfile objects is stored so that the Tempfile instance is held on to until
+    # it's not needed anymore.  The collection is cleared after saving the attachment.
+    def temp_path
+      p = temp_paths.first
+      p.respond_to?(:path) ? p.path : p.to_s
+    end
+
+    # Gets an array of the currently used temp paths.  Defaults to a copy of #full_filename.
+    def temp_paths
+      @temp_paths ||= (new_record? || !respond_to?(:full_filename) || !File.exist?(full_filename) ?
+        [] : [copy_to_temp_file(full_filename)])
+    end
+
+    # Gets the data from the latest temp file.  This will read the file into memory.
+    def temp_data
+      save_attachment? ? File.read(temp_path) : nil
+    end
+
+    # Writes the given data to a Tempfile and adds it to the collection of temp files.
+    def set_temp_data(data)
+      temp_paths.unshift write_to_temp_file data unless data.nil?
+    end
+
+    # Copies the given file to a randomly named Tempfile.
+    def copy_to_temp_file(file)
+      self.class.copy_to_temp_file file, random_tempfile_filename
+    end
+
+    # Writes the given file to a randomly named Tempfile.
+    def write_to_temp_file(data)
+      self.class.write_to_temp_file data, random_tempfile_filename
+    end
+
+    # Stub for creating a temp file from the attachment data.  This should be defined in the backend module.
+    def create_temp_file() end
+
+    protected
+      # Generates a unique filename for a Tempfile.
+      def random_tempfile_filename
+        "#{rand Time.now.to_i}#{filename || 'attachment'}"
+      end
+
+      def sanitize_filename(filename)
+        return unless filename
+        filename.strip.tap do |name|
+          # NOTE: File.basename doesn't work right with Windows paths on Unix
+          # get only the filename, not the whole path
+          name.gsub! /^.*(\\|\/)/, ''
+
+          # Finally, replace all non alphanumeric, underscore or periods with underscore
+          name.gsub! /[^A-Za-z0-9\.\-]/, '_'
+        end
+      end
+
+      # before_validation callback.
+      def set_size_from_temp_path
+        self.size = File.size(temp_path) if save_attachment?
+      end
+
+      # validates the size and content_type attributes according to the current model's options
+      def attachment_attributes_valid?
+        [:size, :content_type].each do |attr_name|
+          enum = attachment_options[attr_name]
+          errors.add attr_name, I18n.translate("activerecord.errors.messages.inclusion", attr_name => enum) unless enum.nil? || enum.include?(send(attr_name))
+        end
+      end
+
+      # Stub for a #process_attachment method in a processor
+      def process_attachment
+        @saved_attachment = save_attachment?
+      end
+
+      # Cleans up after processing.  Thumbnails are created, the attachment is stored to the backend, and the temp_paths are cleared.
+      def after_process_attachment
+        if @saved_attachment
+          save_to_storage
+          @temp_paths.clear
+          @saved_attachment = nil
+        end
+      end
+
+      def callback_with_args(method, arg = self)
+        send(method, arg) if respond_to?(method)
+      end
+
+  end
+  
+end
+
+ActiveRecord::Base.send(:extend, AttachmentMagic::ActMethods)

data/lib/attachment_magic/backends/file_system_backend.rb

@@ -0,0 +1,122 @@
+require 'fileutils'
+require 'digest/sha2'
+
+module AttachmentMagic # :nodoc:
+  module Backends
+    # Methods for file system backed attachments
+    module FileSystemBackend
+      def self.included(base) #:nodoc:
+        base.before_update :rename_file
+      end
+    
+      # Gets the full path to the filename in this format:
+      #
+      #   # This assumes a model name like MyModel
+      #   # public/#{table_name} is the default filesystem path 
+      #   Rails.root.to_s/public/my_models/5/blah.jpg
+      #
+      # Overwrite this method in your model to customize the filename.
+      def full_filename
+        file_system_path = self.attachment_options[:path_prefix].to_s
+        Rails.root.join(file_system_path, *partitioned_path(filename)).to_s
+      end
+    
+      # Used as the base path that #public_filename strips off full_filename to create the public path
+      def base_path
+        @base_path ||= Rails.root.join('public')
+      end
+    
+      # The attachment ID used in the full path of a file
+      def attachment_path_id
+        ((respond_to?(:parent_id) && parent_id) || id) || 0
+      end
+    
+      # Partitions the given path into an array of path components.
+      #
+      # For example, given an <tt>*args</tt> of ["foo", "bar"], it will return
+      # <tt>["0000", "0001", "foo", "bar"]</tt> (assuming that that id returns 1).
+      #
+      # If the id is not an integer, then path partitioning will be performed by
+      # hashing the string value of the id with SHA-512, and splitting the result
+      # into 4 components. If the id a 128-bit UUID (as set by :uuid_primary_key => true)
+      # then it will be split into 2 components.
+      # 
+      # To turn this off entirely, set :partition => false.
+      def partitioned_path(*args)
+        if respond_to?(:attachment_options) && attachment_options[:partition] == false 
+          args
+        elsif attachment_options[:uuid_primary_key]
+          # Primary key is a 128-bit UUID in hex format. Split it into 2 components.
+          path_id = attachment_path_id.to_s
+          component1 = path_id[0..15] || "-"
+          component2 = path_id[16..-1] || "-"
+          [component1, component2] + args
+        else
+          path_id = attachment_path_id
+          if path_id.is_a?(Integer)
+            # Primary key is an integer. Split it after padding it with 0.
+            ("%08d" % path_id).scan(/..../) + args
+          else
+            # Primary key is a String. Hash it, then split it into 4 components.
+            hash = Digest::SHA512.hexdigest(path_id.to_s)
+            [hash[0..31], hash[32..63], hash[64..95], hash[96..127]] + args
+          end
+        end
+      end
+    
+      # Gets the public path to the file
+      def public_filename()
+        full_filename.gsub %r(^#{Regexp.escape(base_path)}), ''
+      end
+    
+      def filename=(value)
+        @old_filename = full_filename unless filename.nil? || @old_filename
+        write_attribute :filename, sanitize_filename(value)
+      end
+
+      # Creates a temp file from the currently saved file.
+      def create_temp_file
+        copy_to_temp_file full_filename
+      end
+
+      protected
+        # Destroys the file.  Called in the after_destroy callback
+        def destroy_file
+          FileUtils.rm full_filename
+          # remove directory also if it is now empty
+          Dir.rmdir(File.dirname(full_filename)) if (Dir.entries(File.dirname(full_filename))-['.','..']).empty?
+        rescue
+          logger.info "Exception destroying  #{full_filename.inspect}: [#{$!.class.name}] #{$1.to_s}"
+          logger.warn $!.backtrace.collect { |b| " > #{b}" }.join("\n")
+        end
+
+        # Renames the given file before saving
+        def rename_file
+          return unless @old_filename && @old_filename != full_filename
+          if save_attachment? && File.exists?(@old_filename)
+            FileUtils.rm @old_filename
+          elsif File.exists?(@old_filename)
+            FileUtils.mv @old_filename, full_filename
+          end
+          @old_filename =  nil
+          true
+        end
+        
+        # Saves the file to the file system
+        def save_to_storage
+          if save_attachment?
+            # TODO: This overwrites the file if it exists, maybe have an allow_overwrite option?
+            FileUtils.mkdir_p(File.dirname(full_filename))
+            FileUtils.cp(temp_path, full_filename)
+            FileUtils.chmod(attachment_options[:chmod] || 0644, full_filename)
+          end
+          @old_filename = nil
+          true
+        end
+        
+        def current_data
+          File.file?(full_filename) ? File.read(full_filename) : nil
+        end
+    end
+  end
+end

data/lib/attachment_magic/version.rb

@@ -0,0 +1,3 @@
+module AttachmentMagic
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: attachment_magic
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Thomas von Deyen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-09 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 1
+        version: "3.1"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 3
+        - 0
+        - 7
+        version: 3.0.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mimetype-fu
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  type: :runtime
+  version_requirements: *id002
+description: A Rails 3 Gem based on attachment_fu, but without the image processing fudge and multiple backend crap! Just simple file attachments with a little mime type magic ;)
+email: 
+- tvdeyen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- attachment_magic.gemspec
+- lib/attachment_magic.rb
+- lib/attachment_magic/backends/file_system_backend.rb
+- lib/attachment_magic/version.rb
+has_rdoc: true
+homepage: https://github.com/magiclabs/attachment_magic
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: attachment_magic
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A simple file attachment gem for Rails 3
+test_files: []
+