ellington 0.0.1 → 0.0.2

data/Gemfile

@@ -1,4 +1,16 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in ellington.gemspec
-gemspec
+gem "hero", "~> 0.1.7"
+gem "state_jacket", "~> 0.0.7"
+
+group :development, :test do
+  gem "yell"
+  gem "awesome_print"
+  gem "pry"
+  #gem "pry-nav"
+  gem "pry-stack_explorer"
+  #gem "pry-rescue"
+  gem "pry-exception_explorer"
+  gem "micro_test"
+  gem "micro_mock"
+end

data/Gemfile.lock

@@ -0,0 +1,40 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.1.0)
+    binding_of_caller (0.6.9)
+      debug_inspector (>= 0.0.1)
+    coderay (1.0.8)
+    debug_inspector (0.0.2)
+    hero (0.1.7)
+    method_source (0.8.1)
+    micro_mock (1.1.0)
+    micro_test (0.3.5)
+      os
+    os (0.9.6)
+    pry (0.9.12)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-exception_explorer (0.2.3)
+      pry-stack_explorer (>= 0.4.6)
+    pry-stack_explorer (0.4.8)
+      binding_of_caller (~> 0.6.8)
+      pry (~> 0.9.11)
+    slop (3.4.3)
+    state_jacket (0.0.7)
+    yell (1.2.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  hero (~> 0.1.7)
+  micro_mock
+  micro_test
+  pry
+  pry-exception_explorer
+  pry-stack_explorer
+  state_jacket (~> 0.0.7)
+  yell

data/README.md

@@ -1,29 +1,78 @@
-# Ellington
+# Ellington 
+Named after [Duke Ellington](http://www.dukeellington.com/) whose signature tune was ["Take the 'A' Train"](http://en.wikipedia.org/wiki/Take_the_%22A%22_Train).
+The song was written about [New York City's A train](http://en.wikipedia.org/wiki/A_%28New_York_City_Subway_service%29).
 
-TODO: Write a gem description
+![Subway Tunnel](https://raw.github.com/hopsoft/ellington/master/doc/tunnel.jpg)
 
-## Installation
+#### Ellington is an architecture for modeling complex business processes.
 
-Add this line to your application's Gemfile:
+Ellington is a collection of simple concepts designed to bring discipline, organization, and modularity to a project.
+The base implementation is very light, weighing in around 500 lines.
 
-    gem 'ellington'
+The nomenclature is taken from [New York's subway system](http://en.wikipedia.org/wiki/New_York_City_Subway).
+We've found that using cohesive physical metaphors helps people reason more clearly about the complexities of software.
+*The subway analogy isn't perfect but gets pretty close.*
 
-And then execute:
+### Important
 
-    $ bundle
+The Ellington architecture should only be applied **after** a good understanding of the problem domain has been established.
+*We recommend [spiking a solution](http://en.wikipedia.org/wiki/Software_prototyping) to learn your project's requirements and then coming back to Ellington.*
 
-Or install it yourself as:
+## Goals
 
-    $ gem install ellington
+- Provide a nomenclature simple enough to be shared by engineering and the business team.
+- Establish constraints to ensure that complex projects are easy to manage, develop, and maintain.
 
-## Usage
+## Lexicon
 
-TODO: Write usage instructions here
+- **[Conductor](https://github.com/hopsoft/ellington/wiki/Conductor)** - A supervisor responsible for gathering `passengers` and putting them on a `route`.
+- **[Passenger](https://github.com/hopsoft/ellington/wiki/Passenger)** - The stateful context that will be riding the virtual subway.
+- **[Route](https://github.com/hopsoft/ellington/wiki/Route)** - A collection of `lines` and their `connections`.
+- **[Line](https://github.com/hopsoft/ellington/wiki/Line)** - A linear track that moves the `passenger` from point A to point B.
+- **[Station](https://github.com/hopsoft/ellington/wiki/Station)** - A discreet chunk of business logic.
+- **[State](https://github.com/hopsoft/ellington/wiki/State)** - A status or disposition assigned to the `passenger`.
 
-## Contributing
+![Ellington Diagram](https://raw.github.com/hopsoft/ellington/master/doc/primary-terms.png)
+
+#### Additional Terms
+
+- **[State Catalog](https://github.com/hopsoft/ellington/wiki/State)** - A collection of states and their transitions.
+- **[State Transition](https://github.com/hopsoft/ellington/wiki/State)** - The `transition`, performed on the `passenger`, from one `state` to another.
+- **[Ticket](https://github.com/hopsoft/ellington/wiki/Ticket)** - An authorization token that indicates the `passenger` can ride a specific `route`.
+- **[Goal](https://github.com/hopsoft/ellington/wiki/Goal)** - A list of expected `states`.
+- **[Connection](https://github.com/hopsoft/ellington/wiki/Connection)** - A link between `lines`.
+- **[Transfer](Transfer)** - A link between `routes`.
+- **[Network](Network)** - An entire system of `routes` & `transfers` designed to work together.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+Route class
+  composed of line instances
+  each line instance holds a ref to this route's class
+
+Line class
+  composed of station instances
+  each station instance holds a ref to this line's class
+
+Station class
+```
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request

data/lib/ellington.rb

@@ -1,5 +1,7 @@
-require "ellington/version"
+require "bundler"
+Bundler.require
+#Bundler.require :development, :test
+
+path = File.join(File.dirname(__FILE__), "ellington/**/*.rb")
+Dir[path].each { |file| require file }
 
-module Ellington
-  # Your code goes here...
-end

data/lib/ellington/attendant.rb

@@ -0,0 +1,21 @@
+module Ellington
+
+  class Attendant
+    attr_reader :station, :passenger_transitions
+
+    def initialize(station)
+      @station = station
+      @passenger_transitions = []
+    end
+
+    def update(transition_info)
+      passenger_transitions << transition_info
+    end
+
+    def approve?
+      passenger_transitions.length == 1 && 
+        station.states.include?(passenger_transitions.first.new_state)
+    end
+
+  end
+end

data/lib/ellington/conductor.rb

@@ -0,0 +1,59 @@
+require "thread"
+
+module Ellington
+  class Conductor
+    attr_reader :route, :conducting
+
+    def initialize(route)
+      @route = route
+      @conducting = false
+    end
+
+    def start(delay=0)
+      return if conducting
+
+      mutex.synchronize do
+        @stop = false
+        @conducting = true
+      end
+
+      thread = Thread.new do
+        loop do
+          if @stop
+            mutex.synchronize { @conducting = false }
+            break
+          end
+          gather_passengers.each do |passenger|
+            escort(passenger)
+          end
+          sleep delay
+        end
+      end
+      thread.join
+    end
+
+    def stop
+      mutex.synchronize { @stop = true }
+    end
+
+    def verify(passenger)
+      true
+    end
+
+    def gather_passengers
+      raise Ellington::NotImplementedError
+    end
+
+    def escort(passenger)
+      return unless verify(passenger) && passenger.locked?
+      route.lines.first.board passenger
+    end
+
+    private
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+  end
+end

data/lib/ellington/connection.rb

@@ -0,0 +1,11 @@
+module Ellington
+  class Connection
+    attr_reader :line, :states
+
+    def initialize(line, states)
+      @line = line
+      @states = states
+    end
+
+  end
+end

data/lib/ellington/connection_list.rb

@@ -0,0 +1,29 @@
+require "delegate"
+module Ellington
+  class ConnectionList < SimpleDelegator
+
+    def initialize
+      @inner_list = []
+      super inner_list
+    end
+
+    def push(connection)
+      check connection
+      inner_list.push connection
+    end
+
+    alias_method :<<, :push
+
+    protected
+
+    attr_reader :inner_list
+
+    def check(connection)
+      matches = inner_list.select do |c| 
+        c.line == connection && c.states == connection.states
+      end
+      raise Ellington::ListAlreadyContainsConnection unless matches.empty?
+    end
+
+  end
+end

data/lib/ellington/errros.rb

@@ -0,0 +1,22 @@
+module Ellington
+  class ListAlreadyContainsType < StandardError
+  end
+
+  class InvalidStates < StandardError
+  end
+
+  class AttendandDisapproves < StandardError
+  end
+
+  class InvalidStateTransition < StandardError
+  end
+
+  class NotImplementedError < StandardError
+  end
+
+  class StationAlreadyBelongsToLine < StandardError
+  end
+
+  class PassengerAlreadyAssignedToTicket < StandardError
+  end
+end

data/lib/ellington/has_targets.rb

@@ -0,0 +1,29 @@
+module Ellington
+  module HasTargets
+
+    def fail_target
+      @non_goal_target ||= begin
+        state_list = states.keys - goal
+        state_list.reject! { |state| state.to_s =~ /\AERROR/ }
+        Ellington::Target.new *state_list
+      end
+    end
+    alias_method :failed, :fail_target
+
+    def error_target
+      @error_target ||= begin
+        Ellington::Target.new states.keys - goal - fail_target
+      end
+    end
+    alias_method :errored, :error_target
+
+    def state(passenger)
+      case
+      when passed.satisfied?(passenger) then "PASS"
+      when failed.satisfied?(passenger) then "FAIL"
+      when errored.satisfied?(passenger) then "ERROR"
+      end
+    end
+
+  end
+end

data/lib/ellington/line.rb

@@ -0,0 +1,95 @@
+require "forwardable"
+require "observer"
+
+module Ellington
+  class Line
+    class << self
+      include Observable
+      attr_accessor :route
+
+      def stations
+        @stations ||= Ellington::StationList.new(self)
+      end
+
+      def pass_target(*states)
+        @goal ||= Ellington::Target.new(*states)
+      end
+      alias_method :passed, :pass_target
+      alias_method :goal, :pass_target
+
+      def connections
+        @connections ||= {}
+      end
+    end
+
+    extend Forwardable
+    include Observable
+    include HasTargets
+
+    def_delegators :"self.class",
+      :route,
+      :route=,
+      :stations,
+      :pass_target,
+      :passed,
+      :goal
+
+    def board(passenger, options={})
+      formula.run passenger, options
+    end
+
+    def name
+      @name ||= "#{self.class.name}::#{route.name}"
+    end
+
+    def formula
+      @formula ||= begin
+        Hero::Formula[name]
+        Hero::Formula[name].steps.clear
+        stations.each do |station|
+          Hero::Formula[name].add_step station
+        end
+        Hero::Formula[name]
+      end
+    end
+
+    def states
+      @states ||= begin
+        catalog = StateJacket::Catalog.new
+        stations.each_with_index do |station, index|
+          catalog.merge! station.states
+          if index < stations.length - 1
+            next_station = stations[index + 1]
+            catalog[station.passed] = next_station.states.keys
+          end
+        end
+        catalog.lock
+        catalog
+      end
+    end
+
+    def station_completed(station_info)
+      line_info = Ellington::LineInfo.new(self, station_info)
+      if line_info.station == stations.last ||
+        line_info.passenger.current_state == line_info.station.failed
+        log line_info, :station_completed => true
+        log line_info, :line_completed => true
+        changed
+        notify_observers line_info
+      else
+        log line_info, :station_completed => true
+        if line_info.passenger.current_state == line_info.station.errored
+          Ellington.logger.info "\n" if Ellington.logger
+        end
+      end
+    end
+
+    private
+
+    def log(line_info, options={})
+      return unless Ellington.logger
+      Ellington.logger.info line_info.log_message(options)
+    end
+
+  end
+end