dragonfly 0.1.0

data/spec/dragonfly/parameters_spec.rb

@@ -0,0 +1,293 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Dragonfly::Parameters do
+  
+  def standard_attributes
+    {
+      :uid => 'ahaha',
+      :processing_method => :round,
+      :format => :gif,
+      :processing_options => {:radius => 5},
+      :encoding => {:flumps_per_minute => 56}
+    }
+  end
+  
+  describe "initializing" do
+    it "should allow initializing without a hash" do
+      parameters = Dragonfly::Parameters.new
+      parameters.uid.should be_nil
+    end
+    it "should allow initializing with a hash" do
+      parameters = Dragonfly::Parameters.new(:uid => 'b')
+      parameters.uid.should == 'b'
+    end
+    it "should raise an error if initialized with a bad hash key" do
+      lambda{
+        Dragonfly::Parameters.new(:fridge => 'cold')
+      }.should raise_error(ArgumentError)
+    end
+  end
+  
+  describe "accessors" do
+    before(:each) do
+      @parameters = Dragonfly::Parameters.new
+    end
+    it "should give the accessors the correct defaults" do
+      @parameters.uid.should be_nil
+      @parameters.processing_method.should be_nil
+      @parameters.format.should be_nil
+      @parameters.processing_options.should == {}
+      @parameters.encoding.should == {}
+    end
+    it "should provide writers too" do
+      @parameters.uid = 'hello'
+      @parameters.uid.should == 'hello'
+    end
+  end
+  
+  describe "array style accessors" do
+    before(:each) do
+      @parameters = Dragonfly::Parameters.new(:uid => 'hello')
+    end
+    it "should be the same as calling the corresponding reader" do
+      @parameters[:uid].should == @parameters.uid
+    end
+    it "should be the same as calling the corresponding writer" do
+      @parameters[:uid] = 'goodbye'
+      @parameters.uid.should == 'goodbye'
+    end
+  end
+  
+  describe "comparing" do
+    before(:each) do
+      @parameters1 = Dragonfly::Parameters.new(standard_attributes)
+      @parameters2 = Dragonfly::Parameters.new(standard_attributes)      
+    end
+    it "should return true when two have all the same attributes" do
+      @parameters1.should == @parameters2
+    end
+    %w(uid processing_method format processing_options encoding).each do |attribute|
+      it "should return false when #{attribute} is different" do
+        @parameters2[attribute.to_sym] = 'fish'
+        @parameters1.should_not == @parameters2
+      end
+    end
+  end
+  
+  describe "to_hash" do
+    it "should return the attributes as a hash" do
+      parameters = Dragonfly::Parameters.new(standard_attributes)
+      parameters.to_hash.should == standard_attributes
+    end
+  end
+  
+  describe "custom parameters classes" do
+    
+    before(:each) do
+      @parameters_class = Class.new(Dragonfly::Parameters)
+    end
+    
+    describe "when defaults are not set" do
+      it "should return the standard defaults" do
+        parameters = @parameters_class.new
+        parameters.processing_method.should be_nil
+        parameters.processing_options.should == {}
+        parameters.format.should be_nil
+        parameters.encoding.should == {}
+      end
+    end
+    
+    describe "when defaults are set" do
+      before(:each) do
+        @parameters_class.configure do |c|
+          c.default_processing_method = :resize
+          c.default_processing_options = {:scale => '0.5'}
+          c.default_format = :png
+          c.default_encoding = {:bit_rate => 24}
+        end
+      end
+      it "should return the default if not set on parameters" do
+        parameters = @parameters_class.new
+        parameters.processing_method.should == :resize
+        parameters.processing_options.should == {:scale => '0.5'}
+        parameters.format.should == :png
+        parameters.encoding.should == {:bit_rate => 24}
+      end
+      it "should return the correct parameter if set" do
+        parameters = @parameters_class.new(
+          :processing_method => :yo,
+          :processing_options => {:a => 'b'},
+          :format => :txt,
+          :encoding => {:ah => :arg}
+        )
+        parameters.processing_method.should == :yo
+        parameters.processing_options.should == {:a => 'b'}
+        parameters.format.should == :txt
+        parameters.encoding.should == {:ah => :arg}
+      end
+    end
+    
+  end
+  
+  describe "validate!" do
+    before(:each) do
+      @parameters = Dragonfly::Parameters.new(standard_attributes)
+    end
+    it "should not raise an error when parameters are ok" do
+      @parameters.validate!
+    end
+    it "should raise an error when the uid is not set" do
+      @parameters.uid = nil
+      lambda{
+        @parameters.validate!
+      }.should raise_error(Dragonfly::Parameters::InvalidParameters)
+    end
+    it "should raise an error when the format is not set" do
+      @parameters.format = nil
+      lambda{
+        @parameters.validate!
+      }.should raise_error(Dragonfly::Parameters::InvalidParameters)
+    end
+    it "should not raise an error when other parameters aren't set" do
+      parameters = Dragonfly::Parameters.new(:uid => 'asdf', :format => :jpg)
+      parameters.validate!
+    end
+  end
+  
+  describe "shortcuts" do
+    
+    before(:each) do
+      @parameters_class = Class.new(Dragonfly::Parameters)
+    end
+    
+    it "should allow for setting simple shortcuts" do
+      attributes = {
+        :processing_method => :duncan,
+        :processing_options => {:bill => :gates},
+        :format => 'mamamia',
+        :encoding => {:doogie => :howser}
+      }
+      @parameters_class.add_shortcut(:doobie, attributes)
+      @parameters_class.from_shortcut(:doobie).should == Dragonfly::Parameters.new(attributes)
+    end
+    
+    it "should raise an error if the shortcut doesn't exist" do
+      lambda{
+        @parameters_class.from_shortcut(:idontexist)
+      }.should raise_error(Dragonfly::Parameters::InvalidShortcut)
+    end
+    
+    describe "block shortcuts" do
+      
+      before(:each) do
+        @parameters_class.add_shortcut(/^hello.*$/, Symbol) do |processing_method, format, matches|
+          {:processing_method => processing_method, :format => format}
+        end
+      end
+      
+      it "should allow for more complex shortcuts by using a block and matching args" do
+        parameters = Dragonfly::Parameters.new(:processing_method => 'hellothere', :format => :tif)
+        @parameters_class.from_shortcut('hellothere', :tif).should == parameters
+      end
+
+      it "should raise an error if the shortcut doesn't match properly" do
+        lambda{
+          @parameters_class.from_shortcut('hellothere', 'tif')
+        }.should raise_error(Dragonfly::Parameters::InvalidShortcut)
+      end
+      
+      it "should raise an error if the shortcut matches but has the wrong number of args" do
+        lambda{
+          @parameters_class.from_shortcut('hellothere', :tif, 'YO')
+        }.should raise_error(Dragonfly::Parameters::InvalidShortcut)
+      end
+
+    end
+    
+    describe "single regexp shortcuts" do
+      
+      it "should yield regexp match data if the args is just one regexp" do
+        @parameters_class.add_shortcut(/^hello(.*)$/) do |arg, match_data|
+          {:processing_options => {:arg => arg, :match_data => match_data}}
+        end
+        processing_options = @parameters_class.from_shortcut('hellothere').processing_options
+        processing_options[:arg].should == 'hellothere'
+        processing_options[:match_data].should be_a(MatchData)
+        processing_options[:match_data][1].should == 'there'
+      end
+      
+    end
+    
+  end
+  
+  describe ".from_args" do
+    
+    before(:each) do
+      @parameters_class = Class.new(Dragonfly::Parameters)
+    end
+    
+    it "should be the same as 'new' if empty args" do
+      @parameters_class.from_args.should == @parameters_class.new
+    end
+    
+    it "should treat the arguments as actual parameter values if args is a single hash" do
+      @parameters_class.from_args(:uid => 'some_uid', :processing_method => :resize).
+        should == @parameters_class.new(:uid => 'some_uid', :processing_method => :resize)
+    end
+
+    it "should simply return the same parameters if args is a single parameters object" do
+      @parameters_class.from_args(@parameters_class.new(:uid => 'some_uid', :processing_method => :resize)).
+        should == @parameters_class.new(:uid => 'some_uid', :processing_method => :resize)
+    end
+    
+    it "should treat the arguments as shortcut arguments otherwise" do
+      @parameters_class.should_receive(:from_shortcut).with('innit').and_return(parameters = mock('parameters'))
+      @parameters_class.from_args('innit').should == parameters
+    end
+    
+  end
+  
+  describe "unique_signature" do
+    
+    before(:each) do
+      @parameters = Dragonfly::Parameters.new(standard_attributes)
+      @parameters2 = Dragonfly::Parameters.new(standard_attributes)
+    end
+    
+    it "should a unique identifier based on its attributes" do
+      @parameters.unique_signature.should be_a(String)
+      @parameters.unique_signature.length.should > 0
+    end
+    
+    it "should be the same if the attributes are the same" do
+      @parameters.unique_signature.should == @parameters2.unique_signature
+    end
+    
+    it "should be different when the uid is changed" do
+      @parameters2.uid = 'different yo'
+      @parameters.unique_signature.should_not == @parameters2.unique_signature
+    end
+   
+    it "should be different when the format is changed" do
+      @parameters2.format = :tif
+      @parameters.unique_signature.should_not == @parameters2.unique_signature
+    end
+    
+    it "should be different when the processing_method is changed" do
+      @parameters2.processing_method = :doogie
+      @parameters.unique_signature.should_not == @parameters2.unique_signature
+    end
+   
+    it "should be different when the processing_options are changed" do
+      @parameters2.processing_options[:slumdog] = 'millionaire'
+      @parameters.unique_signature.should_not == @parameters2.unique_signature
+    end
+    
+    it "should be different when the encoding options are changed" do
+      @parameters2.encoding[:flumps_per_minute] = 50.3
+      @parameters.unique_signature.should_not == @parameters2.unique_signature
+    end
+
+  end
+  
+end

data/spec/dragonfly/processing/rmagick_processor_spec.rb

@@ -0,0 +1,148 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Dragonfly::Processing::RMagickProcessor do
+  
+  before(:each) do
+    sample_file = File.dirname(__FILE__) + '/../../../samples/beach.png' # 280x355
+    @image = Dragonfly::TempObject.new(File.new(sample_file))
+    @processor = Object.new
+    @processor.extend Dragonfly::Processing::RMagickProcessor
+  end
+  
+  describe "#resize" do
+    
+    it "should work correctly with xNN" do
+      image = @processor.resize(@image, :geometry => 'x30')
+      image.should have_width(24)
+      image.should have_height(30)
+    end
+    
+    it "should work correctly with NNx" do
+      image = @processor.resize(@image, :geometry => '30x')
+      image.should have_width(30)
+      image.should have_height(38)
+    end
+    
+    it "should work correctly with NNxNN" do
+      image = @processor.resize(@image, :geometry => '30x30')
+      image.should have_width(24)
+      image.should have_height(30)
+    end
+    
+    it "should work correctly with NNxNN!" do
+      image = @processor.resize(@image, :geometry => '30x30!')
+      image.should have_width(30)
+      image.should have_height(30)
+    end
+    
+    it "should work correctly with NNxNN%" do
+      image = @processor.resize(@image, :geometry => '25x50%')
+      image.should have_width(70)
+      image.should have_height(178)
+    end
+    
+    describe "NNxNN>" do
+      
+      it "should not resize if the image is smaller than specified" do
+        image = @processor.resize(@image, :geometry => '1000x1000>')
+        image.should have_width(280)
+        image.should have_height(355)
+      end
+      
+      it "should resize if the image is larger than specified" do
+        image = @processor.resize(@image, :geometry => '30x30>')
+        image.should have_width(24)
+        image.should have_height(30)
+      end
+      
+    end
+    
+    describe "NNxNN<" do
+      
+      it "should not resize if the image is larger than specified" do
+        image = @processor.resize(@image, :geometry => '10x10<')
+        image.should have_width(280)
+        image.should have_height(355)
+      end
+      
+      it "should resize if the image is smaller than specified" do
+        image = @processor.resize(@image, :geometry => '400x400<')
+        image.should have_width(315)
+        image.should have_height(400)
+      end
+      
+    end
+    
+  end
+  
+  describe "crop" do # Difficult to test here other than dimensions
+    
+    it "should not crop if no args given" do
+      image = @processor.crop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+    
+    it "should crop using the offset given" do
+      image = @processor.crop(@image, :x => '7', :y => '12')
+      image.should have_width(273)
+      image.should have_height(343)
+    end
+    
+    it "should crop using the dimensions given" do
+      image = @processor.crop(@image, :width => '10', :height => '20')
+      image.should have_width(10)
+      image.should have_height(20)
+    end
+    
+    it "should crop in one dimension if given" do
+      image = @processor.crop(@image, :width => '10')
+      image.should have_width(10)
+      image.should have_height(355)
+    end
+    
+    it "should take into account the gravity given" do
+      image1 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+      image2 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'se')
+      image1.should_not == image2
+    end
+    
+    it "should clip bits of the image outside of the requested crop area when not nw gravity" do
+      # Rmagick was previously throwing an error when the cropping area was outside the image size, when
+      # using a gravity other than nw
+      image = @processor.crop(@image, :width => '500', :height => '1000', :x => '100', :y => '200', :gravity => 'se')
+      image.should have_width(180)
+      image.should have_height(155)
+    end
+    
+  end
+  
+  describe "resize_and_crop" do
+    
+    it "should do nothing if no args given" do
+      image = @processor.resize_and_crop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+    
+    it "should crop to the correct dimensions" do
+      image = @processor.resize_and_crop(@image, :width => '100', :height => '100')
+      image.should have_width(100)
+      image.should have_height(100)
+    end
+    
+    it "should allow cropping in one dimension" do
+      image = @processor.resize_and_crop(@image, :width => '100')
+      image.should have_width(100)
+      image.should have_height(355)
+    end
+    
+    it "should take into account the gravity given" do
+      image1 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+      image2 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'se')
+      image1.should_not == image2
+    end
+    
+  end
+  
+end

data/spec/dragonfly/temp_object_spec.rb

@@ -0,0 +1,233 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Dragonfly::TempObject do
+  
+  ####### Helper Methods #######
+
+  def new_tempfile(data = File.read(SAMPLES_DIR + '/round.gif'))
+    tempfile = Tempfile.new('test')
+    tempfile.write(data)
+    tempfile.close
+    tempfile
+  end
+  
+  def new_file(data = File.read(SAMPLES_DIR + '/round.gif'))
+    File.open('/tmp/test_file', 'w') do |f|
+      f.write(data)
+    end
+    File.new('/tmp/test_file')
+  end
+  
+  def get_parts(temp_object)
+    parts = []
+    temp_object.each do |bytes|
+      parts << bytes
+    end
+    parts.length.should >= 2 # Sanity check to check that the sample file is adequate for this test
+    parts
+  end
+  
+  ###############################
+  
+  it "should raise an error if initialized with a non-string/file/tempfile" do
+    lambda{
+      Dragonfly::TempObject.new(3)
+    }.should raise_error(ArgumentError)
+  end
+  
+  describe "common behaviour for #each", :shared => true do
+
+    it "should yield 8192 bytes each time" do
+      parts = get_parts(@temp_object)
+      parts[0...-1].each do |part|
+        part.length.should == 8192
+      end
+      parts.last.length.should <= 8192
+    end
+    
+  end
+  
+  describe "configuring #each" do
+
+    it "should yield the number of bytes specified in the class configuration" do
+      temp_object_class = Class.new(Dragonfly::TempObject)
+      temp_object_class.block_size = 3001
+      temp_object = temp_object_class.new(new_tempfile)
+      parts = get_parts(temp_object)
+      parts[0...-1].each do |part|
+        part.length.should == 3001
+      end
+      parts.last.length.should <= 3001
+    end
+
+  end
+  
+  describe "initializing from a string" do
+    before(:each) do
+      @gif_string = File.read(SAMPLES_DIR + '/round.gif')
+      @temp_object = Dragonfly::TempObject.new(@gif_string)
+    end
+    describe "data" do
+      it "should return the data correctly" do
+        @temp_object.data.should == @gif_string
+      end
+    end
+    describe "file" do
+      it "should lazily create a closed tempfile" do
+        @temp_object.file.should be_a(Tempfile)
+        @temp_object.file.should be_closed
+      end
+      it "should contain the correct data" do
+        @temp_object.file.open.read.should == @gif_string
+      end
+    end
+    describe "each" do
+      it "should not create a file" do
+        @temp_object.should_not_receive(:tempfile)
+        @temp_object.each{}
+      end
+      it_should_behave_like "common behaviour for #each"
+    end
+  end
+  
+  describe "initializing from a tempfile" do
+    before(:each) do
+      @gif_string = File.read(SAMPLES_DIR + '/round.gif')
+      @tempfile = new_tempfile(@gif_string)
+      @temp_object = Dragonfly::TempObject.new(@tempfile)
+    end
+    describe "data" do
+      it "should lazily return the correct data" do
+        @temp_object.data.should == @gif_string
+      end
+    end
+    describe "file" do
+      it "should return the closed tempfile" do
+        @temp_object.file.should be_a(Tempfile)
+        @temp_object.file.should be_closed
+        @temp_object.file.path.should == @tempfile.path
+      end
+    end
+    describe "each" do
+      it "should not create a data string" do
+        @temp_object.should_not_receive(:data)
+        @temp_object.each{}
+      end
+      it_should_behave_like "common behaviour for #each"
+    end
+  end
+  
+  describe "initializing from a file" do
+    before(:each) do
+      @file = File.new(SAMPLES_DIR + '/beach.png')
+      @temp_object = Dragonfly::TempObject.new(@file)
+    end
+    after(:each) do
+      @file.close
+    end
+    describe "data" do
+      it "should lazily return the correct data" do
+        @temp_object.data.should == @file.read
+      end
+    end
+    describe "file" do
+      it "should lazily return a closed tempfile" do
+        @temp_object.file.should be_a(Tempfile)
+        @temp_object.file.should be_closed
+      end
+      it "should contain the correct data" do
+        @temp_object.file.open.read.should == @file.read
+      end
+    end
+    describe "each" do
+      it "should not create a data string" do
+        @temp_object.should_not_receive(:data)
+        @temp_object.each{}
+      end
+      it_should_behave_like "common behaviour for #each"
+    end
+  end
+  
+  describe "initializing from another temp object" do
+    before(:each) do
+      @temp_object1 = Dragonfly::TempObject.new(new_tempfile('hello'))
+      @temp_object2 = Dragonfly::TempObject.new(@temp_object1)
+    end
+    it "should not be the same object" do
+      @temp_object1.should_not == @temp_object2
+    end
+    it "should have the same data" do
+      @temp_object1.data.should == @temp_object2.data
+    end
+    it "should have a different file path" do
+      @temp_object1.path.should_not == @temp_object2.path
+    end
+  end
+  
+  describe "path" do
+    it "should return the absolute file path" do
+      temp_object = Dragonfly::TempObject.new(File.new(SAMPLES_DIR + '/beach.png'))
+      temp_object.path.should == temp_object.file.path
+    end
+  end
+  
+  describe "modify_self!" do
+
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('DATA_ONE')
+      @temp_object.data # Make sure internal stuff is initialized
+      @temp_object.file #
+    end
+    it "should modify itself" do
+      @temp_object.modify_self!('DATA_TWO')
+      @temp_object.data.should == 'DATA_TWO'
+    end
+    it "should return itself" do
+      @temp_object.modify_self!('DATA_TWO').should == @temp_object
+    end
+    it "should modify itself when the new object is a file" do
+      @temp_object.modify_self!(File.new(SAMPLES_DIR + '/beach.png'))
+      @temp_object.data.should == File.read(SAMPLES_DIR + '/beach.png')
+    end
+    it "should modify itself when the new object is a tempfile" do
+      tempfile = new_tempfile
+      data = tempfile.open.read
+      @temp_object.modify_self!(tempfile)
+      @temp_object.data.should == data
+    end
+    
+  end
+  
+  describe "size" do
+    
+    before(:each) do
+      @gif_string = File.read(SAMPLES_DIR + '/round.gif')
+    end
+    
+    it "should return the size in bytes when initialized with a string" do
+      Dragonfly::TempObject.new(@gif_string).size.should == 61346
+    end
+    it "should return the size in bytes when initialized with a tempfile" do
+      Dragonfly::TempObject.new(new_tempfile(@gif_string)).size.should == 61346
+    end
+    it "should return the size in bytes when initialized with a file" do
+      Dragonfly::TempObject.new(new_file(@gif_string)).size.should == 61346
+    end
+  end
+  
+  describe "name" do
+    before(:each) do
+      @obj = new_tempfile
+    end
+    it "should set the name if the initial object responds to 'original filename'" do
+      def @obj.original_filename
+        'jimmy.page'
+      end
+      Dragonfly::TempObject.new(@obj).name.should == 'jimmy.page'
+    end
+    it "should not set the name if the initial object doesn't respond to 'original filename'" do
+      Dragonfly::TempObject.new(@obj).name.should be_nil
+    end
+  end
+  
+end