ray 0.0.1 → 0.1.0.pre1

data/script.rb

@@ -1,10 +0,0 @@
-$: << "./lib" << "./rspec/lib" << "./ruby_stdlib/lib" << "./psp/lib"
-
-def path_of(res)
-  File.expand_path(File.join(File.dirname(__FILE__), "spec", "res", res))
-end
-
-require 'ray'
-require 'spec'
-Dir["spec/**/*_spec.rb"].each { |file| load file }
-Spec::Runner.run

data/spec/ray/audio_spec.rb

@@ -1,146 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-if Ray.has_audio_support?
-  describe Ray::Audio do
-    it "should allow to set and get audio parameters" do
-      Ray.init(:mono => true,
-               :format => Ray::Audio::FORMAT_S8,
-               :frequency => 44100)
-
-      Ray::Audio.frequency.should == 44100
-      Ray::Audio.should be_mono
-      Ray::Audio.format.should == Ray::Audio::FORMAT_S8
-
-      Ray.stop
-    end
-
-    it "should allow to change the volume" do
-      Ray.init(:mono => true,
-               :format => Ray::Audio::FORMAT_S8,
-               :frequency => 44100)
-
-      Ray::Audio.volume = 50
-      Ray::Audio.volume.should be_close(50, 0.1)
-
-      Ray.stop
-    end
-  end
-
-  describe Ray::Sound do
-    before :all do
-      Ray.init
-    end
-
-    it "should allow to load sounds" do
-      lambda {
-        Ray::Sound.new(path_of("pop.wav"))
-      }.should_not raise_exception
-    end
-
-    it "should allow to load sounds from IO objects" do
-      lambda {
-        open(path_of("pop.wav")) do |io|
-          Ray::Sound.new(io)
-        end
-      }.should_not raise_exception
-    end
-
-    it "should allow to change the volume" do
-      sound = Ray::Sound.new(path_of("pop.wav"))
-      sound.volume = 50
-      sound.volume.should be_close(50, 0.1)
-    end
-
-    it "should make Ray play" do
-      sound = Ray::Sound.new(path_of("pop.wav"))
-
-      lambda { sound.play(1) }.should change {
-        Ray::Audio.playing?(1) && !Ray::Audio.paused?(1)
-      }.from(false).to(true)
-
-      Ray::Audio.stop(1)
-    end
-
-    it "can be paused" do
-      sound = Ray::Sound.new(path_of("pop.wav"))
-      sound.play(1)
-
-      lambda { Ray::Audio.pause(1) }.should change {
-        Ray::Audio.playing?(1) && !Ray::Audio.paused?(1)
-      }.from(true).to(false)
-    end
-
-    it "can be resumed" do
-      sound = Ray::Sound.new(path_of("pop.wav"))
-      sound.play(1)
-      Ray::Audio.pause(1)
-
-      lambda { Ray::Audio.resume(1) }.should change {
-        Ray::Audio.playing?(1) && !Ray::Audio.paused?(1)
-      }.from(false).to(true)
-
-      Ray::Audio.stop(1)
-    end
-
-    after :all do
-      Ray.stop
-    end
-  end
-
-  describe Ray::Music do
-    before :all do
-      Ray.init
-    end
-
-    it "should be able to create object from valid files" do
-      lambda {
-        Ray::Music.new(path_of("pop.wav"))
-      }.should_not raise_exception
-    end
-
-    it "should be able to create object from IO objects" do
-      lambda {
-        open(path_of("pop.wav")) { |io| Ray::Music.new(io) }
-      }.should_not raise_exception
-    end
-
-    it "should make Ray play" do
-      music = Ray::Music.new(path_of("pop.wav"))
-      music.play
-
-      Ray::Audio.should be_playing
-      Ray::Audio.stop
-    end
-
-    it "can be paused" do
-      music = Ray::Music.new(path_of("pop.wav"))
-      music.play
-      Ray::Audio.pause
-
-      Ray::Audio.should be_paused
-    end
-
-    it "can be resumed" do
-      music = Ray::Music.new(path_of("pop.wav"))
-      music.play
-
-      Ray::Audio.pause
-      Ray::Audio.resume
-
-      Ray::Audio.should_not be_paused
-      Ray::Audio.stop
-    end
-
-    it "can be stopped" do
-      music = Ray::Music.new(path_of("pop.wav"))
-      music.play
-
-      Ray::Audio.stop
-      Ray::Audio.should_not be_playing
-    end
-
-    after :all do
-      Ray.stop
-    end
-  end
-end

data/spec/ray/color_spec.rb

@@ -1,57 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ray::Color do
-  describe "#initialize" do
-    it "should accept 3 integers" do
-      lambda {
-        Ray::Color.new(10, 20, 30)
-      }.should_not raise_exception(ArgumentError)
-    end
-
-    it "should accept 4 integers" do
-      lambda {
-        Ray::Color.new(10, 20, 30, 40)
-      }.should_not raise_exception(ArgumentError)
-    end
-
-    it "should only work with numerics" do
-      [Ray, "string", Ray::Color].each do |obj|
-        lambda {
-          Ray::Color.new(obj, 0, 0, obj)
-        }.should raise_exception(TypeError)
-      end
-    end
-  end
-
-  [:r, :g, :b, :a].each do |meth|
-    describe "#{meth}=" do
-      it "should only work with numerics" do
-        color = Ray::Color.new(0, 0, 0, 0)
-        [Ray, "string", Ray::Color].each do |obj|
-          lambda {
-            color.send("#{meth}=", obj)
-          }.should raise_exception(TypeError)
-        end
-      end
-
-      it "should set a new value" do
-        color = Ray::Color.new(0, 0, 0, 0)
-
-        lambda {
-          color.send("#{meth}=", 30)
-        }.should change(color, meth).from(0).to(30)
-      end
-    end
-  end
-
-  describe "#==" do
-    it "should return true if both colors are identical" do
-      Ray::Color.new(10, 15, 20, 30).should == Ray::Color.new(10, 15, 20, 30)
-      Ray::Color.new(10, 15, 20, 30).should_not == Ray::Color.new(1, 15, 2, 3)
-    end
-
-    it "should not raise an exception if the argument isn't a color" do
-      Ray::Color.new(1, 1, 1, 1).should_not == 1
-    end
-  end
-end

data/spec/ray/event_spec.rb

@@ -1,80 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ray::DSL do
-  before :each do
-      @runner = Ray::DSL::EventRunner.new
-
-      @obj = Object.new
-      @obj.extend Ray::DSL::EventListener
-      @obj.extend Ray::DSL::EventRaiser
-      @obj.extend Ray::Matchers
-
-      @obj.listener_runner = @runner
-      @obj.raiser_runner = @runner
-    end
-
-  it "should send events with the same arguments and name as in #on" do
-    count = 0
-    @obj.on :right_event, "danger", "bar" do |*args|
-      args.should == ["danger", "bar"]
-      count += 1
-    end
-
-    [:right_event, :wrong_event].each do |name|
-      @obj.raise_event(name)
-      @obj.raise_event(name, "bar")
-      @obj.raise_event(name, "danger")
-      @obj.raise_event(name, "danger", "bar")
-    end
-
-    @runner.run
-    count.should == 1
-  end
-
-  it "should use === to see if an event can be raised" do
-    true_matcher = mock('true_matcher')
-    true_matcher.should_receive(:===).and_return(true)
-
-    false_matcher = mock('false_matcher')
-    false_matcher.should_receive(:===).and_return(false)
-
-    worked = nil
-
-    @obj.on :event, true_matcher do
-      worked.should_not == false
-      worked = true
-    end
-
-    @obj.on :event, false_matcher do
-      worked = false
-    end
-
-    @obj.raise_event(:event, :argument)
-    @runner.run
-
-    worked.should be_true
-  end
-
-  it "should pass the arguments of the event to the block" do
-    @obj.on :foo do |*args|
-      args.should == ["a", "b", "c"]
-    end
-
-    @obj.raise_event(:foo, "a", "b", "c")
-    @runner.run
-  end
-
-  it "should send events with more arguments than #on if they match" do
-    count = 0
-    @obj.on :foo do
-      count += 1
-    end
-
-    @obj.raise_event(:foo, "blabla")
-    @obj.raise_event(:foo)
-    @obj.raise_event(:foo, :error, 3, "read")
-
-    @runner.run
-    count.should == 3
-  end
-end

data/spec/ray/font_spec.rb

@@ -1,93 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-if Ray.has_font_support?
-  describe Ray::Font do
-    before :all do
-      Ray.init
-    end
-
-    it "should be able to load fonts from a file" do
-      lambda {
-        Ray::Font.new(path_of("VeraMono.ttf"), 12)
-      }.should_not raise_exception
-    end
-
-    it "should be able to load fonts from IO objects" do
-      lambda {
-        open(path_of("VeraMono.ttf")) { |io| Ray::Font.new(io, 12) }
-      }.should_not raise_exception
-    end
-
-    it "should create normal font" do
-      Ray::Font.new(path_of("VeraMono.ttf"), 12).should be_normal
-    end
-
-    it "should allow to change its style" do
-      font = Ray::Font.new(path_of("VeraMono.ttf"), 12)
-      font.style = Ray::Font::STYLE_BOLD | Ray::Font::STYLE_ITALIC
-
-      font.should be_italic
-      font.should be_bold
-    end
-
-    describe "#draw" do
-      before :all do
-        @win  = Ray.create_window(:w => 100, :h => 100)
-        @font = Ray::Font.new(path_of("VeraMono.ttf"), 12)
-      end
-
-      it "should return an image when we don't say where to draw" do
-        @font.draw("Something").should be_a(Ray::Image)
-      end
-
-      it "should return the surface it drew on if it did" do
-        @font.draw("Something", :on => @win, :at => [0, 0]).should == @win
-      end
-    end
-
-    after :all do
-      Ray.stop
-    end
-  end
-
-  describe "String#draw" do
-    before :all do
-      Ray.init
-
-      @win  = Ray.create_window(:w => 100, :h => 100)
-      @font = Ray::Font.new(path_of("VeraMono.ttf"), 12)
-    end
-
-    it "should be able to guess the size" do
-      lambda {
-        "Hello world!".draw(:font => @font)
-      }.should_not raise_exception
-    end
-
-    it "should use the specified width unless :on is specified" do
-      img = "Hello world!".draw(:font => @font, :w => 40)
-      img.w.should == 40
-    end
-
-    it "should require the font to be specified" do
-      lambda {
-        "Hello world".draw(:on => @win)
-      }.should raise_exception
-    end
-
-    it "should draw on multiple lines" do
-      img = "Hello\nworld".draw(:font => @font, :w => 100)
-      img.height.should == @font.line_skip * 2
-    end
-
-    it "should allow to specify an explicit size" do
-      img = "Hello\nworld".draw(:font => @font, :h => 100, :w => 50)
-      img.width.should == 50
-      img.height.should == 100
-    end
-
-    after :all do
-      Ray.stop
-    end
-  end
-end

data/spec/ray/image_set_spec.rb

@@ -1,48 +0,0 @@
-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,162 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Ray::Image do
-  before :all do
-    Ray.init
-    @win = Ray.create_window(:w => 100, :h => 100)
-  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
-    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
-
-    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
-
-    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 {
-          img = Ray::Image.new(io)
-        }.should_not raise_exception
-      end
-    end
-
-    if Ray.has_image_support?
-      it "should be able to load other kind of images" do
-        lambda {
-          Ray::Image.new(path_of("aqua.png"))
-        }.should_not raise_exception
-      end
-
-      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(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 :all do
-    Ray.stop
-  end
-end