ray 0.0.1 → 0.1.0.pre1

data/samples/turtle/tree.rb

@@ -0,0 +1,57 @@
+# Drawing code stolen from here:
+#  http://www.rubyquiz.com/quiz104.html
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+class Ray::Turtle
+  def tree(size)
+    if size < 5
+      forward size
+      backward size
+    else
+      forward size / 3
+
+      left 30
+      tree size * 2 / 3
+      right 30
+
+      forward size / 6
+
+      right 25
+      tree size / 2
+      left 25
+
+      forward size / 3
+      right 25
+      tree size / 2
+      left 25
+
+      forward size / 6
+      backward size
+    end
+  end
+end
+
+Ray::Game.new("Turtle") do
+  register do
+    add_hook :quit, method(:exit!)
+  end
+
+  scene :tree do
+    render do |win|
+      win.fill(Ray::Color.black).turtle do
+        pen_up
+        left 90
+        center
+        backward 180
+        pen_down
+        tree(240.0)
+      end
+    end
+  end
+
+  push_scene :tree
+end

data/test/audio_test.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "Ray::Audio" do
+  setup { Ray::Audio }
+
+  asserts(:volume).equals(100)
+
+  asserts(:pos).equals(Ray::Vector3[0, 0, 0])
+  asserts(:direction).equals(Ray::Vector3[0, 0, -1])
+
+  context "after changing the volume" do
+    hookup { topic.volume = 50 }
+    asserts(:volume).equals(50)
+  end
+
+  context "after changing the position" do
+    hookup { topic.pos = [10, -5, 3] }
+    asserts(:pos).equals(Ray::Vector3[10, -5, 3])
+  end
+
+  context "after changing the direction" do
+    hookup { topic.direction = [10, -5, 3] }
+    asserts(:direction).equals(Ray::Vector3[10, -5, 3])
+  end
+end
+
+[Ray::Sound, Ray::Music].each do |klass|
+  context klass do
+    setup { klass }
+
+    denies("created from a file") {
+      topic.new path_of("pop.wav")
+    }.raises(RuntimeError)
+
+    asserts("created from a non-existing file") {
+      topic.new path_of("doesnt_exist.wav")
+    }.raises(RuntimeError)
+
+    denies("created from an IO") {
+      open(path_of("pop.wav")) { |io| topic.new(io) }
+    }.raises(RuntimeError)
+
+    asserts("created from an invalid IO") {
+      open(path_of("aqua.png")) { |io| topic.new(io) }
+    }.raises(RuntimeError)
+  end
+end
+
+{
+  "a sound" => Ray::Sound.new(path_of("pop.wav")),
+  "a music" => Ray::Music.new(path_of("pop.wav"))
+}.each do |name, object|
+  context name do
+    setup { object }
+
+    asserts(:volume).equals(100)
+    asserts(:pitch).equals(1)
+    asserts(:pos).equals(Ray::Vector3[0, 0, 0])
+    denies(:relative?)
+    asserts(:min_distance).equals(1)
+    asserts(:attenuation).equals(1)
+    asserts(:status).equals(:stopped)
+
+    asserts(:current_time).equals(0)
+    denies(:loop?)
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/color_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a color" do
+  setup { Ray::Color.new(10, 10, 10, 10) }
+
+  asserts("#* RGBA(255, 0, 0, 255)") {
+    topic * Ray::Color.red
+  }.equals Ray::Color.new(10, 0, 0, 10)
+
+  asserts("#+ RGBA(20, 10, 4, 255)") {
+    topic + Ray::Color.new(20, 10, 4, 255)
+  }.equals Ray::Color.new(30, 20, 14, 255)
+
+  asserts "is equal to a color with the same components" do
+    topic == Ray::Color.new(10, 10, 10, 10)
+  end
+
+  denies "is equal to a color with different components" do
+    topic == Ray::Color.new(20, 10, 10, 10)
+  end
+
+  [:red, :green, :blue, :alpha].each do |comp|
+    context "after having changed #{comp} to 30" do
+      hookup { topic.send("#{comp}=", 30) }
+
+      asserts(comp).equals(30)
+
+      asserts "other components keep their values" do
+        [:red, :green, :blue, :alpha].all? do |other|
+          other == comp || topic.send(other) == 10
+        end
+      end
+    end
+  end
+
+  context "created with 3 integers" do
+    setup { Ray::Color.new(10, 20, 30) }
+
+    asserts "has the components given at creation" do
+      topic.r == 10 && topic.g == 20 && topic.b == 30
+    end
+
+    asserts(:a).equals(255)
+  end
+
+  context "created with 4 integers" do
+    setup { Ray::Color.new(10, 20, 30, 127) }
+
+    asserts "has the components given at creation" do
+      topic.r == 10 && topic.g == 20 && topic.b == 30 && topic.a == 127
+    end
+  end
+
+  context "copied from another color" do
+    setup do
+      @old_topic = topic
+      topic.dup
+    end
+
+    asserts(:r).equals(10)
+    asserts(:g).equals(10)
+    asserts(:b).equals(10)
+    asserts(:g).equals(10)
+
+    denies "is the same object as the original" do
+      topic.equal? @old_topic
+    end
+
+    asserts "is eql? to the original" do
+      topic.eql? @old_topic
+    end
+
+    asserts(:hash).equals { @old_topic.hash }
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/drawable_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a drawable" do
+  setup do
+    @block = Proc.new {}
+    Ray::Drawable.new(&@block)
+  end
+
+  context "after drawing" do
+    hookup do
+      stub(@block).call
+      (@img = Ray::Image.new(:w => 10, :h => 10)).draw_drawable topic
+    end
+
+    asserts("the block") { @block }.received(:call) { @img }
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/dsl_test.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "an event runner" do
+  helper(:register_for) do |name, *args|
+    stub(@stub).__send__(name)
+    @obj.on(name, *args) { |*block_args| @stub.__send__(name, *block_args) }
+  end
+
+  helper(:raise_event)   { |name, *args| @obj.raise_event(name, *args) }
+
+  helper(:enable_group)  { |name| @obj.enable_event_group(name) }
+  helper(:disable_group) { |name| @obj.disable_event_group(name) }
+
+  helper(:event_group)   { |name| @obj.current_event_group = name }
+
+  def runner_asserts(name, method = :asserts, &block)
+    send(method, "after #{name}") do
+      [:default, :test].each { |o| @obj.remove_event_group o }
+      instance_eval(&block)
+      topic.run
+
+      @stub
+    end
+  end
+
+  def runner_denies(name, &block)
+    runner_asserts(name, :denies, &block)
+  end
+
+  setup do
+    runner = Ray::DSL::EventRunner.new
+
+    @stub = Object.new
+    class << @stub
+      def inspect; "stub"; end
+    end
+
+    @obj = Object.new
+    @obj.extend Ray::Helper
+    @obj.event_runner = runner
+
+    runner
+  end
+
+  runner_asserts("sending a registred event") {
+    register_for :event
+    raise_event :event
+  }.received(:event)
+
+  runner_denies("sending an unregistred event") {
+    register_for :foo
+    raise_event :event
+  }.received(:event)
+
+  runner_asserts("sending a registred event with the same arguments") {
+    register_for :event, "argument"
+    raise_event :event, "argument"
+  }.received(:event, "argument")
+
+  runner_asserts("sending a registred event with matching arguments") {
+    register_for :event, /arg/
+    raise_event :event, "argument"
+  }.received(:event, "argument")
+
+  runner_denies("sending a registred event with less arguments") {
+    register_for :event, "argument1", "argument2"
+    raise_event :event, "argument1"
+  }.received(:event, "argument1")
+
+  runner_asserts("sending a register event with more arguments") {
+    register_for :event
+    raise_event :event, "bar"
+  }.received(:event, "bar")
+
+  runner_denies("sending an event registred in a disabled event group") {
+    event_group   :test
+    register_for  :event
+    disable_group :test
+
+    raise_event :event
+  }.received(:event)
+
+  runner_asserts("sending an event registred in an enabled event_group") {
+    event_group   :test
+    register_for  :event
+    disable_group :test
+    enable_group  :test
+
+    raise_event :event
+  }.received(:event)
+end
+
+run_tests if __FILE__ == $0

data/test/font_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context Ray::Font do
+  setup { Ray::Font }
+
+  denies("creating a font from a file") {
+    topic.new(path_of("VeraMono.ttf"))
+  }.raises(RuntimeError)
+
+  asserts("creating a font from a non-existing file") {
+    topic.new(path_of("doesnt_exist.ttf"))
+  }.raises(RuntimeError)
+
+  denies("creating a font from an IO object") {
+    open(path_of("VeraMono.ttf")) { |io| topic.new(io) }
+  }.raises(RuntimeError)
+
+  asserts("creating a font from an invalid IO object") {
+    open(path_of("aqua.png")) { |io| topic.new(io) }
+  }.raises(RuntimeError)
+end
+
+context "a font" do
+  setup { Ray::Font.default }
+
+  denies("height of a text containing two lines almost equals line skip") {
+    diff = (topic.size_of("Hello\nWorld", :size => 12).height - topic.line_skip(12)).abs
+    diff <= 1
+  }
+
+  asserts("width of a multi-line text") {
+    topic.width_of("Hello\nabcdefghijkmnopqrstuvwxyz\nWorld", :size => 12)
+  }.equals { topic.width_of("abcdefghijkmnopqrstuvwxyz", :size => 12) }
+
+  asserts("a drawn image's size") {
+    img = topic.draw("Hello world", :size => 12)
+    img.size
+  }.equals { topic.size_of("Hello world", :size => 12) }
+
+  asserts("return value of drawn when :on is set") {
+    topic.draw("Hello world", :on => Ray.screen, :size => 12)
+  }.equals { Ray.screen }
+
+  asserts("using an unknown style") {
+    topic.draw("Hello world", :size => 12, :style => [:foo])
+  }.raises(ArgumentError)
+
+  denies("using a know style") {
+    topic.draw("Hello world", :size => 12, :style => [:bold])
+  }.raises(ArgumentError)
+
+  asserts("not specifying the size") {
+    topic.draw("Hello world", {})
+  }.raises(ArgumentError)
+end
+
+run_tests if __FILE__ == $0

data/test/helpers.rb

@@ -0,0 +1,94 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "ext"))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'riot'
+require 'riot/rr'
+
+require 'ray'
+
+include Math
+
+def path_of(res)
+  File.expand_path(File.join(File.dirname(__FILE__), "res", res))
+end
+
+def run_tests
+  Ray.create_window(:w => 100, :h => 150)
+  exit Riot.run.success?
+end
+
+def deg_to_rad(deg)
+  deg * PI / 180
+end
+
+class AlmostEqualMacro < Riot::AssertionMacro
+  register :almost_equals
+
+  def test(actual, expected, epsilon)
+    (actual - expected).abs <= epsilon
+  end
+
+  def evaluate(actual, expected, epsilon = Float::EPSILON)
+    if test(actual, expected, epsilon)
+      pass "is almost equal to #{expected}"
+    else
+      fail "#{actual} +/- #{epsilon} is not equal to #{expected}"
+    end
+  end
+
+  def devaluate(actual, expected, epsilon = Float::EPSILON)
+    if test(actual, expected, epsilon)
+      fail "#{actual} is almost equal to #{expected}"
+    else
+      pass "+/- #{epsilon} is almost equal to #{expected}"
+    end
+  end
+end
+
+class ReceivedMacro < Riot::AssertionMacro
+  register :received
+
+  include RR::Adapters::RRMethods
+
+  def evaluate(recv, msg, *args)
+    msg, times = case msg
+                 when Symbol then [msg, 1]
+                 when Hash   then msg.each.first
+                 end
+
+    begin
+      received(recv).__send__(msg, *args).times(times).call
+      pass "received ##{msg} with #{args.map { |o| o.inspect }.join(', ') } " +
+        "#{times} time#{'s' if times != 1}"
+    rescue ::RR::Errors::RRError => e
+      fail "#{recv.inspect} didn't receive ##{msg} with " +
+        "#{args.map { |o| o.inspect }.join(', ') } " +
+        "#{times} time#{'s' if times != 1}"
+    end
+  end
+
+  def devaluate(recv, msg, *args)
+    msg, times = case msg
+                 when Symbol then [msg, 1]
+                 when Hash   then msg.each.first
+                 end
+
+    begin
+      received(recv).__send__(msg, *args).times(times).call
+      fail "#{recv.inspect} received ##{msg} with " +
+        "#{args.map { |o| o.inspect }.join(', ') } " +
+        "#{times} time#{'s' if times != 1}"
+    rescue ::RR::Errors::RRError
+      pass "received ##{msg} with " +
+        "#{args.map { |o| o.inspect }.join(', ') } " +
+        "#{times} time#{'s' if times != 1}"
+    end
+  end
+end
+
+class Riot::Context
+  include RR::Adapters::RRMethods
+end
+
+Riot.reporter = Riot::DotMatrixReporter unless ARGV.include? "--verbose"
+Riot.alone!