dragonfly 0.1.0

data/lib/dragonfly.rb

@@ -0,0 +1,33 @@
+# AUTOLOAD EVERYTHING IN THE IMAGETASTIC DIRECTORY TREE
+
+# The convention is that dirs are modules
+# so declare them here and autoload any modules/classes inside them
+# All paths here are absolute
+def camelize(path)
+  # e.g. 'test/this_one' => Test::ThisOne
+  "#{path}".
+    chomp('/').
+    gsub('/','::').
+    gsub(/([^a-z])(\w)/){ "#{$1}#{$2.upcase}" }.
+    gsub('_','').
+    sub(/^(\w)/){ $1.upcase }
+end
+def autoload_files_in_dir(path, namespace)
+  # Define the module
+  eval("module #{namespace}; end")
+  # Autoload modules/classes in that module
+  Dir.glob("#{path}/*.rb").each do |file|
+    sub_const_name = camelize( File.basename(file, '.rb') )
+    eval("#{namespace}.autoload('#{sub_const_name}', '#{file}')")
+  end
+  # Recurse on subdirectories
+  Dir.glob("#{path}/*/").each do |dir|
+    sub_namespace = camelize( File.basename(dir) )
+    autoload_files_in_dir(dir, "#{namespace}::#{sub_namespace}")
+  end
+end
+
+autoload_files_in_dir("#{File.dirname(__FILE__)}/dragonfly", 'Dragonfly')
+
+require 'rubygems'
+require File.dirname(__FILE__) + '/dragonfly/core_ext/object'

data/spec/argument_matchers.rb

@@ -0,0 +1,29 @@
+def string_matching(regexp)
+  Spec::Mocks::ArgumentMatchers::RegexpMatcher.new(regexp)
+end
+
+class TempObjectArgumentMatcher
+  def initialize(data)
+    @data = data
+  end
+  def ==(actual)
+    actual.is_a?(Dragonfly::TempObject) && actual.data == @data
+  end
+end
+
+def a_temp_object_with_data(data)
+  TempObjectArgumentMatcher.new(data)
+end
+
+class ParametersArgumentMatcher
+  def initialize(hash)
+    @hash = hash
+  end
+  def ==(actual)
+    actual.to_hash.reject{|k,v| v.nil? || v.respond_to?(:empty?) && v.empty?} == @hash
+  end
+end
+
+def parameters_matching(hash)
+  ParametersArgumentMatcher.new(hash)
+end

data/spec/dragonfly/active_record_extensions/attachment_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Dragonfly::ActiveRecordExtensions::Attachment do  
+
+  # See model_spec - tests are less brittle if doing mini integration tests
+  # at the model level
+
+end

data/spec/dragonfly/active_record_extensions/initializer.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.extend Dragonfly::ActiveRecordExtensions

data/spec/dragonfly/active_record_extensions/migration.rb

@@ -0,0 +1,21 @@
+class MigrationForTest < ActiveRecord::Migration
+  
+  def self.up
+    create_table :items, :force => true do |t|
+      t.string  :title
+      t.string  :preview_image_uid
+      t.string  :preview_image_some_analyser_method
+      t.integer  :preview_image_size
+      t.string  :preview_image_blah_blah
+      t.string  :other_image_uid
+      t.string  :yet_another_image_uid
+      t.string  :trailer_video_uid
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :items
+  end
+
+end

data/spec/dragonfly/active_record_extensions/model_spec.rb

@@ -0,0 +1,400 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Item do
+
+  # See extra setup in models / initializer files
+
+  describe "registering dragonfly apps" do
+
+    before(:each) do
+      @app1, @app2 = Dragonfly::App[:images], Dragonfly::App[:videos]
+      ActiveRecord::Base.register_dragonfly_app(:image, @app1)
+      ActiveRecord::Base.register_dragonfly_app(:video, @app2)
+    end
+
+    it "should return the mapping of apps to attributes" do
+      Item.class_eval do
+        image_accessor :preview_image
+        video_accessor :trailer_video
+      end
+      Item.dragonfly_apps_for_attributes.should == {:preview_image => @app1, :trailer_video => @app2}
+    end
+
+  end
+  
+  describe "defining accessors" do
+
+    it "should raise an error if the wrong method prefix is used" do
+      lambda{
+        Item.class_eval do
+          dog_accessor :preview_image
+        end
+      }.should raise_error(NameError)
+    end
+
+    describe "correctly defined" do
+    
+      before(:each) do
+        @app = Dragonfly::App[:images]
+        ActiveRecord::Base.register_dragonfly_app(:image, @app)
+        Item.class_eval do
+          image_accessor :preview_image
+        end
+        @item = Item.new
+      end    
+
+      it "should provide a reader" do
+        @item.should respond_to(:preview_image)
+      end
+
+      it "should provide a writer" do
+        @item.should respond_to(:preview_image=)
+      end
+
+      describe "when there has been nothing assigned" do
+        it "the reader should return nil" do
+          @item.preview_image.should be_nil
+        end
+        it "the uid should be nil" do
+          @item.preview_image_uid.should be_nil
+        end
+        it "should not try to store anything on save" do
+          @app.datastore.should_not_receive(:store)
+          @item.save!
+        end
+        it "should not try to destroy anything on save" do
+          @app.datastore.should_not_receive(:destroy)
+          @item.save!
+        end
+        it "should not try to destroy anything on destroy" do
+          @app.datastore.should_not_receive(:destroy)
+          @item.destroy
+        end
+      end
+      
+      describe "when there has been some thing assigned but not saved" do
+        before(:each) do
+          @item.preview_image = "DATASTRING"
+        end
+        it "the reader should return an attachment" do
+          @item.preview_image.should be_a(Dragonfly::ActiveRecordExtensions::Attachment)
+        end
+        it "the uid should be a 'pending' object" do
+          @item.preview_image_uid.should be_a(Dragonfly::ActiveRecordExtensions::PendingUID)
+        end
+        it "should store the image when saved" do
+          @app.datastore.should_receive(:store).with(a_temp_object_with_data("DATASTRING"))
+          @item.save!
+        end
+        it "should not try to destroy anything on destroy" do
+          @app.datastore.should_not_receive(:destroy)
+          @item.destroy
+        end
+        it "should return nil for the url" do
+          @item.preview_image.url.should be_nil
+        end
+        it "should return the size" do
+          @item.preview_image.size.should == 10
+        end
+        it "should return the temp_object" do
+          temp_object = @item.preview_image.temp_object
+          temp_object.should be_a(Dragonfly::ExtendedTempObject)
+          temp_object.data.should == 'DATASTRING'
+        end
+      end
+      
+      describe "when something has been assigned and saved" do
+
+        before(:each) do
+          @item.preview_image = "DATASTRING"
+          @app.datastore.should_receive(:store).with(a_temp_object_with_data("DATASTRING")).once.and_return('some_uid')
+          @app.datastore.stub!(:store)
+          @app.datastore.stub!(:destroy)
+          @item.save!
+        end
+        it "should have the correct uid" do
+          @item.preview_image_uid.should == 'some_uid'
+        end
+        it "should not try to store anything if saved again" do
+          @app.datastore.should_not_receive(:store)
+          @item.save!
+        end
+
+        it "should not try to destroy anything if saved again" do
+          @app.datastore.should_not_receive(:destroy)
+          @item.save!
+        end
+        
+        it "should destroy the data on destroy" do
+          @app.datastore.should_receive(:destroy).with('some_uid')
+          @item.destroy
+        end
+
+        it "should return the url for the data" do
+          @app.should_receive(:url_for).with(@item.preview_image_uid, :arg).and_return('some.url')
+          @item.preview_image.url(:arg).should == 'some.url'
+        end
+        
+        describe "when reloaded" do
+          before(:each) do
+            @item.reload
+          end
+          it "should destroy the data on destroy" do
+            @app.datastore.should_receive(:destroy).with(@item.preview_image_uid)
+            @item.destroy
+          end
+          it "should return the size" do
+            @item.preview_image.size.should == 10
+          end
+          it "should return the temp_object" do
+            temp_object = @item.preview_image.temp_object
+            temp_object.should be_a(Dragonfly::ExtendedTempObject)
+            temp_object.data.should == 'DATASTRING'
+          end
+        end
+
+        describe "when something new is assigned" do
+          before(:each) do
+            @item.preview_image = "NEWDATASTRING"
+          end
+          it "should set the uid to pending" do
+            @item.preview_image_uid.should be_a(Dragonfly::ActiveRecordExtensions::PendingUID)
+          end
+          it "should destroy the old data when saved" do
+            @app.datastore.should_receive(:store).with(a_temp_object_with_data("NEWDATASTRING")).once.and_return('some_uid')
+            
+            @app.datastore.should_receive(:destroy).with('some_uid')
+            @item.save!
+          end
+          it "should store the new data when saved" do
+            @app.datastore.should_receive(:store).with(a_temp_object_with_data("NEWDATASTRING"))
+            @item.save!
+          end
+          it "should destroy the old data on destroy" do
+            @app.datastore.should_receive(:destroy).with('some_uid')
+            @item.destroy
+          end
+          it "should return the new size" do
+            @item.preview_image.size.should == 13
+          end
+          it "should return the new temp_object" do
+            temp_object = @item.preview_image.temp_object
+            temp_object.should be_a(Dragonfly::ExtendedTempObject)
+            temp_object.data.should == 'NEWDATASTRING'
+          end
+        end
+        
+        describe "when it is set to nil" do
+          before(:each) do
+            @item.preview_image = nil
+          end
+          it "should set the uid to nil" do
+            @item.preview_image_uid.should be_nil
+          end
+          it "should return the attribute as nil" do
+            @item.preview_image.should be_nil
+          end
+          it "should destroy the data on save" do
+            @app.datastore.should_receive(:destroy).with('some_uid')
+            @item.save!
+          end
+          it "should destroy the old data on destroy" do
+            @app.datastore.should_receive(:destroy).with('some_uid')
+            @item.destroy
+          end
+        end
+
+        describe "when the data can't be found" do
+          before(:each) do
+            @app.datastore.stub!(:destroy).with('some_uid').and_raise(Dragonfly::DataStorage::DataNotFound)
+            @app.datastore.stub!(:retrieve).with('some_uid').and_raise(Dragonfly::DataStorage::DataNotFound)
+          end
+          it "should log a warning if the data wasn't found on destroy" do
+            @app.log.should_receive(:warn)
+            @item.destroy
+          end 
+        end
+
+      end
+
+    end
+  end  
+
+  describe "validations" do
+
+    before(:all) do
+      @app = Dragonfly::App[:images]
+      ActiveRecord::Base.register_dragonfly_app(:image, @app)
+    end
+    
+    describe "validates_presence_of" do
+
+      before(:all) do
+        Item.class_eval do
+          image_accessor :preview_image
+          validates_presence_of :preview_image
+        end
+      end
+
+      it "should be valid if set" do
+        Item.new(:preview_image => "1234567890").should be_valid
+      end
+
+      it "should be invalid if not set" do
+        Item.new.should_not be_valid
+      end
+
+    end
+    
+    describe "validates_size_of" do
+      
+      before(:all) do
+        Item.class_eval do
+          image_accessor :preview_image
+          validates_size_of :preview_image, :within => (6..10)
+        end
+      end
+
+      it "should be valid if ok" do
+        Item.new(:preview_image => "1234567890").should be_valid
+      end
+
+      it "should be invalid if too small" do
+        Item.new(:preview_image => "12345").should_not be_valid
+      end
+      
+    end
+    
+    describe "validates_mime_type_of" do
+
+      before(:each) do
+        @item = Item.new(:preview_image => "1234567890")
+      end
+
+      before(:all) do
+        custom_analyser = Object.new
+        def custom_analyser.mime_type(temp_object)
+          case temp_object.data
+          when "WRONG TYPE" then 'wrong/type'
+          when "OTHER TYPE" then nil
+          else 'how/special'
+          end
+        end
+        @app.analyser.register(custom_analyser)
+        
+        Item.class_eval do
+          validates_mime_type_of :preview_image, :in => ['how/special', 'how/crazy'], :if => :its_friday
+          validates_mime_type_of :other_image, :yet_another_image, :as => 'how/special'
+
+          image_accessor :preview_image
+          image_accessor :other_image
+          image_accessor :yet_another_image
+
+          def its_friday
+            true
+          end
+
+        end
+      end
+    
+      it "should be valid if nil, if not validated on presence (even with validates_mime_type_of)" do
+        @item.other_image = nil
+        @item.should be_valid
+      end
+    
+      it "should be invalid if the mime_type is unknown" do
+        @item.preview_image = "OTHER TYPE"
+        @item.should_not be_valid
+        @item.errors.on(:preview_image).should == "doesn't have the correct MIME-type. It needs to be one of 'how/special', 'how/crazy', but was 'unknown'"
+      end
+
+      it "should be invalid if the mime_type is wrong" do
+        @item.preview_image = "WRONG TYPE"
+        @item.should_not be_valid
+        @item.errors.on(:preview_image).should == "doesn't have the correct MIME-type. It needs to be one of 'how/special', 'how/crazy', but was 'wrong/type'"
+      end
+
+      it "should validate individually" do
+        @item.other_image = "1234567"
+        @item.yet_another_image = "WRONG TYPE"
+        @item.should_not be_valid
+        @item.errors.on(:other_image).should be_nil
+        @item.errors.on(:yet_another_image).should == "doesn't have the correct MIME-type. It needs to be 'how/special', but was 'wrong/type'"
+      end
+
+      it "should include standard extra options like 'if' on mime type validation" do
+        @item.should_receive(:its_friday).and_return(false)
+        @item.preview_image = "WRONG TYPE"
+        @item.should be_valid
+      end
+    
+      it "should require either :as or :in as an argument" do
+        lambda{
+          Item.class_eval do
+            validates_mime_type_of :preview_image
+          end
+        }.should raise_error(ArgumentError)
+      end
+
+    end
+
+  end
+
+  describe "magic attributes" do
+    
+    before(:each) do
+      @app = Dragonfly::App[:images]
+      custom_analyser = Object.new
+      def custom_analyser.some_analyser_method(temp_object)
+        "abc" + temp_object.data[0..0]
+      end
+      @app.analyser.register(custom_analyser)
+      ActiveRecord::Base.register_dragonfly_app(:image, @app)
+      Item.class_eval do
+        image_accessor :preview_image
+      end
+      @item = Item.new
+    end
+    
+    it "should default the magic attribute as nil" do
+      @item.preview_image_some_analyser_method.should be_nil
+    end
+    
+    it "should set the magic attribute when assigned" do
+      @item.preview_image = '123'
+      @item.preview_image_some_analyser_method.should == 'abc1'
+    end
+    
+    it "should not set non-magic attributes with the same prefix when assigned" do
+      @item.preview_image_blah_blah = 'wassup'
+      @item.preview_image = '123'
+      @item.preview_image_blah_blah.should == 'wassup'
+    end
+    
+    it "should update the magic attribute when something else is assigned" do
+      @item.preview_image = '123'
+      @item.preview_image = '456'
+      @item.preview_image_some_analyser_method.should == 'abc4'
+    end
+    
+    it "should reset the magic attribute when set to nil" do
+      @item.preview_image = '123'
+      @item.preview_image = nil
+      @item.preview_image_some_analyser_method.should be_nil
+    end
+    
+    it "should not reset non-magic attributes with the same prefix when set to nil" do
+      @item.preview_image_blah_blah = 'wassup'
+      @item.preview_image = '123'
+      @item.preview_image = nil
+      @item.preview_image_blah_blah.should == 'wassup'
+    end
+    
+    it "should work for size too" do
+      @item.preview_image = '123'
+      @item.preview_image_size.should == 3
+    end
+    
+  end
+
+end

data/spec/dragonfly/active_record_extensions/models.rb

@@ -0,0 +1,2 @@
+class Item < ActiveRecord::Base
+end

data/spec/dragonfly/active_record_extensions/spec_helper.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'active_record'
+
+DB_FILE = File.expand_path(File.dirname(__FILE__)+'/db.sqlite3')
+
+%w{migration initializer models}.each do |file|
+  require "#{File.dirname(__FILE__)}/#{file}"
+end 
+
+Spec::Runner.configure do |config|
+  
+  config.before(:all) do
+    FileUtils.rm_f(DB_FILE)
+    ActiveRecord::Base.establish_connection(
+       :adapter => "sqlite3",
+       :database  => DB_FILE
+     )
+     MigrationForTest.verbose = false
+     MigrationForTest.up
+  end
+  
+end

data/spec/dragonfly/analysis/analyser_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+class ImageAnalyser < Dragonfly::Analysis::Base
+
+  def width(temp_object)
+    temp_object.data.length
+  end
+
+  def mime_type(temp_object)
+    return 'image/fart' if temp_object.data == 'THIS IS AN IMAGE'
+    return 'image/pdf' if temp_object.data == 'THIS IS A PDF'
+  end
+
+end
+
+class PdfAnalyser < Dragonfly::Analysis::Base
+
+  def pdf_type(temp_object)
+    'egg'
+  end
+
+  def mime_type(temp_object)
+    'application/pdf' if temp_object.data == 'THIS IS A PDF'
+  end
+
+end
+
+describe Dragonfly::Analysis::Analyser do
+  
+  describe "mime_type" do
+    
+    before(:each) do
+      @analyser = Dragonfly::Analysis::Analyser.new
+      @image = Dragonfly::TempObject.new("THIS IS AN IMAGE")
+      @pdf = Dragonfly::TempObject.new("THIS IS A PDF")
+    end
+    
+    describe "when no analysers have been registered" do
+
+      it "should return nil when no modules have been registered" do
+        @analyser.mime_type(@image).should be_nil
+      end
+
+      it "should should return analysis methods as an empty array" do
+        @analyser.analysis_methods.should == []
+      end
+      
+    end
+    
+    describe "after registering a number of modules" do
+
+      before(:each) do
+        @analyser.register(ImageAnalyser.new)
+        @analyser.register(PdfAnalyser.new)
+      end
+
+      it "should return the correct value when one of the modules returns non-nil" do
+        @analyser.mime_type(@image).should == 'image/fart'
+      end
+    
+      it "should override the first registered modules's value with the second, when they both return non-nil" do
+        @analyser.mime_type(@pdf).should == 'application/pdf'
+      end
+
+      it "should return all the analysis methods" do
+        @analyser.analysis_methods.sort.should == ['mime_type', 'pdf_type', 'width']
+      end
+      
+      it "should say if if has an analysis method (as a symbol)" do
+        @analyser.has_analysis_method?('pdf_type').should be_true
+      end
+
+      it "should say if if has an analysis method (as a string)" do
+        @analyser.has_analysis_method?(:pdf_type).should be_true
+      end
+
+      it "should delegate the call of a method to the registered analysers" do
+        @analyser.width(@image).should == 16
+      end
+
+    end
+    
+  end
+  
+end

data/spec/dragonfly/analysis/r_magick_analyser_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Dragonfly::Analysis::RMagickAnalyser do
+  
+  before(:each) do
+    image_path = File.dirname(__FILE__) + '/../../../samples/beach.png'
+    @beach = Dragonfly::TempObject.new(File.new(image_path))
+    @analyser = Dragonfly::Analysis::RMagickAnalyser.new
+  end
+
+  it "should return the width" do
+    @analyser.width(@beach).should == 280
+  end
+  
+  it "should return the height" do
+    @analyser.height(@beach).should == 355
+  end
+  
+  it "should return the mime type" do
+    @analyser.mime_type(@beach).should == 'image/png'
+  end
+  
+  it "should return nil if it doesn't know the mime type" do
+    @analyser.mime_type(Dragonfly::TempObject.new('asdf')).should be_nil
+  end
+  
+  it "should return the number of colours" do
+    @analyser.number_of_colours(@beach).should == 34703
+  end
+  
+  it "should return the depth" do
+    @analyser.depth(@beach).should == 8
+  end
+  
+end