ellington 0.0.1 → 0.0.2

data/lib/ellington/line_info.rb

@@ -0,0 +1,34 @@
+require "delegate"
+
+module Ellington
+  class LineInfo < SimpleDelegator
+    attr_reader :line, :station_info
+
+    def initialize(line, station_info)
+      @line = line
+      @station_info = station_info
+      super station_info
+    end
+
+    def station_full_name
+      @station_full_name ||= "#{station.class.name}::#{line.class.name}::#{line.route.name}"
+    end
+
+    def log_message(options={})
+      message = []
+      if options[:line_completed]
+        message << "[LINE COMPLETED]"
+        message << "[#{line.state(passenger)}]"
+      end
+      if options[:station_completed]
+        message << "[STATION COMPLETED]"
+        message << "[#{station.state(passenger)}]"
+      end
+      message << "[#{station_full_name}]"
+      line.route.log_passenger_attrs.each do |attr|
+        message << "[#{attr}:#{passenger.send(attr)}]"
+      end
+      message.join " "
+    end
+  end
+end

data/lib/ellington/line_list.rb

@@ -0,0 +1,24 @@
+require "delegate"
+
+module Ellington
+  class LineList < SimpleDelegator
+    attr_reader :route
+
+    def initialize(route)
+      @route = route
+      @inner_list = UniqueTypeArray.new
+      super @inner_list
+    end
+    
+    def push(line)
+      value = inner_list << line
+      line.route = route
+      value
+    end
+    alias_method :<<, :push
+
+    protected 
+
+    attr_reader :inner_list
+  end
+end

data/lib/ellington/logger.rb

@@ -0,0 +1,11 @@
+module Ellington
+
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(value)
+    @logger = value
+  end
+
+end

data/lib/ellington/passenger.rb

@@ -0,0 +1,67 @@
+require "observer"
+
+module Ellington
+  class Passenger < SimpleDelegator
+    include Observable
+    attr_accessor :context, :ticket
+    attr_reader :route
+
+    def initialize(context, route, ticket=nil)
+      ticket ||= Ellington::Ticket.new
+      @context = context
+      @route = route
+      @ticket = ticket
+      super context
+    end
+
+    def lock
+      return context.lock if context.respond_to?(:lock)
+      @locked = true
+    end
+
+    def unlock
+      return context.unlock if context.respond_to?(:unlock)
+      @locked = false
+    end
+
+    def locked?
+      return context.locked? if context.respond_to?(:locked?)
+      @locked
+    end
+
+    def current_state
+      return context.current_state if context.respond_to?(:current_state)
+      @current_state
+    end
+
+    def current_state=(value)
+      return context.current_state=(value) if context.respond_to?(:current_state=)
+      @current_state = value
+    end
+
+    def transition_to(new_state)
+      if !locked?
+        message = "Cannot transition an unlocked #{self.class.name}'s state"
+        raise Ellington::InvalidStateTransition.new(message)
+      end
+
+      if !route.states.can_transition?(current_state => new_state)
+        message = "Cannot transition #{self.class.name} from:#{current_state} to:#{new_state}"
+        raise Ellington::InvalidStateTransition.new(message)
+      end
+
+      old_state = current_state
+
+      if context.respond_to?(:transition_to)
+        return_value = context.transition_to(new_state) 
+      else
+        self.current_state = new_state
+      end
+
+      changed
+      notify_observers Ellington::TransitionInfo.new(self, old_state, new_state)
+      return_value || new_state
+    end
+
+  end
+end

data/lib/ellington/route.rb

@@ -0,0 +1,114 @@
+require "delegate"
+
+module Ellington
+  class Route < SimpleDelegator
+
+    def initialize
+      super self.class
+      init unless initialized?
+    end
+
+    class << self
+      include HasTargets
+      attr_reader :initialized
+
+      def initialized?
+        @initialized
+      end
+
+      def init
+        initialize_lines
+        states
+        @initialized = true
+      end
+
+      def initialize_lines
+        lines.each do |line|
+          line.add_observer self, :line_completed
+          line.stations.each do |station|
+            station.add_observer line, :station_completed
+          end
+        end
+      end
+
+      def board(passenger, options={})
+        lines.first.board passenger, options
+      end
+
+      def lines
+        @lines ||= Ellington::LineList.new(self)
+      end
+
+      def states
+        @states ||= begin
+          catalog = StateJacket::Catalog.new
+          catalog.add initial_state => lines.first.stations.first.states.keys
+
+          lines.each do |line|
+            catalog.merge! line.states
+          end
+
+          connections.each do |connection|
+            connection.states.each do |state|
+              catalog[state] ||= []
+              catalog[state].concat connection.line.stations.first.states.keys
+            end
+          end
+
+          catalog.lock
+          catalog
+        end
+      end
+
+      def initial_state
+        @initial_state ||= "PRE #{name}"
+      end
+
+      def pass_target(*line_goals)
+        @goal ||= Ellington::Target.new(*line_goals.flatten)
+      end
+      alias_method :passed, :pass_target
+      alias_method :goal, :pass_target
+
+      def connections
+        @connections ||= Ellington::ConnectionList.new
+      end
+
+      def connect_to(line, options)
+        connections << Ellington::Connection.new(line, options[:if])
+      end
+
+      def log_passenger_attrs(*attrs)
+        @log_passenger_attrs ||= attrs
+      end
+
+      def line_completed(line_info)
+        route_info = Ellington::RouteInfo.new(self, line_info)
+
+        required_connections = connections.select do |connection|
+          connection.states.satisfied?(route_info.passenger)
+        end
+
+        if required_connections.empty?
+          if passed.satisfied?(route_info.passenger) || failed.satisfied?(route_info.passenger)
+            log route_info
+          end
+          Ellington.logger.info "\n" if Ellington.logger
+        end
+
+        required_connections.each do |connection|
+          connection.line.board route_info.passenger, route_info.options
+        end
+      end
+
+      private
+
+      def log(route_info)
+        return unless Ellington.logger
+        Ellington.logger.info route_info.log_message
+      end
+
+    end
+
+  end
+end

data/lib/ellington/route_info.rb

@@ -0,0 +1,25 @@
+require "delegate"
+
+module Ellington
+  class RouteInfo < SimpleDelegator
+    attr_reader :route, :line_info
+
+    def initialize(route, line_info)
+      @route = route
+      @line_info = line_info
+      super line_info
+    end
+
+    def log_message(options={})
+      message = []
+      message << "[ROUTE COMPLETED]"
+      message << "[#{route.state(passenger)}]"
+      message << "[#{station_full_name}]"
+      line.route.log_passenger_attrs.each do |attr|
+        message << "[#{attr}:#{passenger.send(attr)}]"
+      end
+      message.join " "
+    end
+  end
+end
+

data/lib/ellington/station.rb

@@ -0,0 +1,88 @@
+require "observer"
+require "forwardable"
+
+module Ellington
+
+  class Station
+    extend Forwardable
+    include Observable
+    attr_accessor :line
+    def_delegators :line, :route
+
+    def name
+      @name ||= "#{self.class.name}::#{line.name}"
+    end
+
+    def state_name(state)
+      "#{state.to_s.upcase} #{name}"
+    end
+
+    def passed
+      @pass_state ||= state_name(:pass)
+    end
+
+    def failed
+      @fail_state ||= state_name(:fail)
+    end
+
+    def errored
+      @error_state ||= state_name(:error)
+    end
+
+    def states
+      @states ||= begin
+        catalog = StateJacket::Catalog.new
+        catalog.add passed
+        catalog.add failed
+        catalog.add errored => [ passed, failed, errored ]
+        catalog.lock
+        catalog
+      end
+    end
+
+    def can_engage?(passenger, options={})
+      passenger.locked? && 
+        route.states.can_transition?(passenger.current_state => states.keys)
+    end
+
+    def engage(passenger, options={})
+      raise Ellington::NotImplementedError
+    end
+
+    def call(passenger, options={})
+      if can_engage?(passenger)
+        attendant = Ellington::Attendant.new(self)
+        passenger.add_observer attendant
+        engage passenger, options
+        passenger.delete_observer attendant
+        raise Ellington::AttendandDisapproves unless attendant.approve?
+        changed
+        notify_observers Ellington::StationInfo.new(self, passenger, attendant.passenger_transitions.first, options)
+      end
+
+      passenger
+    end
+
+    def pass(passenger)
+      passenger.transition_to passed
+    end
+
+    def fail(passenger)
+      passenger.transition_to failed
+    end
+
+    def error(passenger)
+      passenger.transition_to errored
+    end
+
+    def state(passenger)
+      case passenger.current_state
+      when passed then "PASS"
+      when failed then "FAIL"
+      when errored then "ERROR" 
+      end
+    end
+
+  end
+
+end

data/lib/ellington/station_info.rb

@@ -0,0 +1,11 @@
+module Ellington
+  class StationInfo
+    attr_reader :station, :passenger, :transition, :options
+    def initialize(station, passenger, transition, options)
+      @station = station
+      @passenger = passenger
+      @transition = transition
+      @options = options
+    end
+  end
+end

data/lib/ellington/station_list.rb

@@ -0,0 +1,24 @@
+require "delegate"
+
+module Ellington
+  class StationList < SimpleDelegator
+    attr_reader :line
+
+    def initialize(line)
+      @line = line
+      @inner_list = UniqueTypeArray.new
+      super @inner_list
+    end
+
+    def push(station)
+      value = inner_list << station
+      station.line = line
+      value
+    end
+    alias_method :<<, :push
+
+    protected 
+
+    attr_reader :inner_list
+  end
+end

data/lib/ellington/target.rb

@@ -0,0 +1,25 @@
+require "delegate"
+
+module Ellington
+  class Target < SimpleDelegator
+
+    def initialize(*states)
+      @inner_list = states.flatten
+      super inner_list
+    end
+
+    def include?(state)
+      inner_list.include? state
+    end
+
+    def satisfied?(passenger)
+      return false if passenger.nil?
+      include? passenger.current_state
+    end
+
+    protected
+
+    attr_reader :inner_list
+
+  end
+end

data/lib/ellington/ticket.rb

@@ -0,0 +1,22 @@
+require "digest"
+require "delegate"
+
+module Ellington
+
+  class Ticket < SimpleDelegator
+    attr_reader :passenger, :goal
+
+    def initialize(goal=nil, hash={})
+      goal ||= Ellington::Target.new
+      @goal = goal
+      super hash
+    end
+
+    def id
+      Digest::SHA256.hexdigest values.map(&:to_s).join
+    end
+
+  end
+
+end
+