ray 0.0.0.pre2 → 0.0.1

data/spec/ray/image_set_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+Ray.image_set(/^test:(red|green|blue)$/) do |col|
+  %w(red green blue).include?(col).should == true
+  Ray::Image.new(:w => 50, :h => 50).fill(Ray::Color.send(col))
+end
+
+describe Ray::ImageSet do
+  before :all do
+    Ray.init
+  end
+
+  describe ".[]" do
+    it "should return a new image" do
+      Ray::ImageSet["test:red"].should be_a(Ray::Image)
+    end
+
+    it "should always return the same image" do
+      obj = Ray::ImageSet["test:green"]
+      obj.object_id.should == Ray::ImageSet["test:green"].object_id
+    end
+  end
+
+  it "should allow to remove images from cache" do
+    obj = Ray::ImageSet["test:red"]
+    other = Ray::ImageSet["test:blue"]
+    Ray::ImageSet.delete_if { |name, img| name == "test:red" }
+    obj.object_id.should_not == Ray::ImageSet["test:red"].object_id
+    other.object_id.should == Ray::ImageSet["test:blue"].object_id
+  end
+
+  it "should also use Ray::Image's cache" do
+    img = Ray::ImageSet[path_of("aqua.bmp")]
+    img.should == Ray::Image[path_of("aqua.bmp")]
+  end
+
+  it "should also handle Ray::Image's cache" do
+    img = Ray::ImageSet[path_of("aqua.bmp")]
+
+    Ray::ImageSet.delete_if { |name, img| name == path_of("aqua.bmp") }
+    img.should_not == Ray::Image[path_of("aqua.bmp")]
+    img.should_not == Ray::ImageSet[path_of("aqua.bmp")]
+  end
+
+  after :all do
+    Ray.stop
+  end
+end

data/spec/ray/image_spec.rb

@@ -1,76 +1,162 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
 describe Ray::Image do
-  before :each do
+  before :all do
     Ray.init
     @win = Ray.create_window(:w => 100, :h => 100)
   end
 
-  describe "#blit" do
-    context "when trying to blit on a non-surface" do
-      it "should raise a type error" do
-        img = Ray::Image.new(:w => 50, :h => 50)
-        lambda {
-          img.blit(:on => Ray::Color.new(10, 20, 30))
-        }.should raise_exception(TypeError)
-      end
-    end
-
-    context "when trying to use a non-rect as a position" do
-      it "should raise a type error" do
-        img = Ray::Image.new(:w => 50, :h => 50)
-        lambda {
-          img.blit(:from => Ray::Color.new(10, 20, 30), :on => @win)
-        }.should raise_exception(TypeError)
-
-        lambda {
-          img.blit(:on => @win, :at => Ray::Color.new(10, 20, 30))
-        }.should raise_exception(TypeError)
-      end
-    end
+  it "should raise a type error when blitting on something that isn't an image" do
+    img = Ray::Image.new(:w => 50, :h => 50)
+    lambda {
+      img.blit(:on => Ray::Color.new(10, 20, 30))
+    }.should raise_exception(TypeError)
   end
 
   describe "#initialize" do
-    context "when the argument isn't a hash or a string" do
-      it "should raise a type error" do
-        lambda {
-          Ray::Image.new(3)
-        }.should raise_exception(TypeError)
-      end
+    it "should raise a type error if the argument isn't a hash or a string " do
+      lambda {
+        Ray::Image.new(3)
+      }.should raise_exception(TypeError)
     end
 
-    context "when loading an existing file" do
-      it "should not raise an error" do
-        lambda {
-          Ray::Image.new(path_of("aqua.bmp"))
-        }.should_not raise_exception
-      end
+    it "should not raise an error when loading an existing image" do
+      lambda {
+        Ray::Image.new(path_of("aqua.bmp"))
+      }.should_not raise_exception
     end
 
-    context "when loading an unexising file" do
-      it "should raise a runtime error" do
+    it "should raise an error when loading an unexisting file " do
+      lambda {
+        Ray::Image.new("does_not_exist.bmp")
+      }.should raise_exception
+    end
+
+    it "should be able to load a file from an IO" do
+      File.open(path_of("aqua.bmp")) do |io|
         lambda {
-          Ray::Image.new("does_not_exist.bmp")
-        }.should raise_exception
+          img = Ray::Image.new(io)
+        }.should_not raise_exception
       end
     end
 
     if Ray.has_image_support?
-      it "should be able to load other formats" do
+      it "should be able to load other kind of images" do
         lambda {
           Ray::Image.new(path_of("aqua.png"))
         }.should_not raise_exception
       end
 
-      context "if the extension does not match the file type" do
-        it "should still load it correctly" do
+      it "should be able to load other kind of images from an IO" do
+        File.open(path_of("aqua.png")) do |io|
           lambda {
-            Ray::Image.new(path_of("not_a_jpeg.jpeg"))
+            Ray::Image.new(io)
           }.should_not raise_exception
         end
       end
+
+      it "should load images even if the extension is incorrect" do
+        lambda {
+          Ray::Image.new(path_of("not_a_jpeg.jpeg"))
+        }.should_not raise_exception
+      end
+    end
+  end
+
+  describe ".[]" do
+    it "should return a new image" do
+      Ray::Image[path_of("aqua.bmp")].should be_a(Ray::Image)
+    end
+
+    it "should always return the same image" do
+      obj = Ray::Image[path_of("aqua2.bmp")]
+      obj.object_id.should == Ray::Image[path_of("aqua2.bmp")].object_id
+    end
+  end
+
+  describe "#==" do
+    it "should be true if the parameter uses the same surface" do
+      @win.should == Ray.screen
+
+      first = Ray::Image.new(:w => 10, :h => 10).fill(Ray::Color.red)
+      sec = Ray::Image.new(:w => 10, :h => 10).fill(Ray::Color.red)
+
+      first.should_not == sec
+    end
+
+    it "should not raise an exception for non-images" do
+      lambda {
+        @win == 3
+      }.should_not raise_exception
+    end
+  end
+
+  describe "#dup" do
+    it "should create a new surface" do
+      first = Ray::Image.new(:w => 10, :h => 10).fill(Ray::Color.red)
+      sec = first.dup
+
+      first.should_not == sec
+    end
+  end
+
+  describe "#[]" do
+    it "should return nil for pixels outside the image" do
+      Ray::Image.new(:w => 10, :h => 10)[10, 10].should be_nil
+    end
+
+    it "should return a color for pixels inside the image" do
+      Ray::Image.new(:w => 10, :h => 10)[5, 5].should be_a(Ray::Color)
+    end
+  end
+
+  describe "#[]=" do
+    it "should change the color of the pixel" do
+      img = Ray::Image.new(:w => 10, :h => 10)
+      img.lock { img[5, 5] = Ray::Color.new(10, 15, 20) }
+
+      col = img[5, 5]
+      col.r.should == 10
+      col.g.should == 15
+      col.b.should == 20
+    end
+
+    it "should raise an error for pixels outside the image" do
+      img = Ray::Image.new(:w => 10, :h => 10)
+      lambda {
+        img.lock { img[11, 11] = Ray::Color.new(10, 15, 20) }
+      }.should raise_exception
+    end
+  end
+
+  describe "#clip" do
+    it "should return the clipping rect if there are no arguments" do
+      img = Ray::Image.new(:w => 10, :h => 10)
+      img.clip.should == Ray::Rect.new(0, 0, 10, 10)
+    end
+
+    it "should change the clip rect when called with a rect" do
+      img = Ray::Image.new(:w => 10, :h => 10)
+      img.clip([5, 5, 3, 3])
+      img.clip.should == Ray::Rect.new(5, 5, 3, 3)
+    end
+
+    it "should return the new rect" do
+      img = Ray::Image.new(:w => 10, :h => 10)
+      img.clip([5, 5, 3, 3]).should == Ray::Rect.new(5, 5, 3, 3)
+    end
+
+    it "should change the clipping rect only within a block" do
+      img = Ray::Image.new(:w => 10, :h => 10)
+      img.clip([5, 5, 3, 3]) do
+        img.clip.should == Ray::Rect.new(5, 5, 3, 3)
+      end
+
+      img.clip.should == Ray::Rect.new(0, 0, 10, 10)
     end
   end
 
-  after :each do
+  after :all do
     Ray.stop
   end
 end

data/spec/ray/joystick_spec.rb

@@ -1,17 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
 describe Ray::Joystick do
   describe ".handle_event" do
-    context "when handle_event= is called" do
-      before :all do Ray.init end
+    before :all do
+      Ray.init
+    end
 
-      it "should change its value" do
-        Ray::Joystick.handle_event = true
-        Ray::Joystick.handle_event.should be_true
+    it "can be changed" do
+      Ray::Joystick.handle_event = true
+      Ray::Joystick.handle_event.should be_true
 
-        Ray::Joystick.handle_event = false
-        Ray::Joystick.handle_event.should be_false
-      end
+      Ray::Joystick.handle_event = false
+      Ray::Joystick.handle_event.should be_false
+    end
 
-       after :all do Ray.init end
+    after :all do
+      Ray.init
     end
   end
 end

data/spec/ray/matcher_spec.rb

@@ -1,73 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
 describe Ray::Matchers do
-  context "when a matcher is described" do
-    it "should add it as a private method" do
-      Ray.describe_matcher(:match, :string) do |reg|
+  it "should add matchers as public methods" do
+    lambda {
+      Ray.describe_matcher(:awesome_matcher) do |reg|
         lambda { |str| str =~ reg }
       end
-
-      Ray::Matchers.private_instance_methods.should include(:match)
-    end
-
-    context "without a defined target" do
-      it "should create one operate on anything" do
-        Ray.describe_matcher(:foo_matcher) do |something|
-          lambda { |x| x == something }
-        end
-
-        obj = Object.new
-        obj.extend Ray::Matchers
-
-        obj.instance_eval do
-          matcher = foo_matcher("")
-          matcher.can_match_on?(Object).should == true
-        end
+    }.should change {
+      Ray::Matchers.instance_methods.any? do |i|
+        i == :awesome_matcher or i == "awesome_matcher"
       end
-    end
+    }.from(false).to(true)
   end
 
-  describe "'s private methods" do
-    before :all do
-      Ray.describe_matcher(:match, :string) do |reg|
-        lambda { |str| str =~ reg }
-      end
+  it "should return a Ray::DSL::Matchers for defined matchers" do
+    Ray.describe_matcher(:match) do |reg|
+      lambda { |str| str =~ reg }
     end
 
-    before :each do
-      @obj = Object.new
-      @obj.extend Ray::Matchers
-    end
+    @obj = Object.new
+    @obj.extend Ray::Matchers
 
-    it "should return a matcher" do
-      @obj.instance_eval { match("foo") }.should be_a(Ray::DSL::Matcher)
-    end
+    @obj.instance_eval { match("foo") }.should be_a(Ray::DSL::Matcher)
   end
-end
 
-describe Ray::DSL::Matcher do
-  it "should only be able to match on a given class or module" do
-    matcher = Ray::DSL::Matcher.new(:string) { |foo| false }
-    matcher.can_match_on?(Array).should be_false
-    matcher.can_match_on?(Object).should be_false
+  describe "#where" do
+    it "should return a matcher matching if the block returns true" do
+      obj = Object.new
+      obj.extend Ray::Helper
 
-    matcher.can_match_on?(String).should be_true
-    matcher.can_match_on?(Class.new(String)).should be_true
-  end
+      res = 0
+      obj.instance_eval do
+        self.event_runner = Ray::DSL::EventRunner.new
 
-  describe "#can_match_on?" do
-    it "should resolve types" do
-      matcher = Ray::DSL::Matcher.new(:string) { |foo| false }
-      matcher.can_match_on?(:string).should be_true
-    end
-  end
+        on :foo, where { |x| x > 10 } do |x|
+          x.should > 10
+          res += 1
+        end
 
-  describe "#match?" do
-    it "should return false if we can't match on the object's class" do
-      matcher = Ray::DSL::Matcher.new(:string) { |foo| true }
-      matcher.match?([]).should be_false
-      matcher.match?(Object.new).should be_false
+        raise_event(:foo, 10)
+        raise_event(:foo, 15)
+
+        listener_runner.run
+      end
 
-      matcher.match?("").should be_true
-      matcher.match?(Class.new(String).new).should be_true
+      res.should == 1
     end
   end
 end

data/spec/ray/ray_spec.rb

@@ -1,51 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require 'rbconfig'
 
 describe Ray do
   describe ".create_window" do
-    context "when given an unappropriate configuration" do
-      it "should raise runtime error" do
-        Ray.init
+    it "should raise runtime error for invalid configurations" do
+      Ray.init
 
-        lambda {
-          Ray.create_window(:w => 100, :h => 100, :bpp => 1)
-        }.should raise_exception(RuntimeError)
+      lambda {
+        Ray.create_window(:w => 100, :h => 100, :bpp => 1)
+      }.should raise_exception(RuntimeError)
 
-        Ray.stop
-      end
+      Ray.stop
     end
 
-    context "when given a correct configuration" do
-      it "should create a window of the expected size" do
-        Ray.init
+    it "should create a window of the expected size for valid configurations" do
+      Ray.init
 
-        win = Ray.create_window(:w => 100, :h => 50)
-        win.width.should == 100
-        win.height.should == 50
+      win = Ray.create_window(:w => 100, :h => 50)
+      win.width.should == 100
+      win.height.should == 50
 
-        win = Ray.create_window(:width => 50, :height => 100)
-        win.width.should == 50
-        win.height.should == 100
+      win = Ray.create_window(:width => 50, :height => 100)
+      win.width.should == 50
+      win.height.should == 100
 
-        Ray.stop
-      end
+      Ray.stop
     end
   end
 
   describe ".can_use_mode?" do
-    context "when given an unappropriate configuration" do
-      it "should return false" do
-        Ray.init
-        Ray.can_use_mode?(:w => 100, :h => 100, :bpp => 1).should be_false
-        Ray.stop
-      end
+    it "should return false for invalid configurations" do
+      Ray.init
+      Ray.can_use_mode?(:w => 100, :h => 100, :bpp => 1).should be_false
+      Ray.stop
     end
 
-    context "when given a correct configuration" do
-      it "should return true" do
-        Ray.init
-        Ray.can_use_mode?(:w => 100, :h => 100).should be_true
-        Ray.stop
-      end
+    it "should return true for valid configurations" do
+      Ray.init
+      Ray.can_use_mode?(:w => 480, :h => 272).should be_true
+      Ray.stop
     end
   end
 
@@ -83,4 +76,13 @@ describe Ray do
 
     after :all do Ray.stop end
   end
+
+  describe ".init" do
+    it "should allow to pass a hash to add options" do
+      lambda {
+        Ray.init({})
+        Ray.stop
+      }.should_not raise_exception
+    end
+  end
 end