citrusbyte-milton 0.3.0 → 0.3.1

data/lib/milton/core/file.rb

@@ -0,0 +1,22 @@
+begin
+  require 'mimetype_fu'
+rescue MissingSourceFile
+end
+
+module Milton
+  class File < ::File
+    class << self
+      def extension(filename)
+        extension = extname(filename)
+        extension.slice(1, extension.length-1)
+      end
+      
+      # File respond_to?(:mime_type) is true if mimetype_fu is installed, so
+      # this way we always have File.mime_type? available but it favors
+      # mimetype_fu's implementation.
+      def mime_type?(file)
+        ::File.respond_to?(:mime_type?) ? super(file.filename) : file.content_type
+      end
+    end
+  end
+end

data/lib/milton/core/tempfile.rb

@@ -0,0 +1,38 @@
+require 'tempfile'
+
+module Milton
+  # For lack of a better name, a MiltonTempfile adds some helpful
+  # functionality to Ruby's Tempfile
+  class Tempfile < ::Tempfile
+    class << self
+      def create(data_or_path, tempfile_path)
+        FileUtils.mkdir_p(tempfile_path) unless File.exists?(tempfile_path)
+    
+        tempfile = new(basename, tempfile_path)
+    
+        if data_or_path.is_a?(StringIO)
+          tempfile.binmode
+          tempfile.write data_or_path.read
+          tempfile.close
+        else
+          tempfile.close
+          FileUtils.cp((data_or_path.respond_to?(:path) ? data_or_path.path : data_or_path), tempfile.path)
+        end
+    
+        tempfile
+      end
+    
+      def basename
+        "#{rand(Time.now.to_i)}"
+      end
+    
+      def filename(extension)
+        "#{basename}.#{extension}"
+      end
+    
+      def path(tempfile_path, extension)
+        File.join(tempfile_path, filename(extension))
+      end
+    end
+  end
+end

data/lib/milton/derivatives/derivative.rb

@@ -0,0 +1,95 @@
+module Milton
+  # Represents a file created on the file system that is a derivative of the
+  # one referenced by the model, i.e. a thumbnail of an image, or a transcode
+  # of a video.
+  # 
+  # Provides a container for options and a uniform API to dealing with
+  # passing options for the creation of derivatives.
+  # 
+  # Files created as derivatives have their creation options appended into
+  # their filenames so it can be checked later if a file w/ the given
+  # options already exists (so as not to create it again).
+  #
+  class Derivative
+    class << self
+      # Given a string of attachment options, splits them out into a hash,
+      # useful for things that take options on the query string or from
+      # filenames
+      def options_from(string)
+        Hash[*(string.split('_').collect { |option| 
+          key, value = option.split('=')
+          [ key.to_sym, value || true ] # nothing on RHS of = means it's a boolean true
+        }).flatten]
+      end
+
+      # Given a filename (presumably with options embedded in it) parses out
+      # the options and returns them as a hash.
+      def extract_options_from(filename, options)
+        File.basename(filename, File.extname(filename))[(filename.rindex(options[:separator]) + 1)..-1]
+      end
+      
+      # Creates a new Derivative from the given filename by extracting the
+      # options.
+      def from_filename(filename)
+        Derivative.new(filename, options_from(extract_options_from(filename)))
+      end
+      
+      def process(source, options={}, settings={})
+        returning(derivative = new(source, options, settings)) do
+          derivative.process unless derivative.exists?
+        end
+      end
+      
+      def factory(type, source, options={}, settings={})
+        "Milton::#{type.to_s.classify}".constantize.new(source, options, settings)
+      end
+    end
+
+    attr_reader :options, :settings
+
+    # Instantiate a new Derivative:
+    # * +source+: a reference to the Storage::StoredFile this will be a Derivative of
+    # * +options+: options to generate the Derivative using
+    # * +settings+: settings about how to create Derivatives
+    def initialize(source, options={}, settings={})
+      @source   = source
+      @options  = options.is_a?(String) ? self.class.options_from(options) : options
+      @settings = settings
+    end
+
+    # The resulting filename of this Derivative with embedded options.
+    def filename
+      # ignore false booleans and don't output =true for true booleans,
+      # otherwise just k=v
+      append    = options.reject{ |k, v| v.is_a?(FalseClass) }.collect { |k, v| v === true ? k.to_s : "#{k}=#{v}" }.sort.join('_')
+      extension = File.extname(@source.path)
+      File.basename(@source.path, extension) + (append.blank? ? '' : "#{settings[:separator]}#{append}") + extension
+    end
+
+    # The full path and filename to this Derivative.
+    def path
+      file.path
+    end
+    
+    # Returns true if this Derivative has already been generated and stored.
+    def exists?
+      file.exists?
+    end
+    
+    # Overwrite this to provide your derivatives processing.
+    def process;end;
+    
+    # Convenience method, only runs process if the given condition is true.
+    # Returns the derivative so it's chainable.
+    def process_if(condition)
+      process if condition && !exists?
+      return self
+    end
+    
+    # Returns the StoredFile which represents the Derivative (which is a copy
+    # of the source w/ a different filename).
+    def file
+      @file ||= @source.copy(filename)
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Milton
+  class CropCalculator
+    attr_reader :original, :target
+
+    # Initializes a new CropCalculator with the two given Images.
+    #
+    # A CropCalculator is used to calculate the proper zoom/crop dimensions
+    # to be passed to ImageMagick's convert method in order to transform
+    # the original Image's dimensions into the target Image's dimensions
+    # with sensible zoom/cropping.
+    def initialize(original, target)
+      @original = original
+      @target   = target
+    end
+
+    # Returns the geometry string to send to ImageMagick's convert -resize
+    # argument -- that is, the dimensions that the original Image would
+    # need to be resized to in order to result in the given target Image's
+    # dimensions with cropping.
+    def resizing_geometry
+      case
+        when original.wider? then "#{resized_width}x#{target.height}"
+        when original.square? && target.wider? then "#{target.width}x#{resized_height}"
+        when original.square? && !target.wider? then "#{resized_width}x#{target.height}"
+        else "#{target.width}x#{resized_height}"
+      end
+    end
+
+    # The geometry string to send to ImageMagick's convert -crop argument.
+    def cropping_geometry
+      "#{target.width}x#{target.height}+0+0"
+    end
+
+    # The gravity to use for cropping.
+    def gravity
+      original.wider? ? "center" : "north"
+    end
+
+    private
+
+    def resized_width
+      (target.height * original.width / original.height).to_i
+    end
+
+    def resized_height
+      (target.width * original.height / original.width).to_i
+    end
+
+    # TODO: this is the old-school cropping w/ coords, need to implement
+    # cropping w/ coords using the new system calls
+    # def crop_with_coordinates(img, x, y, size, options={})
+    #   gravity = options[:gravity] || Magick::NorthGravity
+    #   cropped_img = nil
+    #   img = Magick::Image.read(img).first unless img.is_a?(Magick::Image)
+    #   szx, szy = img.columns, img.rows
+    #   sz = self.class.get_size_from_parameter(size)
+    #   # logger.info "crop_with_coordinates: img.crop!(#{x}, #{y}, #{sz[0]}, #{sz[1]}, true)"
+    #   # cropped_img = img.resize!(sz[0], sz[1]) # EEEEEK
+    #   cropped_img = img.crop!(x, y, szx, szy, true)
+    #   cropped_img.crop_resized!(sz[0], sz[1], gravity) # EEEEEK
+    #   self.temp_path = write_to_temp_file(cropped_img.to_blob)
+    # end
+  end
+end

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/derivatives/thumbnail.rb

@@ -0,0 +1,46 @@
+require 'milton/derivatives/thumbnail/image'
+require 'milton/derivatives/thumbnail/crop_calculator'
+
+module Milton
+  class Thumbnail < Derivative
+    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
+    
+      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}"}) 
+    
+      # TODO: raise if the store fails
+      file.store(destination)
+    end
+
+    protected
+  
+    # For speed, any derivatives less than 640-wide are made from a 
+    # 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
+    end
+  
+    # Returns and memoizes an Image initialized from the file we're making a
+    # thumbnail of
+    def image
+      @image ||= Image.from_path(@source.path)
+    end
+  end
+end

data/lib/milton/storage/disk_file.rb

@@ -0,0 +1,78 @@
+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)
+          File.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)
+        File.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
+      
+      # 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,89 @@
+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
+      
+      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