metro-ld26 0.3.4

data/spec/metro/models/properties/options_property/no_option_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Metro::Model::OptionsProperty::NoOption do
+
+  context "when attempting to an attribute like color of the no option" do
+
+    let(:log) { mock('log') }
+
+    it "should generate a warning message" do
+      log.should_receive(:warn).with(subject.warning_message)
+      subject.stub(:log) { log }
+      subject.color = :unknown
+    end
+  end
+
+  context "when queried for its action" do
+
+    let(:expected_action) { :missing_menu_action }
+
+    it "should return 'missing_menu_action'" do
+      subject.properties[:action].should eq expected_action
+    end
+  end
+
+end

data/spec/metro/models/properties/options_property/options_property_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Metro::Model::OptionsProperty do
+
+  subject { described_class.new model }
+  let(:model) { mock("model", create: 'builds models for a living') }
+
+  describe "#get" do
+    context "when the value is nil" do
+      context "when no menu has been specified" do
+        it "should return empty options" do
+          subject.get(nil).count.should eq 0
+        end
+      end
+    end
+
+
+    context "when the value is an array of options names" do
+      before do
+        model.stub(:create) { |model_type,options| mock(model_type,options) }
+      end
+
+      let(:names) { [ 'Start Game', 'Options', 'Exit Game' ] }
+      let(:actions) { [ :start_game, :options, :exit_game ] }
+
+      let(:options) { subject.get(names) }
+
+      it "should return an option for each name" do
+        options.count.should eq names.count
+      end
+
+      it "should create labels with text with each name" do
+        options.map { |option| option.text }.should eq names
+      end
+
+      it "should create actions based on each name" do
+        options.map { |option| option.action }.should eq actions
+      end
+
+      it "should set the default selected as the first item" do
+        options.selected.should eq options.first
+      end
+    end
+
+
+    context "when the value is a hash which is a set of option names and the selected index" do
+      before do
+        model.stub(:create) { |model_type,options| mock(model_type,options) }
+      end
+
+      let(:names_and_selected_index) do
+        { 'selected' => selected_index, 'items' => names  }
+      end
+
+      let(:names) { [ 'Start Game', 'Options', 'Exit Game' ] }
+      let(:actions) { [ :start_game, :options, :exit_game ] }
+      let(:selected_index) { 1 }
+      
+      let(:label_model_class) { 'metro::ui::label' }
+      
+
+      let(:options) { subject.get(names_and_selected_index) }
+
+      it "should return an option for each name" do
+        options.count.should eq names.count
+      end
+
+      it "should create labels for each name" do
+        options.each { |option| option.model.should eq label_model_class }
+      end
+
+      it "should create labels with text with each name" do
+        options.map { |option| option.text }.should eq names
+      end
+
+      it "should create actions based on each name" do
+        options.map { |option| option.action }.should eq actions
+      end
+
+      it "should set the default selected as the first item" do
+        options.selected.should eq options[selected_index]
+      end
+    end
+
+
+    context "when the value is hash that contains a set of options (with specific ui details) and the seelcted index" do
+      before do
+        model.stub(:create) { |model_type,options| mock(model_type,options) }
+      end
+
+      let(:names_and_selected_index) do
+        { 'selected' => selected_index, 'items' => details  }
+      end
+
+      let(:details) do
+        [ { model: 'metro::ui::label', text: 'Start Game!', action: 'start_game' },
+          { model: 'metro::ui::image', text: 'Settings', action: 'open_settings' },
+          { model: 'metro::ui::label', text: 'Exit' } ]
+      end
+      
+
+      let(:names) { [ 'Start Game!', 'Settings', 'Exit' ] }
+      let(:actions) { [ :start_game, :open_settings, :exit ] }
+      let(:models) { [ 'metro::ui::label', 'metro::ui::image', 'metro::ui::label' ] }
+      
+      let(:selected_index) { 1 }
+      
+      let(:options) { subject.get(names_and_selected_index) }
+
+      it "should return an option for each name" do
+        options.count.should eq names.count
+      end
+
+      it "should create labels for each name" do
+        options.map { |option| option.model }.should eq models
+      end
+
+      it "should create labels with text with each name" do
+        options.map { |option| option.text }.should eq names
+      end
+
+      it "should create actions based on each name" do
+        options.map { |option| option.action }.should eq actions
+      end
+
+      it "should set the default selected as the first item" do
+        options.selected.should eq options[selected_index]
+      end
+    end
+
+  end
+
+end

data/spec/metro/models/properties/options_property/options_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Metro::Model::OptionsProperty::Options do
+
+  describe "ClassMethods" do
+    describe "#empty" do
+      it "should generate an empty set of options" do
+        described_class.empty.should be_kind_of described_class
+      end
+    end
+  end
+
+  subject { described_class.new [ :a, :b ] }
+
+  describe "#current_selected_index" do
+    it "should by default be 0" do
+      subject.current_selected_index.should eq 0
+    end
+
+    context "when the value is set to negative value" do
+      let(:expected_index) { subject.count - 1 }
+
+      it "should set the current_selected_index to the last item" do
+        subject.current_selected_index = -1
+        subject.current_selected_index.should eq expected_index
+      end
+    end
+
+    context "when the value is set to a value greater than the count" do
+      let(:expected_index) { 0 }
+
+      it "should set the current_selected_index to the first item" do
+        subject.current_selected_index = 4
+        subject.current_selected_index.should eq expected_index
+      end
+    end
+  end
+
+  describe "#next!" do
+    before do
+      subject.current_selected_index = 0
+    end
+
+    let(:expected_index) { 1 }
+
+    it "should move the index to the next item" do
+      subject.next!
+      subject.current_selected_index.should eq expected_index
+    end
+
+    context "when next will pass the last item" do
+      before do
+        subject.current_selected_index = (subject.count - 1)
+      end
+
+      let(:expected_index) { 0 }
+
+      it "should return to the first item" do
+        subject.next!
+        subject.current_selected_index.should eq expected_index
+      end
+    end
+  end
+
+  describe "#previous!" do
+    before do
+      subject.current_selected_index = 1
+    end
+
+    let(:expected_index) { 0 }
+
+    it "should move to the item previous of the current one" do
+      subject.previous!
+      subject.current_selected_index.should eq expected_index
+    end
+
+    context "when previous! will move before the first item" do
+      let(:expected_index) { subject.count - 1 }
+
+      it "should return to the last item" do
+        subject.previous!
+        subject.previous!
+        subject.current_selected_index.should eq expected_index
+      end
+    end
+  end
+
+  describe "#selected" do
+    context "when their are options defined" do
+      let(:expected_selected) { subject[subject.current_selected_index] }
+
+      it "should return the item at the current_selected index" do
+        subject.selected.should eq expected_selected
+      end
+    end
+
+    context "when there are no options defined" do
+      subject { described_class.new [] }
+
+      it "should return a NoOption" do
+        subject.selected.should be_kind_of Metro::Model::OptionsProperty::NoOption
+      end
+    end
+  end
+
+  describe "#selected_action" do
+    context "when there are options defined" do
+      subject { described_class.new [ mock('first-option',properties: { action: expected_action }), mock('second-option') ] }
+      let(:expected_action) { :execute_this_action }
+      
+      it "should return the action defined on the current selected item" do
+        subject.selected_action.should eq expected_action
+      end
+    end
+    
+    context "when there are no options defined" do
+      subject { described_class.new [] }
+      
+      it "should return the action on the NoOption" do
+        subject.selected_action.should eq :missing_menu_action
+      end
+    end
+  end
+
+end

data/spec/metro/models/properties/position_property_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Metro::Model::PositionProperty do
+
+  subject { described_class.new model }
+  let(:model) { "model" }
+
+  describe "#get" do
+
+    context "when the value is nil" do
+      context "when no default value has been specified" do
+
+        let(:expected_position) { Point.at 0.0, 0.0 }
+
+        it "should return the default position" do
+          subject.get(nil).should eq expected_position
+        end
+      end
+
+      context "when a default value has been specified" do
+
+        subject { described_class.new model, default: expected_position }
+        let(:expected_position) { Point.at 4.0, 3.3 }
+
+        it "should return the specified default position" do
+          subject.get(nil).should eq expected_position
+        end
+      end
+    end
+
+    context "when the value is a string" do
+
+      let(:point) { "22.0,33.0" }
+      let(:expected_position) { Point.at 22.0, 33.0 }
+
+      it "should return the position" do
+        subject.get(point).should eq expected_position
+      end
+    end
+
+  end
+
+
+  describe "#set" do
+
+    context "when the value is nil" do
+      context "when no default value has been specified" do
+
+        let(:expected_position) { "0.0,0.0,0.0" }
+
+        it "should return the default position" do
+          subject.set(nil).should eq expected_position
+        end
+      end
+
+      context "when a default value has been specified" do
+
+        subject { described_class.new model, default: default_point }
+        let(:default_point) { Point.at 12, 24 }
+        let(:expected_position) { "12.0,24.0,0.0" }
+
+        it "should return the specified default position" do
+          subject.set(nil).should eq expected_position
+        end
+      end
+    end
+
+    context "when the value is a point" do
+
+      let(:point) { Point.at 10.0, 20.0 }
+      let(:expected_position) { "10.0,20.0,0.0" }
+
+      it "should return the same position" do
+        subject.set(point).should eq expected_position
+      end
+    end
+
+    context "when the value is a string" do
+
+      let(:point) { "22.0,33.0" }
+      let(:expected_position) { "22.0,33.0,0.0" }
+
+      it "should return the position" do
+        subject.set(point).should eq expected_position
+      end
+    end
+
+  end
+
+end

data/spec/metro/models/ui/label_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+describe Metro::UI::Label do
+
+  subject do
+    label = described_class.new text: expected_text
+    label.window = mock('window')
+    label
+  end
+
+  before do
+    # Reset the position of the label to the default
+    subject.position = nil
+    subject.scale = Scale.one
+  end
+
+  let(:expected_position) { Point.zero }
+  its(:position) { should eq expected_position }
+
+  its(:x) { should eq expected_position.x }
+  its(:y) { should eq expected_position.y }
+  its(:z) { should eq expected_position.z }
+  its(:z_order) { should eq expected_position.z_order }
+
+  context "when setting the position" do
+
+    it "should be set succesfully" do
+      subject.position = "10,10"
+      subject.position.should eq Point.at(10,10)
+    end
+
+    context "when setting the x property" do
+      let(:expected_x) { 11 }
+      let(:expected_y) { 0 }
+
+      it "should update successfully" do
+        subject.x = expected_x
+        subject.x.should eq expected_x
+        subject.position.x.should eq expected_x
+      end
+
+      it "should not effect the paired y property" do
+        subject.x = expected_x
+        subject.y.should eq expected_y
+        subject.position.y.should eq expected_y
+      end
+    end
+
+    context "when setting the y property" do
+      before do
+        subject.position = "#{expected_x},#{expected_y}"
+      end
+
+      let(:expected_x) { 320 }
+      let(:expected_y) { 66 }
+
+      it "should update successfully" do
+        subject.y = expected_y
+        subject.y.should eq expected_y
+        subject.position.y.should eq expected_y
+      end
+
+      it "should not effect the paired x property" do
+        subject.y = expected_y
+        subject.x.should eq expected_x
+      end
+    end
+
+  end
+
+  let(:expected_color) { Gosu::Color.new "rgb(255,255,255)" }
+  let(:expected_alpha) { 255 }
+
+  its(:color) { should eq expected_color }
+  its(:alpha) { should eq expected_alpha }
+
+  describe "font" do
+    before do
+      Metro::Font.stub(:find_or_create).and_return(font)
+    end
+
+    let(:font) { mock('font', name: expected_font_name, size: expected_font_size) }
+
+    let(:expected_font) { font }
+    its(:font) { should eq expected_font }
+
+    let(:expected_font_name) { 'mock_font_name' }
+    its(:font_name) { should eq expected_font_name }
+
+    let(:expected_font_size) { 12.0 }
+    its(:font_size) { should eq expected_font_size }
+
+  end
+
+  let(:expected_scale) { Scale.one }
+
+  its(:scale) { should eq expected_scale }
+  its(:x_factor) { should eq expected_scale.x_factor }
+  its(:y_factor) { should eq expected_scale.y_factor }
+
+  context "when setting the scale" do
+    it "should be set successfully" do
+      subject.x_factor = 2.0
+      subject.x_factor.should eq 2.0
+      subject.scale.x_factor.should eq 2.0
+    end
+  end
+
+  its(:align) { should eq expected_horizontal_alignment }
+  let(:expected_horizontal_alignment) { "left" }
+
+  its(:vertical_align) { should eq expected_vertical_alignment }
+  let(:expected_vertical_alignment) { "top" }
+
+  its(:text) { should eq expected_text }
+  let(:expected_text) { "Four Score and Seven Years Ago" }
+
+  context "when the text defines multiple lines (lines separated by newline characters)" do
+
+    let(:given_text) { "My name is something that takes\ntwo lines to express!" }
+    let(:first_line) { given_text.split("\n").first }
+    let(:last_line)  { given_text.split("\n").last }
+
+    let(:x_position) { 320 }
+    let(:y_position) { 200 }
+    let(:z_order) { 12 }
+
+    let(:scale_x) { 1.0 }
+    let(:scale_y) { 1.0 }
+
+    let(:font) { mock('font') }
+
+    let(:line_height) { 20 }
+
+    before do
+      subject.text = given_text
+      subject.position = Point.at(x_position,y_position,z_order)
+      subject.scale = Scale.to(scale_x,scale_y)
+      subject.stub(:font).and_return(font)
+      subject.stub(:line_height) { line_height }
+    end
+
+    it "should have the font draw each of the lines" do
+      font.should_receive(:draw).twice
+      subject.draw
+    end
+
+    context "when the horizontal alignment is center" do
+
+      before do
+        subject.align = "center"
+        subject.vertical_align = "top"
+        subject.stub(:line_width).with(first_line) { 60 }
+        subject.stub(:line_width).with(last_line) { 42 }
+      end
+
+      let(:first_line_x_position) { x_position - 30 }
+      let(:second_line_x_position) { x_position - 21 }
+
+      let(:first_line_y_position) { y_position }
+      let(:second_line_y_position) { y_position + line_height }
+
+      it "should draw the lines correctly based on their on their respective widths" do
+        font.should_receive(:draw).with(first_line,first_line_x_position,first_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        font.should_receive(:draw).with(last_line,second_line_x_position,second_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        subject.draw
+      end
+
+    end
+
+    context "when the horizontal alignment is right" do
+
+      before do
+        subject.align = "right"
+        subject.vertical_align = "top"
+        subject.stub(:line_width).with(first_line) { 60 }
+        subject.stub(:line_width).with(last_line) { 42 }
+      end
+
+      let(:first_line_x_position) { x_position - 60 }
+      let(:second_line_x_position) { x_position - 42 }
+
+      let(:first_line_y_position) { y_position }
+      let(:second_line_y_position) { y_position + line_height }
+
+      it "should draw the lines correctly based on their on their respective widths" do
+        font.should_receive(:draw).with(first_line,first_line_x_position,first_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        font.should_receive(:draw).with(last_line,second_line_x_position,second_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        subject.draw
+      end
+
+    end
+
+    context "when the vertical alignment is top" do
+
+      before do
+        subject.vertical_align = "top"
+      end
+
+      let(:first_line_y_position) { y_position }
+      let(:second_line_y_position) { y_position + line_height }
+
+      it "should draw the first line at the y position" do
+        font.should_receive(:draw).with(first_line,x_position,first_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        font.should_receive(:draw).with(last_line,x_position,second_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        subject.draw
+      end
+
+    end
+
+    context "when the vertical alignment is center" do
+
+      before do
+        subject.text = text
+        subject.vertical_align = "center"
+      end
+
+      let(:text) { "Three Lines\nOf Text\nWill Create Fun!" }
+
+
+      let(:first_line) { text.split("\n")[0] }
+      let(:second_line) { text.split("\n")[1] }
+      let(:third_line) { text.split("\n")[2] }
+
+
+      let(:first_line_y_position) { y_position - line_height - line_height / 2 }
+      let(:second_line_y_position) { y_position - line_height / 2 }
+      let(:third_line_y_position) { y_position + line_height / 2 }
+
+      it "should draw the first line at the y position" do
+        font.should_receive(:draw).with(first_line,x_position,first_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        font.should_receive(:draw).with(second_line,x_position,second_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        font.should_receive(:draw).with(third_line,x_position,third_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        subject.draw
+      end
+
+    end
+
+    context "when the vertical alignment is bottom" do
+
+      before do
+        subject.vertical_align = "bottom"
+      end
+
+      let(:first_line_y_position) { y_position - line_height * 2 }
+      let(:second_line_y_position) { y_position - line_height }
+
+      it "should draw the first line at the y position" do
+        font.should_receive(:draw).with(first_line,x_position,first_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        font.should_receive(:draw).with(last_line,x_position,second_line_y_position,z_order,scale_x,scale_y,an_instance_of(Gosu::Color))
+        subject.draw
+      end
+
+    end
+
+  end
+
+
+end