citrusbyte-milton 0.2.4 → 0.3.0

data/lib/milton/is_image.rb

@@ -1,31 +0,0 @@
-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

@@ -1,212 +0,0 @@
-module Citrusbyte
-  module Milton    
-    module IsResizeable
-      def self.included(base)
-        base.extend IsMethods
-      end
-
-      module IsMethods
-        def is_resizeable(options={})
-          ensure_attachment_methods options
-          
-          require_column 'content_type', "Milton's is_resizeable requires a content_type column on #{class_name} table"
-
-          self.milton_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

@@ -1,124 +0,0 @@
-module Citrusbyte
-  module Milton
-    module IsUploadable
-      def self.included(base)
-        base.extend IsMethods
-      end
-
-      module IsMethods
-        def is_uploadable(options = {})          
-          # TODO: implement size validations
-          # options[:min_size]      ||= 1
-          # options[:max_size]      ||= 4.megabytes
-          # options[:size]          ||= (options[:min_size]..options[:max_size])
-          
-          ensure_attachment_methods options
-          
-          options[:tempfile_path] ||= File.join(RAILS_ROOT, "tmp", "milton")
-          
-          self.milton_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, options)
-          FileUtils.mkdir_p(options[:tempfile_path]) unless File.exists?(options[:tempfile_path])
-          
-          tempfile = Tempfile.new("#{rand(Time.now.to_i)}", options[: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
-      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, attachment.class.milton_options) if respond_to?(:filename)
-        @tempfile       = UploadableFile.write_to_temp_file(data_or_path, attachment.class.milton_options)
-        @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
-        File.cp(temp_path, path)
-        File.chmod(milton_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/spec/milton/attachment_spec.rb

@@ -1,120 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Attachment do
-  describe "setting options" do
-    before :each do
-      Attachment.class_eval("is_uploadable :file_system_path => 'foo'")
-      Image.class_eval("is_uploadable :file_system_path => 'bar'")
-    end
-    
-    it "should not overwrite Attachment's file_system_path setting with Image's" do
-      Attachment.milton_options[:file_system_path].should eql('foo')
-    end
-
-    it "should not overwrite Image's file_system_path setting with Attachment's" do
-      Image.milton_options[:file_system_path].should eql('bar')
-    end
-  end
-  
-  describe "creating attachment folder" do
-    before :all do
-      @output_path = File.join(File.dirname(__FILE__), '..', 'output')
-      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'))
-    end
-    
-    it "should create root path when root path does not exist" do    
-      Attachment.class_eval("is_uploadable :file_system_path => '#{File.join(@output_path, 'nonexistant')}'")
-      @attachment = Attachment.create :file => upload('milton.jpg')
-      
-      File.exists?(@attachment.path).should be_true
-      File.exists?(File.join(@output_path, 'nonexistant')).should be_true
-      @attachment.path.should =~ /nonexistant/
-    end
-    
-    it "should work when root path already exists" do
-      Attachment.class_eval("is_uploadable :file_system_path => '#{File.join(@output_path, 'exists')}'")
-      @attachment = Attachment.create :file => upload('milton.jpg')
-      
-      File.exists?(@attachment.path).should be_true
-      @attachment.path.should =~ /exists/
-    end
-    
-    it "should work when root path is a symlink" do
-      Attachment.class_eval("is_uploadable :file_system_path => '#{File.join(@output_path, 'linked')}'")
-      @attachment = Attachment.create :file => upload('milton.jpg')
-      
-      File.exists?(@attachment.path).should be_true
-      @attachment.path.should =~ /linked/
-    end
-    
-    after :all do
-      Attachment.class_eval("is_uploadable :file_system_path => '#{@output_path}'")
-    end
-  end
-  
-  describe "being destroyed" do
-    before :each do
-      @attachment = Attachment.create :file => upload('milton.jpg')
-    end
-
-    it "should delete the underlying file from the filesystem" do
-      @attachment.destroy
-      File.exists?(@attachment.path).should be_false
-    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!
-    it "should delete the directory containing the file and all derivatives from the filesystem" do
-      @attachment.destroy
-      File.exists?(File.dirname(@attachment.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
-  
-  describe "public path helper" do
-    before :each do
-      @image = Image.new :file => upload('milton.jpg')
-    end
-    
-    it "should give the path from public/ on to the filename" do
-      @image.stub!(:path).and_return('/root/public/assets/1/milton.jpg')
-      @image.public_path.should eql("/assets/1/milton.jpg")
-    end
-    
-    it "should give the path from foo/ on to the filename" do
-      @image.stub!(:path).and_return('/root/foo/assets/1/milton.jpg')
-      @image.public_path({}, 'foo').should eql("/assets/1/milton.jpg")
-    end
-  end
-end