rmagick-windows 2.16.1

data/lib/rvg/transformable.rb

@@ -0,0 +1,126 @@
+#--
+# $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
+
+    # 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
+
+      def initialize(*args, &block)
+        super()
+        @transforms = Transforms.new
+      end
+
+      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
+
+      # 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
+
+      # 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 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

@@ -0,0 +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
+
+        @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

@@ -0,0 +1,46 @@
+require 'date'
+require 'English'
+require './lib/rmagick/version'
+
+def v(version)
+  Gem::Version.new(version)
+end
+
+# RUBY = v(RUBY_VERSION.dup)
+
+Gem::Specification.new do |s|
+  s.name = 'rmagick-windows'
+  s.version = Magick::VERSION
+  s.date = Date.today.to_s
+  s.summary = 'Ruby binding to ImageMagick'
+  s.description = 'RMagick is an interface between Ruby and ImageMagick. Fix for windows.'
+  s.authors = ['Tim Hunter', 'Omer Bar-or', 'Benjamin Thomas', 'Moncef Maiza', 'Cedric Zuger']
+  s.email = 'github@benjaminfleischer.com'
+  s.homepage = 'https://github.com/czuger/rmagick'
+  s.license = 'MIT'
+
+  tracked_files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  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' << 'deprecated'
+
+  s.rubyforge_project = 'rmagick'
+  s.extensions = %w{ext/RMagick/extconf.rb}
+  s.has_rdoc = false
+  s.required_ruby_version = ">= #{Magick::MIN_RUBY_VERSION}"
+  s.requirements << "ImageMagick #{Magick::MIN_IM_VERSION} or later"
+
+  s.add_development_dependency 'rake-compiler'
+  s.add_development_dependency 'rspec', '~> 3'
+  s.add_development_dependency 'rubocop', '~> 0.33.0'
+
+  # if RUBY >= v('2.2.0')
+  #   s.add_development_dependency 'test-unit', '~> 2'
+  # end
+end

data/spec/rmagick/ImageList1_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe Magick::ImageList do
+  describe 'images_from_imagelist' do
+    it 'works with identical instances' do
+      expect do
+        img = Magick::Image.new(1, 1)
+        list = Magick::ImageList.new
+        list << img << img
+        res = list.append(false)
+        expect(res.columns).to eq(2)
+        expect(res.rows).to eq(1)
+      end.not_to raise_error
+
+      expect do
+        img = Magick::Image.new(1, 1)
+        img2 = Magick::Image.new(3, 3)
+        list = Magick::ImageList.new
+        list.concat([img, img2, img, img2, img])
+        res = list.append(false)
+        expect(res.columns).to eq(9)
+        expect(res.rows).to eq(3)
+      end.not_to raise_error
+    end
+  end
+end

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