ray 0.0.0.pre2 → 0.0.1

data/spec/ray/audio_spec.rb

@@ -0,0 +1,146 @@
+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,3 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
 describe Ray::Color do
   describe "#initialize" do
     it "should accept 3 integers" do
@@ -41,4 +43,15 @@ describe Ray::Color do
       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,16 +1,11 @@
-describe "the event DSL" do
-  context "when someone listens to an event" do
-    before :all do
-      Ray.describe_matcher(:more_than, :integer) do |x|
-        lambda { |i| i > x }
-      end
-    end
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-    before :each do
+describe Ray::DSL do
+  before :each do
       @runner = Ray::DSL::EventRunner.new
 
       @obj = Object.new
-      @obj.extend Ray::DSL::Listener
+      @obj.extend Ray::DSL::EventListener
       @obj.extend Ray::DSL::EventRaiser
       @obj.extend Ray::Matchers
 
@@ -18,174 +13,68 @@ describe "the event DSL" do
       @obj.raiser_runner = @runner
     end
 
-    context "without any arguments" do
-      it "should always send it" do
-        var = 0
-        @obj.on :foo do
-          var += 1
-        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)
 
-        @obj.raise_event(:foo, "blabla")
-        @obj.raise_event(:foo)
-        @obj.raise_event(:foo, :error, 3, "read")
+    false_matcher = mock('false_matcher')
+    false_matcher.should_receive(:===).and_return(false)
 
-        @runner.run
-        var.should == 3
-      end
+    worked = nil
+
+    @obj.on :event, true_matcher do
+      worked.should_not == false
+      worked = true
     end
 
-    context "with some arguments" do
-      it "should send the ones with the same arguments" do
-        var = 0
-        @obj.on :foo, "danger", "bar" do
-          var += 1
-        end
-
-        @obj.raise_event(:foo)
-        @obj.raise_event(:foo, "bar")
-        @obj.raise_event(:foo, "danger")
-        @obj.raise_event(:foo, "danger", "bar")
-        @obj.raise_event(:foo, "danger", "bar", "test")
-
-        @runner.run
-        var.should == 1
-      end
-
-      context "if a matcher is one of them" do
-        it "should send the events if it matches the argument" do
-          count = 0
-
-          @obj.instance_eval do
-            on :foo, more_than(10) do |x|
-              x.should > 10
-              count += 1
-            end
-
-            raise_event(:foo, 5)
-            raise_event(:foo, "a")
-            raise_event(:foo, 15)
-          end
-
-          @runner.run
-          count.should == 1
-        end
-      end
-
-      context "if a regex is one of them" do
-        it "should send the event if a string match it" do
-          count = 0
-
-          @obj.instance_eval do
-            on :foo, /hello/ do |str|
-              str.should =~ /hello/
-              count += 1
-            end
-
-            raise_event(:foo, 0)
-            raise_event(:foo, "wat?")
-            raise_event(:foo, "Hey, hello you!")
-            raise_event(:foo, /hey hello you/)
-          end
-
-          @runner.run
-          count.should == 1
-        end
-
-        it "should send then event if the argument is the same regex" do
-          count = 0
-
-          @obj.instance_eval do
-            on :foo, /hello/ do |reg|
-              reg.should == /hello/
-              count += 1
-            end
-
-            raise_event(:foo, 0)
-            raise_event(:foo, 5.5)
-            raise_event(:foo, "Goodbye!")
-            raise_event(:foo, /hello/)
-          end
-
-          @runner.run
-          count.should == 1
-        end
-      end
+    @obj.on :event, false_matcher do
+      worked = false
     end
 
-    context "if the event was described" do
-      before :all do
-        Ray.describe_event(:weird_thing, :string, :integer)
-      end
-
-      it "should convert arguments at creation" do
-        ev = Ray::DSL::Event.new(:weird_thing, [3, "3"])
-        ev.args.should == ["3", 3]
-      end
-
-      it "should not raise an error if it can't convert objects" do
-        ev = Ray::DSL::Event.new(:weird_thing, ["str", String])
-        ev.args.should == ["str", String]
-      end
-
-      it "should always convert if a method like #to_i is available" do
-        obj = Object.new
-        class << obj; def to_i; 3; end; end
-
-        ev = Ray::DSL::Event.new(:weird_thing, [String, obj])
-        ev.args.should == ["String", 3]
-      end
-
-      it "should try to convert arguments for handlers" do
-        count = 0
-
-        @obj.instance_eval do
-          on :weird_thing, 3 do |x|
-            x.should == "3"
-            count += 1
-          end
-
-          raise_event(:weird_thing, 0)
-          raise_event(:weird_thing, 3)
-          raise_event(:weird_thing, "3")
-          raise_event(:weird_thing, String)
-        end
-
-        @runner.run
-        count.should == 2
-      end
-
-      it "should not try to convert matchers and regexps in handlers" do
-        count = 0
-
-        Ray.describe_conversion(Ray::DSL::Matcher => :integer,
-                                Regexp => :string) {}
-
-        Ray.describe_matcher(:more_than, :integer) do |x|
-          lambda { |val| val > x }
-        end
-
-        @obj.instance_eval do
-          on :weird_thing, /\d/, more_than(10) do |x, y|
-            count += 1
-          end
-
-          raise_event(:weird_thing, "1", 15)
-        end
-
-        @runner.run
-        count.should == 1
-      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
 
-    context "when the proc takes arguments" do
-      it "should pass the arguments given to the event" do
-        @obj.on :foo do |*args|
-          args.should == ["a", "b", "c"]
-        end
+    @obj.raise_event(:foo, "a", "b", "c")
+    @runner.run
+  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

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