citrusbyte-milton 0.3.2 → 0.3.3

data/lib/milton/core/tempfile.rb

@@ -33,6 +33,12 @@ module Milton
       def path(tempfile_path, extension)
         File.join(tempfile_path, filename(extension))
       end
+      
+      # Simple helper that returns a path to a tempfile with a uniquely
+      # generated basename and same extension as the given source.
+      def from(source)
+        filename(Milton::File.extension(source))
+      end
     end
   end
 end

data/lib/milton/derivatives/derivative.rb

@@ -100,7 +100,7 @@ module Milton
     # Returns the StoredFile which represents the Derivative (which is a copy
     # of the source w/ a different filename).
     def file
-      @file ||= @source.copy(filename)
+      @file ||= @source.clone(filename)
     end
   end
 end

data/lib/milton/derivatives/thumbnail.rb

@@ -6,25 +6,21 @@ module Milton
     def process
       raise "target size must be specified for resizing" unless options.has_key?(:size)
 
-      destination = Milton::Tempfile.path(settings[:tempfile_path], Milton::File.extension(@source.filename))
-    
-      # TODO: determine if this is neccessary or was just a problem w/ the
-      # way we were calling convert
-      # convert can be destructive to the original image in certain failure
-      # cases, so copy it to a tempfile first before processing
-      # source      = Milton::Tempfile.create(self.source, @source.options[:tempfile_path]).path
-    
+      temp_dst = File.join(settings[:tempfile_path], Milton::Tempfile.from(source.filename))
+      temp_src = File.join(settings[:tempfile_path], Milton::Tempfile.from(source.filename))
+      
+      source.copy(temp_src)
+      
       if options[:crop]
         crop = CropCalculator.new(image, Image.from_geometry(options[:size]))
         size = crop.resizing_geometry
         conversion_options = %Q(-gravity #{crop.gravity} -crop #{crop.cropping_geometry})
       end
-    
-      # TODO: raise if the syscall fails
-      Milton.syscall(%Q{convert #{source} -geometry #{size || options[:size]} #{conversion_options || ''} +repage "#{destination}"}) 
+      
+      Milton.syscall!(%Q{convert #{temp_src} -geometry #{size || options[:size]} #{conversion_options || ''} +repage "#{temp_dst}"})
     
       # TODO: raise if the store fails
-      file.store(destination)
+      file.store(temp_dst)
     end
 
     protected
@@ -33,10 +29,13 @@ module Milton
     # 640-wide version of the image (so you're not generating tiny
     # thumbnails from an 8-megapixel upload)
     def source
-      image.width > 640 && Image.from_geometry(options[:size]).width < 640 ? 
-        Thumbnail.process(@source, { :size => '640x' }, settings).path : @source.path
+      @quick_source ||= if image.width > 640 && Image.from_geometry(options[:size]).width < 640
+        Thumbnail.process(@source, { :size => '640x' }, settings).file
+      else
+        @source
+      end
     end
-  
+    
     # Returns and memoizes an Image initialized from the file we're making a
     # thumbnail of
     def image

data/lib/milton/storage/disk_file.rb

@@ -46,6 +46,12 @@ module Milton
         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/,"")

data/lib/milton/storage/s3_file.rb

@@ -34,6 +34,20 @@ module Milton
         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(bucket_name, key) { |chunk| file.write(chunk) }
+        file.close
+      end
+
       def mime_type
         # TODO: implement
       end        

data/lib/milton/storage/stored_file.rb

@@ -35,11 +35,10 @@ module Milton
         self.options  = options
       end
       
-      # Creates a "copy" of this StoredFile of the same type with the same id
+      # 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, just creates a "copy" of the 
-      # StoredFile object.
-      def copy(filename)
+      # copying of the underlying file data.
+      def clone(filename)
         self.class.new(filename, self.id, self.options)
       end
     end

data/lib/milton.rb

@@ -5,6 +5,7 @@ require 'milton/core/file'
 module Milton
   # Raised when a file which was expected to exist appears not to exist
   class MissingFileError < StandardError;end;
+  class SyscallFailedError < RuntimeError;end;
 
   # Some definitions for file semantics used throughout Milton, understanding
   # this will make understanding the code a bit easier and avoid ambiguity:
@@ -72,11 +73,25 @@ module Milton
   # Redirects stderr to log/milton.stderr.log in order to examine causes of
   # failure.
   def syscall(command)
+    begin
+      syscall!(command)
+    rescue Milton::SyscallFailedError => e      
+      return false
+    end
+  end
+  module_function :syscall
+  
+  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)
+    unless $?.success?
+      e = Milton::SyscallFailedError.new(command)
+      log("failed to execute " + e.message, invoker)
+      raise e
+    end
+    stdout
   end
-  module_function :syscall
+  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

data/test/milton/milton_test.rb

@@ -10,4 +10,12 @@ class MiltonTest < ActiveSupport::TestCase
       assert_equal "foo\n", Milton.syscall("echo foo")
     end
   end
+  
+  context "running a syscall!" do
+    should "raise a Milton::SyscallFailedError if it fails" do
+      assert_raise Milton::SyscallFailedError do
+        Milton.syscall!('ls this_directory_definitely_doesnt_exist')
+      end
+    end
+  end
 end

data/test/test_helper.rb

@@ -52,7 +52,7 @@ class Attachment < ActiveRecord::Base
 end
 
 class Image < ActiveRecord::Base
-  is_attachment :storage_options => { :root => ActiveSupport::TestCase.output_path }, :processors => { :thumbnail => { :postprocessing => true } }
+  is_attachment :storage_options => { :root => ActiveSupport::TestCase.output_path }
 end
 
 class Net::HTTP

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: citrusbyte-milton
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Ben Alavi