coryodaniel-milton 0.3.7

data/lib/milton/derivatives/thumbnail/image.rb

@@ -0,0 +1,49 @@
+module Milton
+  # Generic view of an "Image", or rather, something with a width and a
+  # height we care about =).
+  class Image
+    attr_accessor :width
+    attr_accessor :height
+
+    class << self
+      # Instantiates a new image from the given path. Uses ImageMagick's
+      # identify method to determine the width and height of the image with
+      # the given path and returns a new Image with those dimensions.
+      #
+      # Raises a MissingFileError if the given path could not be identify'd
+      # by ImageMagick (resulting in a height and width).
+      def from_path(path)
+        raise Milton::MissingFileError.new("Could not identify #{path} as an image, does the file exist?") unless Milton.syscall("identify #{path}") =~ /.*? (\d+)x(\d+)\+\d+\+\d+/
+        new($1, $2)
+      end
+
+      # Instantiates a new image from the given geometry string. A geometry
+      # string is just something like 50x40. The first number is the width
+      # and the second is the height.
+      def from_geometry(geometry)
+        new(*(geometry.split("x").collect(&:to_i)))
+      end
+    end
+
+    # Instantiates a new Image with the given width and height
+    def initialize(width=nil, height=nil)
+      @width  = width.to_i
+      @height = height.to_i
+    end
+
+    # Returns the larger dimension of the Image
+    def larger_dimension
+      width > height ? width : height
+    end
+
+    # Returns true if the Image is wider than it is tall
+    def wider?
+      width > height
+    end
+
+    # Returns true if the Image is square
+    def square?
+      width == height
+    end
+  end
+end

data/lib/milton/storage/disk_file.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), 'stored_file')
+
+module Milton
+  module Storage
+    # How Milton deals with a file stored on disk...
+    class DiskFile < StoredFile
+      class << self
+        # Creates the given directory and sets it to the mode given in
+        # options[:chmod]
+        def recreate_directory(directory, options)
+          return true if File.exists?(directory)
+          FileUtils.mkdir_p(directory)
+          FileUtils.chmod(options[:storage_options][:chmod], directory)
+        end
+      end
+
+      # Returns the full path and filename to the file with the given options.
+      # If no options are given then returns the path and filename to the
+      # original file.
+      def path
+        File.join(dirname, filename)
+      end
+
+      # Returns the full directory path up to the file, w/o the filename.
+      def dirname
+        File.join(root_path, partitioned_path)
+      end
+
+      # Returns true if the file exists on the underlying file system.
+      def exists?
+        File.exist?(path)
+      end
+      
+      # Writes the given source file to this file's path.
+      def store(source)
+        Milton.log "storing #{source} to disk at #{path}"
+        self.class.recreate_directory(dirname, options)
+        File.cp(source, path)
+        FileUtils.chmod(options[:storage_options][:chmod], path)
+      end
+      
+      # Removes the file from the underlying file system and any derivatives of
+      # the file.
+      def destroy
+        Milton.log "destroying path #{dirname}"
+        FileUtils.rm_rf dirname if File.exists?(dirname)
+      end
+      
+      # Copies this file to the given location on disk.
+      def copy(destination)
+        Milton.log "copying #{path} to #{destination}"
+        FileUtils.cp(path, destination)
+      end
+      
+      # Returns the mime type of the file.
+      def mime_type
+        Milton.syscall("file -Ib #{path}").gsub(/\n/,"")
+      end
+
+      protected
+
+      # Partitioner that takes an id, pads it up to 12 digits then splits
+      # that into 4 folders deep, each 3 digits long.
+      # 
+      # i.e.
+      #   000/000/012/139
+      # 
+      # Scheme allows for 1000 billion files while never storing more than
+      # 1000 files in a single folder.
+      #
+      # Can overwrite this method to provide your own partitioning scheme.
+      def partitioned_path
+        # TODO: there's probably some fancy 1-line way to do this...
+        padded = ("0"*(12-id.to_s.size)+id.to_s).split('')
+        File.join(*[0, 3, 6, 9].collect{ |i| padded.slice(i, 3).join })
+      end
+
+      # The full path to the root of where files will be stored on disk.
+      def root_path
+        options[:storage_options][:root]
+      end
+    end
+  end
+end

data/lib/milton/storage/s3_file.rb

@@ -0,0 +1,103 @@
+require 'milton/storage/stored_file'
+require 'right_aws'
+# these are required to generate HMAC:SHA1 signature for retrieving private
+# files from S3
+require 'base64'
+require 'openssl'
+require 'digest/sha1'
+
+# TODO: Raise helpful errors on missing required options instead of letting
+# right_aws fail cryptically
+
+module Milton
+  module Storage
+    class S3File < StoredFile
+      def path
+        "http://#{options[:storage_options][:bucket]}.s3.amazonaws.com/#{key}"
+      end
+      
+      def dirname
+        id
+      end
+
+      def exists?
+        bucket.key(key).exists?
+      end
+      
+      def store(source)
+        Milton.log "storing #{source} to #{path} (#{options[:storage_options][:permissions]})"
+        bucket.put(key, File.open(source), {}, options[:storage_options][:permissions])
+      end
+      
+      def destroy
+        Milton.log "destroying #{path}"
+        bucket.key(key).try(:delete)
+      end
+      
+      # Copies this file to the given location on disk.
+      # Note that this copies to a LOCAL location, not to another place on S3!
+      def copy(destination)
+        Milton.log "copying #{path} to #{destination}"
+
+        s3   = RightAws::S3Interface.new(options[:storage_options][:access_key_id], options[:storage_options][:secret_access_key], :logger => Rails.logger)
+        file = File.new(destination, 'wb')
+
+        # stream the download as opposed to downloading the whole thing and reading
+        # it all into memory at once since it might be gigantic...
+        s3.get(options[:storage_options][:bucket], key) { |chunk| file.write(chunk) }
+        file.close
+      end
+
+      def mime_type
+        # TODO: implement
+      end        
+
+      # Generates a signed url to this resource on S3.
+      # 
+      # See doc for +signature+.
+      def signed_url(expires_at=nil)
+        "#{path}?AWSAccessKeyId=#{options[:storage_options][:access_key_id]}" +
+        (expires_at ? "&Expires=#{expires_at.to_i}" : '') +
+        "&Signature=#{signature(expires_at)}"
+      end
+      
+      # Generates a signature for passing authorization for this file on to
+      # another user without having to proxy the file.
+      # 
+      # See http://docs.amazonwebservices.com/AmazonS3/latest/index.html?RESTAuthentication.html
+      # 
+      # Optionally pass +expires_at+ to make the signature valid only until
+      # given expiration date/time -- useful for temporary secure access to
+      # files.
+      def signature(expires_at=nil)
+        CGI.escape(Base64.encode64(OpenSSL::HMAC.digest(
+          OpenSSL::Digest::Digest.new('sha1'),
+          options[:storage_options][:secret_access_key],
+          "GET\n\n\n#{expires_at ? expires_at.to_i : ''}\n/#{options[:storage_options][:bucket]}/#{key}"
+        )).chomp.gsub(/\n/, ''))
+      end
+      
+      protected
+
+      def key
+        "#{dirname}/#{filename}"
+      end
+
+      def s3
+        @s3 ||= RightAws::S3.new(
+          options[:storage_options][:access_key_id], 
+          options[:storage_options][:secret_access_key], 
+          { :protocol => http? ? 'http' : 'https', :port => http? ? 80 : 443, :logger => Rails.logger }
+        )
+      end
+      
+      def http?
+        options[:storage_options].has_key?(:protocol) && options[:storage_options][:protocol] == 'http'
+      end
+      
+      def bucket
+        @bucket ||= s3.bucket(options[:storage_options][:bucket], true, options[:storage_options][:permissions])
+      end
+    end
+  end
+end

data/lib/milton/storage/stored_file.rb

@@ -0,0 +1,46 @@
+module Milton
+  module Storage
+    class StoredFile
+      class << self
+        # Sanitizes the given filename, removes pathnames and the special chars
+        # needed for options seperation for derivatives
+        def sanitize_filename(filename, options)
+          File.basename(filename, File.extname(filename)).gsub(/^.*(\\|\/)/, '').
+            gsub(/[^\w]|#{Regexp.escape(options[:separator])}/, options[:replacement]).
+            strip + File.extname(filename)
+        end
+        
+        def create(filename, id, source, options)
+          returning new(filename, id, options) do |file|
+            file.store(source)
+          end
+        end
+        
+        # Returns the adapter class specified by the given type (by naming
+        # convention)
+        # 
+        #     Storage::StoredFile.adapter(:s3) => Storage::S3File
+        #     Storage::StoredFile.adapter(:disk) => Storage::DiskFile
+        # 
+        def adapter(type)
+          "Milton::Storage::#{type.to_s.classify}File".constantize
+        end
+      end
+              
+      attr_accessor :filename, :id, :options
+
+      def initialize(filename, id, options)
+        self.filename = filename
+        self.id       = id
+        self.options  = options
+      end
+      
+      # Creates a clone of this StoredFile of the same type with the same id
+      # and options but using the given filename. Doesn't actually do any
+      # copying of the underlying file data.
+      def clone(filename)
+        self.class.new(filename, self.id, self.options)
+      end
+    end
+  end
+end

data/lib/milton/uploading.rb

@@ -0,0 +1,82 @@
+module Milton
+  module Uploading
+    module ClassMethods
+      def self.extended(base)
+        base.setup_callbacks
+      end
+      
+      def setup_callbacks
+        # Rails 2.1 fix for callbacks
+        define_callbacks(:before_file_saved, :after_file_saved) if defined?(::ActiveSupport::Callbacks)
+        after_save :save_uploaded_file
+        after_file_saved :create_derivatives if @after_create_callbacks.delete(:create_derivatives)
+      end
+      
+      unless defined?(::ActiveSupport::Callbacks)
+        def before_file_saved(&block) 
+          write_inheritable_array(:before_file_saved, [block])
+        end
+      
+        def after_file_saved(&block)
+          write_inheritable_array(:after_file_saved, [block])
+        end
+      end
+    end
+    
+    module InstanceMethods 
+      def self.included(base)
+        # Rails 2.1 fix for callbacks
+        base.define_callbacks *[:before_file_saved, :after_file_saved] if base.respond_to?(:define_callbacks)
+      end
+      
+      # Set file=<uploaded file> on your model to handle an uploaded file.
+      def file=(file)
+        return nil if file.nil? || file.size == 0
+        @upload           = Upload.new(file, self.class.milton_options)
+        self.filename     = @upload.filename
+        self.size         = @upload.size if respond_to?(:size=)
+        self.content_type = Milton::File.mime_type?(@upload) if respond_to?(:content_type=)
+      end
+      
+      protected
+      
+      def save_uploaded_file
+        if @upload && !@upload.stored?
+          callback :before_file_saved
+          @attached_file = @upload.store(id)
+          callback :after_file_saved
+        end
+      end
+    end
+  end
+  
+  class Upload
+    attr_reader :content_type, :filename, :size, :options
+    
+    def initialize(data_or_path, options)
+      @stored       = false
+      @tempfile     = Milton::Tempfile.create(data_or_path, options[:tempfile_path])
+      @content_type = data_or_path.content_type
+      @filename     = Storage::StoredFile.sanitize_filename(data_or_path.original_filename, options) if respond_to?(:filename)
+      @size         = File.size(self.temp_path)
+      @options      = options
+    end
+
+    def stored?
+      @stored
+    end
+
+    def store(id)
+      return true if stored?
+      returning Storage::StoredFile.adapter(options[:storage]).create(filename, id, temp_path, options) do
+        @stored = true
+      end
+    end
+
+    protected
+    
+    def temp_path
+      @tempfile.respond_to?(:path) ? @tempfile.path : @tempfile.to_s
+    end
+  end
+end

data/test/milton/attachment_test.rb

@@ -0,0 +1,359 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class AttachmentTest < ActiveSupport::TestCase
+  context "being included into a model" do
+    class NotAnAttachment < ActiveRecord::Base
+    end
+    
+    context "NotAnAttachment" do
+      should "not have milton_options" do
+        assert !NotAnAttachment.respond_to?(:milton_options)
+      end
+      
+      should "not have attachment methods" do
+        assert !NotAnAttachment.respond_to?(:has_attachment_methods)
+      end
+    end
+    
+    context "Attachment" do    
+      should "have milton_options on Attachment" do
+        assert Attachment.respond_to?(:milton_options)
+      end
+      
+      should "have attachment methods" do
+        assert Attachment.respond_to?(:has_attachment_methods)
+      end
+      
+      should "have a hash of options" do
+        assert Attachment.milton_options.is_a?(Hash)
+      end
+    end
+  end
+  
+  context "setting options" do
+    context "defaults" do
+      class DefaultAttachment < ActiveRecord::Base
+        is_attachment
+      end
+            
+      should "use :disk as default storage" do
+        assert_equal :disk, Attachment.milton_options[:storage]
+      end
+      
+      should "use #{Rails.root}/public/default_attachments as default disk storage root" do
+        assert_equal File.join(Rails.root, 'public', 'default_attachments'), DefaultAttachment.milton_options[:storage_options][:root]
+      end
+      
+      should "use 0755 as default mode for new disk files" do
+        assert_equal 0755, DefaultAttachment.milton_options[:storage_options][:chmod]
+      end
+
+      should "raise LoadError if storage engine could not be required" do
+        assert_raise LoadError do
+          class BadStorageAttachment < ActiveRecord::Base
+            is_attachment :storage => :foo
+          end
+        end
+      end
+      
+      should "raise helpful LoadError if storage engine could not be required" do
+        begin
+          class BadStorageAttachment < ActiveRecord::Base
+            is_attachment :storage => :foo
+          end
+        rescue LoadError => e
+          assert_equal "No 'foo' storage found for Milton (failed to require milton/storage/foo_file)", e.message
+        end
+      end
+    end
+
+    context "inheritence" do
+      class FooImage < Image
+        is_attachment :resizeable => { :sizes => { :foo => { :size => '10x10' } } }
+      end
+
+      class BarImage < FooImage # note that BarImage < FooImage < Image
+        is_attachment :resizeable => { :sizes => { } }
+      end
+
+      should "inherit settings from Image" do
+        assert_equal Image.milton_options[:storage_options][:root], FooImage.milton_options[:storage_options][:root]
+      end
+
+      should "overwrite settings from Image when redefined in FooImage" do
+        assert_equal({ :foo => { :size => '10x10' } }, FooImage.milton_options[:resizeable][:sizes])
+      end
+
+      should "overwrite settings from FooImage when redefined in BarImage" do
+        assert_equal({}, BarImage.milton_options[:resizeable][:sizes])
+      end
+    end
+    
+    context "encapsulation" do
+      class FooRootImage < Image
+        is_attachment :storage_options => { :root => '/foo' }
+      end
+    
+      class BarRootImage < Image
+        is_attachment :storage_options => { :root => '/bar' }
+      end
+    
+      should "not overwrite FooRootImage's root setting with BarRootImage's" do
+        assert_equal '/foo', FooRootImage.milton_options[:storage_options][:root]
+      end
+
+      should "not overwrite BarRootImage's root setting with FooRootImage's" do
+        assert_equal '/bar', BarRootImage.milton_options[:storage_options][:root]
+      end
+    end
+  end
+  
+  context "getting mime-type" do
+    setup do
+      @attachment = Attachment.new :file => upload('milton.jpg')
+    end
+    
+    context "from freshly uploaded file" do
+      should "recognize it as an image/jpg" do
+        assert_equal 'image/jpg', @attachment.content_type
+      end
+    end
+    
+    context "from existing file" do
+      setup do
+        @attachment.save
+        @attachment.reload
+      end
+      
+      should "recognize it as an image/jpg" do
+        assert_equal 'image/jpg', @attachment.content_type
+      end
+    end
+    
+    context "from file with no content_type set" do
+      setup do
+        @attachment.update_attribute(:content_type, nil)
+        @attachment.save
+        @attachment.reload
+      end
+      
+      should "attempt to determine mime_type from file" do
+        # this is implemented w/ unix file cmd so is system dependent currently...
+        assert_equal 'image/jpeg', @attachment.content_type
+      end
+    end
+  end
+  
+  context "creating attachment folder" do
+    raise "Failed to create #{File.join(output_path, 'exists')}" unless FileUtils.mkdir_p(File.join(output_path, 'exists'))
+    FileUtils.ln_s 'exists', File.join(output_path, 'linked')
+    raise "Failed to symlink #{File.join(output_path, 'linked')}" unless File.symlink?(File.join(output_path, 'linked'))
+    
+    class NoRootAttachment < Attachment
+      is_attachment :storage_options => { :root => File.join(ActiveSupport::TestCase.output_path, 'nonexistant') }
+    end
+    
+    class RootExistsAttachment < Attachment
+      is_attachment :storage_options => { :root => File.join(ActiveSupport::TestCase.output_path, 'exists') }
+    end
+    
+    class SymlinkAttachment < Attachment
+      is_attachment :storage_options => { :root => File.join(ActiveSupport::TestCase.output_path, 'linked') }
+    end
+    
+    should "create root path when root path does not exist" do    
+      @attachment = NoRootAttachment.create :file => upload('milton.jpg')
+      assert File.exists?(@attachment.path)
+      assert File.exists?(File.join(output_path, 'nonexistant'))
+      assert_match /nonexistant/, @attachment.path
+    end
+    
+    should "work when root path already exists" do
+      @attachment = RootExistsAttachment.create :file => upload('milton.jpg')
+      assert File.exists?(@attachment.path)
+      assert_match /exists/, @attachment.path
+    end
+    
+    should "work when root path is a symlink" do
+      @attachment = SymlinkAttachment.create :file => upload('milton.jpg')
+      assert File.exists?(@attachment.path)
+      assert_match /linked/, @attachment.path
+    end
+  end
+  
+  context "being destroyed" do
+    setup do
+      @attachment = Attachment.create :file => upload('milton.jpg')
+    end
+
+    should "delete the underlying file from the filesystem" do
+      @attachment.destroy
+      assert !File.exists?(@attachment.path)
+    end
+    
+    # the partitioning algorithm ensures that each attachment model has its own
+    # folder, so we can safely delete the folder, if you write a new
+    # partitioner this might change!
+    should "delete the directory containing the file and all derivatives from the filesystem" do
+      @attachment.destroy
+      assert !File.exists?(File.dirname(@attachment.path))
+    end
+  end
+  
+  context "instantiating" do
+    setup do
+      @image = Image.new :file => upload('milton.jpg')
+    end
+  
+    should "have a file= method" do
+      assert @image.respond_to?(:file=)
+    end
+  
+    should "set the filename from the uploaded file" do
+      assert_equal 'milton.jpg', @image.filename
+    end
+    
+    should "strip seperator (.) from the filename and replace them with replacement (-)" do
+      @image.filename = 'foo.bar.baz.jpg'
+      assert_equal 'foo-bar-baz.jpg', @image.filename
+    end
+  end
+  
+  context "path partitioning" do
+    setup do
+      @image = Image.new :file => upload('milton.jpg')
+    end
+    
+    should "be stored in a partitioned folder based on its id" do
+      assert_match /^.*\/0*#{@image.id}\/#{@image.filename}$/, @image.path
+    end
+  end
+  
+  context "public path helper" do
+    setup do
+      @image = Image.new(:file => upload('milton.jpg'))
+    end
+    
+    should "give the path from public/ on to the filename" do
+      flexmock(@image, :path => '/root/public/assets/1/milton.jpg')
+      assert_equal "/assets/1/milton.jpg", @image.public_path
+    end
+    
+    should "give the path from foo/ on to the filename" do
+      flexmock(@image, :path => '/root/foo/assets/1/milton.jpg')
+      assert_equal "/assets/1/milton.jpg", @image.public_path({}, 'foo')
+    end
+  end
+  
+  context "handling uploads" do    
+    context "filename column" do
+      should "raise an exception if there is no filename column" do
+        assert_raise RuntimeError do
+          class NotUploadable < ActiveRecord::Base # see schema.rb, there is a not_uploadables table
+            is_attachment
+          end
+        end
+      end
+
+      should "not raise an exception if the underlying table doesn't exist" do
+        assert_nothing_raised do
+          class NoTable < ActiveRecord::Base
+            is_attachment
+          end
+        end
+      end
+    end
+
+    context "class extensions" do
+      context "class methods" do
+        should "add before_file_saved callback" do
+          assert Attachment.respond_to?(:before_file_saved)
+        end
+
+        should "add after_file_saved callback" do
+          assert Attachment.respond_to?(:after_file_saved)
+        end
+      end
+    end
+
+    context "handling file upload" do
+      context "saving upload" do
+        setup do
+          @attachment = Attachment.new :file => upload('milton.jpg')
+        end
+
+        should "save the upload to the filesystem on save" do
+          @attachment.save
+          assert File.exists?(@attachment.path)
+        end
+
+        should "have the same filesize as original file when large enough not to be a StringIO" do
+          # FIXME: this doesn't actually upload as a StringIO, figure out how to
+          # force that
+          @attachment.save
+          assert_equal File.size(File.join(File.dirname(__FILE__), '..', 'fixtures', 'milton.jpg')), File.size(@attachment.path)
+        end
+
+        should "have the same filesize as original file when small enough to be a StringIO" do
+          assert_equal File.size(File.join(File.dirname(__FILE__), '..', 'fixtures', 'mini-milton.jpg')), File.size(Attachment.create(:file => upload('mini-milton.jpg')).path)
+        end
+      end
+
+      context "stored full filename" do
+        setup do
+          @attachment = Attachment.create! :file => upload('milton.jpg')
+        end
+
+        should "use set root" do
+          assert_match /^#{@attachment.milton_options[:storage_options][:root]}.*$/, @attachment.path
+        end
+
+        should "use uploaded filename" do
+          assert_match /^.*#{@attachment.filename}$/, @attachment.path
+        end
+      end
+
+      context "sanitizing filename" do
+        setup do
+          @attachment = Attachment.create! :file => upload('unsanitary .milton.jpg')
+        end
+
+        should "strip the space and . and replace them with -" do
+          assert_match /^.*\/unsanitary--milton.jpg$/, @attachment.path
+        end
+
+        should "exist with sanitized filename" do
+          assert File.exists?(@attachment.path)
+        end
+      end
+
+      context "saving attachment after upload" do
+        setup do
+          @attachment = Attachment.create! :file => upload('unsanitary .milton.jpg')
+        end
+
+        should "save the file again" do
+          assert_nothing_raised do
+            Attachment.find(@attachment.id).save!
+          end
+        end
+      end
+    end
+  end
+  
+  context "updating an existing attachment" do
+    setup do
+      @attachment = Attachment.create! :file => upload('milton.jpg')
+      @original_path = @attachment.path
+      @attachment.update_attributes! :file => upload('big-milton.jpg')
+    end
+    
+    should "store the path to the updated upload" do
+      assert_equal 'big-milton.jpg', File.basename(@attachment.path)
+    end
+    
+    should "save the updated upload" do
+      assert File.exists?(@attachment.path)
+    end
+  end
+end