citrusbyte-milton 0.3.0 → 0.3.1

data/lib/milton/storage/stored_file.rb

@@ -0,0 +1,47 @@
+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 "copy" 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, just creates a "copy" of the 
+      # StoredFile object.
+      def copy(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/lib/milton.rb

@@ -0,0 +1,95 @@
+require 'milton/attachment'
+require 'milton/core/tempfile'
+require 'milton/core/file'
+
+module Milton
+  # Raised when a file which was expected to exist appears not to exist
+  class MissingFileError < StandardError;end;
+
+  # Some definitions for file semantics used throughout Milton, understanding
+  # this will make understanding the code a bit easier and avoid ambiguity:
+  #
+  # path:
+  #   the full path to a file or directory in the filesystem
+  #     /var/log/apache2 or /var/log/apache2/access.log
+  #   can also be defined as:
+  #     path == dirname + filename
+  #     path == dirname + basename + extension
+  #
+  # dirname:
+  #   the directory portion of the path to a file or directory, all the chars
+  #   up to the final /
+  #     /var/log/apache2            => /var/log
+  #     /var/log/apache2/           => /var/log/apache2
+  #     /var/log/apache2/access.log => /var/log/apache2
+  #
+  # basename:
+  #   the portion of a filename *with no extension* (ruby's "basename" may or
+  #   may not have an extension), all the chars after the last / and before
+  #   the last .
+  #     /var/log/apache2                 => apache2
+  #     /var/log/apache2/                => nil
+  #     /var/log/apache2/access.log      => access
+  #     /var/log/apache2/access.2008.log => access.2008
+  #
+  # extension:
+  #   the extension portion of a filename w/ no preceding ., all the chars
+  #   after the final .
+  #     /var/log/apache2                 => nil
+  #     /var/log/apache2/                => nil
+  #     /var/log/apache2/access.log      => log
+  #     /var/log/apache2/access.2008.log => log
+  # 
+  # filename:
+  #   the filename portion of a path w/ extension, all the chars after the
+  #   final /
+  #     /var/log/apache2                 => apache2
+  #     /var/log/apache2/                => nil
+  #     /var/log/apache2/access.log      => access.log
+  #     /var/log/apache2/access.2008.log => access.2008.log
+  #   can also be defined as:
+  #     filename == basename + (extension ? '.' + extension : '')
+  #
+  
+  # Gives the filename and line number of the method which called the method
+  # that invoked #called_by.
+  def called_by
+    caller[1].gsub(/.*\/(.*):in (.*)/, "\\1:\\2")
+  end
+  module_function :called_by
+  
+  # Writes the given message to the Rails log at the info level. If given an
+  # invoker (just a string) it prepends the message with that. If not given
+  # an invoker it outputs the filename and line number which called #log.
+  def log(message, invoker=nil)
+    invoker ||= Milton.called_by
+    Rails.logger.info("[milton] #{invoker}: #{message}")
+  end
+  module_function :log
+
+  # Executes the given command, returning the commands output if successful
+  # or false if the command failed.
+  # Redirects stderr to log/milton.stderr.log in order to examine causes of
+  # failure.
+  def syscall(command)
+    log("executing #{command}", invoker = Milton.called_by)
+    stdout = %x{#{command} 2>>#{File.join(Rails.root, 'log', 'milton.stderr.log')}}
+    $?.success? ? stdout : (log("failed to execute #{command}", invoker) and return false)
+  end
+  module_function :syscall
+  
+  # Wraps +require+ on the given path in a rescue which uses the given
+  # message for the resulting LoadError on failure instead of the default
+  # one to give the user a better idea of what happened (useful for
+  # dynamic +require+)
+  def try_require(path, message)
+    begin
+      require path
+    rescue LoadError => e
+      raise LoadError.new(message + " (failed to require #{path})")
+    end
+  end
+  module_function :try_require
+end
+
+ActiveRecord::Base.extend Milton::Attachment

data/test/milton/attachment_test.rb

@@ -0,0 +1,329 @@
+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
+      should "use :disk as default storage" do
+        assert_equal :disk, Attachment.milton_options[:storage]
+      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