rmagick 2.13.4 → 2.16.0

data/spec/rmagick/draw_spec.rb

@@ -0,0 +1,156 @@
+class Magick::Draw
+  def self._dummy_img_
+    @@_dummy_img_
+  end
+end
+
+RSpec.describe Magick::Draw do
+  let(:draw) { Magick::Draw.new }
+
+  describe '._dummy_img_' do
+    it 'works' do
+      # initially this variable is not defined.
+      expect { Magick::Draw._dummy_img_ }.to raise_error(NameError)
+
+      # cause it to become defined. save the object id.
+      draw.get_type_metrics('ABCDEF')
+      dummy = nil
+      expect { dummy = Magick::Draw._dummy_img_ }.not_to raise_error
+
+      expect(dummy).to be_instance_of(Magick::Image)
+
+      # ensure that it is always the same object
+      draw.get_type_metrics('ABCDEF')
+      dummy2 = nil
+      expect { dummy2 = Magick::Draw._dummy_img_ }.not_to raise_error
+      expect(dummy).to eq dummy2
+    end
+  end
+
+  describe '#kerning=' do
+    it 'assigns without raising an error' do
+      expect { draw.kerning = 1 }.not_to raise_error
+    end
+  end
+
+  describe '#kerning' do
+    it 'accepts a valid parameter without raising an error' do
+      expect { draw.kerning(1) }.not_to raise_error
+    end
+
+    it 'raises an error when given an invalid parameter' do
+      expect { draw.kerning('a') }.to raise_error(ArgumentError)
+      expect { draw.kerning([]) }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#interline_spacing=' do
+    it 'assigns without raising an error' do
+      expect { draw.interline_spacing = 1 }.not_to raise_error
+    end
+  end
+
+  describe '#interline_spacing' do
+    it 'accepts a valid parameter without raising an error' do
+      expect { draw.interline_spacing(1) }.not_to raise_error
+    end
+
+    it 'raises an error when given an invalid parameter' do
+      expect { draw.interline_spacing('a') }.to raise_error(ArgumentError)
+      expect { draw.interline_spacing([]) }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#interword_spacing=' do
+    it 'assigns without raising an error' do
+      expect { draw.interword_spacing = 1 }.not_to raise_error
+    end
+  end
+
+  describe '#interword_spacing' do
+    it 'accepts a valid parameter without raising an error' do
+      expect { draw.interword_spacing(1) }.not_to raise_error
+    end
+
+    it 'raises an error when given an invalid parameter' do
+      expect { draw.interword_spacing('a') }.to raise_error(ArgumentError)
+      expect { draw.interword_spacing([]) }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#marshal_dump', '#marshal_load' do
+    it 'marshals without an error' do
+      skip 'this spec fails on some versions of ImageMagick'
+      rose = Magick::Image.read('rose:').first
+      granite = Magick::Image.read('granite:').first
+      s = granite.to_blob { self.format = 'miff' }
+      granite = Magick::Image.from_blob(s).first
+      blue_stroke = Magick::Image.new(20,20) { self.background_color = 'blue' }
+      s = blue_stroke.to_blob { self.format = 'miff' }
+      blue_stroke = Magick::Image.from_blob(s).first
+
+      draw.affine = Magick::AffineMatrix.new(1, 2, 3, 4, 5, 6)
+      draw.decorate = Magick::LineThroughDecoration
+      draw.encoding = 'AdobeCustom'
+      draw.gravity = Magick::CenterGravity
+      draw.fill = Magick::Pixel.from_color('red')
+      draw.stroke = Magick::Pixel.from_color('blue')
+      draw.stroke_width = 5
+      draw.fill_pattern = granite
+      draw.stroke_pattern = blue_stroke
+      draw.text_antialias = true
+      draw.font = 'Arial-Bold'
+      draw.font_family = 'arial'
+      draw.font_style = Magick::ItalicStyle
+      draw.font_stretch = Magick::CondensedStretch
+      draw.font_weight = Magick::BoldWeight
+      draw.pointsize = 12
+      draw.density = '72x72'
+      draw.align = Magick::CenterAlign
+      draw.undercolor = Magick::Pixel.from_color('green')
+      draw.kerning = 10.5
+      draw.interword_spacing = 3.75
+
+      draw.circle(20, 25, 20, 28)
+      dumped = nil
+      expect { dumped = Marshal.dump(draw) }.not_to raise_error
+      expect { Marshal.load(dumped) }.not_to raise_error
+    end
+  end
+
+  describe '#fill_pattern' do
+    it 'accepts an Image argument' do
+      img = Magick::Image.new(20,20)
+      expect { draw.fill_pattern = img }.not_to raise_error
+    end
+
+    it 'accepts an ImageList argument' do
+      img = Magick::Image.new(20,20)
+      ilist = Magick::ImageList.new
+      ilist << img
+      expect { draw.fill_pattern = ilist }.not_to raise_error
+    end
+
+    it 'does not accept arbitrary arguments' do
+      expect { draw.fill_pattern = 1 }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#stroke_pattern' do
+    it 'accepts an Image argument' do
+      img = Magick::Image.new(20,20)
+      expect { draw.stroke_pattern = img }.not_to raise_error
+    end
+
+    it 'accepts an ImageList argument' do
+      img = Magick::Image.new(20,20)
+      ilist = Magick::ImageList.new
+      ilist << img
+      expect { draw.stroke_pattern = ilist }.not_to raise_error
+    end
+
+    it 'does not accept arbitrary arguments' do
+      expect { draw.stroke_pattern = 1 }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/rmagick/image/blue_shift_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Magick::Image, '#blue_shift' do
+
+  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
+
+  it 'returns a new Image' do
+    res = img.blue_shift
+    expect(res).to be_instance_of(Magick::Image)
+    expect(res).not_to eq img
+  end
+
+  it 'accepts one argument' do
+    expect { img.blue_shift(2) }.not_to raise_error
+    expect { img.blue_shift(2, 3) }.to raise_error(ArgumentError)
+  end
+
+end

data/spec/rmagick/image/composite_spec.rb

@@ -0,0 +1,140 @@
+RSpec.describe Magick::Image, '#composite' do
+
+  let(:img1) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
+  let(:img2) { Magick::Image.read(IMAGES_DIR+'/Button_1.gif').first }
+  let(:composite_ops) do
+    [
+      Magick::UndefinedCompositeOp,
+      Magick::NoCompositeOp,
+      Magick::AddCompositeOp,
+      Magick::AtopCompositeOp,
+      Magick::BumpmapCompositeOp,
+      Magick::ClearCompositeOp,
+      Magick::ColorizeCompositeOp,
+      Magick::CopyBlueCompositeOp,
+      Magick::CopyCompositeOp,
+      Magick::CopyGreenCompositeOp,
+      Magick::CopyOpacityCompositeOp,
+      Magick::CopyRedCompositeOp,
+      Magick::CopyCyanCompositeOp,
+      Magick::CopyMagentaCompositeOp,
+      Magick::CopyYellowCompositeOp,
+      Magick::CopyBlackCompositeOp,
+      Magick::DarkenCompositeOp,
+      Magick::DifferenceCompositeOp,
+      Magick::DisplaceCompositeOp,
+      Magick::DissolveCompositeOp,
+      Magick::DstAtopCompositeOp,
+      Magick::DstCompositeOp,
+      Magick::DstInCompositeOp,
+      Magick::DstOutCompositeOp,
+      Magick::DstOverCompositeOp,
+      Magick::HueCompositeOp,
+      Magick::InCompositeOp,
+      Magick::LightenCompositeOp,
+      Magick::LuminizeCompositeOp,
+      Magick::MinusCompositeOp,
+      Magick::ModulateCompositeOp,
+      Magick::MultiplyCompositeOp,
+      Magick::OutCompositeOp,
+      Magick::OverCompositeOp,
+      Magick::OverlayCompositeOp,
+      Magick::PlusCompositeOp,
+      Magick::ReplaceCompositeOp,
+      Magick::SaturateCompositeOp,
+      Magick::ScreenCompositeOp,
+      Magick::SrcAtopCompositeOp,
+      Magick::SrcCompositeOp,
+      Magick::SrcInCompositeOp,
+      Magick::SrcOutCompositeOp,
+      Magick::SrcOverCompositeOp,
+      Magick::SubtractCompositeOp,
+      Magick::ThresholdCompositeOp,
+      Magick::XorCompositeOp,
+      Magick::BlendCompositeOp,
+      Magick::ColorBurnCompositeOp,
+      Magick::ColorDodgeCompositeOp,
+      Magick::ExclusionCompositeOp,
+      Magick::HardLightCompositeOp,
+      Magick::SoftLightCompositeOp
+    ]
+  end
+  let(:gravity) do
+    [
+      Magick::NorthEastGravity,
+      Magick::EastGravity,
+      Magick::SouthWestGravity,
+      Magick::SouthGravity,
+      Magick::SouthEastGravity
+    ]
+  end
+
+  it 'raises an error given invalid arguments' do
+    expect { img1.composite }.to raise_error(ArgumentError)
+    expect { img1.composite(img2) }.to raise_error(ArgumentError)
+    expect do
+      img1.composite(img2, Magick::NorthWestGravity)
+    end.to raise_error(ArgumentError)
+    expect { img1.composite(2) }.to raise_error(ArgumentError)
+    expect { img1.composite(img2, 2) }.to raise_error(ArgumentError)
+  end
+
+  context 'when given 3 arguments' do
+    it 'works when 2nd argument is a gravity' do
+      composite_ops.each do |op|
+        gravity.each do |grav|
+          expect { img1.composite(img2, grav, op) }.not_to raise_error
+        end
+      end
+    end
+
+    it 'raises an error when 2nd argument is not a gravity' do
+      expect do
+        img1.composite(img2, 2, Magick::OverCompositeOp)
+      end.to raise_error(TypeError)
+    end
+  end
+
+  context 'when given 4 arguments' do
+    it 'works when 4th argument is a composite operator' do
+      # there are way too many CompositeOperators to test them all, so just try
+      # few representative ops
+      composite_ops.each do |op|
+        expect { img1.composite(img2, 0, 0, op) }.not_to raise_error
+      end
+    end
+
+    it 'returns a new Magick::Image object' do
+      res = img1.composite(img2, 0, 0, Magick::OverCompositeOp)
+      expect(res).to be_instance_of(Magick::Image)
+    end
+
+    it 'raises an error when 4th argument is not a composite operator' do
+      expect { img1.composite(img2, 0, 0, 2) }.to raise_error(TypeError)
+    end
+  end
+
+  context 'when given 5 arguments' do
+    it 'works when 2nd argument is gravity and 5th is a composite operator' do
+      composite_ops.each do |op|
+        gravity.each do |grav|
+          expect { img1.composite(img2, grav, 0, 0, op) }.not_to raise_error
+        end
+      end
+    end
+
+    it 'raises an error when 2nd argument is not a gravity' do
+      expect do
+        img1.composite(img2, 0, 0, 2, Magick::OverCompositeOp)
+      end.to raise_error(TypeError)
+    end
+  end
+
+  it 'raises an error when the image has been destroyed' do
+    img2.destroy!
+    expect do
+      img1.composite(img2, Magick::CenterGravity, Magick::OverCompositeOp)
+    end.to raise_error(Magick::DestroyedImageError)
+  end
+
+end

data/spec/rmagick/image/constitute_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Magick::Image, '#constitute' do
+
+  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
+  let(:pixels) { img.dispatch(0, 0, img.columns, img.rows, 'RGBA') }
+
+  it 'returns an equivalent image to the given pixels' do
+    res = Magick::Image.constitute(img.columns, img.rows, 'RGBA', pixels)
+    # The constituted image is in MIFF format so we
+    # can't compare it directly to the original image.
+    expect(res.columns).to eq img.columns
+    expect(res.rows).to eq img.rows
+    expect(pixels.all? { |v| 0 <= v && v <= Magick::QuantumRange }).to be true
+  end
+
+end

data/spec/rmagick/image/dispatch_spec.rb

@@ -0,0 +1,18 @@
+RSpec.describe Magick::Image, '#dispatch' do
+
+  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
+
+  it 'expects exactly 5 or 6 arguments' do
+    expect { img.dispatch }.to raise_error(ArgumentError)
+    expect { img.dispatch(0) }.to raise_error(ArgumentError)
+    expect { img.dispatch(0, 0) }.to raise_error(ArgumentError)
+    expect { img.dispatch(0, 0, img.columns) }.to raise_error(ArgumentError)
+    expect do
+      img.dispatch(0, 0, img.columns, img.rows)
+    end.to raise_error(ArgumentError)
+    expect do
+      img.dispatch(0, 0, 20, 20, 'RGBA', false, false)
+    end.to raise_error(ArgumentError)
+  end
+
+end

data/spec/rmagick/image/from_blob_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe Magick::Image, '#from_blob' do
+
+  let(:img) { Magick::Image.read(IMAGES_DIR+'/Button_0.gif').first }
+  let(:blob) { img.to_blob }
+
+  it 'returns an image equal to the original' do
+    expect(blob).to be_instance_of(String)
+    res = Magick::Image.from_blob(blob)
+    expect(res).to be_instance_of(Array)
+    expect(res.first).to be_instance_of(Magick::Image)
+    expect(res.first).to eq img
+  end
+
+end

data/spec/rmagick/image/ping_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe Magick::Image, '#ping' do
+
+  it 'returns an image from the source, omitting pixel data' do
+    res = Magick::Image.ping(IMAGES_DIR+'/Button_0.gif')
+    expect(res).to be_instance_of(Array)
+    image = res.first
+    expect(image).to be_instance_of(Magick::Image)
+    expect(image.format).to eq 'GIF'
+    expect(image.columns).to eq 127
+    expect(image.rows).to eq 120
+    expect(image.filename).to match(/Button_0.gif/)
+  end
+
+end

data/spec/rmagick/image/properties_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe Magick::Image, '#properties' do
+
+  let(:img) { Magick::Image.new(20, 20) }
+  let(:freeze_error) { RUBY_VERSION[/^1\.9|^2/] ? RuntimeError : TypeError }
+
+  before(:each) do
+    img['a'] = 'str_1'
+    img['b'] = 'str_2'
+    img['c'] = 'str_3'
+  end
+
+  it 'allows assignment of arbitrary properties' do
+    expect(img['a']).to eq 'str_1'
+    expect(img['b']).to eq 'str_2'
+    expect(img['c']).to eq 'str_3'
+    expect(img['d']).to be nil
+  end
+
+  it 'returns a hash of assigned properties' do
+    expected_properties = { 'a' => 'str_1', 'b' => 'str_2', 'c' => 'str_3' }
+    expect(img.properties).to eq(expected_properties)
+  end
+
+  it 'raises an error when trying to assign properties to a frozen image' do
+    img.freeze
+    expect { img['d'] = 'str_4' }.to raise_error(freeze_error)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rmagick'
+
+root_dir = File.expand_path('../..', __FILE__)
+IMAGES_DIR = File.join(root_dir, 'doc/ex/images')