Extract traffic light signals as their own object

Author: AgentAntelope

katas/4-gilded_traffic_light/fell/main.rb

@@ -34,11 +34,15 @@ def progress_lights
     @lights.each do |light|
       light.progress!
 
-      # No car crashes!
+      # TODO: This is only necessary because the timings are such that we will
+      # have a clash each cycle; an ideal solution would be to change the
+      # timings, but the existing output remaining the same is a requirement
+      #
+      # Nothing to do unless there is goign to be a conflict
       next unless @lights.all?(&:allows_traffic?)
 
       # Since we're turning green, then the other light must turn red
-      @lights.find { it.direction != light.direction }.red!
+      @lights.find { it != light }.red!
     end
   end
 end

katas/4-gilded_traffic_light/fell/pedestrian_signal.rb

@@ -1,7 +1,6 @@
 require_relative 'lib/colorize'
 
-# Tracks whether pedestrians can walk or not
-# and provides presentation logic
+# Tracks whether pedestrians can walk or not and provides presentation logic
 class PedestrianSignal
   include Colorize
 

katas/4-gilded_traffic_light/fell/test/traffic_light_state_test.rb

@@ -0,0 +1,75 @@
+require_relative '../traffic_light'
+require 'minitest/autorun'
+
+class TrafficLightStateTest < Minitest::Test
+  def red_test
+    red = TrafficLightState.red
+
+    assert_equal false, red.allows_traffic?
+    assert_equal true, red.allows_pedestrians?
+  end
+
+  def green_test
+    green = TrafficLightState.green
+
+    assert_equal true, green.allows_traffic?
+    assert_equal false, green.allows_pedestrians?
+  end
+
+  def amber_test
+    amber = TrafficLightState.amber
+
+    assert_equal true, amber.allows_traffic?
+    assert_equal false, amber.allows_pedestrians?
+  end
+
+  def complete_test
+    state = TrafficLightState.new(state: TrafficLightState::RED, timer: 0)
+
+    assert_equal true, state.complete?
+  end
+
+  def incomplete_test
+    state = TrafficLightState.new(state: TrafficLightState::RED, timer: 1)
+
+    assert_equal false, state.complete?
+  end
+
+  def next_state_test
+    assert_equal TrafficLightState.green, TrafficLightState.red.next_state
+    assert_equal TrafficLightState.amber, TrafficLightState.green.next_state
+    assert_equal TrafficLightState.red, TrafficLightState.amber.next_state
+  end
+
+  def progress_timer_test
+    state = TrafficLightState.new(state: TrafficLightState::RED, timer: 1)
+
+    assert_equal(false, timer.complete?)
+    state.progress_timer
+    assert_equal(true, timer.complete?)
+  end
+
+  def to_s_contains_red_state
+    state = TrafficLightState.new(state: TrafficLightState::RED, timer: 1)
+
+    assert_includes state.to_s, "State: \e[31mred\e[0m"
+  end
+
+  def to_s_contains_green_state
+    state = TrafficLightState.new(state: TrafficLightState::GREEN, timer: 1)
+
+    assert_includes state.to_s, "State: \e[32mgreen\e[0m"
+  end
+
+  def to_s_contains_amber_state
+    state = TrafficLightState.new(state: TrafficLightState::AMBER, timer: 1)
+
+    assert_includes state.to_s, "State: \e[33mamber\e[0m"
+  end
+
+  def to_s_contains_timer
+    state = TrafficLightState.new(state: TrafficLightState::AMBER, timer: 1)
+
+    assert_includes state.to_s, 'Time left: 1s'
+  end
+end

katas/4-gilded_traffic_light/fell/test/traffic_light_test.rb

@@ -2,174 +2,125 @@
 require 'minitest/autorun'
 
 class TrafficLightTest < Minitest::Test
-  def test_direction
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::GREEN_STATE)
-
-    assert_equal 'Widdershins', light.direction
-  end
-
-  def test_state
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::GREEN_STATE)
-
-    # reader
-    assert_equal TrafficLight::GREEN_STATE, light.state
-
-    # writer
-    light.state = 'test_state'
-    assert_equal 'test_state', light.state
-  end
-
-  def test_timer
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::GREEN_STATE)
-
-    # reader
-    assert_equal 55, light.timer
-
-    # writer
-    light.timer = 101
-    assert_equal 101, light.timer
-  end
-
   def test_direction_to_s
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::GREEN_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLightState::GREEN)
     light.to_s
 
     assert_includes light.to_s, 'Direction: Widdershins'
   end
 
   def test_time_left_to_s
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::GREEN_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLightState::GREEN)
     light.to_s
 
     assert_includes light.to_s, 'Time left: 55s'
   end
 
   def test_red_light_to_s
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::RED_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLightState::RED)
 
     light.to_s
 
     assert_includes light.to_s, "\e[31mred\e[0m"
   end
 
   def test_green_light_to_s
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::GREEN_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLightState::GREEN)
 
     light.to_s
 
     assert_includes light.to_s, "\e[32mgreen\e[0m"
   end
 
   def test_amber_light_to_s
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::AMBER_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLightState::AMBER)
 
     light.to_s
 
     assert_includes light.to_s, "\e[33mamber\e[0m"
   end
 
   def test_progress_with_incomplete_timer
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::GREEN_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLightState::GREEN)
+
     light.progress!
 
-    assert_equal 54, light.timer
-    assert_equal TrafficLight::GREEN_STATE, light.state
+    assert_includes light.to_s, 'green'
   end
 
-  def test_progress_progreses_state
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::GREEN_STATE)
+  def test_progress_progreses_state_with_complete_timer
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::GREEN)
     light.progress!
 
-    assert_equal 3, light.timer
-    assert_equal TrafficLight::AMBER_STATE, light.state
+    assert_includes light.to_s, 'amber'
   end
 
-  def test_cannot_walk_pedestrian_signal_status
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::RED_STATE)
-
-    light.can_walk = true
+  def test_inital_pedestrian_signal_status
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::RED)
 
-    assert_includes light.pedestrian_signal_status, "Widdershins: \e[32mWALK\e[0m"
+    # Even on red, pedestrians cannot walk initially
+    assert_includes light.pedestrian_signal_status, "Widdershins: \e[31mDON'T WALK\e[0m"
   end
 
   def test_can_walk_pedestrian_signal_status
-    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLight::RED_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::AMBER)
 
-    assert_includes light.pedestrian_signal_status, "Widdershins: \e[31mDON'T WALK\e[0m"
-  end
-
-  def test_current_state_complete
-    light = TrafficLight.new(direction: 'Widdershins', timer: 0, state: TrafficLight::RED_STATE)
+    # Progress to red light for traffic
+    light.next_state!
 
-    assert_equal true, light.current_state_complete?
+    assert_includes light.pedestrian_signal_status, "Widdershins: \e[32mWALK\e[0m"
   end
 
-  def test_current_state_incomplete
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::RED_STATE)
+  def test_cannot_walk_pedestrian_signal_status
+    light = TrafficLight.new(direction: 'Widdershins', timer: 55, state: TrafficLightState::GREEN)
+
+    # Run through the whole cycle once
+    3.times do
+      light.next_state!
+    end
 
-    assert_equal false, light.current_state_complete?
+    assert_includes light.pedestrian_signal_status, "Widdershins: \e[31mDON'T WALK\e[0m"
   end
 
   def test_red
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::GREEN_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::GREEN)
 
     light.red!
 
-    assert_equal TrafficLight::RED_STATE, light.state
-    assert_equal 10, light.timer
-    assert_equal true, light.can_walk
-  end
-
-  def test_green
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::RED_STATE)
-
-    light.green!
-
-    assert_equal TrafficLight::GREEN_STATE, light.state
-    assert_equal 8, light.timer
-    assert_equal false, light.can_walk
-  end
-
-  def test_amber
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::RED_STATE)
-
-    light.amber!
-
-    assert_equal TrafficLight::AMBER_STATE, light.state
-    assert_equal 3, light.timer
-    assert_equal false, light.can_walk
+    assert_equal false, light.allows_traffic?
+    assert_equal true, light.allows_pedestrians?
   end
 
   def test_next_state
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::RED_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::RED)
 
     light.next_state!
 
-    assert_equal TrafficLight::GREEN_STATE, light.state
+    assert_includes light.to_s, 'green'
 
     light.next_state!
 
-    assert_equal TrafficLight::AMBER_STATE, light.state
+    assert_includes light.to_s, 'amber'
 
     light.next_state!
 
-    assert_equal TrafficLight::RED_STATE, light.state
+    assert_includes light.to_s, 'red'
   end
 
   def test_allows_traffic_red
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::RED_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::RED)
 
     assert_equal false, light.allows_traffic?
   end
 
   def test_allows_traffic_green
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::GREEN_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::GREEN)
 
     assert_equal true, light.allows_traffic?
   end
 
   def test_allows_traffic_amber
-    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLight::AMBER_STATE)
+    light = TrafficLight.new(direction: 'Widdershins', timer: 1, state: TrafficLightState::AMBER)
 
     assert_equal true, light.allows_traffic?
   end