classiccms 0.2.4.pre → 0.3.0

data/vendor/bundle/gems/dragonfly-0.9.12/spec/dragonfly/active_model_extensions/spec_helper.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'active_model'
+
+# --------------------------------------------------------------- #
+# MODELS
+# --------------------------------------------------------------- #
+class MyModel
+  
+  # Callbacks
+  extend ActiveModel::Callbacks
+  define_model_callbacks :save, :destroy
+  
+  include ActiveModel::Validations
+  include ActiveModel::Dirty
+  
+  class << self
+    def create!(attrs={})
+      new(attrs).save!
+    end
+    
+    def find(id)
+      new(instances[id])
+    end
+    
+    def instances
+      @instances ||= {}
+    end
+  end
+
+  def initialize(attrs={})
+    attrs.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+  
+  attr_accessor :id
+  
+  def to_hash
+    self.class::ATTRIBUTES.inject({}) do |hash, attr|
+      hash[attr] = send(attr)
+      hash
+    end
+  end
+  
+  def save
+    _run_save_callbacks {
+      self.id ||= rand(1000)
+      self.class.instances[id] = self.to_hash
+    }
+  end
+  def save!
+    save
+    self
+  end
+  
+  def destroy
+    _run_destroy_callbacks {}
+  end
+end
+
+class Item < MyModel
+  
+  ATTRIBUTES = [
+    :title,
+    :preview_image_uid,
+    :preview_image_some_analyser_method,
+    :preview_image_size,
+    :preview_image_name,
+    :preview_image_blah_blah,
+    :other_image_uid,
+    :yet_another_image_uid,
+    :otra_imagen_uid,
+    :trailer_video_uid,
+    :created_at,
+    :updated_at
+  ]
+  define_attribute_methods ATTRIBUTES
+  attr_accessor *ATTRIBUTES
+end
+
+class Car < MyModel
+  ATTRIBUTES = [
+    :image_uid,
+    :reliant_image_uid,
+    :type
+  ]
+  define_attribute_methods ATTRIBUTES
+  attr_accessor *ATTRIBUTES
+end
+
+class Photo < MyModel
+  ATTRIBUTES = [:image_uid]
+  define_attribute_methods ATTRIBUTES
+  attr_accessor *ATTRIBUTES
+end

data/vendor/bundle/gems/dragonfly-0.9.12/spec/dragonfly/analyser_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Dragonfly::Analyser do
+  
+  before(:each) do
+    @analyser = Dragonfly::Analyser.new
+    @analyser.log = Logger.new(LOG_FILE)
+  end
+  
+  describe "analysis_methods module" do
+    
+    before(:each) do
+      @analyser.add(:num_letters){|temp_object, letter| temp_object.data.count(letter) }
+      @obj = Object.new
+      @obj.extend @analyser.analysis_methods
+    end
+    
+    it "should return a module" do
+      @analyser.analysis_methods.should be_a(Module)
+    end
+    
+    it "should provide the object with the analyser method" do
+      @obj.analyser.should == @analyser
+    end
+    
+    it "should provide the object with the direct analysis method, provided that analyse method exists" do
+      def @obj.analyse(meth, *args)
+        analyser.analyse Dragonfly::TempObject.new('HELLO'), meth, *args
+      end
+      @obj.num_letters('L').should == 2
+    end
+    
+  end
+  
+  describe "analyse" do
+    it "should return nil if the function isn't defined" do
+      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
+    end
+    it "should return nil if the function can't be handled" do
+      @analyser.add(:width){ throw :unable_to_handle }
+      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
+    end
+  end
+  
+  describe "analysis_method_names" do
+    it "should return the analysis methods" do
+      @analyser.add(:width){}
+      @analyser.add(:height){}
+      @analyser.analysis_method_names.should == [:width, :height]
+    end
+  end
+  
+  describe "cache" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('HELLO')
+    end
+
+    def it_should_analyse_using(meth, temp_object, *args)
+      result = mock('result')
+      @analyser.should_receive(:call_last).with(meth, temp_object, *args).exactly(:once).and_return result
+      @analyser.analyse(temp_object, meth, *args).should == result
+      result
+    end
+
+    it "should do the analysis the first time" do
+      it_should_analyse_using(:blah, @temp_object, :arg1)
+    end
+
+    describe "when already called" do
+      before(:each) do
+        @result = it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+
+      it "should not do it subsequent times but still return the result" do
+        @analyser.should_not_receive(:call_last)
+        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
+        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
+      end
+      
+      it "should not use the cache if the temp_object is different" do
+        temp_object = Dragonfly::TempObject.new('aaa')
+        it_should_analyse_using(:blah, temp_object, :arg1)
+      end
+      
+      it "should not use the cache if the method name is different" do
+        it_should_analyse_using(:egghead, @temp_object, :arg1)
+      end
+      
+      it "should not use the cache if the args are different" do
+        it_should_analyse_using(:blah, @temp_object, :arg2)
+      end
+      
+      it "should do it again if the cache has been cleared" do
+        @analyser.clear_cache!
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+
+      it "should not use the cache if it has been turned off" do
+        @analyser.enable_cache = false
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+      
+    end
+
+    describe "cache size" do
+      it "should not exceed the cache size" do
+        @analyser.cache_size = 2
+
+        res1 = it_should_analyse_using(:blah, @temp_object, :arg1)
+        res2 = it_should_analyse_using(:blah, @temp_object, :arg2)
+        res3 = it_should_analyse_using(:blah, @temp_object, :arg3) # Should kick out first one
+        
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+
+        # Third analysis should still be cached
+        @analyser.should_not_receive(:call_last)
+        @analyser.analyse(@temp_object, :blah, :arg3).should == res3
+      end
+    end
+
+  end
+  
+end

data/vendor/bundle/gems/dragonfly-0.9.12/spec/dragonfly/analysis/file_command_analyser_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+png_path = File.dirname(__FILE__) + '/../../../samples/egg.png'
+
+describe Dragonfly::Analysis::FileCommandAnalyser do
+  
+  before(:each) do
+    pending "not applicable to windows" if Dragonfly.running_on_windows?
+    @analyser = Dragonfly::Analysis::FileCommandAnalyser.new
+  end
+  
+  describe "mime_type" do
+    
+    describe "when using the filesystem" do
+      before(:each) do
+        @analyser.use_filesystem = true
+        @temp_object = Dragonfly::TempObject.new(File.new(png_path))
+      end
+      it "should give the mime-type" do
+        @analyser.mime_type(@temp_object).should == 'image/png'
+      end
+      it "should not have initialized the data string" do
+        @analyser.mime_type(@temp_object)
+        @temp_object.instance_eval{@data}.should be_nil
+      end
+    end
+    
+    describe "when not using the filesystem" do
+      before(:each) do
+        @analyser.use_filesystem = false
+        @temp_object = Dragonfly::TempObject.new(File.read(png_path))
+      end
+      it "should give the mime-type" do
+        @analyser.mime_type(@temp_object).should == 'image/png'
+      end
+      it "should not have initialized the file" do
+        @analyser.mime_type(@temp_object)
+        @temp_object.instance_eval{@tempfile}.should be_nil
+      end
+      it "should work properly (without a broken pipe error) for big files of format jpg" do
+        data = Dragonfly::ImageMagick::Generator.new.plasma(1000, 1000, :jpg).first
+        temp_object = Dragonfly::TempObject.new(data)
+        @analyser.mime_type(temp_object).should == "image/jpeg"
+      end
+    end
+  
+  end
+  
+end

data/vendor/bundle/gems/dragonfly-0.9.12/spec/dragonfly/app_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+require 'rack/mock'
+
+def request(app, path)
+  Rack::MockRequest.new(app).get(path)
+end
+
+describe Dragonfly::App do
+
+  describe ".instance" do
+
+    it "should create a new instance if it didn't already exist" do
+      app = Dragonfly::App.instance(:images)
+      app.should be_a(Dragonfly::App)
+    end
+
+    it "should return an existing instance if called by name" do
+      app = Dragonfly::App.instance(:images)
+      Dragonfly::App.instance(:images).should == app
+    end
+
+    it "should also work using square brackets" do
+      Dragonfly[:images].should == Dragonfly::App.instance(:images)
+    end
+
+  end
+
+  describe ".new" do
+    it "should not be callable" do
+      lambda{
+        Dragonfly::App.new
+      }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "mime types" do
+    describe "#mime_type_for" do
+      before(:each) do
+        @app = test_app
+      end
+      it "should return the correct mime type for a symbol" do
+        @app.mime_type_for(:png).should == 'image/png'
+      end
+      it "should work for strings" do
+        @app.mime_type_for('png').should == 'image/png'
+      end
+      it "should work with uppercase strings" do
+        @app.mime_type_for('PNG').should == 'image/png'
+      end
+      it "should work with a dot" do
+        @app.mime_type_for('.png').should == 'image/png'
+      end
+      it "should return nil if not known" do
+        @app.mime_type_for(:mark).should be_nil
+      end
+      it "should allow for configuring extra mime types" do
+        @app.register_mime_type 'mark', 'application/mark'
+        @app.mime_type_for(:mark).should == 'application/mark'
+      end
+      it "should override existing mime types when registered" do
+        @app.register_mime_type :png, 'ping/pong'
+        @app.mime_type_for(:png).should == 'ping/pong'
+      end
+      it "should have a per-app mime-type configuration" do
+        other_app = Dragonfly[:other_app]
+        @app.register_mime_type(:mark, 'first/one')
+        other_app.register_mime_type(:mark, 'second/one')
+        @app.mime_type_for(:mark).should == 'first/one'
+        other_app.mime_type_for(:mark).should == 'second/one'
+      end
+    end
+  end
+
+  describe "remote_url_for" do
+    before(:each) do
+      @app = test_app
+      @app.datastore = Object.new
+    end
+    it "should raise an error if the datastore doesn't provide it" do
+      lambda{
+        @app.remote_url_for('some_uid')
+      }.should raise_error(NotImplementedError)
+    end
+    it "should correctly call it if the datastore provides it" do
+      @app.datastore.should_receive(:url_for).with('some_uid', :some => :opts).and_return 'http://egg.head'
+      @app.remote_url_for('some_uid', :some => :opts).should == 'http://egg.head'
+    end
+  end
+
+  describe "#store" do
+    before(:each) do
+      @app = test_app
+    end
+    it "should allow just storing content" do
+      @app.datastore.should_receive(:store).with(a_temp_object_with_data("HELLO"), {})
+      @app.store("HELLO")
+    end
+    it "should allow storing using a TempObject" do
+      temp_object = Dragonfly::TempObject.new("HELLO")
+      @app.datastore.should_receive(:store).with(temp_object, {})
+      @app.store(temp_object)
+    end
+    it "should allow storing with extra stuff" do
+      @app.datastore.should_receive(:store).with do |temp_object, opts|
+        temp_object.data.should == 'HELLO'
+        temp_object.meta.should == {:egg => :head}
+        opts[:option].should == :blarney
+      end
+      @app.store("HELLO", :meta => {:egg => :head}, :option => :blarney)
+    end
+    it "should still pass in meta in the opts arg, for deprecated use of meta" do
+      @app.datastore.should_receive(:store).with do |temp_object, opts|
+        opts[:meta].should == {:egg => :head}
+      end
+      @app.store("HELLO", :meta => {:egg => :head}, :option => :blarney)
+    end
+  end
+
+  describe "url_for" do
+    before(:each) do
+      @app = test_app
+      @job = @app.fetch('eggs')
+    end
+    it "should give the server url by default" do
+      @app.url_for(@job).should =~ %r{^/\w+$}
+    end
+    it "should allow configuring" do
+      @app.configure do |c|
+        c.define_url do |app, job, opts|
+          "doogies"
+        end
+      end
+      @app.url_for(@job).should == 'doogies'
+    end
+    it "should yield the correct dooberries" do
+      @app.define_url do |app, job, opts|
+        [app, job, opts]
+      end
+      @app.url_for(@job, {'chuddies' => 'margate'}).should == [@app, @job, {'chuddies' => 'margate'}]
+    end
+  end
+
+  describe "reflection methods" do
+    before(:each) do
+      @app = test_app.configure do |c|
+        c.processor.add(:milk){}
+        c.generator.add(:butter){}
+        c.analyser.add(:cheese){}
+        c.job(:bacon){}
+      end
+      
+    end
+    it "should return processor methods" do
+      @app.processor_methods.should == [:milk]
+    end
+    it "should return generator methods" do
+      @app.generator_methods.should == [:butter]
+    end
+    it "should return analyser methods" do
+      @app.analyser_methods.should == [:cheese]
+    end
+    it "should return job methods" do
+      @app.job_methods.should == [:bacon]
+    end
+  end
+
+  describe "inspect" do
+    it "should give a neat output" do
+      Dragonfly[:hello].inspect.should == "<Dragonfly::App name=:hello >"
+    end
+  end
+
+end