dragonfly 0.9.15 → 1.0

data/spec/dragonfly/image_magick/analysers/image_properties_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Dragonfly::ImageMagick::Analysers::ImageProperties do
+
+  let(:app) { test_imagemagick_app }
+  let(:analyser) { Dragonfly::ImageMagick::Analysers::ImageProperties.new }
+  let(:content) { Dragonfly::Content.new(app, SAMPLES_DIR.join('beach.png')) } # 280x355
+
+  describe "call" do
+    it "returns a hash of properties" do
+      analyser.call(content).should == {
+        'width' => 280,
+        'height' => 355,
+        'format' => 'png'
+      }
+    end
+  end
+
+end
+

data/spec/dragonfly/image_magick/generators/convert_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Dragonfly::ImageMagick::Generators::Convert do
+  let (:generator) { Dragonfly::ImageMagick::Generators::Convert.new }
+  let (:app) { test_app }
+  let (:image) { Dragonfly::Content.new(app) }
+
+  describe "calling convert" do
+    before(:each) do
+      generator.call(image, "-size 1x1 xc:white", 'png')
+    end
+    it {image.should have_width(1)}
+    it {image.should have_height(1)}
+    it {image.should have_format('png')}
+    it {image.meta.should == {'format' => 'png'}}
+  end
+
+end
+

data/spec/dragonfly/image_magick/generators/plain_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Dragonfly::ImageMagick::Generators::Plain do
+  let (:generator) { Dragonfly::ImageMagick::Generators::Plain.new }
+  let (:app) { test_imagemagick_app }
+  let (:image) { Dragonfly::Content.new(app) }
+
+  describe "of given dimensions" do
+    before(:each) do
+      generator.call(image, 3, 2)
+    end
+    it {image.should have_width(3)}
+    it {image.should have_height(2)}
+    it {image.should have_format('png')}
+    it {image.meta.should == {'format' => 'png', 'name' => 'plain.png'}}
+  end
+
+  describe "specifying the format" do
+    before(:each) do
+      generator.call(image, 1, 1, 'format'=> 'gif')
+    end
+    it {image.should have_format('gif')}
+    it {image.meta.should == {'format' => 'gif', 'name' => 'plain.gif'}}
+  end
+
+  describe "specifying the colour" do
+    it "works with English spelling" do
+      generator.call(image, 1, 1, 'colour' => 'red')
+    end
+
+    it "works with American spelling" do
+      generator.call(image, 1, 1, 'color' => 'red')
+    end
+
+    it "blows up with a bad colour" do
+      expect {
+        generator.call(image, 1, 1, 'colour' => 'lardoin')
+      }.to raise_error(Dragonfly::Shell::CommandFailed)
+    end
+  end
+
+  describe "urls" do
+    it "updates the url" do
+      url_attributes = Dragonfly::UrlAttributes.new
+      generator.update_url(url_attributes, 1, 1, 'format' => 'gif')
+      url_attributes.name.should == 'plain.gif'
+    end
+  end
+
+end

data/spec/dragonfly/image_magick/generators/plasma_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Dragonfly::ImageMagick::Generators::Plasma do
+  let (:generator) { Dragonfly::ImageMagick::Generators::Plasma.new }
+  let (:app) { test_imagemagick_app }
+  let (:image) { Dragonfly::Content.new(app) }
+
+  describe "call" do
+    it "generates a png image" do
+      generator.call(image, 5, 3)
+      image.should have_width(5)
+      image.should have_height(3)
+      image.should have_format('png')
+      image.meta.should == {'format' => 'png', 'name' => 'plasma.png'}
+    end
+
+    it "allows changing the format" do
+      generator.call(image, 1, 1, 'format' => 'jpg')
+      image.should have_format('jpeg')
+      image.meta.should == {'format' => 'jpg', 'name' => 'plasma.jpg'}
+    end
+  end
+
+  describe "urls" do
+    it "updates the url" do
+      url_attributes = Dragonfly::UrlAttributes.new
+      generator.update_url(url_attributes, 1, 1, 'format' => 'jpg')
+      url_attributes.name.should == 'plasma.jpg'
+    end
+  end
+end
+

data/spec/dragonfly/image_magick/generators/text_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Dragonfly::ImageMagick::Generators::Text do
+  let (:generator) { Dragonfly::ImageMagick::Generators::Text.new }
+  let (:app) { test_imagemagick_app }
+  let (:image) { Dragonfly::Content.new(app) }
+
+  describe "creating a text image" do
+    before(:each) do
+      generator.call(image, "mmm", 'font_size' => 12)
+    end
+    it {image.should have_width(20..40)} # approximate
+    it {image.should have_height(10..20)}
+    it {image.should have_format('png')}
+    it {image.meta.should == {'format' => 'png', 'name' => 'text.png'}}
+  end
+
+  describe "specifying the format" do
+    before(:each) do
+      generator.call(image, "mmm", 'format' => 'gif')
+    end
+    it {image.should have_format('gif')}
+    it {image.meta.should == {'format' => 'gif', 'name' => 'text.gif'}}
+  end
+
+  describe "padding" do
+    before(:each) do
+      image_without_padding = image.clone
+      generator.call(image_without_padding, "mmm", 'font_size' => 12)
+      @width = image_properties(image_without_padding)[:width].to_i
+      @height = image_properties(image_without_padding)[:height].to_i
+    end
+    it "1 number shortcut" do
+      generator.call(image, "mmm", 'padding' => '10')
+      image.should have_width(@width + 20)
+      image.should have_height(@height + 20)
+    end
+    it "2 numbers shortcut" do
+      generator.call(image, "mmm", 'padding' => '10 5')
+      image.should have_width(@width + 10)
+      image.should have_height(@height + 20)
+    end
+    it "3 numbers shortcut" do
+      generator.call(image, "mmm", 'padding' => '10 5 8')
+      image.should have_width(@width + 10)
+      image.should have_height(@height + 18)
+    end
+    it "4 numbers shortcut" do
+      generator.call(image, "mmm", 'padding' => '1 2 3 4')
+      image.should have_width(@width + 6)
+      image.should have_height(@height + 4)
+    end
+    it "should override the general padding declaration with the specific one (e.g. 'padding-left')" do
+      generator.call(image, "mmm", 'padding' => '10', 'padding-left' => 9)
+      image.should have_width(@width + 19)
+      image.should have_height(@height + 20)
+    end
+    it "should ignore 'px' suffixes" do
+      generator.call(image, "mmm", 'padding' => '1px 2px 3px 4px')
+      image.should have_width(@width + 6)
+      image.should have_height(@height + 4)
+    end
+    it "bad padding string" do
+      lambda{
+        generator.call(image, "mmm", 'padding' => '1 2 3 4 5')
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "urls" do
+    it "updates the url" do
+      url_attributes = Dragonfly::UrlAttributes.new
+      generator.update_url(url_attributes, "mmm", 'format' => 'gif')
+      url_attributes.name.should == 'text.gif'
+    end
+  end
+end

data/spec/dragonfly/image_magick/plugin_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe "a configured imagemagick app" do
+
+  let(:app){ test_app.configure_with(:imagemagick) }
+  let(:image){ app.fetch_file(SAMPLES_DIR.join('beach.png')) }
+
+  describe "env variables" do
+    let(:app){ test_app }
+
+    it "allows setting the convert command" do
+      app.configure do
+        plugin :imagemagick, :convert_command => '/bin/convert'
+      end
+      app.env[:convert_command].should == '/bin/convert'
+    end
+
+    it "allows setting the identify command" do
+      app.configure do
+        plugin :imagemagick, :identify_command => '/bin/identify'
+      end
+      app.env[:identify_command].should == '/bin/identify'
+    end
+  end
+
+  describe "analysers" do
+    it "should return the width" do
+      image.width.should == 280
+    end
+
+    it "should return the height" do
+      image.height.should == 355
+    end
+
+    it "should return the aspect ratio" do
+      image.aspect_ratio.should == (280.0/355.0)
+    end
+
+    it "should say if it's portrait" do
+      image.portrait?.should be_true
+      image.portrait.should be_true # for using with magic attributes
+    end
+
+    it "should say if it's landscape" do
+      image.landscape?.should be_false
+      image.landscape.should be_false # for using with magic attributes
+    end
+
+    it "should return the format" do
+      image.format.should == "png"
+    end
+
+    it "should say if it's an image" do
+      image.image?.should be_true
+      image.image.should be_true # for using with magic attributes
+    end
+
+    it "should say if it's not an image" do
+      app.create("blah").image?.should be_false
+    end
+
+    it "should return false for pdfs" do
+      image.encode('pdf').image?.should be_false
+    end
+  end
+
+  describe "processors that change the url" do
+    before do
+      app.configure{ url_format '/:name' }
+    end
+
+    describe "convert" do
+      it "sanity check with format" do
+        thumb = image.convert('-resize 1x1!', 'format' => 'jpg')
+        thumb.url.should =~ /^\/beach\.jpg\?job=\w+/
+        thumb.width.should == 1
+        thumb.format.should == 'jpeg'
+        thumb.meta['format'].should == 'jpg'
+      end
+
+      it "sanity check without format" do
+        thumb = image.convert('-resize 1x1!')
+        thumb.url.should =~ /^\/beach\.png\?job=\w+/
+        thumb.width.should == 1
+        thumb.format.should == 'png'
+        thumb.meta['format'].should be_nil
+      end
+    end
+
+    describe "encode" do
+      it "sanity check" do
+        thumb = image.encode('jpg')
+        thumb.url.should =~ /^\/beach\.jpg\?job=\w+/
+        thumb.format.should == 'jpeg'
+        thumb.meta['format'].should == 'jpg'
+      end
+    end
+  end
+
+  describe "other processors" do
+    describe "encode" do
+      it "should encode the image to the correct format" do
+        image.encode!('gif')
+        image.format.should == 'gif'
+      end
+
+      it "should allow for extra args" do
+        image.encode!('jpg', '-quality 1')
+        image.format.should == 'jpeg'
+        image.size.should < 2000
+      end
+    end
+
+    describe "rotate" do
+      it "should rotate by 90 degrees" do
+        image.rotate!(90)
+        image.width.should == 355
+        image.height.should == 280
+      end
+    end
+
+  end
+
+  describe "identify" do
+    it "gives the output of the command line" do
+      image.identify.should =~ /280/
+      image.identify("-format %h").should == "355\n"
+    end
+  end
+
+end

data/spec/dragonfly/image_magick/processors/convert_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Dragonfly::ImageMagick::Processors::Convert do
+
+  def sample_content(name)
+    Dragonfly::Content.new(app, SAMPLES_DIR.join(name))
+  end
+
+  let(:app){ test_app }
+  let(:image){ sample_content('beach.png') } # 280x355
+  let(:processor){ Dragonfly::ImageMagick::Processors::Convert.new }
+
+  it "should allow for general convert commands" do
+    processor.call(image, '-scale 56x71')
+    image.should have_width(56)
+    image.should have_height(71)
+  end
+
+  it "should allow for general convert commands with added format" do
+    processor.call(image, '-scale 56x71', 'format' => 'gif')
+    image.should have_width(56)
+    image.should have_height(71)
+    image.should have_format('gif')
+    image.meta['format'].should == 'gif'
+  end
+
+  it "should work for commands with parenthesis" do
+    processor.call(image, "\\( +clone -sparse-color Barycentric '0,0 black 0,%[fx:h-1] white' -function polynomial 2,-2,0.5 \\) -compose Blur -set option:compose:args 15 -composite")
+    image.should have_width(280)
+  end
+
+  it "should work for files with spaces in the name" do
+    image = Dragonfly::Content.new(app, SAMPLES_DIR.join('white pixel.png'))
+    processor.call(image, "-resize 2x2!")
+    image.should have_width(2)
+  end
+
+  it "updates the url with format if given" do
+    url_attributes = Dragonfly::UrlAttributes.new
+    processor.update_url(url_attributes, '-scale 56x71', 'format' => 'gif')
+    url_attributes.ext.should == 'gif'
+  end
+
+  it "allows converting specific frames" do
+    gif = sample_content('gif.gif')
+    processor.call(gif, '-resize 50x50')
+    all_frames_size = gif.size
+
+    gif = sample_content('gif.gif')
+    processor.call(gif, '-resize 50x50', 'frame' => 0)
+    one_frame_size = gif.size
+
+    one_frame_size.should < all_frames_size
+  end
+
+end

data/spec/dragonfly/image_magick/processors/thumb_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Dragonfly::ImageMagick::Processors::Thumb do
+
+  let (:app) { test_imagemagick_app }
+  let (:image) { Dragonfly::Content.new(app, SAMPLES_DIR.join('beach.png')) } # 280x355
+  let (:processor) { Dragonfly::ImageMagick::Processors::Thumb.new }
+
+  it "raises an error if an unrecognized string is given" do
+    expect{
+      processor.call(image, '30x40#ne!')
+    }.to raise_error(ArgumentError)
+  end
+
+  describe "resizing" do
+
+    it "works with xNN" do
+      processor.call(image, 'x30')
+      image.should have_width(24)
+      image.should have_height(30)
+    end
+
+    it "works with NNx" do
+      processor.call(image, '30x')
+      image.should have_width(30)
+      image.should have_height(38)
+    end
+
+    it "works with NNxNN" do
+      processor.call(image, '30x30')
+      image.should have_width(24)
+      image.should have_height(30)
+    end
+
+    it "works with NNxNN!" do
+      processor.call(image, '30x30!')
+      image.should have_width(30)
+      image.should have_height(30)
+    end
+
+    it "works with NNxNN%" do
+      processor.call(image, '25x50%')
+      image.should have_width(70)
+      image.should have_height(178)
+    end
+
+    describe "NNxNN>" do
+
+      it "doesn't resize if the image is smaller than specified" do
+        processor.call(image, '1000x1000>')
+        image.should have_width(280)
+        image.should have_height(355)
+      end
+
+      it "resizes if the image is larger than specified" do
+        processor.call(image, '30x30>')
+        image.should have_width(24)
+        image.should have_height(30)
+      end
+
+    end
+
+    describe "NNxNN<" do
+
+      it "doesn't resize if the image is larger than specified" do
+        processor.call(image, '10x10<')
+        image.should have_width(280)
+        image.should have_height(355)
+      end
+
+      it "resizes if the image is smaller than specified" do
+        processor.call(image, '400x400<')
+        image.should have_width(315)
+        image.should have_height(400)
+      end
+
+    end
+
+  end
+
+  describe "cropping" do # Difficult to test here other than dimensions
+
+    it "crops" do
+      processor.call(image, '10x20+30+30')
+      image.should have_width(10)
+      image.should have_height(20)
+    end
+
+    it "crops with gravity" do
+      image2 = image.clone
+
+      processor.call(image, '10x8nw')
+      image.should have_width(10)
+      image.should have_height(8)
+
+      processor.call(image2, '10x8se')
+      image2.should have_width(10)
+      image2.should have_height(8)
+
+      image2.should_not equal_image(image)
+    end
+
+    it "raises if given both gravity and offset" do
+      expect {
+        processor.call(image, '100x100+10+10se')
+      }.to raise_error(ArgumentError)
+    end
+
+    it "works when the crop area is outside the image" do
+      processor.call(image, '100x100+250+300')
+      image.should have_width(30)
+      image.should have_height(55)
+    end
+
+    it "crops twice in a row correctly" do
+      processor.call(image, '100x100+10+10')
+      processor.call(image, '50x50+0+0')
+      image.should have_width(50)
+      image.should have_height(50)
+    end
+
+  end
+
+  describe "resize_and_crop" do
+
+    it "crops to the correct dimensions" do
+      processor.call(image, '100x100#')
+      image.should have_width(100)
+      image.should have_height(100)
+    end
+
+    it "resizes before cropping" do
+      image2 = image.clone
+      processor.call(image, '100x100#')
+      processor.call(image2, '100x100c')
+      image2.should_not equal_image(image)
+    end
+
+    it "works with gravity" do
+      image2 = image.clone
+      processor.call(image, '10x10#nw')
+      processor.call(image, '10x10#se')
+      image2.should_not equal_image(image)
+    end
+
+  end
+
+  describe "format" do
+    let (:url_attributes) { OpenStruct.new }
+
+    it "changes the format if passed in" do
+      processor.call(image, '2x2', 'format' => 'jpeg')
+      image.should have_format('jpeg')
+    end
+
+    it "doesn't change the format if not passed in" do
+      processor.call(image, '2x2')
+      image.should have_format('png')
+    end
+
+    it "updates the url ext if passed in" do
+      processor.update_url(url_attributes, '2x2', 'format' => 'png')
+      url_attributes.ext.should == 'png'
+    end
+
+    it "doesn't update the url ext if not passed in" do
+      processor.update_url(url_attributes, '2x2')
+      url_attributes.ext.should be_nil
+    end
+  end
+
+end