Merge pull request #2 from fmizzell/fixes

The machine of machines' logic was getting too complex, refactoring.

src/StateMachine/Execution.php

@@ -10,15 +10,15 @@ trait Execution
     private function recordStateExecution($next_states)
     {
         if (json_encode($this->currentStates) != json_encode($next_states)) {
-            $this->execution->push($next_states);
-            $this->execution->push("");
+            array_push($this->execution, $next_states);
+            array_push($this->execution, "");
         }
     }
 
     private function recordInputExecution($input)
     {
-        $inputs = $this->execution->pop();
+        $inputs = array_pop($this->execution);
         $inputs .= $input;
-        $this->execution->push($inputs);
+        array_push($this->execution, $inputs);
     }
 }

src/StateMachine/Machine.php

@@ -20,14 +20,14 @@ class Machine implements IStateMachine
 
     private $endStates = [];
 
-    private $halted = false;
+    protected $halted = false;
 
   /**
    * Constructor.
    */
     public function __construct(array $initial_states)
     {
-        $this->execution = new \SplStack();
+        $this->execution = [];
         $this->initialStates = $initial_states;
 
         $this->recordStateExecution($this->initialStates);
@@ -73,7 +73,7 @@ public function processInput(string $input)
 
             $this->currentStates = $next_states;
 
-            $this->didWeHalt();
+            $this->halted = $this->didWeHalt();
         } else {
             throw new \Exception("Invalid Input {$input}");
         }
@@ -83,21 +83,23 @@ public function reset()
     {
         $this->recordStateExecution($this->initialStates);
         $this->currentStates = $this->initialStates;
+        $this->halted = false;
     }
 
     public function getCurrentStates(): array
     {
         return $this->currentStates;
     }
 
-    private function didWeHalt()
+    protected function didWeHalt()
     {
-        $this->halted = false;
+        $halted = false;
         foreach ($this->currentStates as $current_state) {
             if (in_array($current_state, $this->endStates)) {
-                $this->halted = true;
+                $halted = true;
             }
         }
+        return $halted;
     }
 
     private function transitionIsValid($input)

src/StateMachine/MachineOfMachines.php

@@ -13,7 +13,28 @@ public function addMachine($state, IStateMachine $machine)
 
     public function processInput(string $input)
     {
-        $got_machine = false;
+        $machines = $this->getCurrentMachines();
+        $errors = [];
+        if (!empty($machines)) {
+            foreach ($machines as $state => $machine) {
+                if ($this->feedMachine($state, $machine, $input)) {
+                    $errors[] = true;
+                }
+            }
+        }
+
+        $all_machines_errored_out = ((!empty($machines)) && (count($errors) == count($machines)));
+        if ($all_machines_errored_out || empty($machines)) {
+            if ($all_machines_errored_out && !$this->machineHalted()) {
+                throw new \Exception("We had machines for state(s) " .
+                implode(", ", $this->currentStates) . " but no machine finished");
+            }
+
+            $this->resetCurrentMachines();
+            parent::processInput($input);
+        }
+
+      /*$got_machine = false;
         $machine_finished = false;
 
         $machines = [];
@@ -26,6 +47,7 @@ public function processInput(string $input)
                 $got_machine = true;
                 try {
                     $machine->processInput($input);
+                    $this->halted = $this->didWeHalt();
                 } catch (\Exception $e) {
                     $errors[] = true;
 
@@ -36,6 +58,7 @@ public function processInput(string $input)
                             unset($this->currentStates[$key]);
                         }
                     }
+                    $this->halted = $this->didWeHalt();
                     $machine->reset();
                 }
             }
@@ -44,18 +67,71 @@ public function processInput(string $input)
         if ($got_machine) {
             if (count($machines) === count($errors)) {
                 if ($machine_finished) {
+                    $real_halted = $this->halted;
                     parent::processInput($input);
+                    $this->halted = $real_halted;
                 } else {
                     throw new \Exception("We had machines for state(s) " .
                       implode(", ", $this->currentStates) . " but no machine finished");
                 }
             }
         } else {
+            $real_halted = $this->halted;
             parent::processInput($input);
+            $this->halted = $real_halted;
+        }*/
+    }
+
+    private function machineHalted()
+    {
+        $halted = false;
+        foreach ($this->getCurrentMachines() as $machine) {
+            if ($machine->isCurrentlyAtAnEndState()) {
+                $halted = true;
+            }
+        }
+        return $halted;
+    }
+
+    private function getCurrentMachines()
+    {
+        $machines = [];
+        foreach ($this->currentStates as $key => $current_state) {
+            $machine = $this->getStateMachine($current_state);
+            if ($machine) {
+                $machines[$current_state] = $machine;
+            }
         }
+        return $machines;
     }
 
-    public function isCurrentlyAtAnEndState(): bool
+    private function feedMachine($state, $machine, $input)
+    {
+        $error = false;
+        try {
+            $machine->processInput($input);
+            $this->halted = $this->didWeHalt();
+        } catch (\Exception $e) {
+            if (count($this->currentStates) > 1) {
+                $key = array_search($state, $this->currentStates);
+                if ($key !== false) {
+                    $machine->reset();
+                    unset($this->currentStates[$key]);
+                }
+            }
+            $error = true;
+        }
+        return $error;
+    }
+
+    public function resetCurrentMachines()
+    {
+        foreach ($this->getCurrentMachines() as $machine) {
+            $machine->reset();
+        }
+    }
+
+    /*public function isCurrentlyAtAnEndState(): bool
     {
         $is = parent::isCurrentlyAtAnEndState();
         if ($is === false) {
@@ -87,7 +163,7 @@ public function isCurrentlyAtAnEndState(): bool
                 return true;
             }
         }
-    }
+    }*/
 
     public function getStateMachine($state): ?IStateMachine
     {
@@ -105,4 +181,26 @@ public function gsm($state): ?IStateMachine
     {
         return $this->getStateMachine($state);
     }
+
+    protected function didWeHalt()
+    {
+        $parent_halt = parent::didWeHalt();
+        $machines = $this->getCurrentMachines();
+
+        if (!$parent_halt) {
+            return false;
+        }
+
+        if ($parent_halt && empty($machines)) {
+            return true;
+        } else {
+            $halted = false;
+            foreach ($machines as $machine) {
+                if ($machine->isCurrentlyAtAnEndState()) {
+                    $halted = true;
+                }
+            }
+            return $halted;
+        }
+    }
 }