gosu_enhanced 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86a01316020552b01f0150a2bb8959dbdbdeaa21
-  data.tar.gz: 275b3afa6758e7a4c5183ebb39ecfe66714dfab3
+  metadata.gz: 1ef82237800c5e7fd75f41a937f99d7b808404ab
+  data.tar.gz: b98df43837d6c32aea1ac89ed56535312aba3122
 SHA512:
-  metadata.gz: 6f4abcb1c2bcaffac031df9bdd7fc1f167de6b0d96204d7657eb558c79221c8ca470d79eb3d542a7371e8f188a3cd45bf2877eac468cbc049fa42bbeba95e469
-  data.tar.gz: 5bff949502d28ffe791207ed7b363efdfe98b7d8c75f5a25646d7b4d8a641434bdbe3829d4483502c05f79ae86633d032ec0aa369a556edf505cc5d31cbc3b2c
+  metadata.gz: a72b1e8286b8db6942610d7a3c5ecae0ea1f0406266141867e242d38359cf9b9bde2b0d89b5ff267f1142d725f6d43e854e76e724f29faa9daef78e84118bce0
+  data.tar.gz: ffb4c4a46f40322495bed1705429e7e36d13a439aa8c7dcfb2a0502d9c25c17c9bd215c2da938a98a58645cdf31586b9534addd1cf0a9673180f6ea6b5c2be3d

data/Gemfile.lock

@@ -1,49 +1,24 @@
 PATH
   remote: .
   specs:
-    gosu_enhanced (0.3.4)
+    gosu_enhanced (0.4.1)
       gosu (~> 0.10)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    coderay (1.1.0)
-    diff-lcs (1.2.5)
-    gosu (0.10.0)
-    method_source (0.8.2)
-    pry (0.10.0)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rake (0.9.6)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.2)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.2)
-      rspec-support (~> 3.0.0)
-    rspec-nc (0.1.0)
-      rspec (>= 2.9)
-      terminal-notifier (~> 1.4.2)
-    rspec-support (3.0.2)
-    slop (3.5.0)
-    terminal-notifier (1.4.2)
+    gosu (0.10.1.2)
+    minitest (5.8.0)
+    rake (10.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler
+  bundler (~> 1.10)
   gosu_enhanced!
-  pry
-  rake
-  rspec
-  rspec-nc
+  minitest (~> 5.8)
+  rake (~> 10.0)
 
 BUNDLED WITH
    1.10.6

data/Rakefile

@@ -1,10 +1,10 @@
-require 'rspec/core/rake_task'
-require 'bundler/gem_tasks'
+require 'rake'
+require 'rake/testtask'
 
-# Default directory for tests is ./spec
-# Run with rake spec
-RSpec::Core::RakeTask.new(:spec) do |task|
-  task.rspec_opts = ['--color']
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
 end
 
-task default: :spec
+task default: :test

data/gosu_enhanced.gemspec

@@ -26,7 +26,5 @@ of text in a rectangle size.)
 
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rspec-nc', '~> 0.2'
-  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'minitest', '~> 5.8'
 end

data/lib/gosu_enhanced/point.rb

@@ -59,5 +59,7 @@ module GosuEnhanced
   def Point(x, y)
     Point.new(x, y)
   end
+
+  module_function :Point
 end
 

data/lib/gosu_enhanced/region.rb

@@ -15,13 +15,19 @@ module GosuEnhanced
     attr_reader :size
 
     # Create a new region with specified +pos+ as top left corner and +size+
-    # as width and height
+    # as width and height.
+    #
+    # Alternatively, can be initialized with 2 +Point+s.
+
     def initialize(pos, size)
+      size = Size.new(size.x - pos.x, size.y - pos.y) if size.respond_to? :x
+
       @position = pos.dup
       @size = size.dup
     end
 
     # Return whether the region contains the specified +row+ and +col+
+    # Alternatively, can be passed a +Point+
     def contains?(col, row = nil)
       return contains_point?(col) if col.respond_to? :x
 
@@ -39,7 +45,6 @@ module GosuEnhanced
       position.x
     end
 
-    # It is necessary to override dup to produce an actual duplicate.
     def dup
       Region.new(position, size)
     end
@@ -57,10 +62,15 @@ module GosuEnhanced
 
     private
 
-    # NODOC
     def contains_point?(pt)
       pt.x.between?(left, left + width - 1) &&
         pt.y.between?(top, top + height - 1)
     end
   end
+
+  def Region(pos, size)
+    Region.new(pos, size)
+  end
+
+  module_function :Region
 end

data/lib/gosu_enhanced/size.rb

@@ -109,4 +109,6 @@ module GosuEnhanced
   def Size(x, y)
     Size.new(x, y)
   end
+
+  module_function :Size
 end

data/lib/gosu_enhanced/version.rb

@@ -1,5 +1,5 @@
 # Version of the gosu_enhanced gem.
 module GosuEnhanced
   # gosu_enhanced gem version
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/{spec/point_spec.rb → test/point_test.rb}

@@ -1,25 +1,31 @@
-require 'spec_helper'
+require 'test_helper'
 
 describe GosuEnhanced::Point do
   describe '#initialize' do
     it 'should work with two positive values' do
       point = GosuEnhanced::Point.new(10, 20)
-      expect(point.x).to eq 10
-      expect(point.y).to eq 20
+      point.x.must_equal 10
+      point.y.must_equal 20
     end
 
     it 'should work with negative values' do
       point = GosuEnhanced::Point.new(-10, 20)
-      expect(point.x).to eq(-10)
-      expect(point.y).to eq 20
+      point.x.must_equal(-10)
+      point.y.must_equal 20
 
       point = GosuEnhanced::Point.new(10, -20)
-      expect(point.x).to eq 10
-      expect(point.y).to eq(-20)
+      point.x.must_equal 10
+      point.y.must_equal(-20)
 
       point = GosuEnhanced::Point.new(-10, -20)
-      expect(point.x).to eq(-10)
-      expect(point.y).to eq(-20)
+      point.x.must_equal(-10)
+      point.y.must_equal(-20)
+    end
+
+    it "should work with the utility function" do
+      point = GosuEnhanced::Point(10, 20)
+      point.x.must_equal 10
+      point.y.must_equal 20
     end
   end
 
@@ -27,36 +33,36 @@ describe GosuEnhanced::Point do
     it 'should work with another Point' do
       point  = GosuEnhanced::Point.new(10, 20)
       opoint = point.offset(GosuEnhanced::Point.new(30, 40))
-      expect(opoint.x).to eq 40
-      expect(opoint.y).to eq 60
+      opoint.x.must_equal 40
+      opoint.y.must_equal 60
     end
 
     it 'should work with a Size' do
       point  = GosuEnhanced::Point.new(10, 20)
       opoint = point.offset(GosuEnhanced::Size.new(50, 60))
-      expect(opoint.x).to eq 60
-      expect(opoint.y).to eq 80
+      opoint.x.must_equal 60
+      opoint.y.must_equal 80
     end
 
     it 'should work with two positive values' do
       point  = GosuEnhanced::Point.new(10, 20)
       opoint = point.offset(40, 50)
-      expect(opoint.x).to eq 50
-      expect(opoint.y).to eq 70
+      opoint.x.must_equal 50
+      opoint.y.must_equal 70
     end
 
     it 'should work with two negative values' do
       point  = GosuEnhanced::Point.new(60, 80)
       opoint = point.offset(-40, -50)
-      expect(opoint.x).to eq 20
-      expect(opoint.y).to eq 30
+      opoint.x.must_equal 20
+      opoint.y.must_equal 30
     end
 
     it 'should work with values that result in negative co-ordinates' do
       point  = GosuEnhanced::Point.new(60, 80)
       opoint = point.offset(-80, -150)
-      expect(opoint.x).to eq(-20)
-      expect(opoint.y).to eq(-70)
+      opoint.x.must_equal(-20)
+      opoint.y.must_equal(-70)
     end
   end
 
@@ -64,36 +70,36 @@ describe GosuEnhanced::Point do
     it 'should work with another Point' do
       point  = GosuEnhanced::Point.new(10, 20)
       point.move_by!(GosuEnhanced::Point.new(30, 40))
-      expect(point.x).to eq 40
-      expect(point.y).to eq 60
+      point.x.must_equal 40
+      point.y.must_equal 60
     end
 
     it 'should work with a Size' do
       point  = GosuEnhanced::Point.new(10, 20)
       point.move_by!(GosuEnhanced::Size.new(40, 50))
-      expect(point.x).to eq 50
-      expect(point.y).to eq 70
+      point.x.must_equal 50
+      point.y.must_equal 70
     end
 
     it 'should work with two positive values' do
       point  = GosuEnhanced::Point.new(10, 20)
       point.move_by!(40, 50)
-      expect(point.x).to eq 50
-      expect(point.y).to eq 70
+      point.x.must_equal 50
+      point.y.must_equal 70
     end
 
     it 'should work with two negative values' do
       point  = GosuEnhanced::Point.new(60, 80)
       point.move_by!(-40, -50)
-      expect(point.x).to eq 20
-      expect(point.y).to eq 30
+      point.x.must_equal 20
+      point.y.must_equal 30
     end
 
     it 'should work with values that result in negative co-ordinates' do
       point  = GosuEnhanced::Point.new(60, 80)
       point.move_by!(-80, -150)
-      expect(point.x).to eq(-20)
-      expect(point.y).to eq(-70)
+      point.x.must_equal(-20)
+      point.y.must_equal(-70)
     end
   end
 
@@ -101,22 +107,22 @@ describe GosuEnhanced::Point do
     it 'should work with another Point' do
       point  = GosuEnhanced::Point.new(10, 20)
       point.move_to!(GosuEnhanced::Point.new(30, 40))
-      expect(point.x).to eq 30
-      expect(point.y).to eq 40
+      point.x.must_equal 30
+      point.y.must_equal 40
     end
 
     it 'should work with two positive values' do
       point  = GosuEnhanced::Point.new(10, 20)
       point.move_to!(40, 50)
-      expect(point.x).to eq 40
-      expect(point.y).to eq 50
+      point.x.must_equal 40
+      point.y.must_equal 50
     end
 
     it 'should work with two negative values' do
       point  = GosuEnhanced::Point.new(60, 80)
       point.move_to!(-40, -50)
-      expect(point.x).to eq(-40)
-      expect(point.y).to eq(-50)
+      point.x.must_equal(-40)
+      point.y.must_equal(-50)
     end
   end
 
@@ -127,25 +133,25 @@ describe GosuEnhanced::Point do
       point  = GosuEnhanced::Point.new(10, 20)
       npoint = point.dup
 
-      expect(point.x).to eq 10
-      expect(point.y).to eq 20
+      point.x.must_equal 10
+      point.y.must_equal 20
 
-      expect(npoint.x).to eq 10
-      expect(npoint.y).to eq 20
+      npoint.x.must_equal 10
+      npoint.y.must_equal 20
 
       npoint.move_to!(40, 50)
-      expect(npoint.x).to eq 40
-      expect(npoint.y).to eq 50
+      npoint.x.must_equal 40
+      npoint.y.must_equal 50
 
-      expect(point.x).to eq 10
-      expect(point.y).to eq 20
+      point.x.must_equal 10
+      point.y.must_equal 20
     end
   end
 
   describe '#to_s' do
     it 'should render usefully.' do
       point  = GosuEnhanced::Point.new(10, 20)
-      expect(point.to_s).to eq '#<struct GosuEnhanced::Point x=10, y=20>'
+      point.to_s.must_equal '#<struct GosuEnhanced::Point x=10, y=20>'
     end
   end
 end

data/{spec/region_delegation_spec.rb → test/region_delegation_test.rb}

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'test_helper'
 
 describe GosuEnhanced::Region do
   let(:point) { GosuEnhanced::Point.new(10, 20) }
@@ -7,28 +7,28 @@ describe GosuEnhanced::Region do
   describe '#x' do
     it 'should return the left (x) co-ordinate' do
       reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.x).to eq 10
+      reg.x.must_equal 10
     end
   end
 
   describe '#y' do
     it 'should return the top (y) co-ordinate' do
       reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.y).to eq 20
+      reg.y.must_equal 20
     end
   end
 
   describe '#width' do
     it 'should return the width' do
       reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.width).to eq 30
+      reg.width.must_equal 30
     end
   end
 
   describe '#height' do
     it 'should return the height' do
       reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.height).to eq 40
+      reg.height.must_equal 40
     end
   end
 
@@ -36,40 +36,40 @@ describe GosuEnhanced::Region do
     it 'should work with a Point' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_by!(GosuEnhanced::Point.new(30, 40))
-      expect(reg.left).to eq 40
-      expect(reg.top).to eq 60
+      reg.left.must_equal 40
+      reg.top.must_equal 60
 
       # The original point should not have been changed by the move_by!
-      expect(point.x).to eq 10
-      expect(point.y).to eq 20
+      point.x.must_equal 10
+      point.y.must_equal 20
     end
 
     it 'should work with a Size' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_by!(GosuEnhanced::Size.new(40, 50))
-      expect(reg.left).to eq 50
-      expect(reg.top).to eq 70
+      reg.left.must_equal 50
+      reg.top.must_equal 70
     end
 
     it 'should work with two positive values' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_by!(40, 50)
-      expect(reg.left).to eq 50
-      expect(reg.top).to eq 70
+      reg.left.must_equal 50
+      reg.top.must_equal 70
     end
 
     it 'should work with two negative values' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_by!(-5, -10)
-      expect(reg.left).to eq 5
-      expect(reg.top).to eq 10
+      reg.left.must_equal 5
+      reg.top.must_equal 10
     end
 
     it 'should work with values that result in negative co-ordinates' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_by!(-80, -150)
-      expect(reg.left).to eq(-70)
-      expect(reg.top).to eq(-130)
+      reg.left.must_equal(-70)
+      reg.top.must_equal(-130)
     end
   end
 
@@ -77,25 +77,25 @@ describe GosuEnhanced::Region do
     it 'should work with a Point' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_to!(GosuEnhanced::Point.new(30, 40))
-      expect(reg.left).to eq 30
-      expect(reg.top).to eq 40
+      reg.left.must_equal 30
+      reg.top.must_equal 40
 
-      expect(point.x).to eq 10
-      expect(point.y).to eq 20
+      point.x.must_equal 10
+      point.y.must_equal 20
     end
 
     it 'should work with two positive values' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_to!(40, 50)
-      expect(reg.left).to eq 40
-      expect(reg.top).to eq 50
+      reg.left.must_equal 40
+      reg.top.must_equal 50
     end
 
     it 'should work with two negative values' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.move_to!(-5, -10)
-      expect(reg.left).to eq(-5)
-      expect(reg.top).to eq(-10)
+      reg.left.must_equal(-5)
+      reg.top.must_equal(-10)
     end
   end
 
@@ -103,33 +103,33 @@ describe GosuEnhanced::Region do
     it 'should work with a Size' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.inflate!(GosuEnhanced::Size.new(30, 40))
-      expect(reg.width).to eq 60
-      expect(reg.height).to eq 80
+      reg.width.must_equal 60
+      reg.height.must_equal 80
 
       # The original size should not have been changed by the inflate!
-      expect(size.width).to eq 30
-      expect(size.height).to eq 40
+      size.width.must_equal 30
+      size.height.must_equal 40
     end
 
     it 'should work with two values' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.inflate!(40, 50)
-      expect(reg.width).to eq 70
-      expect(reg.height).to eq 90
+      reg.width.must_equal 70
+      reg.height.must_equal 90
     end
 
     it 'should work with negative values' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.inflate!(-20, -35)
-      expect(reg.width).to eq 10
-      expect(reg.height).to eq 5
+      reg.width.must_equal 10
+      reg.height.must_equal 5
     end
 
     it 'should raise an error with out-of-range values' do
       reg = GosuEnhanced::Region.new(point, size)
-      expect { reg.inflate!(-50, -20) }.to raise_error Exception
-      expect { reg.inflate!(-25, -60) }.to raise_error Exception
-      expect { reg.inflate!(-50, -70) }.to raise_error Exception
+      expect { reg.inflate!(-50, -20) }.must_raise Exception
+      expect { reg.inflate!(-25, -60) }.must_raise Exception
+      expect { reg.inflate!(-50, -70) }.must_raise Exception
     end
   end
 
@@ -137,25 +137,25 @@ describe GosuEnhanced::Region do
     it 'should work with a Size' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.deflate!(GosuEnhanced::Size.new(20, 35))
-      expect(reg.width).to eq 10
-      expect(reg.height).to eq 5
+      reg.width.must_equal 10
+      reg.height.must_equal 5
 
-      expect(size.width).to eq 30
-      expect(size.height).to eq 40
+      size.width.must_equal 30
+      size.height.must_equal 40
     end
 
     it 'should work with two values' do
       reg = GosuEnhanced::Region.new(point, size)
       reg.deflate!(10, 25)
-      expect(reg.width).to eq 20
-      expect(reg.height).to eq 15
+      reg.width.must_equal 20
+      reg.height.must_equal 15
     end
 
     it 'should raise an error for out-of-range values' do
       reg = GosuEnhanced::Region.new(point, size)
-      expect { reg.deflate!(25, 50) }.to raise_error Exception
-      expect { reg.deflate!(60, 35) }.to raise_error Exception
-      expect { reg.deflate!(80, 70) }.to raise_error Exception
+      expect { reg.deflate!(25, 50) }.must_raise Exception
+      expect { reg.deflate!(60, 35) }.must_raise Exception
+      expect { reg.deflate!(80, 70) }.must_raise Exception
     end
   end
 end

data/test/region_test.rb

@@ -0,0 +1,112 @@
+require 'test_helper'
+
+describe GosuEnhanced::Region do
+  let(:point) { GosuEnhanced::Point.new(10, 20) }
+  let(:size)  { GosuEnhanced::Size.new(30, 40) }
+
+  describe '#initialize' do
+    it 'should work with a Point and a Size' do
+      reg = GosuEnhanced::Region.new(point, size)
+
+      reg.position.must_equal GosuEnhanced::Point.new(10, 20)
+      reg.size.must_equal GosuEnhanced::Size.new(30, 40)
+    end
+
+    it 'should work with 2 Points' do
+      point2 = GosuEnhanced::Point.new(40, 60)
+      reg    = GosuEnhanced::Region.new(point, point2)
+
+      reg.position.must_equal GosuEnhanced::Point.new(10, 20)
+      reg.size.must_equal GosuEnhanced::Size.new(30, 40)
+    end
+
+    it 'should work with the utility function' do
+      reg = GosuEnhanced.Region(point, size)
+
+      reg.position.must_equal GosuEnhanced::Point.new(10, 20)
+      reg.size.must_equal GosuEnhanced::Size.new(30, 40)
+    end
+  end
+
+  describe '#position' do
+    it 'should return the position as a Point' do
+      reg = GosuEnhanced::Region.new(point, size)
+      reg.position.must_equal GosuEnhanced::Point.new(10, 20)
+    end
+  end
+
+  describe '#top' do
+    it 'should return the top co-ordinate' do
+      reg = GosuEnhanced::Region.new(point, size)
+      reg.top.must_equal 20
+    end
+  end
+
+  describe '#left' do
+    it 'should return the left co-ordinate' do
+      reg = GosuEnhanced::Region.new(point, size)
+      reg.left.must_equal 10
+    end
+  end
+
+  describe '#size' do
+    it 'should return the size as a Size' do
+      reg = GosuEnhanced::Region.new(point, size)
+      reg.size.must_equal GosuEnhanced::Size.new(30, 40)
+    end
+  end
+
+  describe '#contains?' do
+    it 'should work with two co-ordinates' do
+      reg = GosuEnhanced::Region.new(point, size)
+      reg.contains?(10, 20).must_equal true
+      reg.contains?(20, 35).must_equal true
+      reg.contains?(29, 59).must_equal true
+      reg.contains?(30, 60).must_equal false
+    end
+
+    it 'should work with a Point' do
+      reg = GosuEnhanced::Region.new(point, size)
+      reg.contains?(GosuEnhanced::Point.new(10, 20)).must_equal true
+      reg.contains?(GosuEnhanced::Point.new(20, 35)).must_equal true
+      reg.contains?(GosuEnhanced::Point.new(29, 59)).must_equal true
+      reg.contains?(GosuEnhanced::Point.new(30, 60)).must_equal false
+    end
+  end
+
+  # Unlike the Point and Size, a Region needs a dup override to actually return
+  # a duplicate correctly.
+
+  describe '#dup' do
+    it 'should duplicate a region without affecting the copied region' do
+      reg     = GosuEnhanced::Region.new(point, size)
+      new_reg = reg.dup
+
+      reg.position.must_equal GosuEnhanced::Point.new(10, 20)
+      reg.size.must_equal GosuEnhanced::Size.new(30, 40)
+
+      new_reg.position.must_equal GosuEnhanced::Point.new(10, 20)
+      new_reg.size.must_equal GosuEnhanced::Size.new(30, 40)
+
+      new_reg.move_to!(20, 30)
+      new_reg.inflate!(10, 10)
+      new_reg.position.must_equal GosuEnhanced::Point.new(20, 30)
+      new_reg.size.must_equal GosuEnhanced::Size.new(40, 50)
+
+      reg.position.must_equal GosuEnhanced::Point.new(10, 20)
+      reg.size.must_equal GosuEnhanced::Size.new(30, 40)
+    end
+  end
+
+  describe '#to_s' do
+    it 'should render usefully' do
+      point   = GosuEnhanced::Point.new(10, 20)
+      size    = GosuEnhanced::Size.new(30, 40)
+      region  = GosuEnhanced::Region.new(point, size)
+
+      region.to_s.must_equal '<GosuEnhanced::Region: ' \
+      '#<struct GosuEnhanced::Point x=10, y=20>' \
+      ', <GosuEnhanced::Size 30x40>>'
+    end
+  end
+end

data/{spec/size_spec.rb → test/size_test.rb}

@@ -1,17 +1,23 @@
-require 'spec_helper'
+require 'test_helper'
 
 describe GosuEnhanced::Size do
   describe '#initialize' do
     it 'should work with two values' do
       size = GosuEnhanced::Size.new(10, 20)
-      expect(size.width).to eq 10
-      expect(size.height).to eq 20
+      size.width.must_equal 10
+      size.height.must_equal 20
     end
 
     it 'should reject negative values' do
-      expect { GosuEnhanced::Size.new(-10, 20) }.to raise_error Exception
-      expect { GosuEnhanced::Size.new(10, -20) }.to raise_error Exception
-      expect { GosuEnhanced::Size.new(-10, -20) }.to raise_error Exception
+      expect { GosuEnhanced::Size.new(-10, 20) }.must_raise Exception
+      expect { GosuEnhanced::Size.new(10, -20) }.must_raise Exception
+      expect { GosuEnhanced::Size.new(-10, -20) }.must_raise Exception
+    end
+
+    it 'should work with the utility function' do
+      size = GosuEnhanced.Size(10, 20)
+      size.width.must_equal 10
+      size.height.must_equal 20
     end
   end
 
@@ -19,29 +25,29 @@ describe GosuEnhanced::Size do
     it 'should work with another Size' do
       size  = GosuEnhanced::Size.new(10, 20)
       esize = size.inflate(GosuEnhanced::Size.new(30, 40))
-      expect(esize.width).to eq 40
-      expect(esize.height).to eq 60
+      esize.width.must_equal 40
+      esize.height.must_equal 60
     end
 
     it 'should work with two values' do
       size  = GosuEnhanced::Size.new(10, 20)
       esize = size.inflate(40, 50)
-      expect(esize.width).to eq 50
-      expect(esize.height).to eq 70
+      esize.width.must_equal 50
+      esize.height.must_equal 70
     end
 
     it 'should work with negative values' do
       size  = GosuEnhanced::Size.new(40, 50)
       esize = size.inflate(-30, -20)
-      expect(esize.width).to eq 10
-      expect(esize.height).to eq 30
+      esize.width.must_equal 10
+      esize.height.must_equal 30
     end
 
     it 'should raise an error with out-of-range values' do
       size  = GosuEnhanced::Size.new(40, 50)
-      expect { size.inflate(-50, -20) }.to raise_error Exception
-      expect { size.inflate(-30, -60) }.to raise_error Exception
-      expect { size.inflate(-50, -70) }.to raise_error Exception
+      expect { size.inflate(-50, -20) }.must_raise Exception
+      expect { size.inflate(-30, -60) }.must_raise Exception
+      expect { size.inflate(-50, -70) }.must_raise Exception
     end
   end
 
@@ -49,22 +55,22 @@ describe GosuEnhanced::Size do
     it 'should work with another Size' do
       size  = GosuEnhanced::Size.new(60, 80)
       esize = size.deflate(GosuEnhanced::Size.new(30, 40))
-      expect(esize.width).to eq 30
-      expect(esize.height).to eq 40
+      esize.width.must_equal 30
+      esize.height.must_equal 40
     end
 
     it 'should work with two values' do
       size  = GosuEnhanced::Size.new(70, 60)
       esize = size.deflate(40, 50)
-      expect(esize.width).to eq 30
-      expect(esize.height).to eq 10
+      esize.width.must_equal 30
+      esize.height.must_equal 10
     end
 
     it 'should raise an error for out-of-range values' do
       size  = GosuEnhanced::Size.new(70, 60)
-      expect { size.deflate(80, 50) }.to raise_error Exception
-      expect { size.deflate(60, 70) }.to raise_error Exception
-      expect { size.deflate(80, 70) }.to raise_error Exception
+      expect { size.deflate(80, 50) }.must_raise Exception
+      expect { size.deflate(60, 70) }.must_raise Exception
+      expect { size.deflate(80, 70) }.must_raise Exception
     end
   end
 
@@ -72,29 +78,29 @@ describe GosuEnhanced::Size do
     it 'should work with another Size' do
       size  = GosuEnhanced::Size.new(10, 20)
       size.inflate!(GosuEnhanced::Size.new(30, 40))
-      expect(size.width).to eq 40
-      expect(size.height).to eq 60
+      size.width.must_equal 40
+      size.height.must_equal 60
     end
 
     it 'should work with two values' do
       size  = GosuEnhanced::Size.new(10, 20)
       size.inflate!(40, 50)
-      expect(size.width).to eq 50
-      expect(size.height).to eq 70
+      size.width.must_equal 50
+      size.height.must_equal 70
     end
 
     it 'should work with negative values' do
       size  = GosuEnhanced::Size.new(40, 50)
       size.inflate!(-30, -20)
-      expect(size.width).to eq 10
-      expect(size.height).to eq 30
+      size.width.must_equal 10
+      size.height.must_equal 30
     end
 
     it 'should raise an error with out-of-range values' do
       size  = GosuEnhanced::Size.new(40, 50)
-      expect { size.inflate!(-50, -20) }.to raise_error Exception
-      expect { size.inflate!(-30, -60) }.to raise_error Exception
-      expect { size.inflate!(-50, -70) }.to raise_error Exception
+      expect { size.inflate!(-50, -20) }.must_raise Exception
+      expect { size.inflate!(-30, -60) }.must_raise Exception
+      expect { size.inflate!(-50, -70) }.must_raise Exception
     end
   end
 
@@ -102,22 +108,22 @@ describe GosuEnhanced::Size do
     it 'should work with another Size' do
       size  = GosuEnhanced::Size.new(60, 80)
       size.deflate!(GosuEnhanced::Size.new(30, 40))
-      expect(size.width).to eq 30
-      expect(size.height).to eq 40
+      size.width.must_equal 30
+      size.height.must_equal 40
     end
 
     it 'should work with two values' do
       size  = GosuEnhanced::Size.new(70, 60)
       size.deflate!(40, 50)
-      expect(size.width).to eq 30
-      expect(size.height).to eq 10
+      size.width.must_equal 30
+      size.height.must_equal 10
     end
 
     it 'should raise an error for out-of-range values' do
       size  = GosuEnhanced::Size.new(70, 60)
-      expect { size.deflate!(80, 50) }.to raise_error Exception
-      expect { size.deflate!(60, 70) }.to raise_error Exception
-      expect { size.deflate!(80, 70) }.to raise_error Exception
+      expect { size.deflate!(80, 50) }.must_raise Exception
+      expect { size.deflate!(60, 70) }.must_raise Exception
+      expect { size.deflate!(80, 70) }.must_raise Exception
     end
   end
 
@@ -126,25 +132,25 @@ describe GosuEnhanced::Size do
       size  = GosuEnhanced::Size.new(10, 20)
       nsize = size.dup
 
-      expect(size.width).to eq 10
-      expect(size.height).to eq 20
+      size.width.must_equal 10
+      size.height.must_equal 20
 
-      expect(nsize.width).to eq 10
-      expect(nsize.height).to eq 20
+      nsize.width.must_equal 10
+      nsize.height.must_equal 20
 
       nsize.inflate!(40, 50)
-      expect(nsize.width).to eq 50
-      expect(nsize.height).to eq 70
+      nsize.width.must_equal 50
+      nsize.height.must_equal 70
 
-      expect(size.width).to eq 10
-      expect(size.height).to eq 20
+      size.width.must_equal 10
+      size.height.must_equal 20
     end
   end
 
   describe '#to_s' do
     it 'should render usefully' do
       size  = GosuEnhanced::Size.new(10, 20)
-      expect(size.to_s).to eq '<GosuEnhanced::Size 10x20>'
+      size.to_s.must_equal '<GosuEnhanced::Size 10x20>'
     end
   end
 end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require 'gosu_enhanced'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosu_enhanced
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Julian Nicholls
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-07 00:00:00.000000000 Z
+date: 2015-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu
@@ -53,47 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rspec-nc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '5.8'
 description: |-
   Point, Size, and Region classes to hold pixel co-ordinatess
   and rectangle sizes respectively.
@@ -119,11 +91,11 @@ files:
 - lib/gosu_enhanced/region.rb
 - lib/gosu_enhanced/size.rb
 - lib/gosu_enhanced/version.rb
-- spec/point_spec.rb
-- spec/region_delegation_spec.rb
-- spec/region_spec.rb
-- spec/size_spec.rb
-- spec/spec_helper.rb
+- test/point_test.rb
+- test/region_delegation_test.rb
+- test/region_test.rb
+- test/size_test.rb
+- test/test_helper.rb
 homepage: https://github.com/JulianNicholls/gosu_enhanced-gem
 licenses:
 - MIT
@@ -144,13 +116,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.7
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Enhanced versions of some Gosu classes.
 test_files:
-- spec/point_spec.rb
-- spec/region_delegation_spec.rb
-- spec/region_spec.rb
-- spec/size_spec.rb
-- spec/spec_helper.rb
+- test/point_test.rb
+- test/region_delegation_test.rb
+- test/region_test.rb
+- test/size_test.rb
+- test/test_helper.rb

data/spec/region_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-describe GosuEnhanced::Region do
-  let(:point) { GosuEnhanced::Point.new(10, 20) }
-  let(:size)  { GosuEnhanced::Size.new(30, 40) }
-
-  describe '#initialize' do
-    it 'should work with a Point and a Size' do
-      GosuEnhanced::Region.new(point, size)
-    end
-  end
-
-  describe '#position' do
-    it 'should return the position as a Point' do
-      reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.position).to eq GosuEnhanced::Point.new(10, 20)
-    end
-  end
-
-  describe '#top' do
-    it 'should return the top co-ordinate' do
-      reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.top).to eq 20
-    end
-  end
-
-  describe '#left' do
-    it 'should return the left co-ordinate' do
-      reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.left).to eq 10
-    end
-  end
-
-  describe '#size' do
-    it 'should return the size as a Size' do
-      reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.size).to eq GosuEnhanced::Size.new(30, 40)
-    end
-  end
-
-  describe '#contains?' do
-    it 'should work with two co-ordinates' do
-      reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.contains?(10, 20)).to be true
-      expect(reg.contains?(20, 35)).to be true
-      expect(reg.contains?(29, 59)).to be true
-      expect(reg.contains?(30, 60)).to be false
-    end
-
-    it 'should work with a Point' do
-      reg = GosuEnhanced::Region.new(point, size)
-      expect(reg.contains?(GosuEnhanced::Point.new(10, 20))).to be true
-      expect(reg.contains?(GosuEnhanced::Point.new(20, 35))).to be true
-      expect(reg.contains?(GosuEnhanced::Point.new(29, 59))).to be true
-      expect(reg.contains?(GosuEnhanced::Point.new(30, 60))).to be false
-    end
-  end
-
-  # Unlike the Point and Size, a Region needs a dup override to actually return
-  # a duplicate correctly.
-
-  describe '#dup' do
-    it 'should duplicate a region' do
-      reg     = GosuEnhanced::Region.new(point, size)
-      new_reg = reg.dup
-
-      expect(reg.position).to eq GosuEnhanced::Point.new(10, 20)
-      expect(reg.size).to eq GosuEnhanced::Size.new(30, 40)
-
-      expect(new_reg.position).to eq GosuEnhanced::Point.new(10, 20)
-      expect(new_reg.size).to eq GosuEnhanced::Size.new(30, 40)
-
-      new_reg.move_to!(20, 30)
-      new_reg.inflate!(10, 10)
-      expect(new_reg.position).to eq GosuEnhanced::Point.new(20, 30)
-      expect(new_reg.size).to eq GosuEnhanced::Size.new(40, 50)
-
-      expect(reg.position).to eq GosuEnhanced::Point.new(10, 20)
-      expect(reg.size).to eq GosuEnhanced::Size.new(30, 40)
-    end
-  end
-
-  describe '#to_s' do
-    it 'should render usefully' do
-      point   = GosuEnhanced::Point.new(10, 20)
-      size    = GosuEnhanced::Size.new(30, 40)
-      region  = GosuEnhanced::Region.new(point, size)
-
-      expect(region.to_s).to eq '<GosuEnhanced::Region: ' \
-      '#<struct GosuEnhanced::Point x=10, y=20>' \
-      ', <GosuEnhanced::Size 30x40>>'
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-require 'rspec'
-require 'pry'
-require 'gosu_enhanced'