rmagick 2.13.3 → 2.13.4

data/rmagick.gemspec

@@ -11,13 +11,22 @@ Gem::Specification.new do |s|
   s.email = %q{github@benjaminfleischer.com}
   s.homepage = %q{https://github.com/gemhome/rmagick}
   s.license = 'MIT'
-  s.files = Dir.glob('**/*')
-  s.bindir = 'bin'
-  s.executables = Dir.glob('bin/*').collect {|f| File.basename(f)}
+
+      tracked_files = `git ls-files`.split($\)
+      file_exclusion_regex = %r{(\Alib/rvg/to_c.rb)}
+      files         = tracked_files.reject{|file| file[file_exclusion_regex] }
+      test_files    = files.grep(%r{^(test|spec|features)/})
+      executables   = files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+
+  s.files                       = files
+  s.test_files                  = test_files
+  s.executables                 = executables
   s.require_paths << 'ext'
+
   s.rubyforge_project = %q{rmagick}
   s.extensions = %w{ext/RMagick/extconf.rb}
   s.has_rdoc = false
-  s.required_ruby_version = '>= 1.8.5'
-  s.requirements << 'ImageMagick 6.4.9 or later'
+  s.required_ruby_version = ">= #{Magick::MIN_RUBY_VERSION}"
+  s.requirements << "ImageMagick #{Magick::MIN_IM_VERSION} or later"
+  s.add_development_dependency 'rake-compiler'
 end

data/test/Image2.rb

@@ -124,7 +124,7 @@ class Image2_UT < Test::Unit::TestCase
         assert_raise(IndexError) { @img.convolve(5, kernel) }
         assert_raise(IndexError) { @img.convolve(order, "x") }
         assert_raise(TypeError) { @img.convolve(3, [1.0, 1.0, 1.0, 1.0, 'x', 1.0, 1.0, 1.0, 1.0]) }
-        assert_raise(Magick::ImageMagickError) { @img.convolve(2, [1.0, 1.0, 1.0, 1.0]) }
+        assert_raise(Magick::ImageMagickError) { @img.convolve(-1, [1.0, 1.0, 1.0, 1.0]) }
     end
 
     def test_convolve_channel
@@ -444,7 +444,11 @@ class Image2_UT < Test::Unit::TestCase
             @img.each_profile do |name, value|
                 assert_equal("iptc", name)
                 # As of 6.3.1
-                assert_equal("8BIM\004\004\000\000\000\000\001\340test profile", value)
+                if IM_VERSION < Gem::Version.new("6.6.4") || (IM_VERSION == Gem::Version.new("6.6.4") && IM_REVISION < Gem::Version.new("5"))
+                    assert_equal("8BIM\004\004\000\000\000\000\001\340test profile", value)
+                else
+                    assert_equal("test profile", value)
+                end
             end
         end
     end
@@ -582,7 +586,7 @@ class Image2_UT < Test::Unit::TestCase
         end
         assert_nothing_raised do
             res = @img.export_pixels_to_str(0, 0, 10, 10, "I", Magick::LongPixel)
-            assert_equal(10*10*8, res.length)
+            assert_equal(10*10*[1].pack("L!").length, res.length)
         end
         assert_nothing_raised do
             res = @img.export_pixels_to_str(0, 0, 10, 10, "I", Magick::FloatPixel)

data/test/Image3.rb

@@ -10,7 +10,7 @@ ColorspaceTypes = [
   Magick::GRAYColorspace,
   Magick::TransparentColorspace,
   Magick::OHTAColorspace,
-  Magick::LABColorspace,
+  Magick::LabColorspace,
   Magick::XYZColorspace,
   Magick::YCbCrColorspace,
   Magick::YCCColorspace,
@@ -22,7 +22,6 @@ ColorspaceTypes = [
   Magick::HSLColorspace,
   Magick::HWBColorspace,
   Magick::HSBColorspace,
-  Magick::LABColorspace,
   Magick::Rec601LumaColorspace,
   Magick::Rec601YCbCrColorspace,
   Magick::Rec709LumaColorspace,
@@ -30,6 +29,23 @@ ColorspaceTypes = [
   Magick::LogColorspace
 ]
 
+Filters = [
+  Magick::PointFilter,
+  Magick::BoxFilter,
+  Magick::TriangleFilter,
+  Magick::HermiteFilter,
+  Magick::HanningFilter,
+  Magick::HammingFilter,
+  Magick::BlackmanFilter,
+  Magick::GaussianFilter,
+  Magick::QuadraticFilter,
+  Magick::CubicFilter,
+  Magick::CatromFilter,
+  Magick::MitchellFilter,
+  Magick::LanczosFilter,
+  Magick::BesselFilter,
+  Magick::SincFilter
+]
 
 
 class Image3_UT < Test::Unit::TestCase
@@ -168,6 +184,14 @@ class Image3_UT < Test::Unit::TestCase
     end
 
     def test_resample
+        @img.x_resolution = 72
+        @img.y_resolution = 72
+        assert_nothing_raised { @img.resample }
+        assert_nothing_raised { @img.resample(100) }
+        assert_nothing_raised { @img.resample(100, 100) }
+
+        @img.x_resolution = 0
+        @img.y_resolution = 0
         assert_nothing_raised { @img.resample }
         assert_nothing_raised { @img.resample(100) }
         assert_nothing_raised { @img.resample(100, 100) }
@@ -180,9 +204,32 @@ class Image3_UT < Test::Unit::TestCase
         assert_equal(125, res.rows)
         assert_equal(120.0, res.x_resolution)
         assert_equal(120.0, res.y_resolution)
+        assert_equal(200, girl.columns)
+        assert_equal(250, girl.rows)
+        assert_equal(240.0, girl.x_resolution)
+        assert_equal(240.0, girl.y_resolution)
+
+        Filters.each do |filter|
+            assert_nothing_raised { @img.resample(50, 50, filter) }
+        end
+        assert_nothing_raised { @img.resample(50, 50, Magick::PointFilter, 2.0) }
+
+        assert_raise(TypeError) { @img.resample('x') }
+        assert_raise(TypeError) { @img.resample(100, 'x') }
+        assert_raise(TypeError) { @img.resample(50, 50, 2) }
+        assert_raise(TypeError) { @img.resample(50, 50, Magick::CubicFilter, 'x') }
+        assert_raise(ArgumentError) { @img.resample(50, 50, Magick::SincFilter, 2.0, 'x') }
+        assert_raise(ArgumentError) { @img.resample(-100) }
+        assert_raise(ArgumentError) { @img.resample(100, -100) }
+    end
 
-        assert_raise(NoMethodError) { @img.resample('x') }
-        assert_raise(NoMethodError) { @img.resample(100, 'x') }
+    def test_resample!
+        assert_nothing_raised do
+            res = @img.resample!(50)
+            assert_same(@img, res)
+        end
+        @img.freeze
+        assert_raise(FreezeError) { @img.resample!(50) }
     end
 
     def test_resize
@@ -191,24 +238,8 @@ class Image3_UT < Test::Unit::TestCase
             assert_instance_of(Magick::Image, res)
         end
         assert_nothing_raised { @img.resize(50,50) }
-        filters = [
-          Magick::PointFilter,
-          Magick::BoxFilter,
-          Magick::TriangleFilter,
-          Magick::HermiteFilter,
-          Magick::HanningFilter,
-          Magick::HammingFilter,
-          Magick::BlackmanFilter,
-          Magick::GaussianFilter,
-          Magick::QuadraticFilter,
-          Magick::CubicFilter,
-          Magick::CatromFilter,
-          Magick::MitchellFilter,
-          Magick::LanczosFilter,
-          Magick::BesselFilter,
-          Magick::SincFilter ]
-
-        filters.each do |filter|
+
+        Filters.each do |filter|
             assert_nothing_raised { @img.resize(50, 50, filter) }
         end
         assert_nothing_raised { @img.resize(50, 50, Magick::PointFilter, 2.0) }
@@ -406,7 +437,7 @@ class Image3_UT < Test::Unit::TestCase
 
         # Don't test colorspaces that require PsuedoColor images
         (ColorspaceTypes - [Magick::OHTAColorspace,
-                            Magick::LABColorspace,
+                            Magick::LabColorspace,
                             Magick::XYZColorspace,
                             Magick::YCbCrColorspace,
                             Magick::YCCColorspace,

data/test/ImageList2.rb

@@ -100,7 +100,7 @@ class ImageList2_UT < Test::Unit::TestCase
     end
 
     def test_from_blob
-        hat = File.open(FLOWER_HAT)
+        hat = File.open(FLOWER_HAT, "rb")
         blob = hat.read
         assert_nothing_raised { @ilist.from_blob(blob) }
         assert_instance_of(Magick::Image, @ilist[0])

data/test/Image_attributes.rb

@@ -163,7 +163,11 @@ class Image_Attributes_UT < Test::Unit::TestCase
     def test_colorspace
         assert_nothing_raised { @img.colorspace }
         assert_instance_of(Magick::ColorspaceType, @img.colorspace)
-        assert_equal(Magick::RGBColorspace, @img.colorspace)
+        if IM_VERSION < Gem::Version.new("6.7.5") || (IM_VERSION == Gem::Version.new("6.7.5") && IM_REVISION < Gem::Version.new("5"))
+          assert_equal(Magick::RGBColorspace, @img.colorspace)
+        else
+          assert_equal(Magick::SRGBColorspace, @img.colorspace)
+        end
         img = @img.copy
         assert_nothing_raised { img.colorspace = Magick::GRAYColorspace }
         assert_equal(Magick::GRAYColorspace, img.colorspace)
@@ -279,7 +283,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
     def test_density
         assert_nothing_raised { @img.density }
-        assert_equal('72x72', @img.density)
         assert_nothing_raised { @img.density = '90x90' }
         assert_nothing_raised { @img.density = 'x90' }
         assert_nothing_raised { @img.density = '90' }
@@ -287,7 +290,7 @@ class Image_Attributes_UT < Test::Unit::TestCase
     end
 
     def test_depth
-        assert_equal(Magick::QuantumDepth, @img.depth)
+        assert_equal(Magick::MAGICKCORE_QUANTUM_DEPTH, @img.depth)
         assert_raise(NoMethodError) { @img.depth = 2 }
     end
 
@@ -394,7 +397,11 @@ class Image_Attributes_UT < Test::Unit::TestCase
     def test_gamma
         assert_nothing_raised { @img.gamma }
         assert_instance_of(Float, @img.gamma)
-        assert_equal(0.0, @img.gamma)
+        if IM_VERSION < Gem::Version.new("6.7.5") || (IM_VERSION == Gem::Version.new("6.7.5") && IM_REVISION < Gem::Version.new("5"))
+          assert_equal(0.0, @img.gamma)
+        else
+          assert_equal(0.45454543828964233, @img.gamma)
+        end
         assert_nothing_raised { @img.gamma = 2.0 }
         assert_equal(2.0, @img.gamma)
         assert_raise(TypeError) { @img.gamma = 'x' }
@@ -483,7 +490,11 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
     def test_number_colors
         assert_nothing_raised { @hat.number_colors }
-        assert_equal(27980, @hat.number_colors)
+        if IM_VERSION < Gem::Version.new("6.7.5") || (IM_VERSION == Gem::Version.new("6.7.5") && IM_REVISION < Gem::Version.new("5"))
+          assert_equal(27980, @hat.number_colors)
+        else
+          assert_equal(27942, @hat.number_colors)
+        end
         assert_raise(NoMethodError) { @hat.number_colors = 2 }
     end
 
@@ -539,14 +550,18 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
     def test_quantum_depth
         assert_nothing_raised { @img.quantum_depth }
-        assert_equal(Magick::QuantumDepth, @img.quantum_depth)
+        assert_equal(Magick::MAGICKCORE_QUANTUM_DEPTH, @img.quantum_depth)
         assert_raise(NoMethodError) { @img.quantum_depth = 8 }
     end
 
     def test_rendering_intent
         assert_nothing_raised { @img.rendering_intent }
         assert_instance_of(Magick::RenderingIntent, @img.rendering_intent)
-        assert_equal(Magick::UndefinedIntent, @img.rendering_intent)
+        if IM_VERSION < Gem::Version.new("6.7.5") || (IM_VERSION == Gem::Version.new("6.7.5") && IM_REVISION < Gem::Version.new("5"))
+          assert_equal(Magick::UndefinedIntent, @img.rendering_intent)
+        else
+          assert_equal(Magick::PerceptualIntent, @img.rendering_intent)
+        end
         assert_nothing_raised { @img.rendering_intent = Magick::SaturationIntent }
         assert_nothing_raised { @img.rendering_intent = Magick::PerceptualIntent }
         assert_nothing_raised { @img.rendering_intent = Magick::AbsoluteIntent }
@@ -591,7 +606,11 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
     def test_total_colors
         assert_nothing_raised { @hat.total_colors }
-        assert_equal(27980, @hat.total_colors)
+        if IM_VERSION < Gem::Version.new("6.7.5") || (IM_VERSION == Gem::Version.new("6.7.5") && IM_REVISION < Gem::Version.new("5"))
+          assert_equal(27980, @hat.total_colors)
+        else
+          assert_equal(27942, @hat.total_colors)
+        end
         assert_raise(NoMethodError) { @img.total_colors = 2 }
     end
 
@@ -619,7 +638,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
     def test_x_resolution
         assert_nothing_raised { @img.x_resolution }
-        assert_equal(72.0, @img.x_resolution)
         assert_nothing_raised { @img.x_resolution = 90 }
         assert_equal(90.0, @img.x_resolution)
         assert_raise(TypeError) { @img.x_resolution = 'x' }
@@ -627,7 +645,6 @@ class Image_Attributes_UT < Test::Unit::TestCase
 
     def test_y_resolution
         assert_nothing_raised { @img.y_resolution }
-        assert_equal(72.0, @img.y_resolution)
         assert_nothing_raised { @img.y_resolution = 90 }
         assert_equal(90.0, @img.y_resolution)
         assert_raise(TypeError) { @img.y_resolution = 'x' }

data/test/Import_Export.rb

@@ -40,12 +40,16 @@ class Import_Export_UT < Test::Unit::TestCase
   end
 
   def test_import_export
+    is_hdri_support = Magick::Magick_features =~ /HDRI/
     pixels = @test.export_pixels(0, 0, @test.columns, @test.rows, "RGB")
 
-    case Magick::QuantumDepth
+    case Magick::MAGICKCORE_QUANTUM_DEPTH
       when 8
         p = pixels.pack("C*")
         import(p, Magick::CharPixel)
+        if is_hdri_support
+          p = pixels.pack("F*")
+        end
         import(p, Magick::QuantumPixel)
 
         spixels = pixels.collect {|px| px * 257}
@@ -64,6 +68,9 @@ class Import_Export_UT < Test::Unit::TestCase
 
         p = pixels.pack("S*")
         import(p, Magick::ShortPixel)
+        if is_hdri_support
+          p = pixels.pack("F*")
+        end
         import(p, Magick::QuantumPixel)
 
         ipixels = pixels.collect {|px| px * 65537}
@@ -84,6 +91,9 @@ class Import_Export_UT < Test::Unit::TestCase
         p = pixels.pack("I*")
         import(p, Magick::IntegerPixel)
         import(p, Magick::LongPixel)
+        if is_hdri_support
+          p = pixels.pack("D*")
+        end
         import(p, Magick::QuantumPixel)
 
       when 64

data/test/Info.rb

@@ -58,7 +58,7 @@ class Info_UT < Test::Unit::TestCase
 
     def test_background_color
       assert_nothing_raised { @info.background_color = "red" }
-      red = Magick::Pixel.new(Magick::MaxRGB)
+      red = Magick::Pixel.new(Magick::QuantumRange)
       assert_nothing_raised { @info.background_color = red }
       assert_equal("red", @info.background_color)
       img = Magick::Image.new(20,20) { self.background_color = "red" }
@@ -67,7 +67,7 @@ class Info_UT < Test::Unit::TestCase
 
     def test_border_color
       assert_nothing_raised { @info.border_color = "red" }
-      red = Magick::Pixel.new(Magick::MaxRGB)
+      red = Magick::Pixel.new(Magick::QuantumRange)
       assert_nothing_raised { @info.border_color = red }
       assert_equal("red", @info.border_color)
       img = Magick::Image.new(20,20) { self.border_color = "red" }
@@ -185,7 +185,7 @@ class Info_UT < Test::Unit::TestCase
       assert_nothing_raised { @info.fuzz = 50 }
       assert_equal(50, @info.fuzz)
       assert_nothing_raised { @info.fuzz = "50%" }
-      assert_equal(Magick::MaxRGB * 0.5, @info.fuzz)
+      assert_equal(Magick::QuantumRange * 0.5, @info.fuzz)
     end
 
     def test_gravity
@@ -216,7 +216,7 @@ class Info_UT < Test::Unit::TestCase
 
     def test_matte_color
       assert_nothing_raised { @info.matte_color = "red" }
-      red = Magick::Pixel.new(Magick::MaxRGB)
+      red = Magick::Pixel.new(Magick::QuantumRange)
       assert_nothing_raised { @info.matte_color = red }
       assert_equal("red", @info.matte_color)
       img = Magick::Image.new(20,20) { self.matte_color = "red" }

data/test/Magick.rb

@@ -69,6 +69,12 @@ class Magick_UT < Test::Unit::TestCase
       assert_equal(3, ary.length)
     end
 
+    def test_features
+      res = nil
+      assert_nothing_raised { res = Magick::Magick_features }
+      assert_instance_of(String, res)
+    end
+
     def test_fonts
       res = nil
       assert_nothing_raised { res = Magick.fonts }
@@ -260,30 +266,33 @@ class Magick_UT < Test::Unit::TestCase
       assert_nothing_raised { Magick.set_log_format("format %d%e%f") }
     end
 
-    # put old limits back in place after testing
     def test_limit_resources
         cur = new = nil
 
         assert_nothing_raised {cur = Magick::limit_resource(:memory, 500)}
-        assert_equal(782635008, cur)
+        assert_kind_of(Integer, cur)
+        assert(cur > 1024 ** 2)
         assert_nothing_raised {new = Magick::limit_resource("memory")}
         assert_equal(500, new)
         Magick::limit_resource(:memory, cur)
 
         assert_nothing_raised {cur = Magick::limit_resource(:map, 3500)}
-        assert_equal(2087026688, cur)
+        assert_kind_of(Integer, cur)
+        assert(cur > 1024 ** 2)
         assert_nothing_raised {new = Magick::limit_resource("map")}
         assert_equal(3500, new)
         Magick::limit_resource(:map, cur)
 
         assert_nothing_raised {cur = Magick::limit_resource(:disk, 3*1024*1024*1024)}
-        assert_equal(4294967295, cur)
+        assert_kind_of(Integer, cur)
+        assert(cur > 1024 ** 2)
         assert_nothing_raised {new = Magick::limit_resource("disk")}
         assert_equal(3221225472, new)
         Magick::limit_resource(:disk, cur)
 
         assert_nothing_raised {cur = Magick::limit_resource(:file, 500)}
-        assert_equal(768, cur)
+        assert_kind_of(Integer, cur)
+        assert(cur > 512)
         assert_nothing_raised {new = Magick::limit_resource("file")}
         assert_equal(500, new)
         Magick::limit_resource(:file, cur)
@@ -292,55 +301,6 @@ class Magick_UT < Test::Unit::TestCase
         assert_raise(ArgumentError) { Magick::limit_resource("xxx") }
         assert_raise(ArgumentError) { Magick::limit_resource("map", 3500, 2) }
         assert_raise(ArgumentError) { Magick::limit_resource() }
-
-    end
-
-    # test the @@_tmpnam_ class variable
-    # the count is incremented by Image::Info#texture=,
-    # ImageList::Montage#texture=, and Draw.composite
-
-    def test_tmpnam
-
-      tmpfiles = Dir[ENV["HOME"] + "/tmp/magick*"].length
-
-      texture = Magick::Image.read("granite:") {self.size = "20x20" }.first
-      info = Magick::Image::Info.new
-
-      # does not exist at first
-      # assert_raise(NameError) { x = Magick._tmpnam_ }
-      info.texture = texture
-
-      # now it exists
-      assert_nothing_raised { x = Magick._tmpnam_ }
-      assert_equal(1, Magick._tmpnam_)
-
-      info.texture = texture
-      assert_equal(2, Magick._tmpnam_)
-
-      mon = Magick::ImageList::Montage.new
-      mon.texture = texture
-      assert_equal(3, Magick._tmpnam_)
-
-      mon.texture = texture
-      assert_equal(4, Magick._tmpnam_)
-
-      gc = Magick::Draw.new
-      gc.composite(0, 0, 20, 20, texture)
-      assert_equal(5, Magick._tmpnam_)
-
-      gc.composite(0, 0, 20, 20, texture)
-      assert_equal(6, Magick._tmpnam_)
-
-      tmpfiles2 = Dir[ENV["HOME"] + "/tmp/magick*"].length
-
-      # The 2nd montage texture deletes the first.
-      # The 2nd info texture deletes the first.
-      # Both composite images are still alive.
-      # Therefore only 4 tmp files are left.
-      #assert_equal(tmpfiles+4, tmpfiles2)
-      # 6.4.1-5 - only 1 tmpfile?
-      assert_equal(tmpfiles, tmpfiles2)
-
     end
 
     def test_trace_proc