bulldog 0.0.1

data/spec/unit/processor/image_magick_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+describe Processor::ImageMagick do
+  use_model_class(:Thing, :attachment_file_name => :string)
+
+  before do
+    spec = self
+    Thing.has_attachment :attachment do
+      path "#{spec.temporary_directory}/attachment.:style.:extension"
+    end
+    thing = Thing.create(:attachment => test_image_file('test.jpg'))
+    @thing = Thing.find(thing.id)
+  end
+
+  def convert
+    Processor::ImageMagick.convert_command
+  end
+
+  def original_path
+    "#{temporary_directory}/attachment.original.jpg"
+  end
+
+  def output_path(style_name=:output)
+    "#{temporary_directory}/attachment.#{style_name}.jpg"
+  end
+
+  def configure(&block)
+    Thing.attachment_reflections[:attachment].configure(&block)
+  end
+
+  def style(name, attributes={})
+    configure do
+      style name, attributes
+    end
+  end
+
+  def process(&block)
+    configure do
+      process(:on => :event, :with => :image_magick, &block)
+    end
+    @thing.attachment.process(:event)
+  end
+
+  describe "#dimensions" do
+    it "should yield the dimensions of the input file at that point in the processing pipeline if a block is given" do
+      style :output
+      values = []
+      process do
+        dimensions do |*args|
+          values << args
+        end
+      end
+      styles = Thing.attachment_reflections[:attachment].styles.to_a
+      values.should == [[styles, 40, 30]]
+    end
+
+    it "should yield the dimensions once per branch if called with a block after a branch in the pipeline" do
+      style :small, :size => '4x3'
+      style :large, :size => '400x300'
+      values = []
+      process do
+        resize
+        dimensions do |*args|
+          values << args
+        end
+      end
+      styles = Thing.attachment_reflections[:attachment].styles
+      values.should have(2).sets_of_arguments
+      values[0].should == [[styles[:small]], 4, 3]
+      values[1].should == [[styles[:large]], 400, 300]
+    end
+  end
+
+  describe "#process" do
+    it "should run convert if no block is given" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", output_path).returns('')
+      process
+    end
+
+    it "should use the given :quality style attribute" do
+      style :output, :quality => 50
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-quality', '50', output_path).returns('')
+      process
+    end
+
+    it "should use the :colorspace style attribute" do
+      style :output, :colorspace => 'rgb'
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-colorspace', 'rgb', output_path).returns('')
+      process
+    end
+
+    it "should use the :format style attribute to set the file extension if it's specified by the :extension interpolation key" do
+      style :output, :format => 'png'
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", output_path.sub(/jpg\z/, 'png')).returns('')
+      process
+    end
+
+    it "should log the command run if a logger is set" do
+      style :output
+      log_path = "#{temporary_directory}/log"
+      open(log_path, 'w') do |file|
+        Bulldog.logger = Logger.new(file)
+        process
+      end
+      File.read(log_path).should include("[Bulldog] Running: #{convert}")
+    end
+
+    it "should not blow up if the logger is set to nil" do
+      style :output
+      Bulldog.logger = nil
+      lambda{process}.should_not raise_error
+    end
+  end
+
+  describe "#resize" do
+    it "should resize the images to the style's size" do
+      style :output, :size => '10x10'
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-resize', '10x10', output_path).returns('')
+      process{resize}
+    end
+  end
+
+  describe "#auto_orient" do
+    it "should auto-orient the images" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-auto-orient', output_path).returns('')
+      process{auto_orient}
+    end
+  end
+
+  describe "#strip" do
+    it "should strip the images" do
+      style :output, :size => '10x10'
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-strip', output_path).returns('')
+      process{strip}
+    end
+  end
+
+  describe "#flip" do
+    it "should flip the image vertically" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-flip', output_path).returns('')
+      process{flip}
+    end
+  end
+
+  describe "#flop" do
+    it "should flip the image horizontally" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-flop', output_path).returns('')
+      process{flop}
+    end
+  end
+
+  describe "#thumbnail" do
+    describe "for filled styles" do
+      it "should resize the image to fill the rectangle of the specified size and crop off the edges" do
+        style :output, :size => '10x10', :filled => true
+        Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-resize', '10x10^',
+          '-gravity', 'Center', '-crop', '10x10+0+0', '+repage', output_path).returns('')
+        process{thumbnail}
+      end
+    end
+
+    describe "for unfilled styles" do
+      it "should resize the image to fit inside the specified box size" do
+        style :output, :size => '10x10'
+        Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-resize', '10x10', output_path).returns('')
+        process{thumbnail}
+      end
+    end
+  end
+
+  describe "#rotate" do
+    it "should rotate the image by the given angle" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-rotate', '90', output_path).returns('')
+      process{rotate 90}
+    end
+
+    it "should allow the angle to be given by a string" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-rotate', '90', output_path).returns('')
+      process{rotate '90'}
+    end
+
+    it "should not perform any rotation if the given angle is zero" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", output_path).returns('')
+      process{rotate 0}
+    end
+
+    it "should not perform any rotation if the given angle is blank" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", output_path).returns('')
+      process{rotate ''}
+    end
+  end
+
+  describe "#crop" do
+    it "should crop the image by the given size and origin, and repage" do
+      style :output
+      Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-crop', '10x20+30-40', '+repage', output_path).returns('')
+      process do
+        crop(:size => '10x20', :origin => '30,-40')
+      end
+    end
+  end
+
+  it "should extract a common prefix if there are multiple styles which start with the same operations" do
+    Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-auto-orient',
+      '(', '+clone', '-resize', '100x100', '-write', output_path(:big), '+delete', ')', '-resize', '40x40', output_path(:small)).returns('')
+    style :big, :size => '100x100'
+    style :small, :size => '40x40'
+    process do
+      auto_orient
+      resize
+    end
+  end
+
+  it "should handle a complex tree of arguments optimally" do
+    # The tree:
+    #   auto-orient
+    #     resize 10x20
+    #       flip        [:a]
+    #       flop        [:b]
+    #     flip
+    #       strip       [:c]
+    #       quality 75  [:d]
+    Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-auto-orient',
+      '(', '+clone', '-resize', '10x20', '(', '+clone', '-flip', '-write', output_path(:a), '+delete', ')',
+                                              '-flop', '-write', output_path(:b), '+delete', ')',
+      '-flip', '(', '+clone', '-flop', '-write', output_path(:c), '+delete', ')',
+                               '-quality', '75', output_path(:d)).returns('')
+    style :a, :size => '10x20'
+    style :b, :size => '10x20'
+    style :c, :size => '30x40'
+    style :d, :size => '30x40', :quality => 75
+    process do
+      auto_orient
+      resize if [:a, :b].include?(style.name)
+      flip unless style.name == :b
+      flop if [:b, :c].include?(style.name)
+    end
+  end
+
+  it "should allow specifying operations for some styles only by checking #style" do
+    Bulldog.expects(:run).once.with(convert, "#{original_path}[0]", '-auto-orient',
+      '(', '+clone', '-flip', '-write', output_path(:flipped), '+delete', ')',
+      '-flop', output_path(:flopped)).returns('')
+    style :flipped, :path => '/tmp/flipped.jpg'
+    style :flopped, :path => '/tmp/flopped.jpg'
+    process do
+      auto_orient
+      flip if style.name == :flipped
+      flop if style.name == :flopped
+    end
+  end
+end

data/spec/unit/processor/one_shot_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Processor::OneShot do
+  use_model_class(:Thing)
+
+  before do
+    Thing.has_attachment :attachment
+    @thing = Thing.create(:attachment => test_empty_file)
+  end
+
+  def configure(&block)
+    Thing.attachment_reflections[:attachment].configure(&block)
+  end
+
+  def process(&block)
+    configure do
+      process(:on => :event, :with => :one_shot, &block)
+    end
+    @thing.attachment.process(:event)
+  end
+
+  describe "any one shot processor", :shared => true do
+    it "should run the process block exactly once" do
+      num_runs = 0
+      process do
+        num_runs += 1
+      end
+      num_runs.should == 1
+    end
+
+    it "should provide no styles to the process block" do
+      styles = nil
+      process do
+        styles = self.styles
+      end
+      styles.should be_empty
+    end
+
+    it "should provide no style to the process block" do
+      style = nil
+      process do
+        style = self.style
+      end
+      style.should be_nil
+    end
+
+    it "should provide no output files to the process block" do
+      output_file = nil
+      process do
+        output_file = self.output_file(:one)
+      end
+      output_file.should be_nil
+    end
+  end
+
+  describe "when there are no styles defined" do
+    it_should_behave_like "any one shot processor"
+  end
+
+  describe "when there are multiple styles defined" do
+    before do
+      configure do
+        style :one
+        style :two
+      end
+    end
+
+    it_should_behave_like "any one shot processor"
+  end
+end

data/spec/unit/reflection_spec.rb

@@ -0,0 +1,338 @@
+require 'spec_helper'
+
+describe Reflection do
+  use_model_class(:Thing,
+                  :photo_file_name => :string,
+                  :photo_content_type => :string,
+                  :custom_file_name => :string,
+                  :custom_content_type => :string)
+
+  def reflection
+    Thing.attachment_reflections[:photo]
+  end
+
+  describe "#configure" do
+    it "should append the configuration to any existing configuration" do
+      Thing.has_attachment :photo do
+        path "/custom/path"
+      end
+      Thing.attachment_reflections[:photo].configure do
+        url "/custom/url"
+      end
+      reflection.path_template.should == "/custom/path"
+      reflection.url_template.should == "/custom/url"
+    end
+
+    it "should overwrite any configuration items specified in later blocks" do
+      Thing.has_attachment :photo do
+        path "/custom/path"
+      end
+      Thing.has_attachment :photo do
+        path "/new/custom/path"
+      end
+      reflection.path_template.should == "/new/custom/path"
+    end
+  end
+
+  describe "configuration" do
+    # TODO: Restructure the tests so we test by configuration method,
+    # not reflection method.
+    describe "#process_once" do
+      it "should add a process event with a one_shot processor" do
+        Thing.has_attachment :photo do
+          process_once(:on => :test_event){}
+        end
+        events = reflection.events[:test_event]
+        events.map(&:processor_type).should == [:one_shot]
+      end
+
+      it "should raise an ArgumentError if a processor is specified" do
+        block_run = false
+        spec = self
+        Thing.has_attachment :photo do
+          block_run = true
+          lambda{process_once(:with => :image_magick){}}.should spec.raise_error(ArgumentError)
+        end
+        block_run.should be_true
+      end
+
+      it "should raise an ArgumentError if styles are specified" do
+        block_run = false
+        spec = self
+        Thing.has_attachment :photo do
+          block_run = true
+          style :one
+          lambda{process_once(:styles => [:one]){}}.should spec.raise_error(ArgumentError)
+        end
+        block_run.should be_true
+      end
+    end
+  end
+
+  describe "#path_template" do
+    describe "when a path has been confired for the attachment" do
+      before do
+        Thing.has_attachment :photo do
+          path "/configured/path"
+        end
+      end
+
+      it "should return the configured path" do
+        reflection.path_template.should == "/configured/path"
+      end
+    end
+
+    describe "when no path has been configured for the attachment, and there is a default path template" do
+      use_temporary_attribute_value Bulldog, :default_path_template, "/default/path/template"
+
+      before do
+        Thing.has_attachment :photo
+      end
+
+      it "should return the default path template" do
+        reflection.path_template.should == "/default/path/template"
+      end
+    end
+
+    describe "when no path has been configured, and there is no default path template" do
+      use_temporary_attribute_value Bulldog, :default_path_template, nil
+
+      before do
+        Thing.has_attachment :photo do
+          url "/configured/url"
+        end
+      end
+
+      it "should return the URL prefixed with the public path" do
+        reflection.path_template.should == ":public_path/configured/url"
+      end
+    end
+  end
+
+  describe "#url_template" do
+    describe "when an URL has been configured for the attachment" do
+      before do
+        Thing.has_attachment :photo do
+          url "/path/to/somewhere"
+        end
+      end
+
+      it "should return the configured URL template" do
+        reflection.url_template.should == "/path/to/somewhere"
+      end
+    end
+
+    describe "when no URL has been configured for the attachment" do
+      use_temporary_attribute_value Bulldog, :default_url_template, "/default/url/template"
+
+      before do
+        Thing.has_attachment :photo
+      end
+
+      it "should return the default URL template" do
+        reflection.url_template.should == "/default/url/template"
+      end
+    end
+  end
+
+  describe "#style" do
+    it "should return the set of styles" do
+      Thing.has_attachment :photo do
+        style :small, :size => '32x32'
+        style :large, :size => '512x512'
+      end
+      reflection.styles.should == StyleSet[
+        Style.new(:small, {:size => '32x32'}),
+        Style.new(:large, {:size => '512x512'}),
+      ]
+    end
+  end
+
+  describe "#default_style" do
+    it "should return the configured default_style" do
+      Thing.has_attachment :photo do
+        style :small, :size => '32x32'
+        default_style :small
+      end
+      reflection.default_style.should == :small
+    end
+
+    it "should default to :original" do
+      Thing.has_attachment :photo
+      reflection.default_style.should == :original
+    end
+
+    it "should raise an error if the configured default_style is invalid" do
+      Thing.has_attachment :photo do
+        default_style :bad
+      end
+      lambda{reflection.default_style}.should raise_error(Error)
+    end
+  end
+
+  describe "#events" do
+    it "should return the map of configured events" do
+      Thing.has_attachment :photo do
+        process(:on => :test_event){}
+      end
+      events = reflection.events[:test_event]
+      events.should have(1).event
+      events.first.should be_a(Reflection::Event)
+    end
+
+    it "should provide access to the processor type of each event" do
+      Thing.has_attachment :photo do
+        process(:on => :test_event, :with => :test){}
+      end
+      event = reflection.events[:test_event].first
+      event.processor_type.should == :test
+    end
+
+    it "should have nil as the processor type if the default processor type is to be used" do
+      Thing.has_attachment :photo do
+        process(:on => :test_event){}
+      end
+      event = reflection.events[:test_event].first
+      event.processor_type.should be_nil
+    end
+
+    it "should have the configured styles" do
+      Thing.has_attachment :photo do
+        style :small, :size => '10x10'
+        style :large, :size => '1000x1000'
+        process(:on => :test_event, :styles => [:small]){}
+      end
+      event = reflection.events[:test_event].first
+      event.styles.should == [:small]
+    end
+
+    it "should provide access to the callback of each event" do
+      Thing.has_attachment :photo do
+        process(:on => :test_event){}
+      end
+      event = reflection.events[:test_event].first
+      event.callback.should be_a(Proc)
+    end
+  end
+
+  describe "#detect_type_by" do
+    describe "when configured with a symbol" do
+      it "should use the named registered type detection proc" do
+        args = nil
+        Bulldog::Reflection.to_detect_type_by :test_detector do |*args|
+          :type
+        end
+        Thing.has_attachment :photo do
+          detect_type_by :test_detector
+        end
+
+        thing = Thing.new
+        stream = mock
+        reflection.detect_attachment_type(thing, stream).should == :type
+        args.should == [thing, :photo, stream]
+      end
+    end
+
+    describe "when configured with a block" do
+      it "should call the given block" do
+        Thing.has_attachment :photo do
+          detect_type_by{:type}
+        end
+        reflection.detect_attachment_type(Thing.new, mock).should == :type
+      end
+    end
+
+    describe "when configured with a BoundMethod" do
+      it "should call the given method" do
+        Thing.stubs(:detect_type).returns(:type)
+        Thing.has_attachment :photo do
+          detect_type_by Thing.method(:detect_type)
+        end
+        reflection.detect_attachment_type(Thing.new, mock).should == :type
+      end
+    end
+
+    describe "when configured with a proc" do
+      it "should call the given proc" do
+        Thing.has_attachment :photo do
+          detect_type_by lambda{:type}
+        end
+        reflection.detect_attachment_type(Thing.new, mock).should == :type
+      end
+    end
+
+    describe "when configured with both an argument and a block" do
+      it "should raise an ArgumentError" do
+        block_run = false
+        spec = self
+        Thing.has_attachment :photo do
+          block_run = true
+          lambda do
+            detect_type_by(lambda{:type}){:type}
+          end.should spec.raise_error(ArgumentError)
+        end
+        block_run.should be_true
+      end
+    end
+
+    describe "when configured with #type" do
+      it "should return the given type" do
+        Thing.has_attachment :photo do
+          type :type
+        end
+        reflection.detect_attachment_type(Thing.new, mock).should == :type
+      end
+    end
+  end
+
+  describe "#stored_attributes" do
+    it "should return the configured stored attributes" do
+      Thing.has_attachment :photo do
+        store_attributes(
+          :file_name => :custom_file_name,
+          :content_type => :custom_content_type
+        )
+      end
+      reflection.stored_attributes.should == {
+          :file_name => :custom_file_name,
+          :content_type => :custom_content_type
+      }
+    end
+
+    it "should allow a shortcut if the field names follow convention" do
+      Thing.has_attachment :photo do
+        store_attributes :file_name, :content_type
+      end
+      reflection.stored_attributes.should == {
+        :file_name => :photo_file_name,
+        :content_type => :photo_content_type,
+      }
+    end
+  end
+
+  describe "#column_name_for_stored_attribute" do
+    it "should return nil if the stored attribute has been explicitly mapped to nil" do
+      Thing.has_attachment :photo do
+        store_attributes :file_name => nil
+      end
+      reflection.column_name_for_stored_attribute(:file_name).should be_nil
+    end
+
+    it "should return the column specified if has been mapped to a column name" do
+      Thing.has_attachment :photo do
+        store_attributes :file_name => :photo_content_type
+      end
+      reflection.column_name_for_stored_attribute(:file_name).should == :photo_content_type
+    end
+
+    it "should return the default column name if the stored attribute is unspecified, and the column exists" do
+      Thing.has_attachment :photo
+      reflection.column_name_for_stored_attribute(:file_name).should == :photo_file_name
+    end
+
+    it "should return nil if the stored attribute is unspecified, and the column does not exist" do
+      Thing.has_attachment :photo
+      reflection.column_name_for_stored_attribute(:file_size).should be_nil
+    end
+  end
+end