metro-ld26 0.3.4

data/spec/metro/parameters/command_line_args_parser_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Metro::Parameters::CommandLineArgsParser do
+
+  describe "Class Methods" do
+
+    subject { described_class }
+
+    describe "#parse" do
+      context "when given no parameters" do
+
+      end
+
+      context "when given an array of parameters" do
+
+        subject { described_class.parse parameters }
+        let(:parameters) { [ '--upset-the-world', expected_filename, '--check-dependencies', 'unread_command' ] }
+        let(:expected_filename) { 'metro' }
+
+        it "should maintain an original parameter list" do
+          subject.execution_parameters.should eq parameters
+        end
+
+        it "should consider the first non-flag the game file" do
+          subject.filename.should eq expected_filename
+        end
+
+        it "should find all the flags" do
+          subject.upset_the_world?.should be_true
+          subject.check_dependencies?.should be_true
+        end
+        
+        it "should return false when non-existant flags are present" do
+          subject.wants_food_mild?.should be_false
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/metro/scene_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Metro::Scene do
+
+  class SpecScene < Metro::Scene ; end
+
+  subject { SpecScene.new }
+
+  let(:expected_view_name) { "spec" }
+  its(:view_name) { should eq expected_view_name }
+  
+  let(:expected_scene_name) { "spec" }
+  its(:scene_name) { should eq expected_scene_name }
+
+end

data/spec/metro/scene_views/json_view_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Metro::Views::JSONView do
+
+  subject { described_class }
+  let(:view_name) { "example" }
+
+  before do
+    File.stub(:exists?).and_return(false)
+  end
+
+  describe ".exists?" do
+    context "when a view file exists with the extension JSON" do
+      before do
+        File.stub(:exists?).with(filepath_that_exists).and_return(true)
+      end
+
+      let(:filepath_that_exists) { "#{view_name}.json" }
+
+      it "should return true" do
+        subject.exists?(view_name).should be_true
+      end
+
+    end
+  end
+
+end

data/spec/metro/scene_views/yaml_view_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Metro::Views::YAMLView do
+
+  subject { described_class }
+  let(:view_name) { "example" }
+
+  before do
+    File.stub(:exists?).and_return(false)
+  end
+
+  describe ".exists?" do
+    context "when a view file exists with the extension YAML" do
+      before do
+        File.stub(:exists?).with(filepath_that_exists).and_return(true)
+      end
+
+      let(:filepath_that_exists) { "#{view_name}.yaml" }
+
+      it "should return true" do
+        subject.exists?(view_name).should be_true
+      end
+
+    end
+    context "when a view file exists with the extension YML" do
+      before :each do
+        File.stub(:exists?).with(filepath_that_exists).and_return(true)
+      end
+
+      let(:filepath_that_exists) { "#{view_name}.yml" }
+
+      it "should return true" do
+        subject.exists?(view_name).should be_true
+      end
+    end
+  end
+
+end

data/spec/metro/scenes_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Metro::Scenes do
+
+  subject { described_class }
+
+  class SpecScene < Metro::Scene ; end
+  let(:existing_scene_name) { :spec }
+
+  describe ".find" do
+    context "when a scene does exist" do
+
+      let(:expected_value) { SpecScene }
+
+      it "should return the scene" do
+        subject.find(existing_scene_name).should eq expected_value
+      end
+    end
+
+    context "when a scene does not exist" do
+      let(:unknown_scene_name) { :unknown }
+
+      it "should return a missing scene" do
+        missing_scene = subject.find(unknown_scene_name)
+        missing_scene.missing_scene.should eq unknown_scene_name
+      end
+    end
+  end
+
+  describe ".generate" do
+    let(:existing_scene_name) { :spec }
+
+    context "when the provided scene name does exist" do
+
+      let(:expected_scene_class) { SpecScene }
+
+      it "should return an instance of the scene" do
+        subject.generate(existing_scene_name).should be_kind_of expected_scene_class
+      end
+    end
+
+    context "when the provided scene object does exist" do
+
+      let(:scene_instance) { SpecScene.new }
+
+      it "should return the same instance of scene" do
+        subject.generate(scene_instance).should eq scene_instance
+      end
+    end
+
+    it "should process the scene through the post filters" do
+      subject.should_receive(:apply_post_filters)
+      subject.generate(existing_scene_name)
+    end
+  end
+
+  describe ".register_post_filter" do
+
+    class SpecScenesPostFilter
+      def self.filter(scene,options)
+        scene
+      end
+    end
+
+    context "when a post filter is added" do
+      let(:post_filter) { SpecScenesPostFilter }
+
+      it "should be in the list of post filters" do
+        subject.register_post_filter SpecScenesPostFilter
+        subject.post_filters.should include(post_filter)
+      end
+    end
+
+  end
+
+
+end

data/spec/metro/units/point_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Metro::Units::Point do
+
+  subject { described_class.new x, y, z }
+
+  let(:x) { 12 }
+  let(:y) { 24 }
+  let(:z) { 36 }
+
+  its(:x) { should eq x }
+  its(:y) { should eq y }
+  its(:z) { should eq z }
+  its(:z_order) { should eq z }
+
+  let(:expected_string) { "#{x},#{y},#{z}" }
+  its(:to_s) { should eq expected_string }
+
+  describe "#+" do
+    context "when adding it to another point" do
+      let(:point) { described_class.at 1, 2, 3 }
+      let(:summed_point) { described_class.at 13, 26, 39 }
+
+      it "should be a sum of the two points" do
+        sum = subject + point
+        sum.should eq summed_point
+      end
+    end
+
+    context "when adding it to another point-like object" do
+      let(:point) { stub('Point Like',x: 1, y: 2, z: 3) }
+      let(:summed_point) { described_class.at 13, 26, 39 }
+
+      it "should be a sum of the two points" do
+        sum = subject + point
+        sum.should eq summed_point
+      end
+    end
+
+    context "when adding it to something not like a point" do
+      let(:point) { stub('Not Point Like') }
+      let(:summed_point) { described_class.at 13, 26, 39 }
+
+      it "should raise an error" do
+        expect { subject + point }.to raise_error
+      end
+    end
+  end
+
+  describe "#-" do
+    context "when adding it to another point" do
+      let(:point) { described_class.at 1, 2, 3 }
+      let(:summed_point) { described_class.at 11, 22, 33 }
+
+      it "should be a sum of the two points" do
+        sum = subject - point
+        sum.should eq summed_point
+      end
+    end
+
+    context "when adding it to another point-like object" do
+      let(:point) { stub('Point Like',x: 1, y: 2, z: 3) }
+      let(:summed_point) { described_class.at 11, 22, 33 }
+
+      it "should be a sum of the two points" do
+        sum = subject - point
+        sum.should eq summed_point
+      end
+    end
+
+    context "when adding it to something not like a point" do
+      let(:point) { stub('Not Point Like') }
+      let(:summed_point) { described_class.at 13, 26, 39 }
+
+      it "should raise an error" do
+        expect { subject - point }.to raise_error
+      end
+    end
+  end
+
+  describe "Class Methods" do
+
+    subject { described_class }
+
+    describe "#zero" do
+      let(:expected_point) { Point.new 0,0,0 }
+
+      it "should create a zero point" do
+        subject.zero.should == expected_point
+      end
+    end
+
+    describe "#at" do
+      let(:expected_point) { Point.new 1,2,3 }
+
+      it "should be equal to a new created point" do
+        subject.at(1,2,3).should == expected_point
+      end
+    end
+
+    describe "#parse" do
+      context "when the input string is defined with 'x,y,z'" do
+        let(:input) { "1,2,3" }
+        let(:expected_value) { Point.at(1,2,3) }
+
+        it "should create the expected point" do
+          subject.parse(input).should eq expected_value
+        end
+      end
+
+      context "when the input string is defined with 'x,y'" do
+        let(:input) { "1,2" }
+        let(:expected_value) { Point.at(1,2,0) }
+
+        it "should create the expected point" do
+          subject.parse(input).should eq expected_value
+        end
+      end
+
+      context "when the input is a nil" do
+        let(:input) { nil }
+        let(:expected_value) { Point.at(0,0,0) }
+
+        it "should create the expected point" do
+          subject.parse(input).should eq expected_value
+        end
+      end
+    end
+
+  end
+
+end

data/spec/metro/units/rectangle_bounds_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe RectangleBounds do
+
+  let(:subject) { described_class.new left: 20, top: 30, right: 40, bottom: 60 }
+
+  shared_examples "valid point" do
+    it "correct point" do
+      expect(given_point).to eq expected_point
+    end
+  end
+
+  describe "#top_left" do
+    it_behaves_like "valid point" do
+      let(:given_point) { subject.top_left }
+      let(:expected_point) { Point.at 20, 30 }
+    end
+  end
+
+  describe "#top_right" do
+    it_behaves_like "valid point" do
+      let(:given_point) { subject.top_right }
+      let(:expected_point) { Point.at 40, 30 }
+    end
+  end
+
+  describe "#bottom_left" do
+    it_behaves_like "valid point" do
+      let(:given_point) { subject.bottom_left }
+      let(:expected_point) { Point.at 20, 60 }
+    end
+  end
+
+  describe "#bottom_right" do
+    it_behaves_like "valid point" do
+      let(:given_point) { subject.bottom_right }
+      let(:expected_point) { Point.at 40, 60 }
+    end
+  end
+  
+  describe "#center" do
+    it_behaves_like "valid point" do
+      let(:given_point) { subject.center }
+      let(:expected_point) { Point.at 30, 45 }
+    end
+  end
+  
+
+  describe "#dimensions" do
+    it "correct dimensions" do
+      expect(subject.dimensions).to eq Dimensions.of(20,30)
+    end
+  end
+
+
+end

data/spec/metro/views/view_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Metro::View do
+  before do
+    subject.name = "spec"
+  end
+
+  let(:expected_view_path) { "views/spec" }
+  its(:view_path) { should eq expected_view_path }
+
+  describe "#parser" do
+    before do
+      subject.stub(:supported_parsers) { [ mock(exists?: false), expected_parser ] }
+    end
+
+    let(:expected_parser) { mock(exists?: true) }
+
+    it "should return the first parser which has a existing view" do
+      subject.parser.should eq expected_parser
+    end
+  end
+
+  describe "#writer" do
+
+    context "when the parser has a format that matches a writer" do
+      before do
+        subject.stub(:parser) { mock(format: :json) }
+        subject.stub(:supported_writers) { [ mock(format: :yaml), expected_writer ] }
+      end
+
+      let(:expected_writer) { mock(format: :json) }
+
+      it "should match the parser format" do
+        subject.writer.format.should eq :json
+      end
+    end
+
+    context "when the format has been specified" do
+      before do
+        subject.stub(:parser) { mock(format: :json) }
+        subject.stub(:supported_writers) { [ expected_writer, mock(format: :json) ] }
+      end
+
+      let(:expected_writer) { mock(format: :yaml) }
+
+      it "should match the format (ignoring the parser format)" do
+        subject.format = :yaml
+        subject.writer.format.should eq :yaml
+      end
+    end
+  end
+
+end