colstrom-fidgit 0.2.7

data/lib/fidgit/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module Fidgit
+  VERSION = '0.2.7'
+end

data/lib/fidgit/window.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Fidgit
+  module Window
+
+    def self.included(base)
+      base.send :include, Methods
+    end
+
+    module Methods
+
+      def close
+        super
+        GuiState.clear
+      end
+    end
+    
+  end
+end

data/spec/fidgit/elements/helpers/helper.rb

@@ -0,0 +1,3 @@
+require "rspec"
+
+require_relative File.join(File.dirname(__FILE__), "..", "..", "..", "..", "lib", "fidgit")

data/spec/fidgit/elements/helpers/tex_play_helper.rb

@@ -0,0 +1,9 @@
+require 'texplay'
+
+module Gosu
+  class Image
+    def self.create(width, height, options = {})
+      TexPlay.create_image($window, width, height, options)
+    end
+  end
+end

data/spec/fidgit/elements/image_frame_spec.rb

@@ -0,0 +1,69 @@
+require_relative 'helpers/helper'
+require_relative 'helpers/tex_play_helper'
+
+require 'fidgit'
+
+def check_thumbnail_is_square
+  {square: [10, 10], tall: [5, 12], wide: [6, 5]}.each_pair do |type, dimensions|
+    context "with a #{type} image" do
+      it "should be square and just large enough to contain the image" do
+        subject = described_class.new(Gosu::Image.create(*dimensions), thumbnail: true)
+        subject.width.should equal dimensions.max
+        subject.height.should equal dimensions.max
+      end
+    end
+  end
+end
+
+def check_image_dimensions
+  {square: [10, 10], tall: [5, 12], wide: [6, 5]}.each_pair do |type, dimensions|
+    context "with a #{type} image" do
+      it "should be just large enough to contain the image" do
+        subject = described_class.new(Gosu::Image.create(*dimensions))
+        subject.width.should equal dimensions.first
+        subject.height.should equal dimensions.last
+      end
+    end
+  end
+end
+
+module Fidgit
+  describe ImageFrame do
+    before :all do
+      $window = Chingu::Window.new(100, 100, false) unless $window
+    end
+
+    before :each do
+      @image = Gosu::Image.create(10, 10)
+    end
+
+    subject { described_class.new(@image) }
+
+    describe '#image' do
+      it "should have the image set" do
+        subject.image.should be @image
+      end
+    end
+
+    describe '#width and #height' do
+      check_image_dimensions
+    end
+
+    describe "Thumbnails" do
+      subject { described_class.new(@image, thumbnail: true) }
+
+      describe '#image=' do
+        it "should update the height and width" do
+          image = Gosu::Image.create(8, 2)
+          subject.image = image
+          subject.height.should equal 8
+          subject.width.should equal 8
+        end
+      end
+
+      describe '#width and #height' do
+        check_thumbnail_is_square
+      end
+    end
+  end
+end

data/spec/fidgit/elements/label_spec.rb

@@ -0,0 +1,37 @@
+require_relative "helpers/helper"
+
+include Fidgit
+
+describe Label do
+  before :all do
+    $window = Chingu::Window.new(100, 100, false) unless $window
+  end
+
+  context "with default parameters" do
+    subject { Label.new( "Hello world!") }
+
+    it "should have text value set" do
+      subject.text.should eq "Hello world!"
+    end
+
+    it "should have white text" do
+      subject.color.should eq Gosu::Color.rgb(255, 255, 255)
+    end
+
+    it "should have a transparent background" do
+      subject.background_color.should be_transparent
+    end
+
+    it "should have a transparent border" do
+      subject.border_color.should be_transparent
+    end
+
+    it "should be enabled" do
+      subject.should be_enabled
+    end
+
+    it "should not have an image" do
+      subject.icon.should be_nil
+    end
+  end
+end

data/spec/fidgit/event_spec.rb

@@ -0,0 +1,210 @@
+require_relative 'helpers/helper'
+
+require 'event'
+
+module Fidgit
+  describe Event do
+    before :each do
+      class Test
+        include Event
+      end
+    end
+
+    after :each do
+      Fidgit.send :remove_const, :Test
+    end
+
+    subject { Test }
+
+    describe "events" do
+      it "should initially be empty" do
+        subject.events.should be_empty
+      end
+    end
+
+    describe "event" do
+      it "should add the event to the list of events handled" do
+        subject.event :frog
+        subject.events.should include :frog
+      end
+
+      it "should inherit parent's events and be able to add more" do
+        Test.event :frog
+        class Test2 < Test; end
+        Test2.event :fish
+        Test2.events.should include :frog
+        Test2.events.should include :fish
+      end
+    end
+
+    context "When included into a class that is instanced" do
+      subject { Test.event :frog; Test.new }
+
+      describe "#subscribe" do
+        it "should add a handler as a block" do
+          subject.subscribe(:frog) { puts "hello" }
+        end
+
+        it "should fail if the event name isn't handled by this object" do
+          ->{ subject.subscribe(:unhandled_event) {} }.should raise_error ArgumentError
+        end
+
+        it "should add a handler as a method" do
+          subject.stub! :handler
+          subject.subscribe(:frog, subject.method(:handler))
+        end
+
+        it "should fail if neither a method or a block is passed" do
+          ->{ subject.subscribe(:frog) }.should raise_error ArgumentError
+        end
+
+        it "should fail if both a method and a block is passed" do
+          subject.stub! :handler
+          ->{ subject.subscribe(:frog, subject.method(:handler)) { } }.should raise_error ArgumentError
+        end
+
+        it "should return a Subscription" do
+          handler = proc {}
+          result = subject.subscribe(:frog, &handler)
+          result.should be_a Fidgit::Event::Subscription
+          result.handler.should be handler
+          result.publisher.should be subject
+          result.event.should equal :frog
+        end
+
+        it "should return a Subscription that can use Subscription#unsubscribe" do
+          handler_ran = false
+          subscription = subject.subscribe(:frog) { handler_ran = true }
+          subscription.unsubscribe
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+      end
+
+      describe "#unsubscribe" do
+        it "should accept a Subscription" do
+          handler_ran = false
+          subscription = subject.subscribe(:frog) { handler_ran = true }
+          subject.unsubscribe subscription
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+
+        it "should accept a handler" do
+          handler_ran = false
+          handler = proc { handler_ran = true }
+          subject.subscribe(:frog, &handler)
+          subject.unsubscribe handler
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+
+        it "should accept an event and handler" do
+          handler_ran = false
+          handler = proc { handler_ran = true }
+          subject.subscribe(:frog, &handler)
+          subject.unsubscribe :frog, handler
+          subject.publish :frog
+          handler_ran.should be_false
+        end
+
+        it "should require 1..2 arguments" do
+          ->{ subject.unsubscribe }.should raise_error ArgumentError
+          ->{ subject.unsubscribe 1, 2, 3 }.should raise_error ArgumentError
+        end
+
+        it "should fail with bad types" do
+          ->{ subject.unsubscribe 1 }.should raise_error TypeError
+          ->{ subject.unsubscribe 1, ->{} }.should raise_error TypeError
+          ->{ subject.unsubscribe :event, 2 }.should raise_error TypeError
+        end
+
+        it "should fail if passed a Subscription to another object" do
+          subscription = Fidgit::Event::Subscription.new(Object.new.extend(Fidgit::Event), :event, proc {})
+          ->{ subject.unsubscribe subscription }.should raise_error ArgumentError
+        end
+      end
+
+      describe "#publish" do
+        it "should return nil if there are no handlers" do
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should return nil if there are no handlers that handle the event" do
+          subject.should_receive(:frog).with(subject)
+          subject.should_receive(:handler).with(subject)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should return :handled if a manual handler handled the event and not call other handlers" do
+          subject.should_not_receive(:handler1)
+          subject.should_receive(:handler2).with(subject).and_return(:handled)
+          subject.subscribe(:frog, subject.method(:handler1))
+          subject.subscribe(:frog, subject.method(:handler2))
+          subject.publish(:frog).should == :handled
+        end
+
+        it "should return :handled if an automatic handler handled the event and not call other handlers" do
+          subject.should_receive(:frog).with(subject).and_return(:handled)
+          subject.should_not_receive(:handler2)
+          subject.subscribe(:frog, subject.method(:handler2))
+          subject.publish(:frog).should == :handled
+        end
+
+        it "should pass the object as the first parameter" do
+          subject.should_receive(:handler).with(subject)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish :frog
+        end
+
+        it "should call all the handlers, once each" do
+          subject.should_receive(:handler1).with(subject)
+          subject.should_receive(:handler2).with(subject)
+          subject.subscribe(:frog, subject.method(:handler1))
+          subject.subscribe(:frog, subject.method(:handler2))
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should pass parameters passed to it" do
+          subject.should_receive(:handler).with(subject, 1, 2)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog, 1, 2).should be_nil
+        end
+
+        it "should do nothing if the subject is disabled" do
+          subject.should_receive(:enabled?).and_return(false)
+          subject.should_not_receive(:handler)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog, 1, 2).should be_nil
+        end
+
+        it "should act normally if the subject is enabled" do
+          subject.should_receive(:enabled?).and_return(true)
+          subject.should_receive(:handler)
+          subject.subscribe(:frog, subject.method(:handler))
+          subject.publish(:frog, 1, 2).should be_nil
+        end
+
+        it "should only call the handlers requested" do
+          Test.event :fish
+
+          subject.should_receive(:handler1).with(subject)
+          subject.should_not_receive(:handler2)
+          subject.subscribe(:frog, subject.method(:handler1))
+          subject.subscribe(:fish, subject.method(:handler2))
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should automatically call a method on the publisher if it exists" do
+          subject.should_receive(:frog).with(subject)
+          subject.publish(:frog).should be_nil
+        end
+
+        it "should fail if the event name isn't handled by this object" do
+          ->{ subject.publish(:unhandled_event) }.should raise_error ArgumentError
+        end
+      end
+    end
+  end
+end

data/spec/fidgit/gosu_ext/color_spec.rb

@@ -0,0 +1,130 @@
+require_relative "helpers/helper"
+
+include Gosu
+
+describe Color do
+  describe "rgb" do
+    it "should create a color with the correct values from channel values" do
+      color = Color.rgb(1, 2, 3)
+      color.red.should equal 1
+      color.green.should equal 2
+      color.blue.should equal 3
+      color.alpha.should equal 255
+    end
+  end
+
+  describe "rgba" do
+    it "should create a color with the correct value from channel valuess" do
+      color = Color.rgba(1, 2, 3, 4)
+      color.red.should equal 1
+      color.green.should equal 2
+      color.blue.should equal 3
+      color.alpha.should equal 4
+    end
+  end
+
+  describe "argb" do
+    it "should create a color with the correct values from channel values" do
+      color = Color.argb(1, 2, 3, 4)
+      color.red.should equal 2
+      color.green.should equal 3
+      color.blue.should equal 4
+      color.alpha.should equal 1
+    end
+  end
+
+  describe "ahsv" do
+    it "should create a color with the correct values from channel values" do
+      color = Color.ahsv(1, 180.0, 0.5, 0.7)
+      color.hue.should be_within(0.001).of(180.0)
+      color.saturation.should be_within(0.01).of(0.5)
+      color.value.should be_within(0.01).of(0.7)
+      color.alpha.should equal 1
+    end
+  end
+
+  describe "hsva" do
+    it "should create a color with the correct values from channel values" do
+      color = Color.hsva(180.0, 0.5, 0.7, 4)
+      color.hue.should be_within(0.001).of(180.0)
+      color.saturation.should be_within(0.01).of(0.5)
+      color.value.should be_within(0.01).of(0.7)
+      color.alpha.should equal 4
+    end
+  end
+
+  describe "from_tex_play" do
+    it "should create a color with the correct values" do
+      color = Color.from_tex_play([1 / 255.0, 2 / 255.0, 3 / 255.0, 4 / 255.0])
+      color.red.should equal 1
+      color.green.should equal 2
+      color.blue.should equal 3
+      color.alpha.should equal 4
+    end
+  end
+
+  describe "#to_tex_play" do
+    it "should create an array with the correct values" do
+      array = Color.rgba(1, 2, 3, 4).to_tex_play
+      array.should eq [1 / 255.0, 2 / 255.0, 3 / 255.0, 4 / 255.0]
+    end
+  end
+
+  describe "#==" do
+    it "should return true for colours that are identical" do
+      (Color.rgb(1, 2, 3) == Color.rgb(1, 2, 3)).should be_true
+    end
+
+    it "should return false for colours that are not the same" do
+      (Color.rgb(1, 2, 3) == Color.rgb(4, 2, 3)).should be_false
+    end
+  end
+
+  describe "#transparent?" do
+    it "should be true if alpha is 0" do
+      Color.rgba(1, 1, 1, 0).should be_transparent
+    end
+
+    it "should be false if 0 > alpha > 255" do
+      Color.rgba(1, 1, 1, 2).should_not be_transparent
+    end
+
+    it "should be false if alpha == 255" do
+      Color.rgba(1, 1, 1, 255).should_not be_transparent
+    end
+  end
+
+  describe "#opaque?" do
+    it "should be true if alpha is 0" do
+      Color.rgba(1, 1, 1, 0).should_not be_opaque
+    end
+
+    it "should be false if 0 > alpha > 255" do
+      Color.rgba(1, 1, 1, 2).should_not be_opaque
+    end
+
+    it "should be false if alpha == 255" do
+      Color.rgba(1, 1, 1, 255).should be_opaque
+    end
+  end
+
+  describe "#+" do
+    it "should add two colours together" do
+      (Color.rgba(1, 2, 3, 4) + Color.rgba(10, 20, 30, 40)).should == Color.rgba(11, 22, 33, 44)
+    end
+
+    it "should cap values at 255" do
+      (Color.rgba(56, 56, 56, 56) + Color.rgba(200, 200, 200, 200)).should == Color.rgba(255, 255, 255, 255)
+    end
+  end
+
+  describe "#-" do
+    it "should subtract one color from another two colours together" do
+      (Color.rgba(10, 20, 30, 40) - Color.rgba(1, 2, 3, 4)).should == Color.rgba(9, 18, 27, 36)
+    end
+
+    it "should cap values at 0" do
+      (Color.rgba(56, 56, 56, 56) - Color.rgba(57, 57, 57, 57)).should == Color.rgba(0, 0, 0, 0)
+    end
+  end
+end