dragonfly 1.1.4 → 1.4.0

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

@@ -1,4 +1,5 @@
-require 'spec_helper'
+require "spec_helper"
+require "dragonfly/param_validators"
 
 describe Dragonfly::ImageMagick::Generators::Plain do
   let (:generator) { Dragonfly::ImageMagick::Generators::Plain.new }
@@ -9,32 +10,32 @@ describe Dragonfly::ImageMagick::Generators::Plain 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'}}
+    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')
+      generator.call(image, 1, 1, "format" => "gif")
     end
-    it {image.should have_format('gif')}
-    it {image.meta.should == {'format' => 'gif', 'name' => 'plain.gif'}}
+    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')
+      generator.call(image, 1, 1, "colour" => "red")
     end
 
     it "works with American spelling" do
-      generator.call(image, 1, 1, 'color' => 'red')
+      generator.call(image, 1, 1, "color" => "red")
     end
 
     it "blows up with a bad colour" do
       expect {
-        generator.call(image, 1, 1, 'colour' => 'lardoin')
+        generator.call(image, 1, 1, "colour" => "lardoin")
       }.to raise_error(Dragonfly::Shell::CommandFailed)
     end
   end
@@ -42,9 +43,34 @@ describe Dragonfly::ImageMagick::Generators::Plain do
   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'
+      generator.update_url(url_attributes, 1, 1, "format" => "gif")
+      url_attributes.name.should == "plain.gif"
     end
   end
 
+  describe "param validations" do
+    {
+      "color" => "white -write bad.png",
+      "colour" => "white -write bad.png",
+      "format" => "png -write bad.png",
+    }.each do |opt, value|
+      it "validates bad opts like #{opt} = '#{value}'" do
+        expect {
+          generator.call(image, 1, 1, opt => value)
+        }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+      end
+    end
+
+    it "validates width" do
+      expect {
+        generator.call(image, "1 -write bad.png", 1)
+      }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+    end
+
+    it "validates height" do
+      expect {
+        generator.call(image, 1, "1 -write bad.png")
+      }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+    end
+  end
 end

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

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Dragonfly::ImageMagick::Generators::Plasma do
   let (:generator) { Dragonfly::ImageMagick::Generators::Plasma.new }
@@ -10,23 +10,42 @@ describe Dragonfly::ImageMagick::Generators::Plasma 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'}
+      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'}
+      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'
+      generator.update_url(url_attributes, 1, 1, "format" => "jpg")
+      url_attributes.name.should == "plasma.jpg"
     end
   end
-end
 
+  describe "param validations" do
+    it "validates format" do
+      expect {
+        generator.call(image, 1, 1, "format" => "png -write bad.png")
+      }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+    end
+
+    it "validates width" do
+      expect {
+        generator.call(image, "1 -write bad.png", 1)
+      }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+    end
+
+    it "validates height" do
+      expect {
+        generator.call(image, 1, "1 -write bad.png")
+      }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Dragonfly::ImageMagick::Generators::Text do
   let (:generator) { Dragonfly::ImageMagick::Generators::Text.new }
@@ -7,62 +7,62 @@ describe Dragonfly::ImageMagick::Generators::Text do
 
   describe "creating a text image" do
     before(:each) do
-      generator.call(image, "mmm", 'font_size' => 12)
+      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'}}
+    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')
+      generator.call(image, "mmm", "format" => "gif")
     end
-    it {image.should have_format('gif')}
-    it {image.meta.should == {'format' => 'gif', 'name' => 'text.gif'}}
+    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)
+      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')
+      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')
+      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')
+      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')
+      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)
+      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')
+      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')
+      lambda {
+        generator.call(image, "mmm", "padding" => "1 2 3 4 5")
       }.should raise_error(ArgumentError)
     end
   end
@@ -70,8 +70,39 @@ describe Dragonfly::ImageMagick::Generators::Text do
   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'
+      generator.update_url(url_attributes, "mmm", "format" => "gif")
+      url_attributes.name.should == "text.gif"
+    end
+  end
+
+  describe "param validations" do
+    {
+      "font" => "Times New Roman -write bad.png",
+      "font_family" => "Times New Roman -write bad.png",
+      "color" => "rgb(255, 34, 55) -write bad.png",
+      "background_color" => "rgb(255, 52, 55) -write bad.png",
+      "stroke_color" => "rgb(255, 52, 55) -write bad.png",
+      "format" => "png -write bad.png",
+    }.each do |opt, value|
+      it "validates bad opts like #{opt} = '#{value}'" do
+        expect {
+          generator.call(image, "some text", opt => value)
+        }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+      end
+    end
+
+    ["rgb(33,33,33)", "rgba(33,33,33,0.5)", "rgb(33.5,33.5,33.5)", "#fff", "#efefef", "blue"].each do |colour|
+      it "allows #{colour.inspect} as a colour specification" do
+        generator.call(image, "mmm", "color" => colour)
+      end
+    end
+
+    ["rgb(33, 33, 33)", "something else", "blue:", "f#ff"].each do |colour|
+      it "disallows #{colour.inspect} as a colour specification" do
+        expect {
+          generator.call(image, "mmm", "color" => colour)
+        }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+      end
     end
   end
 end

data/spec/dragonfly/image_magick/plugin_spec.rb

@@ -1,25 +1,24 @@
-require 'spec_helper'
+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')) }
+  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 }
+    let(:app) { test_app }
 
     it "allows setting the convert command" do
       app.configure do
-        plugin :imagemagick, :convert_command => '/bin/convert'
+        plugin :imagemagick, :convert_command => "/bin/convert"
       end
-      app.env[:convert_command].should == '/bin/convert'
+      app.env[:convert_command].should == "/bin/convert"
     end
 
     it "allows setting the identify command" do
       app.configure do
-        plugin :imagemagick, :identify_command => '/bin/identify'
+        plugin :imagemagick, :identify_command => "/bin/identify"
       end
-      app.env[:identify_command].should == '/bin/identify'
+      app.env[:identify_command].should == "/bin/identify"
     end
   end
 
@@ -33,7 +32,7 @@ describe "a configured imagemagick app" do
     end
 
     it "should return the aspect ratio" do
-      image.aspect_ratio.should == (280.0/355.0)
+      image.aspect_ratio.should == (280.0 / 355.0)
     end
 
     it "should say if it's portrait" do
@@ -60,39 +59,39 @@ describe "a configured imagemagick app" do
     end
 
     it "should return false for pdfs" do
-      image.encode('pdf').image?.should be_falsey
-    end
+      image.encode("pdf").image?.should be_falsey
+    end unless ENV["SKIP_FLAKY_TESTS"]
   end
 
   describe "processors that change the url" do
     before do
-      app.configure{ url_format '/:name' }
+      app.configure { url_format "/:name" }
     end
 
-    describe "convert" do
+    describe "thumb" do
       it "sanity check with format" do
-        thumb = image.convert('-resize 1x1!', 'format' => 'jpg')
+        thumb = image.thumb("1x1!", "format" => "jpg")
         thumb.url.should =~ /^\/beach\.jpg\?.*job=\w+/
         thumb.width.should == 1
-        thumb.format.should == 'jpeg'
-        thumb.meta['format'].should == 'jpg'
+        thumb.format.should == "jpeg"
+        thumb.meta["format"].should == "jpg"
       end
 
       it "sanity check without format" do
-        thumb = image.convert('-resize 1x1!')
+        thumb = image.thumb("1x1!")
         thumb.url.should =~ /^\/beach\.png\?.*job=\w+/
         thumb.width.should == 1
-        thumb.format.should == 'png'
-        thumb.meta['format'].should be_nil
+        thumb.format.should == "png"
+        thumb.meta["format"].should be_nil
       end
     end
 
     describe "encode" do
       it "sanity check" do
-        thumb = image.encode('jpg')
+        thumb = image.encode("jpg")
         thumb.url.should =~ /^\/beach\.jpg\?.*job=\w+/
-        thumb.format.should == 'jpeg'
-        thumb.meta['format'].should == 'jpg'
+        thumb.format.should == "jpeg"
+        thumb.meta["format"].should == "jpg"
       end
     end
   end
@@ -100,13 +99,13 @@ describe "a configured imagemagick app" do
   describe "other processors" do
     describe "encode" do
       it "should encode the image to the correct format" do
-        image.encode!('gif')
-        image.format.should == 'gif'
+        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.encode!("jpg", "-quality 1")
+        image.format.should == "jpeg"
         image.size.should < 2000
       end
     end
@@ -117,8 +116,13 @@ describe "a configured imagemagick app" do
         image.width.should == 355
         image.height.should == 280
       end
-    end
 
+      it "disallows bad parameters" do
+        expect {
+          image.rotate!("90 -write bad.png").apply
+        }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+      end
+    end
   end
 
   describe "identify" do
@@ -128,4 +132,17 @@ describe "a configured imagemagick app" do
     end
   end
 
+  describe "deprecated convert commands" do
+    it "raises a deprecated message if using the convert processor" do
+      expect {
+        image.convert!("into something").apply
+      }.to raise_error(/deprecated/i)
+    end
+
+    it "raises a deprecated message if using the convert generator" do
+      expect {
+        image.generate!(:convert, "into something").apply
+      }.to raise_error(/deprecated/i)
+    end
+  end
 end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Dragonfly::ImageMagick::Processors::Encode do
+  let (:app) { test_imagemagick_app }
+  let (:image) { Dragonfly::Content.new(app, SAMPLES_DIR.join("beach.png")) } # 280x355
+  let (:processor) { Dragonfly::ImageMagick::Processors::Encode.new }
+
+  it "encodes to a different format" do
+    processor.call(image, "jpeg")
+    image.should have_format("jpeg")
+  end
+
+  describe "param validations" do
+    it "validates the format param" do
+      expect {
+        processor.call(image, "jpeg -write bad.png")
+      }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+    end
+
+    it "allows good args" do
+      processor.call(image, "jpeg", "-quality 10")
+    end
+
+    it "disallows bad args" do
+      expect {
+        processor.call(image, "jpeg", "-write bad.png")
+      }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+    end
+  end
+end

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

@@ -1,88 +1,80 @@
-require 'spec_helper'
-require 'ostruct'
+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 (: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!')
+    expect {
+      processor.call(image, "30x40#ne!")
     }.to raise_error(ArgumentError)
   end
 
   describe "resizing" do
-
     it "works with xNN" do
-      processor.call(image, 'x30')
+      processor.call(image, "x30")
       image.should have_width(24)
       image.should have_height(30)
     end
 
     it "works with NNx" do
-      processor.call(image, '30x')
+      processor.call(image, "30x")
       image.should have_width(30)
       image.should have_height(38)
     end
 
     it "works with NNxNN" do
-      processor.call(image, '30x30')
+      processor.call(image, "30x30")
       image.should have_width(24)
       image.should have_height(30)
     end
 
     it "works with NNxNN!" do
-      processor.call(image, '30x30!')
+      processor.call(image, "30x30!")
       image.should have_width(30)
       image.should have_height(30)
     end
 
     it "works with NNxNN%" do
-      processor.call(image, '25x50%')
+      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>')
+        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>')
+        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<')
+        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<')
+        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')
+      processor.call(image, "10x20+30+30")
       image.should have_width(10)
       image.should have_height(20)
     end
@@ -90,11 +82,11 @@ describe Dragonfly::ImageMagick::Processors::Thumb do
     it "crops with gravity" do
       image2 = image.clone
 
-      processor.call(image, '10x8nw')
+      processor.call(image, "10x8nw")
       image.should have_width(10)
       image.should have_height(8)
 
-      processor.call(image2, '10x8se')
+      processor.call(image2, "10x8se")
       image2.should have_width(10)
       image2.should have_height(8)
 
@@ -103,77 +95,86 @@ describe Dragonfly::ImageMagick::Processors::Thumb do
 
     it "raises if given both gravity and offset" do
       expect {
-        processor.call(image, '100x100+10+10se')
+        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')
+      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')
+      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#')
+      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')
+      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')
+      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')
+      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')
+      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'
+      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')
+      processor.update_url(url_attributes, "2x2")
       url_attributes.ext.should be_nil
     end
   end
 
   describe "args_for_geometry" do
     it "returns the convert arguments used for a given geometry" do
-      expect(processor.args_for_geometry('30x40')).to eq('-resize 30x40')
+      expect(processor.args_for_geometry("30x40")).to eq("-resize 30x40")
     end
   end
 
+  describe "param validations" do
+    {
+      "format" => "png -write bad.png",
+      "frame" => "0] -write bad.png [",
+    }.each do |opt, value|
+      it "validates bad opts like #{opt} = '#{value}'" do
+        expect {
+          processor.call(image, "30x30", opt => value)
+        }.to raise_error(Dragonfly::ParamValidators::InvalidParameter)
+      end
+    end
+  end
 end