kangoroo_robot 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 142b9ff41c89f3b726732224dc9ca5da085f74e8
-  data.tar.gz: d6d06cfa5b796c80dd4d1f6f96b24748707c5dbd
+  metadata.gz: e446f745751fd301416bc9fafe29240c422a367b
+  data.tar.gz: bedccb72bbb6a2d4a4ba23ad671136bf78e3d039
 SHA512:
-  metadata.gz: 1358260f8d2307a97cd60ce6be517ffef8ffb6326a92346791ed6b4abd15c7aef65e6a07a6897680c3abc7fccfdc3426b842b5b335060e38d58f18f43824c3ed
-  data.tar.gz: b81cb1bc2daafc83c16496e9263a6c07889f6364b92f9688d11ceb7628cc4416b92a0c1134fad078f2971b9b42bc3f3746dc037acb3d27f77a92314f2b07687c
+  metadata.gz: 2eae8f4ee40cec27e0dbe8e268cd06779ed89faad58d7816a2cdc129c3a364ec53dfc977e8a1e60bd0df33be280a162b24f4fecc09b413bfc766f50bb266da78
+  data.tar.gz: 9d37de0c3173322516ee4feb0ab63f7aa1666b933e74273604384b6e0b65a171cf6375922f07965ca1680a3b3abf1997812b3b86dec91e484268a1bb78358107

data/bin/kangoroo_robot

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'kangoroo_robot')
+
+robot = KangorooRobot::Robot.new
+robot.listen

data/lib/kangoroo_robot/direction.rb

@@ -0,0 +1,11 @@
+module KangorooRobot
+  class Direction
+
+    attr_accessor :cardinal_point
+
+    def initialize(cardinal_point = "NORTH")
+      @cardinal_point = cardinal_point
+    end
+
+  end
+end

data/lib/kangoroo_robot/instruction.rb

@@ -0,0 +1,13 @@
+module KangorooRobot
+  class Instruction
+
+    def initialize
+    end
+
+    def is_off_limits?(x, y, table)
+      x > table.xlimit - 1 || x < 0 ||
+      y > table.ylimit - 1 || y < 0
+    end
+
+  end
+end

data/lib/kangoroo_robot/instructions/left.rb

@@ -0,0 +1,27 @@
+module KangorooRobot
+  class Instruction::Left < Instruction 
+
+    def initialize
+    end
+
+    def rotate(direction)
+      case direction.cardinal_point
+        when "NORTH"
+          "WEST"
+        when "WEST"
+          "SOUTH"
+        when "SOUTH"
+          "EAST"
+        when "EAST"
+          "NORTH"
+      end
+    end
+
+    def execute(position, direction, table)
+      return false if !position.settled
+
+      direction.cardinal_point = rotate(direction)
+    end
+
+  end
+end

data/lib/kangoroo_robot/instructions/move.rb

@@ -0,0 +1,21 @@
+module KangorooRobot
+  class Instruction::Move < Instruction 
+
+    def initialize
+    end
+
+    def execute(position, direction, table)
+
+      return false unless position.settled
+
+      next_position = position.next(direction)
+
+      return false if is_off_limits?(next_position[:x], next_position[:y], table)
+
+      position.set(next_position[:x], next_position[:y])
+
+      true
+    end
+
+  end
+end

data/lib/kangoroo_robot/instructions/place.rb

@@ -0,0 +1,25 @@
+module KangorooRobot
+  class Instruction::Place < Instruction 
+
+    attr_accessor :x, :y, :cardinal_point
+
+    def initialize(x, y, cardinal_point)
+      @x = x.to_i
+      @y = y.to_i
+      @cardinal_point = cardinal_point
+    end
+
+    def execute(position, direction, table)
+      if is_off_limits?(x, y, table)
+        puts "The limits of this table are #{table.xlimit}x#{table.ylimit}"
+        return false 
+      end
+
+      position.set(x,y)
+      direction.cardinal_point = cardinal_point
+
+      true
+    end
+
+  end
+end

data/lib/kangoroo_robot/instructions/report.rb

@@ -0,0 +1,19 @@
+module KangorooRobot
+  class Instruction::Report < Instruction 
+
+    def initialize
+    end
+
+    def execute(position, direction, table)
+      if !position.settled
+        puts "I am not on the map, PLACE me first"
+        return false
+      end
+
+      puts "#{position.x},#{position.y},#{direction.cardinal_point}"
+
+      return true      
+    end
+
+  end
+end

data/lib/kangoroo_robot/instructions/right.rb

@@ -0,0 +1,28 @@
+module KangorooRobot
+  class Instruction::Right < Instruction 
+
+    def initialize
+    end
+
+    def rotate(direction)
+      case direction.cardinal_point
+        when "NORTH"
+          "EAST"
+        when "EAST"
+          "SOUTH"
+        when "SOUTH"
+          "WEST"
+        when "WEST"
+          "NORTH"
+      end
+    end
+
+    def execute(position, direction, table)
+
+      return false if !position.settled
+
+      direction.cardinal_point = rotate(direction)
+    end
+
+  end
+end

data/lib/kangoroo_robot/parser.rb

@@ -0,0 +1,44 @@
+module KangorooRobot
+  class Parser
+
+    attr_accessor :regexp, :matches
+
+    def initialize
+      @regexp = %r{ ^(?<command>MOVE|LEFT|RIGHT|REPORT|
+                    (PLACE\s+
+                    (?<x>\d+),
+                    (?<y>\d+),
+                    (?<direction>NORTH|EAST|SOUTH|WEST)))$
+                }x
+
+      @matches = matches
+    end  
+
+    def validate(str)
+      if @matches = str.match(regexp)
+        true
+      else
+        puts "Sorry I didn't understand your command"
+        puts "Refer to the README for available commands"      
+
+        false
+      end
+    end
+
+    def load_instruction
+      case @matches[:command]
+        when "MOVE"
+          Instruction::Move.new
+        when "LEFT"
+          Instruction::Left.new
+        when "RIGHT"
+          Instruction::Right.new
+        when "REPORT"
+          Instruction::Report.new
+        when /PLACE.*/
+          Instruction::Place.new(@matches[:x], @matches[:y], @matches[:direction])
+      end    
+    end
+
+  end
+end

data/lib/kangoroo_robot/position.rb

@@ -0,0 +1,40 @@
+module KangorooRobot
+  class Position
+
+    attr_reader :x, :y
+    attr_accessor :settled
+
+    def initialize
+      @settled = false
+    end
+
+    def set(x, y)
+      @x, @y = x, y
+
+      @settled = true
+    end
+
+    def now 
+      return false unless @settled
+
+      {x: x, y: y}
+    end
+
+    # Next position according to current direction
+    def next(direction)
+      return false unless @settled
+      
+      case direction.cardinal_point
+        when "NORTH"     
+          {x: x,   y: y+1}
+        when "EAST"
+          {x: x+1, y: y}
+        when "SOUTH"
+          {x: x,   y: y-1}
+        when "WEST"
+          {x: x-1, y: y}
+      end           
+    end
+
+  end
+end

data/lib/kangoroo_robot/robot.rb

@@ -0,0 +1,61 @@
+module KangorooRobot
+  class Robot
+    attr_reader :table, :position, :direction, :parser
+
+    def initialize
+      @table      = Table.new(5,5)
+      @position   = Position.new
+      @direction  = Direction.new
+      
+      @parser     = Parser.new    
+
+      welcome
+    end
+
+    def listen
+      ARGF.each do |line|
+        read line
+      end
+    end
+
+    def read(str)
+      return unless @parser.validate(str)
+      
+      instruction = @parser.load_instruction()
+      instruction.execute(@position, @direction, @table)
+    end
+
+    def welcome
+
+      puts %{
+
+                  | Kangaroo Robot |
+        | Herve Tatche's exercice for Lookahead |
+                         .
+                     /\ /l
+                    ((.Y(!
+                     \ |/
+                     /  6~6,
+                     \ _    +-.
+                      \`-=--^-'
+                      _/  \ 
+                      (  .  Y
+                    /"\ `--^--v--.
+                   / _ `--"T~\/~\/
+                  / " ~\.  !
+            _    Y      Y./'
+           Y^|   |      |~~7
+           | l   |     / ./'
+           | `L  | Y .^/~T
+           |  l  ! | |/| |
+           | .`\/' | Y | !   
+           l  "~   j l j_L______
+            \,____{ __"~ __ ,\_,\_
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ }
+
+      }
+
+    end
+
+  end
+end

data/lib/kangoroo_robot/table.rb

@@ -0,0 +1,24 @@
+module KangorooRobot
+  class Table
+
+    attr_accessor :xlimit, :ylimit
+
+    def initialize(xlimit, ylimit)
+      @xlimit = xlimit
+      @ylimit = ylimit
+
+      is_valid?
+    end
+
+    def is_valid?
+      if xlimit.is_a?(Integer) && ylimit.is_a?(Integer)
+        if xlimit > 0 && ylimit > 0
+          return true
+        end
+      end
+
+      # We stop execution if table is not valid
+      raise ArgumentError
+    end
+  end
+end

data/lib/kangoroo_robot/version.rb

@@ -1,3 +1,3 @@
 module KangorooRobot
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/lib/direction_spec.rb

@@ -0,0 +1,15 @@
+require "direction"
+
+module KangorooRobot
+  describe "Direction" do
+
+    let(:direction) { Direction.new("EAST") }  
+
+    context "after initializing" do
+      it "receives a cardinal point" do
+        expect(direction.cardinal_point).to eq("EAST")
+      end    
+    end
+   
+  end
+end

data/spec/lib/instruction_spec.rb

@@ -0,0 +1,15 @@
+require "instruction"
+require "table"
+
+module KangorooRobot
+  describe "Instruction" do
+
+    let(:instruction) { Instruction.new }
+    let(:table) { Table.new(5,5) }
+
+    it "detects off limits position" do
+      expect(instruction.is_off_limits?(10,20, table)).to be true
+    end   
+
+  end
+end

data/spec/lib/instructions/left_spec.rb

@@ -0,0 +1,62 @@
+require "instructions/left"
+
+module KangorooRobot
+  describe "Left" do
+
+    let(:table) { Table.new(5,5) }
+    let(:position) { Position.new }
+    let(:direction) { Direction.new }
+    let(:left) { Instruction::Left.new } 
+
+    describe "#execute" do
+
+      it "executes the instruction" do
+        place = Instruction::Place.new(2,2,"NORTH")
+
+        place.execute(position, direction, table)
+        left.execute(position, direction, table)
+
+        expect(direction.cardinal_point).to eq("WEST")
+      end  
+
+      it "does not executes the instruction if position is not settled" do
+        place = Instruction::Place.new(2,2,"NORTH")
+
+        expect(left.execute(position, direction, table)).to be false
+      end 
+
+    end
+
+    describe "#rotate" do
+
+      it "rotates 90 degrees to left from NORTH" do
+        place = Instruction::Place.new(2,2,"NORTH")
+        place.execute(position, direction, table)
+
+        expect(left.rotate(direction)).to eq("WEST")
+      end
+
+      it "rotates 90 degrees to left from WEST" do
+        place = Instruction::Place.new(2,2,"WEST")
+        place.execute(position, direction, table)
+
+        expect(left.rotate(direction)).to eq("SOUTH")
+      end
+
+      it "rotates 90 degrees to left from SOUTH" do
+        place = Instruction::Place.new(2,2,"SOUTH")
+        place.execute(position, direction, table)
+
+        expect(left.rotate(direction)).to eq("EAST")
+      end
+
+      it "rotates 90 degrees to left from EAST" do
+        place = Instruction::Place.new(2,2,"EAST")
+        place.execute(position, direction, table)
+
+        expect(left.rotate(direction)).to eq("NORTH")
+      end        
+    end
+
+  end
+end

data/spec/lib/instructions/move_spec.rb

@@ -0,0 +1,73 @@
+require "instructions/move"
+
+module KangorooRobot
+  describe "Move" do
+
+    let(:table) { Table.new(5,5) }
+    let(:position) { Position.new }
+    let(:direction) { Direction.new }
+    let(:move) { Instruction::Move.new } 
+
+    context "when edge cases" do
+
+      it "does not execute instruction if robot will go off limits" do
+        place = Instruction::Place.new(5,5,"NORTH")
+        place.execute(position, direction, table)
+
+        expect(move.execute(position, direction, table)).to be false
+      end
+
+      it "does not move if robot will go off limits" do
+        place = Instruction::Place.new(0,0,"SOUTH")
+        place.execute(position, direction, table)
+        move.execute(position, direction, table)
+
+        expect(position.now).to eq({x: 0, y: 0})
+      end
+
+      it "does not execute instruction if robot is not placed" do
+        place = Instruction::Place.new(0,0,"NORTH")
+
+        expect(move.execute(position, direction, table)).to be false
+      end
+
+    end
+
+    context "when executing instruction" do
+
+      it "goes north" do
+        place = Instruction::Place.new(0,0,"NORTH")
+        place.execute(position, direction, table)
+        move.execute(position, direction, table)
+
+        expect(position.now).to eq({x: 0, y: 1})
+      end
+
+      it "goes east" do
+        place = Instruction::Place.new(0,0,"EAST")
+        place.execute(position, direction, table)
+        move.execute(position, direction, table)
+
+        expect(position.now).to eq({x: 1, y: 0})
+      end
+
+      it "goes south" do
+        place = Instruction::Place.new(1,3,"SOUTH")
+        place.execute(position, direction, table)
+        move.execute(position, direction, table)
+
+        expect(position.now).to eq({x: 1, y: 2})
+      end
+
+      it "goes west" do
+        place = Instruction::Place.new(1,3,"WEST")
+        place.execute(position, direction, table)
+        move.execute(position, direction, table)
+
+        expect(position.now).to eq({x: 0, y: 3})
+      end  
+
+    end
+
+  end
+end

data/spec/lib/instructions/place_spec.rb

@@ -0,0 +1,31 @@
+require "instructions/place"
+
+module KangorooRobot
+  describe "Place" do
+
+    let(:table) { Table.new(5,5) }
+    let(:position) { Position.new }
+    let(:direction) { Direction.new("EAST") }
+    let(:place) { Instruction::Place.new(3,4,"EAST") }
+
+    context "after initializing" do
+      it "has an x coordinate" do
+        expect(place.x).to eq(3)
+      end
+    end
+
+    describe "#execute" do
+      it "executes the instruction" do
+        expect(place.execute(position, direction, table)).to be true
+      end
+
+      context "when position is off limits" do
+        it "does not execute the instruction" do
+          unvalid_placing = Instruction::Place.new(3,25,"EAST")
+          expect(unvalid_placing.execute(position, direction, table)).to be false
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/instructions/report_spec.rb

@@ -0,0 +1,21 @@
+require "instructions/report"
+
+module KangorooRobot
+  describe "Report" do
+
+    let(:table) { Table.new(5,5) }
+    let(:position) { Position.new }
+    let(:direction) { Direction.new("EAST") }
+    let(:report) { Instruction::Report.new }  
+
+    describe "#execute" do
+
+       context "when robot is not placed" do
+        it "ignores command" do
+          expect(report.execute(position, direction, table)).to be false
+        end           
+      end
+
+    end
+  end
+end

data/spec/lib/instructions/right_spec.rb

@@ -0,0 +1,62 @@
+require "instructions/right"
+
+module KangorooRobot
+  describe "Right" do
+
+    let(:table) { Table.new(5,5) }
+    let(:position) { Position.new }
+    let(:direction) { Direction.new }
+    let(:right) { Instruction::Right.new } 
+
+    describe "#execute" do
+
+      it "executes the instruction" do
+        place = Instruction::Place.new(2,2,"NORTH")
+
+        place.execute(position, direction, table)
+        right.execute(position, direction, table)
+
+        expect(direction.cardinal_point).to eq("EAST")
+      end  
+
+      it "does not executes the instruction if position is not settled" do
+        place = Instruction::Place.new(2,2,"NORTH")
+
+        expect(right.execute(position, direction, table)).to be false
+      end 
+
+    end
+
+    describe "#rotate" do
+
+      it "rotates 90 degrees to right from NORTH" do
+        place = Instruction::Place.new(2,2,"NORTH")
+        place.execute(position, direction, table)
+
+        expect(right.rotate(direction)).to eq("EAST")
+      end
+
+      it "rotates 90 degrees to right from EAST" do
+        place = Instruction::Place.new(2,2,"EAST")
+        place.execute(position, direction, table)
+
+        expect(right.rotate(direction)).to eq("SOUTH")
+      end
+
+      it "rotates 90 degrees to right from SOUTH" do
+        place = Instruction::Place.new(2,2,"SOUTH")
+        place.execute(position, direction, table)
+
+        expect(right.rotate(direction)).to eq("WEST")
+      end
+
+      it "rotates 90 degrees to right from WEST" do
+        place = Instruction::Place.new(2,2,"WEST")
+        place.execute(position, direction, table)
+
+        expect(right.rotate(direction)).to eq("NORTH")
+      end        
+    end
+
+  end
+end

data/spec/lib/kangoroo_robot_spec.rb

@@ -0,0 +1,9 @@
+module KangorooRobot
+
+  describe KangorooRobot do
+    it 'has a version number' do
+      expect(KangorooRobot::VERSION).not_to be nil
+    end
+
+  end
+end

data/spec/lib/parser_spec.rb

@@ -0,0 +1,59 @@
+require "parser"
+
+module KangorooRobot
+  describe "Parser" do
+
+    let(:parser) { Parser.new }
+
+    context "after initializing" do
+      it "has a regular expression" do
+        expect(parser.regexp.is_a?(Regexp)).to be true
+      end
+
+      it "loads a PLACE command" do
+        parser.validate "PLACE 1,2,EAST"
+        instruction = parser.load_instruction
+        expect(instruction.is_a?(Instruction::Place)).to be true
+      end        
+    end
+
+    context "when validating" do 
+      it "does not validate a wrong command" do
+        instruction = parser.validate "🙈 🙉 🙊"
+        expect(instruction).to be false
+      end 
+
+      it "validates a PLACE command" do
+        valid = parser.validate "PLACE 1,2,EAST"
+        expect(valid).to be true
+      end        
+    end
+
+    context "when parsing" do
+      it "parses a MOVE instruction" do
+        parser.validate "MOVE"
+        instruction = parser.load_instruction
+        expect(instruction.is_a?(Instruction::Move)).to be true
+      end
+
+      it "parses a LEFT instruction" do
+        parser.validate "LEFT"
+        instruction = parser.load_instruction
+        expect(instruction.is_a?(Instruction::Left)).to be true
+      end
+
+      it "parses a RIGHT instruction" do
+        parser.validate "RIGHT"
+        instruction = parser.load_instruction
+        expect(instruction.is_a?(Instruction::Right)).to be true
+      end    
+
+      it "parses a REPORT instruction" do
+        parser.validate "REPORT"
+        instruction = parser.load_instruction
+        expect(instruction.is_a?(Instruction::Report)).to be true
+      end
+    end  
+
+  end
+end

data/spec/lib/position_spec.rb

@@ -0,0 +1,74 @@
+require "position"
+
+module KangorooRobot
+  describe "Position" do
+
+    let(:position) { Position.new }
+
+    context "when setting the position" do
+
+      it "has x coordinate" do
+        position.set(1,2)
+        expect(position.x).to eq(1)
+      end    
+
+      it "has y coordinate" do
+        position.set(1,2)
+        expect(position.y).to eq(2)
+      end   
+
+      it "is settled" do
+        position.set(1,2)
+        expect(position.settled).to be true
+      end
+
+      it "gives the current position" do
+        position.set(1,2)
+        expect(position.now).to eq({x: 1, y: 2})
+      end 
+
+    end
+
+    describe "#next" do
+
+      it "gives the next position before moving" do
+        table = Table.new(5,5)
+        direction = Direction.new
+        position = Position.new
+        place = Instruction::Place.new(0,0,"EAST")
+
+        place.execute(position, direction, table)
+        next_position = position.next(direction)
+
+        expect(next_position).to eq({x: 1, y: 0})
+      end
+      
+    end
+
+    describe "#now" do
+
+      it "gives the current position" do
+        table = Table.new(5,5)
+        direction = Direction.new
+        position = Position.new
+        place = Instruction::Place.new(0,0,"EAST")
+
+        place.execute(position, direction, table)
+        next_position = position.next(direction)
+
+        expect(next_position).to eq({x: 1, y: 0})
+      end
+      
+      it "does not give position if robot is not placed" do
+        table = Table.new(5,5)
+        position = Position.new
+
+        current_position = position.now
+
+        expect(current_position).to be false
+      end
+
+    end
+      
+  end
+end

data/spec/lib/robot_spec.rb

@@ -0,0 +1,43 @@
+require "robot"
+
+module KangorooRobot
+  describe "Robot" do
+
+    let(:robot) { Robot.new }
+
+    context "after initializing" do
+
+      it "has a table" do
+        expect(robot.table.is_a?(Table)).to be true
+      end    
+
+      it "has a position" do
+        expect(robot.position.is_a?(Position)).to be true
+      end  
+
+      it "has a direction" do
+        expect(robot.direction.is_a?(Direction)).to be true
+      end 
+
+      it "has a parser" do
+        expect(robot.parser.is_a?(Parser)).to be true
+      end     
+
+    end
+
+    context "when listening the user input" do
+      it "reads the command and executes instruction" do
+        command = "PLACE 2,3,NORTH"
+        robot.read(command)
+        expect(robot.position.now).to eq({x:2, y:3})
+      end
+
+      it "does not execute unvalid commands" do
+        command = "PLA_CE 2,3,NORTH"
+        robot.read(command)
+        expect(robot.position.settled).to be false
+      end      
+    end
+
+  end
+end

data/spec/lib/table_spec.rb

@@ -0,0 +1,25 @@
+require "table"
+
+module KangorooRobot
+  describe "Table" do
+
+    context "after initializing" do
+
+      it "needs two arguments" do
+        expect{Table.new}.to raise_error(ArgumentError)
+      end    
+
+      it "needs a valid size" do
+        expect{Table.new("a", 1)}.to raise_error(ArgumentError)
+      end 
+
+    end
+
+    describe "#is_valid?" do
+      it "is false if table is unvalid" do
+        expect{Table.new("a", "b")}.to raise_error(ArgumentError)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+$:<< File.join(File.dirname(__FILE__), '../lib/kangoroo_robot/')
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # Avoid printing 'put' messages in STDOUT when testing
+  # config.before { allow($stdout).to receive(:puts) }
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kangoroo_robot
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Herve Tatche
@@ -45,19 +45,37 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
-- Gemfile
-- LICENSE.txt
 - README.md
-- Rakefile
 - bin/console
+- bin/kangoroo_robot
 - bin/setup
-- kangoroo_robot.gemspec
 - lib/kangoroo_robot.rb
+- lib/kangoroo_robot/direction.rb
+- lib/kangoroo_robot/instruction.rb
+- lib/kangoroo_robot/instructions/left.rb
+- lib/kangoroo_robot/instructions/move.rb
+- lib/kangoroo_robot/instructions/place.rb
+- lib/kangoroo_robot/instructions/report.rb
+- lib/kangoroo_robot/instructions/right.rb
+- lib/kangoroo_robot/parser.rb
+- lib/kangoroo_robot/position.rb
+- lib/kangoroo_robot/robot.rb
+- lib/kangoroo_robot/table.rb
 - lib/kangoroo_robot/version.rb
+- spec/lib/direction_spec.rb
+- spec/lib/instruction_spec.rb
+- spec/lib/instructions/left_spec.rb
+- spec/lib/instructions/move_spec.rb
+- spec/lib/instructions/place_spec.rb
+- spec/lib/instructions/report_spec.rb
+- spec/lib/instructions/right_spec.rb
+- spec/lib/kangoroo_robot_spec.rb
+- spec/lib/parser_spec.rb
+- spec/lib/position_spec.rb
+- spec/lib/robot_spec.rb
+- spec/lib/table_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/htatche/kangoroo_robot
 licenses:
 - MIT
@@ -82,4 +100,17 @@ rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Coding exercise for Lookahead
-test_files: []
+test_files:
+- spec/lib/direction_spec.rb
+- spec/lib/instruction_spec.rb
+- spec/lib/instructions/left_spec.rb
+- spec/lib/instructions/move_spec.rb
+- spec/lib/instructions/place_spec.rb
+- spec/lib/instructions/report_spec.rb
+- spec/lib/instructions/right_spec.rb
+- spec/lib/kangoroo_robot_spec.rb
+- spec/lib/parser_spec.rb
+- spec/lib/position_spec.rb
+- spec/lib/robot_spec.rb
+- spec/lib/table_spec.rb
+- spec/spec_helper.rb

data/.gitignore

@@ -1,9 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/

data/.rspec

@@ -1,3 +0,0 @@
---require spec_helper
---format documentation
---color

data/.travis.yml

@@ -1,3 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.1

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in kangoroo_robot.gemspec
-gemspec

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Herve Tatche
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"

data/kangoroo_robot.gemspec

@@ -1,28 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'kangoroo_robot/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "kangoroo_robot"
-  spec.version       = KangorooRobot::VERSION
-  spec.authors       = ["Herve Tatche"]
-  spec.email         = ["herve.tatche@gmail.com"]
-
-  spec.summary       = %q{Coding exercise for Lookahead}
-  spec.description   = %q{Robot game controlled by giving him commands through the STDIN}
-  spec.homepage      = "https://github.com/htatche/kangoroo_robot"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  # if spec.respond_to?(:metadata)
-  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."
-  # end
-
-  spec.add_development_dependency "bundler", "~> 1.9"
-  spec.add_development_dependency "rake", "~> 10.0"
-end