rmagick 2.15.3 → 2.15.4

data/lib/rvg/text.rb

@@ -3,7 +3,6 @@
 # Copyright (C) 2009 Timothy P. Hunter
 #++
 # Text-related classes
-
 module Magick
     class RVG
         # Base class for Tspan, Tref and Text.

data/lib/rvg/transformable.rb

@@ -2,125 +2,125 @@
 # $Id: transformable.rb,v 1.5 2009/02/28 23:52:28 rmagick Exp $
 # Copyright (C) 2009 Timothy P. Hunter
 #++
-
 module Magick
-    class RVG
-        # Transforms is an Array with a deep_copy method.
-        # During unit-testing it also has a deep_equal method.
-        class Transforms < Array        #:nodoc:
-            def deep_copy(h=nil)
-                copy = self.class.new
-                each { |transform| copy << [transform[0], transform[1].dup] }
-                copy
-            end
-        end     # class Transform
+  class RVG
+    # Transforms is an Array with a deep_copy method.
+    # During unit-testing it also has a deep_equal method.
+    class Transforms < Array #:nodoc:
+      def deep_copy(h = nil)
+        copy = self.class.new
+        each { |transform| copy << [transform[0], transform[1].dup] }
+        copy
+      end
+    end     # class Transform
 
-        # Transformations are operations on the coordinate system.
-        # All the transformations defined within a container (an RVG object
-        # or a group) are applied before drawing any shapes or text.
-        # All transformations are applied in the order they were
-        # defined. <em>Note:</em> This means that
-        #   g.translate(10,20).scale(2)
-        # is not the same as
-        #   g.scale(2).translate(10,20)
-        module Transformable
-          private
+    # Transformations are operations on the coordinate system.
+    # All the transformations defined within a container (an RVG object
+    # or a group) are applied before drawing any shapes or text.
+    # All transformations are applied in the order they were
+    # defined. <em>Note:</em> This means that
+    #   g.translate(10,20).scale(2)
+    # is not the same as
+    #   g.scale(2).translate(10,20)
+    module Transformable
+      private
 
-            # Apply transforms in the same order they were specified!
-            def add_transform_primitives(gc)
-                @transforms.each { |transform| gc.__send__(transform[0], *transform[1]) }
-            end
+      # Apply transforms in the same order they were specified!
+      def add_transform_primitives(gc)
+        @transforms.each { |transform| gc.__send__(transform[0], *transform[1]) }
+      end
 
-            def initialize(*args, &block)
-                super()
-                @transforms = Transforms.new
-            end
+      def initialize(*args, &block)
+        super()
+        @transforms = Transforms.new
+      end
 
-          public
+      public
 
-            # Applies the transformation matrix [sx, rx, ry, sy, tx, ty]
-            def matrix(sx, rx, ry, sy, tx, ty)
-                begin
-                    @transforms << [:affine, [Float(sx), Float(rx), Float(ry), Float(sy), Float(tx), Float(ty)]]
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{rx.class}, #{ry.class}, #{sy.class}, #{sx.class}, #{sx.class}, #{tx.class}, #{ty.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
+      # Applies the transformation matrix [sx, rx, ry, sy, tx, ty]
+      def matrix(sx, rx, ry, sy, tx, ty)
+        begin
+          @transforms << [:affine, [Float(sx), Float(rx), Float(ry), Float(sy), Float(tx), Float(ty)]]
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{rx.class}, #{ry.class}, #{sy.class}, #{sx.class}, #{sx.class}, #{tx.class}, #{ty.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
 
-            # Add <tt>tx</tt> to all x-coordinates and <tt>ty</tt>
-            # to all y-coordinates. If <tt>ty</tt> is omitted it defaults
-            # to <tt>tx</tt>.
-            def translate(tx, ty=nil)
-                ty ||= tx
-                begin
-                    @transforms << [:translate, [Float(tx), Float(ty)]]
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{tx.class}, #{ty.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
+      # Add <tt>tx</tt> to all x-coordinates and <tt>ty</tt>
+      # to all y-coordinates. If <tt>ty</tt> is omitted it defaults
+      # to <tt>tx</tt>.
+      def translate(tx, ty = nil)
+        ty ||= tx
+        begin
+          @transforms << [:translate, [Float(tx), Float(ty)]]
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{tx.class}, #{ty.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
 
-            # Multiply the x-coordinates by <tt>sx</tt> and the y-coordinates
-            # by <tt>sy</tt>. If <tt>sy</tt> is omitted it defaults to <tt>sx</tt>.
-            def scale(sx, sy=nil)
-                sy ||= sx
-                begin
-                    @transforms << [:scale, [Float(sx), Float(sy)]]
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{sy.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
+      # Multiply the x-coordinates by <tt>sx</tt> and the y-coordinates
+      # by <tt>sy</tt>. If <tt>sy</tt> is omitted it defaults to <tt>sx</tt>.
+      def scale(sx, sy = nil)
+        sy ||= sx
+        begin
+          @transforms << [:scale, [Float(sx), Float(sy)]]
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{sy.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
 
-            # This method can take either of two argument lists:
-            # [rotate(angle)] rotate by <tt>angle</tt> degrees
-            # [rotate(angle, cx, cy)] rotate by <tt>angle</tt> degrees about
-            #                         the point [<tt>cx</tt>, <tt>cy</tt>].
-            def rotate(angle, *args)
-                begin
-                    case args.length
-                        when 0
-                            @transforms << [:rotate, [Float(angle)]]
-                        when 2
-                            cx, cy = Float(args[0]), Float(args[1])
-                            @transforms << [:translate, [cx, cy]]
-                            @transforms << [:rotate, [angle]]
-                            @transforms << [:translate, [-cx, -cy]]
-                        else
-                            fail ArgumentError, "wrong number of arguments (#{args.length} for 1 or 3)"
-                    end
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{[angle, *args].collect {|a| a.class}.join(', ')})"
-                end
-                yield(self) if block_given?
-                self
-            end
+      # This method can take either of two argument lists:
+      # [rotate(angle)] rotate by <tt>angle</tt> degrees
+      # [rotate(angle, cx, cy)] rotate by <tt>angle</tt> degrees about
+      #                         the point [<tt>cx</tt>, <tt>cy</tt>].
+      def rotate(angle, *args)
+        begin
+          case args.length
+            when 0
+              @transforms << [:rotate, [Float(angle)]]
+            when 2
+              cx = Float(args[0])
+              cy = Float(args[1])
+              @transforms << [:translate, [cx, cy]]
+              @transforms << [:rotate, [angle]]
+              @transforms << [:translate, [-cx, -cy]]
+            else
+              fail ArgumentError, "wrong number of arguments (#{args.length} for 1 or 3)"
+          end
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{[angle, *args].collect {|a| a.class}.join(', ')})"
+        end
+        yield(self) if block_given?
+        self
+      end
 
-            # Skew the X-axis by <tt>angle</tt> degrees.
-            def skewX(angle)
-                begin
-                    @transforms << [:skewx, [Float(angle)]]
-                rescue ArgumentError
-                    raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
+      # Skew the X-axis by <tt>angle</tt> degrees.
+      def skewX(angle)
+        begin
+          @transforms << [:skewx, [Float(angle)]]
+        rescue ArgumentError
+          raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
 
-            # Skew the Y-axis by <tt>angle</tt> degrees.
-            def skewY(angle)
-                begin
-                    @transforms << [:skewy, [Float(angle)]]
-                rescue ArgumentError
-                    raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
-        end     # module Transformable
-    end # class RVG
+      # Skew the Y-axis by <tt>angle</tt> degrees.
+      def skewY(angle)
+        begin
+          @transforms << [:skewy, [Float(angle)]]
+        rescue ArgumentError
+          raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
+    end     # module Transformable
+  end # class RVG
 end # module Magick

data/lib/rvg/units.rb

@@ -1,63 +1,63 @@
 # $Id: units.rb,v 1.5 2009/02/28 23:52:28 rmagick Exp $
 # Copyright (C) 2009 Timothy P. Hunter
 module Magick
-    class RVG
-        # Define RVG.dpi and RVG.dpi=. Add conversions to Fixnum and Float classes
-        class << self
-            attr_reader :dpi
-            def dpi=(n)
-                unless defined?(@dpi)
-                    [Float, Fixnum].each do |c|
-                        c.class_eval <<-END_DEFS
-                            # the default measurement - 1px is 1 pixel
-                            def px
-                                self
-                            end
-                            # inches
-                            def in
-                                self * ::Magick::RVG.dpi
-                            end
-                            # millimeters
-                            def mm
-                                self * ::Magick::RVG.dpi / 25.4
-                            end
-                            # centimeters
-                            def cm
-                                self * ::Magick::RVG.dpi / 2.54
-                            end
-                            # points
-                            def pt
-                                self * ::Magick::RVG.dpi / 72.0
-                            end
-                            # picas
-                            def pc
-                                self * ::Magick::RVG.dpi / 6.0
-                            end
-                            # percentage of the argument
-                            def pct(of)
-                                self * Float(of) / 100.0
-                            end
-                            # the default is deg
-                            def deg
-                                self
-                            end
-                            # radians -> degrees
-                            def rad
-                                self * 180.0 / Math::PI
-                            end
-                            # grads -> degrees
-                            def grad
-                                self * 9.0 / 10.0
-                            end
-                        END_DEFS
-                    end
-                end
+  class RVG
+    # Define RVG.dpi and RVG.dpi=. Add conversions to Fixnum and Float classes
+    class << self
+      attr_reader :dpi
+      def dpi=(n)
+        unless defined?(@dpi)
+          [Float, Fixnum].each do |c|
+            c.class_eval <<-END_DEFS
+              # the default measurement - 1px is 1 pixel
+              def px
+                self
+              end
+              # inches
+              def in
+                self * ::Magick::RVG.dpi
+              end
+              # millimeters
+              def mm
+                self * ::Magick::RVG.dpi / 25.4
+              end
+              # centimeters
+              def cm
+                self * ::Magick::RVG.dpi / 2.54
+              end
+              # points
+              def pt
+                self * ::Magick::RVG.dpi / 72.0
+              end
+              # picas
+              def pc
+                self * ::Magick::RVG.dpi / 6.0
+              end
+              # percentage of the argument
+              def pct(of)
+                self * Float(of) / 100.0
+              end
+              # the default is deg
+              def deg
+                self
+              end
+              # radians -> degrees
+              def rad
+                self * 180.0 / Math::PI
+              end
+              # grads -> degrees
+              def grad
+                self * 9.0 / 10.0
+              end
+            END_DEFS
+          end
+        end
 
-                @dpi = Float(n)
-                return @dpi
-            rescue ArgumentError
-                raise TypeError, "Can't convert `#{n}' to Float"
-            end
-        end     # class << self
-    end # class RVG
+        @dpi = Float(n)
+        return @dpi
+      rescue ArgumentError
+        raise TypeError, "Can't convert `#{n}' to Float"
+      end
+    end     # class << self
+  end # class RVG
 end # module Magick

data/rmagick.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec', '~> 3.2.0'
 
   if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('1.9.2')
-    s.add_development_dependency 'rubocop'
+    s.add_development_dependency 'rubocop', '~> 0.33.0'
   end
 
   if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.2.0')

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