ray 0.0.0.pre2 → 0.0.1

data/spec/ray/rect_spec.rb

@@ -1,3 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
 describe Ray::Rect do
   [:x, :y, :width, :height].each do |meth|
     describe "##{meth}=" do
@@ -71,4 +73,82 @@ describe Ray::Rect do
       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

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

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

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--format html:report.html
+--format p
+-c
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), "..", "ext"))
+$: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+def path_of(res)
+  File.expand_path(File.join(File.dirname(__FILE__), "res", res))
+end
+
+require 'ray'

data/yard_ext.rb

@@ -0,0 +1,91 @@
+require 'yard'
+
+class MatcherHandler < YARD::Handlers::Ruby::Base
+  handles method_call(:describe_matcher)
+
+  def process
+    src = statement.parameters.children.first.source[1..-1]
+    MethodObject.new(P("Ray::Matchers"), src) do |o|
+      register(o)
+
+      args = statement.last.first
+      if args
+        o.parameters = [args.source]
+      end
+    end
+  end
+end
+
+class CustomCParser < YARD::Parser::CParser
+  include YARD
+
+  def parse
+    super
+    parse_constants
+  end
+
+  private
+
+  def find_method_body(object, func_name, content = @content)
+    case content
+    when %r"((?>/\*.*?\*/\s*))(?:(?:static|SWIGINTERN)\s+)?(?:intern\s+)?VALUE\s+#{func_name}
+                \s*(\([^)]*\))([^;]|$)"xm
+      comment, params = $1, $2
+      body_text = $&
+
+      remove_private_comments(comment) if comment
+
+      # see if we can find the whole body
+
+      re = Regexp.escape(body_text.strip) + '[^(]*\{.*?^\}'
+      if /#{re}/m =~ content
+        body_text = $&
+      end
+
+      # The comment block may have been overridden with a 'Document-method'
+      # block. This happens in the interpreter when multiple methods are
+      # vectored through to the same C method but those methods are logically
+      # distinct (for example Kernel.hash and Kernel.object_id share the same
+      # implementation
+
+      # override_comment = find_override_comment(object)
+      # comment = override_comment if override_comment
+
+      object.docstring = parse_comments(object, comment) if comment
+      object.source = body_text
+    when %r{((?>/\*.*?\*/\s*))^\s*\#\s*define\s+#{func_name}\s+(\w+)}m
+      comment = $1
+      find_method_body(object, $2, content)
+    else
+      # No body, but might still have an override comment
+      # comment = find_override_comment(object)
+      comment = nil
+      object.docstring = parse_comments(object, comment) if comment
+    end
+  end
+
+  def handle_constants(type, var_name, const_name, definition)
+    namespace = @namespaces[var_name]
+    obj = CodeObjects::ConstantObject.new(namespace, const_name)
+    obj.value = definition
+  end
+
+  def parse_constants
+    @content.scan(%r{\Wrb_define_
+                   ( variable          |
+                     readonly_variable |
+                     const             |
+                     global_const      | )
+               \s*\(
+                 (?:\s*(\w+),)?
+                 \s*"(\w+)",
+                 \s*(.*?)\s*\)\s*;
+                 }xm) do |type, var_name, const_name, definition|
+      var_name = "rb_cObject" if !var_name or var_name == "rb_mKernel"
+      handle_constants type, var_name, const_name, definition
+    end
+  end
+end
+
+YARD::Parser::SourceParser.register_parser_type(:c, CustomCParser,
+                                                ['c', 'cc', 'cxx', 'cpp'])