ellington 0.0.1 → 0.0.2

data/lib/ellington/transition_info.rb

@@ -0,0 +1,4 @@
+module Ellington
+  class TransitionInfo < Struct.new(:passenger, :old_state, :new_state)
+  end
+end

data/lib/ellington/unique_type_array.rb

@@ -0,0 +1,39 @@
+require "delegate"
+
+module Ellington
+  class UniqueTypeArray < SimpleDelegator
+
+    def initialize
+      @inner_list = []
+      super inner_list
+    end
+
+    def push(value)
+      check value
+      inner_list.push value
+    end
+
+    def <<(value)
+      check value
+      inner_list << value
+    end
+
+    def contains_a?(klass)
+      each do |entry|
+        return true if entry.class == klass
+      end
+      false
+    end
+
+    protected
+
+    attr_reader :inner_list
+
+    def check(value)
+      if contains_a?(value.class)
+        raise Ellington::ListAlreadyContainsType.new("List already contains a #{value.class.name} type!")
+      end
+    end
+
+  end
+end

data/lib/ellington/version.rb

@@ -1,3 +1,3 @@
 module Ellington
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/attendant_test.rb

@@ -0,0 +1,42 @@
+require_relative "test_helper"
+
+class AttendantTest < MicroTest::Test
+
+  before do
+    @route = BasicMath.new
+    @line = @route.lines.first
+    @station = @line.stations.first
+    @passenger = Ellington::Passenger.new(NumberWithHistory.new(0), @route)
+    @passenger.current_state = @route.initial_state
+    @passenger.lock
+    @attendant = Ellington::Attendant.new(@station)
+    @passenger.add_observer @attendant
+  end
+
+  test "passenger transition is captured" do
+    @passenger.transition_to @station.passed
+    assert @attendant.passenger_transitions.length == 1
+  end
+
+  test "approves of single passenger transition" do
+    @passenger.transition_to @station.passed
+    assert @attendant.approve?
+  end
+
+  test "multiple passenger transitions are captured" do
+    @passenger.transition_to @station.errored
+    @passenger.transition_to @station.passed
+    assert @attendant.passenger_transitions.length == 2
+  end
+
+  test "disapproves of multiple passenger transitions" do
+    @passenger.transition_to @station.errored
+    @passenger.transition_to @station.passed
+    assert !@attendant.approve?
+  end
+
+  test "a transition must be made in order to be approved" do
+    assert !@attendant.approve?
+  end
+
+end

data/test/conductor_test.rb

@@ -0,0 +1,32 @@
+require_relative "test_helper"
+
+class ConductorTest < MicroTest::Test
+
+  #before do
+  #  route = Ellington::Route.new("Example Route", StateJacket::Catalog.new)
+  #  route.add Ellington::Line.new("A Line")
+  #  route["A Line"] << ConductorTest::Station.new
+  #  @conductor = Ellington::Conductor.new(route)
+  #end
+
+  #test "verify is abstract" do
+  #  error = nil
+  #  begin
+  #    @conductor.verify nil
+  #  rescue Ellington::NotImplementedError => e
+  #    error = e
+  #  end
+  #  assert !error.nil?
+  #end
+
+  #test "gather_passengers is abstract" do
+  #  error = nil
+  #  begin
+  #    @conductor.gather_passengers
+  #  rescue Ellington::NotImplementedError => e
+  #    error = e
+  #  end
+  #  assert !error.nil?
+  #end
+
+end

data/test/example.rb

@@ -0,0 +1,212 @@
+require "logger"
+require_relative "../lib/ellington"
+
+require "yell"
+Ellington.logger = Yell.new do |logger|
+  logger.adapter STDOUT, :level => [:info], :format => "%m"
+end
+#Ellington.logger = Logger.new($stdout)
+
+class NumberWithHistory
+  attr_reader :original_value, :current_value, :history
+  def initialize(value)
+    @original_value = value
+    @current_value = value
+    @history = []
+  end
+
+  def calc(operand, other)
+    value = current_value
+    @current_value = current_value.send(operand, other)
+    history.push(:before => value, :after => current_value)
+    current_value
+  end
+end
+
+# stations -----------------------------------------------------------------
+class Add10 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :+, 10
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class Add100 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :+, 100
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class Add1000 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :+, 1000
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class MultiplyBy10 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :*, 10
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class MultiplyBy100 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :*, 100
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class MultiplyBy1000 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :*, 1000
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class DivideBy10 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :/, 10.0
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class DivideBy100 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :/, 100.0
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+class DivideBy1000 < Ellington::Station
+  def engage(passenger, options)
+    raise if rand(100) == 0
+    if rand(100) > 5
+      passenger.calc :/, 1000.0
+      pass passenger
+    else
+      fail passenger
+    end
+  rescue
+    error passenger
+  end
+end
+
+# lines --------------------------------------------------------------------
+class Addition < Ellington::Line
+  stations << Add10.new
+  stations << Add100.new
+  stations << Add1000.new
+  goal stations.last.passed
+end
+
+class Multiplication < Ellington::Line
+  stations << MultiplyBy10.new
+  stations << MultiplyBy100.new
+  stations << MultiplyBy1000.new
+  goal stations.last.passed
+end
+
+class Division < Ellington::Line
+  stations << DivideBy10.new
+  stations << DivideBy100.new
+  stations << DivideBy1000.new
+  goal stations.last.passed
+end
+
+# route -------------------------------------------------------------------
+class BasicMath < Ellington::Route
+  addition = Addition.new
+  multiplication = Multiplication.new
+  division = Division.new
+
+  lines << addition
+  lines << division
+  lines << multiplication
+
+  goal division.passed, multiplication.passed
+
+  connect_to division, :if => addition.passed
+  connect_to multiplication, :if => addition.failed
+
+  log_passenger_attrs :original_value, :current_value
+end
+
+# conductor ---------------------------------------------------------------
+class NumberConductor < Ellington::Conductor
+
+  def gather_passengers
+    (0..999).to_a.sample(10).map do |num|
+      num = NumberWithHistory.new(num)
+      passenger = Ellington::Passenger.new(num, route)
+      passenger.current_state = route.initial_state
+      passenger.lock
+      passenger
+    end
+  end
+
+end
+
+if ENV["START"]
+  route = BasicMath.new
+  conductor = NumberConductor.new(route)
+  conductor.start
+end

data/test/line_test.rb

@@ -0,0 +1,95 @@
+require_relative "test_helper"
+
+class LineTest < MicroTest::Test
+
+  before do
+    @route = BasicMath.new
+    @line = @route.lines.first
+  end
+
+  test "stations on class" do
+    assert @line.stations.length == 3
+    assert @line.stations[0].is_a?(Add10)
+    assert @line.stations[1].is_a?(Add100)
+    assert @line.stations[2].is_a?(Add1000)
+  end
+
+  test "lines on instance" do
+    assert @line.stations.length == 3
+    assert @line.stations[0].is_a?(Add10)
+    assert @line.stations[1].is_a?(Add100)
+    assert @line.stations[2].is_a?(Add1000)
+  end
+
+  test "type of stations must be unique" do
+    begin
+      @line.stations << Add10.new
+    rescue Ellington::ListAlreadyContainsType => e
+    end
+    assert !e.nil?
+  end
+
+  test "stations are assigned line" do
+    @line.stations.each do |station|
+      assert station.line == @line.class
+    end
+  end
+
+  test "name" do
+    line = @route.lines.first
+    assert line.name == "Addition::BasicMath"
+  end
+
+  test "formula" do
+    line = @route.lines.first
+    assert line.formula.steps[0].last == line.stations[0]
+    assert line.formula.steps[1].last == line.stations[1]
+    assert line.formula.steps[2].last == line.stations[2]
+  end
+
+  test "station1 'PASS' can transition to all station2 states" do
+    line = @route.lines.first
+    pass = line.stations[0].state_name(:pass)
+    transitions = line.states[pass]
+    assert transitions.include?(line.stations[1].state_name(:pass))
+    assert transitions.include?(line.stations[1].state_name(:fail))
+    assert transitions.include?(line.stations[1].state_name(:error))
+  end
+
+  test "station2 'PASS' can transition to all station3 states" do
+    line = @route.lines.first
+    pass = line.stations[1].state_name(:pass)
+    transitions = line.states[pass]
+    assert transitions.include?(line.stations[2].state_name(:pass))
+    assert transitions.include?(line.stations[2].state_name(:fail))
+    assert transitions.include?(line.stations[2].state_name(:error))
+  end
+
+  test "station3 'PASS' is terminal" do
+    line = @route.lines.first
+    pass = line.stations[2].state_name(:pass)
+    transitions = line.states[pass]
+    assert transitions.nil?
+  end
+
+  test "station3 'FAIL' is terminal" do
+    line = @route.lines.first
+    pass = line.stations[2].state_name(:fail)
+    transitions = line.states[pass]
+    assert transitions.nil?
+  end
+
+  test "pass_target" do
+    line = @route.lines.first
+    assert line.goal == [line.stations[2].passed]
+  end
+
+  test "fail_target" do
+    line = @route.lines.first
+    expected = (line.states.keys - line.goal).delete_if do |state|
+      state.to_s =~ /\AERROR/
+    end
+    assert line.fail_target == expected
+  end
+
+end

data/test/passenger_test.rb

@@ -0,0 +1,73 @@
+require_relative "test_helper"
+
+class PassengerTest < MicroTest::Test
+
+  before do
+    @route = BasicMath.new
+    @number = NumberWithHistory.new(0)
+    @passenger = Ellington::Passenger.new(@number, @route)
+  end
+
+  test "lock" do
+    @passenger.lock
+    assert @passenger.locked?
+  end
+
+  test "unlock" do
+    @passenger.lock
+    @passenger.unlock
+    assert !@passenger.locked?
+  end
+
+  test "transition_to fails when unlocked" do
+    error = nil
+    begin
+      @passenger.current_state = @route.initial_state
+      @passenger.transition_to @route.lines.first.states.keys.first
+    rescue Ellington::InvalidStateTransition => e
+      error = e
+    end
+    assert !error.nil?
+    assert error.message == "Cannot transition an unlocked Ellington::Passenger's state"
+  end
+
+  test "transition_to valid state" do
+    @passenger.lock
+    @passenger.current_state = @route.initial_state
+    @passenger.transition_to @route.lines.first.states.keys.first
+    @passenger.unlock
+    assert @passenger.current_state == @route.lines.first.states.keys.first
+  end
+
+  test "transition_to invalid state" do
+    error = nil
+    begin
+      @passenger.lock
+      @passenger.current_state = :error
+      @passenger.transition_to :happy
+    rescue Ellington::InvalidStateTransition => e
+      error = e
+    end
+    assert !error.nil?
+    assert error.message == "Cannot transition Ellington::Passenger from:error to:happy"
+  end
+
+  test "observers are notified on transition" do
+    watcher = MicroMock.make.new
+    watcher.attrs(:info)
+    watcher.def(:update) do |info|
+      self.info = info 
+    end
+
+    @passenger.add_observer(watcher)
+    @passenger.lock
+    @passenger.current_state = @route.initial_state
+    @passenger.transition_to @route.lines.first.states.keys.first
+    @passenger.unlock
+
+    assert watcher.info.passenger == @passenger
+    assert watcher.info.old_state == "PRE BasicMath"
+    assert watcher.info.new_state == "PASS Add10::Addition"
+  end
+
+end