citrusbyte-milton 0.1.1

data/INSTALL

@@ -0,0 +1,26 @@
+== Installing Milton
+
+GemPlugin (Rails 2.1+)
+-------------------------------------------------------------------------------
+ 
+Add to your environment.rb:
+  
+  config.gem "citrusbyte-milton", :source => "http://gems.github.com", :lib => "milton"
+  
+Then run "rake gems:install" to install the gem.
+
+Plugin
+-------------------------------------------------------------------------------
+  
+  script/plugin install git://github.com/citrusbyte/milton.git
+  
+Gem
+-------------------------------------------------------------------------------
+
+  gem install citrusbyte-milton --source http://gems.github.com
+  
+== Installing ImageMagick (for image resizing)
+
+== Installing a FileSystem
+
+...j/k j/k

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Citrusbyte, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,12 @@
+== Milton
+
+Milton is an extensible attachment handling plugin that makes few assumptions
+but provides a lot of power.
+
+== Dependencies
+* ActiveRecord
+* Rails (for now?)
+* A filesystem (more storage solutions coming soon...)
+
+=== For Image manipulation (not required!)
+* ImageMagick (more processors coming soon)

data/init.rb

@@ -0,0 +1,2 @@
+require 'milton'
+ActiveRecord::Base.send(:include, Citrusbyte::Milton)

data/lib/milton/attachment.rb

@@ -0,0 +1,265 @@
+require 'ftools'
+require 'fileutils'
+
+module Citrusbyte
+  module Milton
+    module Attachment
+      def self.included(base)
+        base.extend Citrusbyte::Milton::Attachment::AttachmentMethods
+      end
+      
+      module AttachmentMethods
+        def has_attachment_methods(options={})
+          raise "Milton requires a filename column on #{table_name} table" unless column_names.include?("filename")
+          
+          # character used to seperate a filename from its derivative options, this
+          # character will be stripped from all incoming filenames and replaced by
+          # replacement
+          options[:separator]        ||= '.'
+          options[:replacement]      ||= '-'
+          
+          # root of where the underlying files are stored (or will be stored)
+          # on the file system
+          options[:file_system_path] ||= File.join(RAILS_ROOT, "public", table_name)
+          
+          # mode to set on stored files and created directories
+          options[:chmod]            ||= 0755
+          
+          AttachableFile.options = options
+          
+          validates_presence_of :filename
+          
+          before_destroy :destroy_attached_file
+          
+          include Citrusbyte::Milton::Attachment::InstanceMethods
+        end
+      end
+      
+      module InstanceMethods
+        # Sets the filename to the given filename (sanitizes the given filename
+        # as well)
+        #
+        # TODO: change the filename on the underlying file system on save so as
+        # not to orphan the file
+        def filename=(name)
+          write_attribute :filename, AttachableFile.sanitize_filename(name)
+        end
+
+        # The path to the file, takes an optional hash of options which can be
+        # used to determine a particular derivative of the file desired
+        def path(options={})
+          attached_file.path(options)
+        end
+                
+        protected
+          # A reference to the attached file, this is probably what you want to
+          # overwrite to introduce a new behavior
+          #
+          # i.e. 
+          #   have attached_file return a ResizeableFile, or a TranscodableFile
+          def attached_file
+            @attached_file ||= AttachableFile.new(self, filename)
+          end
+          
+          # Clean the file from the filesystem
+          def destroy_attached_file
+            attached_file.destroy
+          end
+      end
+    end
+
+    # AttachableFile is what Milton uses to interface between your model and
+    # the underlying file. Rather than just pushing a whole bunch of methods
+    # into your model, you get a reference to an AttachableFile (or something
+    # that extends AttachableFile).
+    class AttachableFile
+      class_inheritable_accessor :options
+
+      class << self
+        # Sanitizes the given filename, removes pathnames and the special chars
+        # needed for options seperation for derivatives
+        def sanitize_filename(filename)
+          File.basename(filename, File.extname(filename)).gsub(/^.*(\\|\/)/, '').
+            gsub(/[^\w]|#{Regexp.escape(options[:separator])}/, options[:replacement]).
+            strip + File.extname(filename)
+        end
+
+        # Creates the given directory and sets it to the mode given in
+        # options[:chmod]
+        def recreate_directory(directory)
+          FileUtils.mkdir_p(directory)
+          File.chmod(options[:chmod], directory)
+        end
+        
+        # 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 partition(id)
+          # 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
+      end
+      
+      # TODO: can probably fanagle a way to only pass a reference to the model
+      # and not need the filename (or better yet just the filename and 
+      # decouple)
+      def initialize(attachment, filename)
+        @attachment = attachment
+        @filename   = filename
+      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(options={})
+        options.empty? ? File.join(dirname, @filename) : Derivative.new(@filename, options).path
+      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
+      
+      # Removes the file from the underlying file system and any derivatives of
+      # the file.
+      def destroy
+        destroy_derivatives
+        destroy_file
+      end
+      
+      protected
+        # Returns the file as a File object opened for reading.
+        def file_reference
+          File.new(path)
+        end
+        
+        # Returns the partitioned path segment based on the id of the model
+        # this file is attached to.
+        def partitioned_path
+          self.class.partition(@attachment.id)
+        end
+
+        # The full path to the root of where files will be stored on disk.
+        def root_path
+          self.class.options[:file_system_path]
+        end
+
+        # Recreates the directory this file will be stored in.
+        def recreate_directory
+          self.class.recreate_directory(dirname) unless File.exists?(dirname)
+        end
+        
+        # Removes the file from the filesystem.
+        def destroy_file
+          FileUtils.rm path if File.exists?(path)
+        end
+
+        # Derivatives of this Attachment ====================================
+        
+        # Returns an array of derivatives of this attachment
+        def derivatives
+          Dir.glob(Derivative.dirname_for(path)).collect do |filename|
+            Derivative.from_filename(filename)
+          end
+        end
+        
+        # Recreates the directory derivatives of this file will be stored in.
+        def recreate_derivative_directory
+          dirname = Derivative.dirname_for(path)
+          self.class.recreate_directory(dirname) unless File.exists?(dirname)
+        end
+
+        # Removes the derivatives folder for this file and all files within.
+        def destroy_derivatives
+          FileUtils.rm_rf dirname if File.exists?(dirname)
+        end
+    end
+
+    # 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
+      attr_reader :options
+      
+      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 ]
+          }).flatten]
+        end
+
+        # Merges the given options to build a derviative filename and returns
+        # the resulting filename.
+        def filename_for(filename, options={})
+          append = options.collect{ |k, v| "#{k}=#{v}" }.sort.join('_')
+          File.basename(filename, File.extname(filename)) + (append.blank? ? '' : "#{AttachableFile.options[:separator]}#{append}") + File.extname(filename)
+        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)
+          File.basename(filename, File.extname(filename))[(filename.rindex(AttachableFile.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
+        
+        # Gives the path to where derivatives of this file are stored.
+        # Derivatives are any files which are based off of this file but are
+        # not Attachments themselves (i.e. thumbnails, transcoded copies, 
+        # etc...)
+        def dirname_for(path)
+          File.join(File.dirname(path), File.basename(path, File.extname(path)))
+        end
+      end
+      
+      def initialize(file, options)
+        @file    = file
+        @options = options
+      end
+      
+      # The filename of this Derivative with embedded options.
+      def filename
+        self.class.filename_for(@file.path, options)
+      end
+      
+      # The full path and filename to this Derivative.
+      def path
+        File.join(Derivative.dirname_for(@file.path), filename)
+      end
+      
+      # Returns true if the file resulting from this Derivative exists.
+      def exists?
+        File.exists?(path)
+      end
+    end
+  end
+end

data/lib/milton/is_image.rb

@@ -0,0 +1,31 @@
+module Citrusbyte
+  module Milton
+    module IsImage
+      def self.included(base)
+        base.extend IsMethods
+      end
+
+      module IsMethods
+        # Stupid little helper for defining something as an image, this used to
+        # have more functionality, it's just being kept around because it will
+        # probably be useful in the future. For the time being it just allows
+        # you to do:
+        #
+        # class Image < ActiveRecord::Base
+        #   is_image
+        # end
+        #
+        # rather than:
+        #
+        # class Image < ActiveRecord::Base
+        #   is_uploadable
+        #   is_resizeable
+        # end
+        def is_image(options={})
+          is_uploadable options
+          is_resizeable options
+        end
+      end
+    end
+  end
+end

data/lib/milton/is_resizeable.rb

@@ -0,0 +1,212 @@
+module Citrusbyte
+  module Milton    
+    module IsResizeable
+      def self.included(base)
+        base.extend IsMethods
+      end
+
+      module IsMethods
+        def is_resizeable(options={})
+          raise "is_resizeable requires a content_type column on #{class_name} table" unless column_names.include?("content_type")
+          
+          ensure_attachment_methods options
+
+          ResizeableFile.options = AttachableFile.options.merge(options)
+          
+          extend  Citrusbyte::Milton::IsResizeable::ClassMethods
+          include Citrusbyte::Milton::IsResizeable::InstanceMethods
+        end
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        # Returns the content_type of this attachment, tries to determine it if
+        # hasn't been determined yet or is not saved to the database
+        def content_type
+          return self[:content_type] unless self[:content_type].blank?
+          self.content_type = file_reference.mime_type? if file_reference.respond_to?(:mime_type?)
+        end
+                
+        # Sets the content type to the given type
+        def content_type=(type)
+          write_attribute :content_type, type.to_s.strip
+        end
+        
+        protected
+          def attached_file
+            @attached_file ||= ResizeableFile.new(self, filename)
+          end
+      end
+        
+      # 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 Citrusbyte::Milton::MissingFileError.new("Could not identify #{path} as an image, does the file exist?") unless `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
+    
+      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
+    
+    class ResizeableFile < AttachableFile
+      class << self
+        # Returns the given size as an array of two integers, width first. Can
+        # handle:
+        #
+        # A fixnum argument, which results in a square sizing:
+        #   parse_size(40) => [40, 40]
+        # An Array argument, which is simply returned:
+        #   parse_size([40, 40]) => [40, 40]
+        # A String argument, which is split on 'x' and converted:
+        #   parse_size("40x40") => [40, 40]
+        def parse_size(size)
+          case size.class.to_s
+          when "Fixnum" then [size.to_i, size.to_i]
+          when "Array"  then size
+          when "String" then size.split('x').collect(&:to_i)
+          end
+        end
+      end
+      
+      def initialize(attachment, filename)
+        super attachment, filename
+      end
+      
+      def path(options={})
+        options = Derivative.options_from(options) if options.is_a?(String)
+        return super if options.empty?
+        
+        derivative = Derivative.new(self, options)
+        resize(derivative) unless derivative.exists?
+        derivative.path
+      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 presize_options(derivative)
+          image.width > 640 && IsResizeable::Image.from_geometry(derivative.options[:size]).width < 640 ? { :size => '640x' } : {}
+        end
+      
+        def image
+          @image ||= IsResizeable::Image.from_path(path)
+        end
+      
+        def resize(derivative)
+          raise "target size must be specified for resizing" unless derivative.options.has_key?(:size)
+          
+          if derivative.options[:crop]
+            crop = IsResizeable::CropCalculator.new(image, IsResizeable::Image.from_geometry(derivative.options[:size]))
+            size = crop.resizing_geometry
+            conversion_options = %Q(-gravity #{crop.gravity} -crop #{crop.cropping_geometry})
+          end
+
+          system %Q(convert -geometry #{size || derivative.options[:size]} #{ResizeableFile.new(@attachment, @attachment.filename).path(presize_options(derivative))} #{conversion_options || ''} +repage "#{derivative.path}")
+        end
+    end
+  end
+end

data/lib/milton/is_uploadable.rb

@@ -0,0 +1,127 @@
+module Citrusbyte
+  module Milton
+    module IsUploadable
+      def self.included(base)
+        base.extend IsMethods
+      end
+
+      module IsMethods
+        def is_uploadable(options = {})
+          raise "Milton's is_uploadable requires a filename column on #{class_name} table" unless column_names.include?("filename")
+
+          # TODO: implement size validations
+          # options[:min_size]      ||= 1
+          # options[:max_size]      ||= 4.megabytes
+          # options[:size]          ||= (options[:min_size]..options[:max_size])
+          
+          options[:tempfile_path] ||= File.join(RAILS_ROOT, "tmp", "milton")
+
+          ensure_attachment_methods options
+
+          UploadableFile.options = AttachableFile.options.merge(options)
+          
+          after_create :save_uploaded_file
+
+          extend  Citrusbyte::Milton::IsUploadable::ClassMethods
+          include Citrusbyte::Milton::IsUploadable::InstanceMethods
+        end
+      end
+
+      module ClassMethods
+        def self.extended(base)
+          # Rails 2.1 fix for callbacks
+          if defined?(::ActiveSupport::Callbacks)
+            base.define_callbacks :before_file_saved, :after_file_saved
+          end
+        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 
+        FILENAME_REGEX = /^[^\/\\]+$/
+      
+        def self.included(base)
+          # Nasty rails 2.1 fix for callbacks
+          base.define_callbacks *[:before_file_saved, :after_file_saved] if base.respond_to?(:define_callbacks)
+        end
+        
+        def file=(file)
+          return nil if file.nil? || file.size == 0
+          @upload           = UploadableFile.new(self, file)
+          self.filename     = @upload.filename
+          self.size         = @upload.size if respond_to?(:size=)
+          self.content_type = @upload.content_type if respond_to?(:content_type=)
+        end
+        
+        protected          
+          def save_uploaded_file
+            unless @upload.saved?
+              callback :before_file_saved
+              @upload.save
+              callback :after_file_saved
+            end
+          end
+      end
+    end
+    
+    class UploadableFile < AttachableFile
+      attr_reader :content_type, :filename, :size
+
+      class << self
+        def write_to_temp_file(data_or_path)
+          FileUtils.mkdir_p(self.options[:tempfile_path]) unless File.exists?(self.options[:tempfile_path])
+          
+          tempfile = Tempfile.new("#{rand(Time.now.to_i)}", self.options[:tempfile_path])
+          
+          if data_or_path.is_a?(StringIO)
+            tempfile.binmode
+            tempfile.write data
+            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
+      end
+
+      def initialize(attachment, data_or_path)
+        @has_been_saved = false
+        @content_type   = data_or_path.content_type
+        @filename       = AttachableFile.sanitize_filename(data_or_path.original_filename) if respond_to?(:filename)
+        @tempfile       = UploadableFile.write_to_temp_file(data_or_path)
+        @size           = File.size(self.temp_path)
+
+        super attachment, filename
+      end
+
+      def saved?
+        @has_been_saved
+      end
+
+      def save
+        return true if self.saved?
+        recreate_directory
+        recreate_derivative_directory
+        File.cp(temp_path, path)
+        File.chmod(self.class.options[:chmod], path)
+        @has_been_saved = true
+      end
+
+      protected      
+        def temp_path
+          @tempfile.respond_to?(:path) ? @tempfile.path : @tempfile.to_s
+        end
+    end
+  end
+end

data/lib/milton.rb

@@ -0,0 +1,76 @@
+require 'milton/attachment'
+require 'milton/is_image'
+require 'milton/is_resizeable'
+require 'milton/is_uploadable'
+
+module Citrusbyte
+  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 : '')
+    #
+    
+    def self.included(base)
+      base.extend Citrusbyte::Milton::BaseMethods
+      base.extend Citrusbyte::Milton::IsUploadable::IsMethods
+      base.extend Citrusbyte::Milton::IsResizeable::IsMethods
+      base.extend Citrusbyte::Milton::IsImage::IsMethods
+    end
+    
+    module BaseMethods
+      protected
+        # The attachment methods give the core of Milton's file-handling, so
+        # various extensions can use this when they're included to make sure
+        # that the core attachment methods are available
+        def ensure_attachment_methods(options={})
+          unless included_modules.include?(Citrusbyte::Milton::Attachment)
+            include Citrusbyte::Milton::Attachment
+            has_attachment_methods(options)
+          end
+        end
+    end
+  end
+end

data/spec/milton/attachment_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Attachment do
+  describe "being destroyed" do
+    before :each do
+      @attachment = Attachment.create :file => upload('milton.jpg')
+      @derivative_path = File.dirname(@attachment.path) + '/milton'
+    end
+
+    it "should delete the underlying file from the filesystem" do
+      @attachment.destroy
+      File.exists?(@attachment.path).should be_false
+    end
+    
+    it "should have a derivative path before being destroyed" do
+      File.exists?(@derivative_path).should be_true
+    end
+    
+    it "should delete the derivative folder from the filesystem" do
+      @attachment.destroy
+      File.exists?(@derivative_path).should be_false
+    end
+  end
+  
+  describe "instantiating" do
+    before :each do
+      @image = Image.new :file => upload('milton.jpg')
+    end
+  
+    it "should have a file= method" do
+      @image.should respond_to(:file=)
+    end
+  
+    it "should set the filename from the uploaded file" do
+      @image.filename.should eql('milton.jpg')
+    end
+    
+    it "should strip seperator (.) from the filename and replace them with replacement (-)" do
+      @image.filename = 'foo.bar.baz.jpg'
+      @image.filename.should eql('foo-bar-baz.jpg')
+    end
+  end
+  
+  describe "path partitioning" do
+    before :each do
+      @image = Image.new :file => upload('milton.jpg')
+    end
+    
+    it "should be stored in a partitioned folder based on its id" do
+      @image.path.should =~ /^.*\/#{Citrusbyte::Milton::AttachableFile.partition(@image.id)}\/#{@image.filename}$/
+    end
+  end
+end

data/spec/milton/is_image_spec.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Citrusbyte::Milton::IsImage do
+end

data/spec/milton/is_uploadable_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Citrusbyte::Milton::IsUploadable do
+  class NotUploadable < ActiveRecord::Base
+  end
+  
+  describe "filename column" do
+    it "should raise an exception if there is no filename column" do
+      lambda { NotUploadable.class_eval("is_uploadable") }.should raise_error
+    end
+
+    it 'should not raise an exception if there is a filename column' do
+      lambda { Attachment.class_eval("is_uploadable") }.should_not raise_error
+    end
+  end
+  
+  describe "setting :file_system_path" do
+    it "should allow options to be accessed" do
+      Citrusbyte::Milton::UploadableFile.options.should be_kind_of(Hash)
+    end
+    
+    it "should be able to overwrite file_system_path from is_uploadable call" do
+      Attachment.class_eval("is_uploadable(:file_system_path => 'foo')")
+      Citrusbyte::Milton::UploadableFile.options[:file_system_path].should eql('foo')
+    end
+    
+    after :all do
+      Citrusbyte::Milton::UploadableFile.options[:file_system_path] = File.join(File.dirname(__FILE__), '..', 'output')
+    end
+  end
+    
+  describe "class extensions" do
+    describe "class methods" do
+      it "should add before_file_saved callback" do
+        Attachment.should respond_to(:before_file_saved)
+      end
+      
+      it "should add after_file_saved callback" do
+        Attachment.should respond_to(:after_file_saved)
+      end
+    end
+  end
+    
+  describe "handling file upload" do
+    describe "saving upload" do
+      before :each do
+        @attachment = Attachment.new :file => upload('milton.jpg')
+      end
+      
+      it "should save the upload to the filesystem on save" do
+        @attachment.save
+        File.exists?(@attachment.path).should be_true
+      end
+      
+      it "should have the same filesize as original file when large enough not to be a StringIO" do
+        @attachment.save
+        File.size(@attachment.path).should be_eql(File.size(File.join(File.dirname(__FILE__), '..', 'fixtures', 'milton.jpg')))
+      end
+      
+      it "should have the same filesize as original file when small enough to be a StringIO" do
+        File.size(Attachment.create(:file => upload('mini-milton.jpg')).path).should be_eql(File.size(File.join(File.dirname(__FILE__), '..', 'fixtures', 'mini-milton.jpg')))
+      end
+    end
+    
+    describe "stored full filename" do
+      before :each do
+        @attachment = Attachment.create! :file => upload('milton.jpg')
+      end
+
+      it "should use set file_system_path" do
+        @attachment.path.should =~ /^#{Citrusbyte::Milton::AttachableFile.options[:file_system_path]}.*$/
+      end
+      
+      it "should use uploaded filename" do
+        @attachment.path.should =~ /^.*#{@attachment.filename}$/
+      end
+    end
+    
+    describe "sanitizing filename" do
+      before :each do
+        @attachment = Attachment.create! :file => upload('unsanitary .milton.jpg')
+      end
+      
+      it "should strip the space and . and replace them with -" do
+        @attachment.path.should =~ /^.*\/unsanitary--milton.jpg$/
+      end
+      
+      it "should exist with sanitized filename" do
+        File.exists?(@attachment.path).should be_true
+      end
+    end
+    
+    describe "saving attachment after upload" do
+      before :each do
+        @attachment = Attachment.create! :file => upload('unsanitary .milton.jpg')
+      end
+      
+      it "should save the file again" do
+        lambda {
+          Attachment.find(@attachment.id).save!
+        }.should_not raise_error
+      end
+    end
+  end
+end

data/spec/milton/milton_spec.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Citrusbyte::Milton do
+end

data/spec/schema.rb

@@ -0,0 +1,10 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table :attachments, :force => true do |t|
+    t.string :filename
+  end
+
+  create_table :images, :force => true do |t|
+    t.string :filename
+    t.string :content_type
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../../../spec/spec_helper'
+
+plugin_spec_dir = File.dirname(__FILE__)
+ActiveRecord::Base.logger = Logger.new(plugin_spec_dir + "/debug.log")
+
+load(File.dirname(__FILE__) + '/schema.rb')
+
+Spec::Runner.configure do |config|
+  config.fixture_path = File.join(File.dirname(__FILE__), 'fixtures/')
+  
+  # remove files created from previous spec run, happens before instead of
+  # after so you can view them after you run the specs
+  FileUtils.rm_rf(File.join(File.dirname(__FILE__), 'output'))
+end
+
+def upload(file, type='image/jpg')
+  fixture_file_upload file, type
+end
+
+class Attachment < ActiveRecord::Base
+  is_uploadable :file_system_path => File.join(File.dirname(__FILE__), 'output')
+end
+
+class Image < ActiveRecord::Base
+  is_image :file_system_path => File.join(File.dirname(__FILE__), 'output')
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: citrusbyte-milton
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Ben Alavi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-27 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: ben.alavi@citrusbyte.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- INSTALL
+- MIT-LICENSE
+- README
+- init.rb
+- lib/milton.rb
+- lib/milton/attachment.rb
+- lib/milton/is_image.rb
+- lib/milton/is_resizeable.rb
+- lib/milton/is_uploadable.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/fixtures/big-milton.jpg
+- spec/fixtures/milton.jpg
+- spec/fixtures/mini-milton.jpg
+- spec/fixtures/unsanitary .milton.jpg
+- spec/milton/attachment_spec.rb
+- spec/milton/is_image_spec.rb
+- spec/milton/is_resizeable_spec.rb
+- spec/milton/is_uploadable_spec.rb
+- spec/milton/milton_spec.rb
+has_rdoc: true
+homepage: http://labs.citrusbyte.com/milton
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Asset handling Rails plugin that makes few assumptions and is highly extensible.
+test_files: []
+