metro-ld25 0.3.3

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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Metro::Model::ArrayProperty 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) { [] }
+
+        it "should return an empty array" do
+          subject.get(nil).should eq expected
+        end
+      end
+
+      context "when a default value has been specified" do
+        subject { described_class.new model, default: expected }
+        let(:expected) { [:default_1,:default_2] }
+
+        it "should return the specified default" do
+          subject.get(nil).should eq expected
+        end
+      end
+
+    end
+  end
+
+  describe "#set" do
+    context "when the value is nil" do
+      let(:expected) { [] }
+
+      it "should return an empty array" do
+        subject.set(nil).should eq expected
+      end
+    end
+
+    context "when the value contains symbols" do
+      let(:input) { [ :a, :b, :c ] }
+      let(:expected) { input }
+
+      it "should not convert the items to strings" do
+        subject.set(input).should eq expected
+      end
+    end
+
+    context "when the value contains numbers" do
+      let(:input) { [ 1, 5.4, 0xABAB ] }
+      let(:expected) { input }
+
+      it "should not convert the items to strings" do
+        subject.set(input).should eq expected
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Metro::Model::ColorProperty do
+
+  subject { described_class.new model }
+  let(:model) { mock("model", window: window) }
+  let(:window) { mock('window') }
+
+  describe "#get" do
+    let(:expected_color) { mock('color') }
+
+    context "when the value is nil" do
+      context "when no default value has been specified" do
+        let(:default_color_string) { "rgba(255,255,255,1.0)" }
+
+
+        it "should return the default value" do
+          subject.stub(:create_color).with(default_color_string) { expected_color }
+          subject.get(nil).should eq expected_color
+        end
+      end
+
+      context "when a default value has been specified" do
+        subject do
+          described_class.new model, default: expected_color_string
+        end
+
+        let(:expected_color_string) { "rgba(255,255,127,0.5)" }
+
+        it "should return the specified default value" do
+          subject.stub(:create_color).with(expected_color_string) { expected_color }
+          subject.get(nil).should eq expected_color
+        end
+      end
+    end
+
+    context "when the value is a string" do
+
+      let(:color_string) { "#666666" }
+
+      it "should return the color" do
+        subject.stub(:create_color).with(color_string) { expected_color }
+        subject.get(color_string).should eq expected_color
+      end
+    end
+
+  end
+
+  describe "#set" do
+    let(:expected_color) { mock('color') }
+
+    context "when the value is nil" do
+
+      context "when no default value has been specified" do
+        let(:expected_color_string) { "rgba(255,255,255,1.0)" }
+
+        it "should return a string representation of the default color" do
+          subject.set(nil).should eq expected_color_string
+        end
+      end
+
+      context "when a default value has been specified" do
+        subject do
+          described_class.new model, default: expected_color_string
+        end
+
+        let(:expected_color_string) { "rgba(0,127,11,0.4)" }
+
+        it "should return a string representation of the specified default color" do
+          subject.set(nil).should eq expected_color_string
+        end
+      end
+    end
+
+    context "when the value is a color" do
+      let(:color) { Gosu::Color.new expected_color_string }
+      let(:expected_color_string) { "rgba(45,12,12,1.0)" }
+
+      it "should return a string representation of the color" do
+        subject.set(color).should eq expected_color_string
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Metro::Model::DimensionsProperty do
+
+  subject { desribed_class.new model }
+  let(:model) { mock("model", window: window) }
+  let(:window) do
+    mock('window',dimensions: window_dimensions )
+  end
+
+  let(:window_dimensions) { Dimensions.of(1,1) }
+
+  context "when defined with a default block" do
+
+    subject do
+      described_class.new model do
+        window.dimensions
+      end
+    end
+
+    let(:expected_dimensions) { window_dimensions }
+
+    it "should calculate the correct default value" do
+      subject.get(nil).should eq expected_dimensions
+    end
+
+  end
+
+end

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

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Metro::Model::FontProperty do
+
+  subject { described_class.new model }
+  let(:model) { mock("model", window: window) }
+  let(:window) { mock('window') }
+
+  describe "#get" do
+    let(:expected_font) { stub('font') }
+    let(:expected_options) { { name: expected_font_name, size: expected_font_size, window: window } }
+    
+    context "when the value is nil" do
+      context "when no default value has been specified" do
+        let(:expected_font_name) { Gosu::default_font_name }
+        let(:expected_font_size) { 40 }
+    
+        it "should return the default value" do
+          described_class.stub(:font_for).with(expected_options) { expected_font }
+          subject.get(nil).should eq expected_font
+        end
+      end
+
+      context "when a default value has been specified" do
+        subject do
+          described_class.new model, default: { name: expected_font_name, size: expected_font_size }
+        end
+
+        let(:expected_font_name) { 'Times New Roman' }
+        let(:expected_font_size) { 60 }
+
+        it "should return the specified default value" do
+          described_class.stub(:font_for).with(expected_options) { expected_font }
+          subject.get(nil).should eq expected_font
+        end
+      end
+    end
+
+    context "when the value is a hash" do
+      let(:expected_font_name) { 'Helvetica' }
+      let(:expected_font_size) { 80 }
+    
+      let(:font_hash) { { name: expected_font_name, size: expected_font_size } }
+    
+      it "should return the font value" do
+        described_class.stub(:font_for).with(expected_options) { expected_font }
+        subject.get(font_hash).should eq expected_font
+      end
+    end
+
+    context "when the same font is requested" do
+      let(:expected_font_name) { Gosu::default_font_name }
+      let(:expected_font_size) { 40 }
+    
+      it "should not be created a second time (pullled from memory)" do
+        described_class.should_receive(:font_for).twice { expected_font }
+        subject.get(nil)
+        subject.get(nil)
+      end
+    end
+
+
+  end
+
+  describe "#set" do
+    context "when the value is nil" do
+      context "when no default value has been specified" do
+        let(:expected_font_name) { Gosu::default_font_name }
+        let(:expected_font_size) { 40 }
+        let(:expected_font) { stub('font') }
+
+        let(:expected_result) { { name: expected_font_name, size: expected_font_size } }
+        let(:expected_options) { { name: expected_font_name, size: expected_font_size, window: window } }
+
+        it "should return a hash of the default value" do
+          described_class.stub(:font_for).with(expected_options) { expected_font }
+          subject.set(nil).should eq expected_result
+        end
+      end
+
+      context "when a default value has been specified" do
+        subject do
+          described_class.new model, default: { name: expected_font_name, size: expected_font_size }
+        end
+
+        let(:expected_font_name) { 'Times New Roman' }
+        let(:expected_font_size) { 60 }
+
+        let(:expected_result) { { name: expected_font_name, size: expected_font_size } }
+
+        it "should return the specified default value" do
+          subject.set(nil).should eq expected_result
+        end
+      end
+    end
+
+    context "when the value is a font" do
+
+      let(:gosu_font) do
+        font = stub('font', name: expected_font_name, height: expected_font_size)
+        font.stub(:class) { Metro::Font }
+        font
+      end
+
+      let(:expected_font_name) { 'Comic Sans' }
+      let(:expected_font_size) { 45 }
+
+      let(:expected_result) { { name: expected_font_name, size: expected_font_size } }
+
+      it "should return a hash of the font" do
+        subject.set(gosu_font).should eq expected_result
+      end
+    end
+
+    context "when the value is a hash" do
+
+      let(:expected_font_name) { 'Wingdings' }
+      let(:expected_font_size) { 33 }
+      let(:expected_result) { { name: expected_font_name, size: expected_font_size } }
+
+      it "should return the hash representation of the font" do
+        subject.set(expected_result).should eq expected_result
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Metro::Model::NumericProperty 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_number) { 0.0 }
+
+        it "should return the default position" do
+          subject.get(nil).should eq expected_number
+        end
+      end
+
+      context "when a default value has been specified" do
+
+        subject { described_class.new model, default: expected_number }
+        let(:expected_number) { 1.0 }
+
+        it "should return the specified default position" do
+          subject.get(nil).should eq expected_number
+        end
+      end
+    end
+
+    context "when the value is a String" do
+
+      let(:number) { "4.3" }
+      let(:expected_number) { 4.3 }
+
+      it "should get the float value of the string" do
+        subject.get(number).should eq expected_number
+      end
+    end
+
+  end
+
+  describe "#set" do
+
+  end
+
+end

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