ray 0.0.1 → 0.1.0.pre1

data/spec/ray/joystick_spec.rb

@@ -1,21 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ray::Joystick do
-  describe ".handle_event" do
-    before :all do
-      Ray.init
-    end
-
-    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
-
-    after :all do
-      Ray.init
-    end
-  end
-end

data/spec/ray/matcher_spec.rb

@@ -1,50 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ray::Matchers do
-  it "should add matchers as public methods" do
-    lambda {
-      Ray.describe_matcher(:awesome_matcher) do |reg|
-        lambda { |str| str =~ reg }
-      end
-    }.should change {
-      Ray::Matchers.instance_methods.any? do |i|
-        i == :awesome_matcher or i == "awesome_matcher"
-      end
-    }.from(false).to(true)
-  end
-
-  it "should return a Ray::DSL::Matchers for defined matchers" do
-    Ray.describe_matcher(:match) do |reg|
-      lambda { |str| str =~ reg }
-    end
-
-    @obj = Object.new
-    @obj.extend Ray::Matchers
-
-    @obj.instance_eval { match("foo") }.should be_a(Ray::DSL::Matcher)
-  end
-
-  describe "#where" do
-    it "should return a matcher matching if the block returns true" do
-      obj = Object.new
-      obj.extend Ray::Helper
-
-      res = 0
-      obj.instance_eval do
-        self.event_runner = Ray::DSL::EventRunner.new
-
-        on :foo, where { |x| x > 10 } do |x|
-          x.should > 10
-          res += 1
-        end
-
-        raise_event(:foo, 10)
-        raise_event(:foo, 15)
-
-        listener_runner.run
-      end
-
-      res.should == 1
-    end
-  end
-end

data/spec/ray/ray_spec.rb

@@ -1,88 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'rbconfig'
-
-describe Ray do
-  describe ".create_window" do
-    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)
-
-      Ray.stop
-    end
-
-    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(:width => 50, :height => 100)
-      win.width.should == 50
-      win.height.should == 100
-
-      Ray.stop
-    end
-  end
-
-  describe ".can_use_mode?" do
-    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
-
-    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
-
-  context "after being initialized" do
-    before :all do Ray.init end
-
-    subject { Ray }
-
-    its(:window_title) { should be_nil }
-    its(:text_icon) { should be_nil }
-
-    its(:grab_input) { should be_false }
-
-    after :all do Ray.stop end
-  end
-
-  context "after changing the title" do
-    before :all do Ray.init end
-
-    it "should change the window title and text icon and grab the input" do
-      Ray.text_icon = "foo"
-      Ray.text_icon.should == "foo"
-
-      Ray.window_title = "bar"
-      Ray.window_title == "bar"
-
-      unless RbConfig::CONFIG["target_vendor"] == "psp"
-        Ray.grab_input = false
-        Ray.grab_input.should be_false
-
-        Ray.grab_input = true
-        Ray.grab_input.should be_true
-      end
-    end
-
-    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

data/spec/ray/rect_spec.rb

@@ -1,154 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ray::Rect do
-  [:x, :y, :width, :height].each do |meth|
-    describe "##{meth}=" do
-      it "should set a new value to #{meth}" do
-        rect = Ray::Rect.new(0, 0)
-        lambda {
-          rect.send("#{meth}=", 30)
-        }.should change(rect, meth).from(0).to(30)
-      end
-
-      it "should only allow numerics" do
-        rect = Ray::Rect.new(0, 0)
-
-        ["1.0", "5.d", Ray, Ray::Rect, rect].each do |obj|
-          lambda {
-            rect.send("#{meth}=", obj)
-          }.should raise_exception(TypeError)
-        end
-      end
-    end
-  end
-
-  describe "#initialize" do
-    context "with a hash" do
-      it "should not allow to pass x but not y" do
-        lambda {
-          Ray::Rect.new(:x => 10)
-        }.should raise_exception(ArgumentError)
-      end
-
-      it "should not allow to pass width but not height" do
-        lambda {
-          Ray::Rect.new(:x => 10, :y => 200, :width => 300)
-        }.should raise_exception(ArgumentError)
-      end
-
-      it "should require x and y to be present" do
-        lambda {
-          Ray::Rect.new(:width => 400, :height => 300)
-        }.should raise_exception(ArgumentError)
-      end
-
-      it "should only work with numerics" do
-        ["1.0", "5.d", Ray, Ray::Rect].each do |obj|
-          lambda {
-            Ray::Rect.new(:x => obj, :y => 30)
-          }.should raise_exception(TypeError)
-        end
-      end
-    end
-
-    context "with separated arguments" do
-      it "should not work with one integer" do
-        lambda {
-          Ray::Rect.new(10)
-        }.should raise_exception(ArgumentError)
-      end
-
-      it "should not work with 3 integers" do
-        lambda {
-          Ray::Rect.new(10, 30, 40)
-        }.should raise_exception(ArgumentError)
-      end
-
-      it "should only work with numerics" do
-        ["1.0", "5.d", Ray, Ray::Rect].each do |obj|
-          lambda {
-            Ray::Rect.new(obj, 30)
-          }.should raise_exception(TypeError)
-        end
-      end
-    end
-  end
-
-  describe "#inside?" do
-    it "should return true if the rect is the receiver itself" do
-      rect = Ray::Rect.new(10, 15, 20, 30)
-      rect.should be_inside(rect)
-    end
-
-    it "should return true if the rect inside the receiver" do
-      rect = Ray::Rect.new(10, 15, 30, 40)
-      Ray::Rect.new(13, 17, 10, 20).should be_inside(rect)
-    end
-
-    it "should return false if the rect only collides with the receiver" do
-      rect = Ray::Rect.new(10, 15, 30, 40)
-
-      Ray::Rect.new(5, 10, 20, 20).should_not be_inside(rect)
-      Ray::Rect.new(11, 16, 40, 50).should_not be_inside(rect)
-    end
-
-    it "should return false if the rect is outside the receiver" do
-      rect = Ray::Rect.new(10, 15, 20, 30)
-
-      Ray::Rect.new(1, 2, 3, 5).should_not be_inside(rect)
-      Ray::Rect.new(100, 150, 350, 450).should_not be_inside(rect)
-    end
-  end
-
-  describe "#outside?" do
-    it "should return false if the rect is the receiver itself" do
-      rect = Ray::Rect.new(10, 15, 20, 30)
-      rect.should_not be_outside(rect)
-    end
-
-    it "should return true if the rect is outside the receiver" do
-      rect = Ray::Rect.new(10, 15, 20, 30)
-
-      Ray::Rect.new(1, 2, 3, 5).should be_outside(rect)
-      Ray::Rect.new(100, 150, 350, 450).should be_outside(rect)
-    end
-
-    it "should return false if the rect is inside the receiver" do
-      rect = Ray::Rect.new(10, 15, 30, 40)
-      Ray::Rect.new(13, 17, 10, 20).should_not be_outside(rect)
-    end
-
-    it "should return false if the rect collides with the receiver" do
-      rect = Ray::Rect.new(10, 15, 30, 40)
-
-      Ray::Rect.new(5, 10, 20, 20).should_not be_outside(rect)
-      Ray::Rect.new(11, 16, 40, 50).should_not be_outside(rect)
-    end
-  end
-
-  describe "#colllide?" do
-    it "should return true if the rect is the receiver itself" do
-      rect = Ray::Rect.new(10, 15, 20, 30)
-      rect.collide?(rect).should be_true
-    end
-
-    it "should return false if the rect is outside the receiver" do
-      rect = Ray::Rect.new(10, 15, 20, 30)
-
-      Ray::Rect.new(1, 2, 3, 5).collide?(rect).should_not be_true
-      Ray::Rect.new(100, 150, 350, 450).collide?(rect).should_not be_true
-    end
-
-    it "should return true if the rect is inside the receiver" do
-      rect = Ray::Rect.new(10, 15, 30, 40)
-      Ray::Rect.new(13, 17, 10, 20).collide?(rect).should be_true
-    end
-
-    it "should return true if the rect collides with the receiver" do
-      rect = Ray::Rect.new(10, 15, 30, 40)
-
-      Ray::Rect.new(5, 10, 20, 20).collide?(rect).should be_true
-      Ray::Rect.new(11, 16, 40, 50).collide?(rect).should be_true
-    end
-  end
-end

data/spec/ray/resource_set_spec.rb

@@ -1,105 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-module TestSet
-  extend Ray::ResourceSet
-
-  def self.missing_pattern(string)
-    "unknown"
-  end
-
-  add_set(/^string:(.+)$/) do |str|
-    str
-  end
-end
-
-module DefaultMissingPattern
-  extend Ray::ResourceSet
-end
-
-module MultipleArgumentsSet
-  extend Ray::ResourceSet
-
-  need_argument_count 1
-
-  add_set(/^string:(.+)$/) do |str, times|
-    str * times
-  end
-
-  def self.missing_pattern(*args)
-    args
-  end
-end
-
-module CacheTestSet
-  extend Ray::ResourceSet
-
-  add_set(/(.+)/) { |str| str }
-end
-
-describe Ray::ResourceSet do
-  it "should use the block we passed to create a string" do
-    TestSet["string:test"].should == "test"
-  end
-
-  it "should always return the same object for the same key" do
-    str = TestSet["string:my string"]
-    str.object_id.should == TestSet["string:my string"].object_id
-  end
-
-  it "should call the missing_pattern method when a string isn't matched" do
-    TestSet["Hello world"].should == "unknown"
-  end
-
-  it "should raise NoPatternError for unmatched string by default" do
-    lambda {
-      DefaultMissingPattern["unknown"]
-    }.should raise_exception(Ray::NoPatternError)
-  end
-
-  it "should allow more arguments in []" do
-    lambda {
-      MultipleArgumentsSet["string:test", 3]
-    }.should_not raise_exception
-  end
-
-  it "should raise an error when using an invalid argument count" do
-    lambda {
-      TestSet["string:foo", 3]
-    }.should raise_exception
-  end
-
-  it "should provide user arguments at the end" do
-    MultipleArgumentsSet.add_set(/my_(.)/) do |char, times|
-      char.should  == "a"
-      times.should == 3
-
-      true
-    end
-
-    MultipleArgumentsSet["my_a", 3]
-  end
-
-  it "should be able to select objects from the cache" do
-    first = CacheTestSet["first"]
-    sec   = CacheTestSet["sec"]
-
-    CacheTestSet.select! { |key, val| key == "first" }
-
-    first.object_id.should == CacheTestSet["first"].object_id
-    sec.object_id.should_not == CacheTestSet["sec"].object_id
-  end
-
-  it "should be able to reject objects from the cache" do
-    first = CacheTestSet["first"]
-    sec   = CacheTestSet["sec"]
-
-    CacheTestSet.reject! { |key, val| key == "first" }
-
-    first.object_id.should_not == CacheTestSet["first"].object_id
-    sec.object_id.should == CacheTestSet["sec"].object_id
-  end
-
-  it "should pass all the arguments to missing_pattern" do
-    MultipleArgumentsSet["a", 3].should == ["a", 3]
-  end
-end

data/spec/ray/sprite_spec.rb

@@ -1,163 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ray::Sprite do
-  before :all do
-    Ray.init
-    @win = Ray.create_window(:w => 100, :h => 100)
-  end
-
-  it "should wrap an image" do
-    image = Ray::Image.new(:w => 10, :h => 10)
-
-    sprite = Ray::Sprite.new(image)
-    sprite.image.should == image
-  end
-
-  it "should convert strings to images" do
-    image = Ray::ImageSet[path_of("aqua.bmp")]
-
-    sprite = Ray::Sprite.new(path_of("aqua.bmp"))
-    sprite.image.should == image
-  end
-
-  it "should blit its image when drawn" do
-    image = mock("image")
-    image.stub!(:to_image).and_return(image)
-    image.stub!(:is_a?).and_return(true)
-    image.should_receive(:blit).and_return(@win)
-
-    sprite = Ray::Sprite.new(image)
-    sprite.draw_on(@win)
-  end
-
-  it "should draw on the screen by default" do
-    image = mock("image")
-    image.stub!(:to_image).and_return(image)
-    image.stub!(:is_a?).and_return(true)
-    image.should_receive(:blit).with(hash_including(:on => @win)).and_return(@win)
-
-    sprite = Ray::Sprite.new(image)
-    sprite.draw
-  end
-
-  it "should have a position" do
-    sprite = Ray::Sprite.new(@win, :at => [10, 15])
-    sprite.is_at?(10, 15).should be_true
-  end
-
-  it "should not be at a position it wan't assigned to" do
-    sprite = Ray::Sprite.new(@win, :at => [13, 20])
-    sprite.is_at?(10, 15).should be_false
-  end
-
-  it "should be at (0, 0) by default" do
-    sprite = Ray::Sprite.new(@win)
-    sprite.is_at?(0, 0).should be_true
-  end
-
-  it "should draw the image at its position" do
-    image = mock("image")
-    image.stub!(:to_image).and_return(image)
-    image.stub!(:is_a?).and_return(true)
-    image.should_receive(:blit).with(hash_including(:at => [10, 15])).
-      and_return(@win)
-
-    sprite = Ray::Sprite.new(image, :at => [10, 15])
-    sprite.draw
-  end
-
-  it "should allow to draw only a small rect of the image" do
-    image = mock("image")
-    image.stub!(:to_image).and_return(image)
-    image.stub!(:is_a?).and_return(true)
-    rect = Ray::Rect.new(50, 30, 100, 120)
-    image.should_receive(:blit).with(hash_including(:rect => rect)).
-      and_return(@win)
-
-    sprite = Ray::Sprite.new(image, :rect => [50, 30, 100, 120])
-    sprite.draw
-  end
-
-  it "should default to an empty rect" do
-    sprite = Ray::Sprite.new(@win)
-    sprite.from_rect.should == Ray::Rect.new(0, 0, 0, 0)
-  end
-
-  describe "#rect" do
-    it "should return the rect where the image will be drawn" do
-      sprite = Ray::Sprite.new(@win, :rect => [70, 80, 80, 80],
-                               :at => [50, 30])
-      sprite.rect.should == Ray::Rect.new(50, 30, 80, 80)
-    end
-
-    it "should return the image size if the rect is not set" do
-      sprite = Ray::Sprite.new(@win)
-      sprite.rect.should == Ray::Rect.new(0, 0, 100, 100)
-    end
-  end
-
-  it "should allow to set an angle" do
-    sprite = Ray::Sprite.new(@win, :angle => 30)
-    sprite.angle.should == 30
-  end
-
-  it "should draw using its angle" do
-    image = mock("image")
-    image.stub!(:to_image).and_return(image)
-    image.stub!(:is_a?).and_return(true)
-    image.should_receive(:blit).with(hash_including(:angle => 40))
-
-    sprite = Ray::Sprite.new(image, :angle => 40)
-    sprite.draw
-  end
-
-  it "should allow to zoom" do
-    sprite = Ray::Sprite.new(@win, :zoom => 3)
-    sprite.zoom.should == 3
-  end
-
-  it "should draw using its zoom level" do
-    image = mock("image")
-    image.stub!(:to_image).and_return(image)
-    image.stub!(:is_a?).and_return(true)
-    image.should_receive(:blit).with(hash_including(:zoom => 3))
-
-    sprite = Ray::Sprite.new(image, :zoom => 3)
-    sprite.draw
-  end
-  
-  it "should allow to set its position using an array" do
-    sprite = Ray::Sprite.new(@win)
-    sprite.pos = [10, 15]
-    sprite.pos.to_rect.should == Ray::Rect.new(10, 15)
-  end
-  
-  it "should allow to use a sprite sheet" do
-    sprite = Ray::Sprite.new(@win)
-    sprite.sheet_size = [10, 10]
-    
-    sprite.rect.w.should == (@win.w / 10)
-    sprite.rect.h.should == (@win.h / 10)
-  end
-  
-  it "should allow to change the cell which will be drawn" do
-    sprite = Ray::Sprite.new(@win)
-    sprite.sheet_size = [10, 10]
-    sprite.sheet_pos = [3, 6]
-    
-    sprite.from_rect.should == Ray::Rect.new((@win.w / 10) * 3,
-                                             (@win.h / 10) * 6,
-                                             @win.w / 10, @win.h / 10)
-  end
-  
-  it "should allow to disable the use of a sprite sheet" do
-    sprite = Ray::Sprite.new(@win)
-    sprite.sheet_size = [10, 10]
-    sprite.disable_sprite_sheet
-    sprite.from_rect.should == Ray::Rect.new(0, 0, @win.w, @win.h)
-  end
-
-  after :all do
-    Ray.stop
-  end
-end