rachinations 0.0.3 → 0.0.4

data/testing/spec/diagram_spec.rb

@@ -1,404 +1,407 @@
 require_relative 'spec_helper'
 
 describe Diagram do
+  using NumberModifiers
+  using ProcConvenienceMethods
 
-  it 'can be empty' do
-    d = Diagram.new 'empty'
-    expect(d.name).to eq 'empty'
-  end
 
-  it 'should be created with a source and a pool and run n times with no errors' do
+  context 'integration' do
 
-    d=Diagram.new 'simple'
+    it 'can be empty' do
+      d = Diagram.new 'empty'
+      expect(d.name).to eq 'empty'
+    end
 
-    d.add_node! Source, {
-        :name => 'source'
-    }
+    it 'should be created with a source and a pool and run n times with no errors' do
 
-    d.add_node! Pool, {
-        :name => 'deposit',
-        :initial_value => 0
-    }
+      d=Diagram.new 'simple'
 
-    d.add_edge! Edge, {
-        :name => 'connector',
-        :from => 'source',
-        :to => 'deposit'
-    }
+      d.add_node! Source, {
+          :name => 'source'
+      }
 
-    d.run!(10)
+      d.add_node! Pool, {
+          :name => 'deposit',
+          :initial_value => 0
+      }
 
-    expect(d.resource_count).to eq 10
-    expect(d.get_node('deposit').resource_count).to eq 10
+      d.add_edge! Edge, {
+          :name => 'connector',
+          :from => 'source',
+          :to => 'deposit'
+      }
 
-  end
+      d.run!(10)
 
-  it "runs for 2 turns with two pools using PULL and there's the correct amount of resources at the end" do
+      expect(d.resource_count).to eq 10
+      expect(d.get_node('deposit').resource_count).to eq 10
 
-    d = Diagram.new 'some_name'
+    end
 
-    d.add_node! Pool, name: 'pool1', initial_value: 5
+    it "runs for 2 turns with two pools using PULL and there's the correct amount of resources at the end" do
 
-    d.add_node! Pool, name: 'pool2', activation: :automatic
+      d = Diagram.new 'some_name'
 
-    d.add_edge! Edge, name: 'edge', from: 'pool1', to: 'pool2'
+      d.add_node! Pool, name: 'pool1', initial_value: 5
 
-    d.run!(2)
+      d.add_node! Pool, name: 'pool2', activation: :automatic
 
-    expect(d.get_node('pool1').resource_count).to eq 3
-    expect(d.get_node('pool2').resource_count).to eq 2
+      d.add_edge! Edge, name: 'edge', from: 'pool1', to: 'pool2'
 
-  end
+      d.run!(2)
 
-  it "runs for 2 turns with two pools using PULL and add  the correct amount" do
+      expect(d.get_node('pool1').resource_count).to eq 3
+      expect(d.get_node('pool2').resource_count).to eq 2
 
-    d = Diagram.new 'some_name'
+    end
 
-    d.add_node! Pool, name: 'pool1', initial_value: 5
+    it "runs for 2 turns with two pools using PULL and add  the correct amount" do
 
-    d.add_node! Pool, name: 'pool2', activation: :automatic
+      d = Diagram.new
 
-    d.add_edge! Edge, name: 'edge', from: 'pool1', to: 'pool2'
+      d.add_node! Pool, name: 'pool1', initial_value: 5
 
-    d.run!(2)
+      d.add_node! Pool, name: 'pool2', activation: :automatic
 
-    expect(d.get_node('pool1').resources_added).to eq 0
-    expect(d.get_node('pool2').resources_added).to eq 2
+      d.add_edge! Edge, name: 'edge', from: 'pool1', to: 'pool2'
 
-    expect(d.get_node('pool2').resources_removed).to eq 0
-    expect(d.get_node('pool1').resources_removed).to eq 2
+      d.run!(2)
 
-  end
+      expect(d.get_node('pool1').resources_added).to eq 0
+      expect(d.get_node('pool2').resources_added).to eq 2
+      expect(d.get_node('pool2').resources_removed).to eq 0
+      expect(d.get_node('pool1').resources_removed).to eq 2
 
-  it "runs for 2 turns with source and pool using PULL and add and remove the correct amount" do
+    end
 
-    d = Diagram.new 'some_name'
+    it "runs for 2 turns with source and pool using PULL and add and remove the correct amount" do
 
-    d.add_node! Source, name: 's1', activation: :automatic
+      d = Diagram.new 'some_name'
 
-    d.add_node! Pool, name: 'pool2'
+      d.add_node! Source, name: 's1', activation: :automatic
 
-    d.add_edge! Edge, name: 'edge', from: 's1', to: 'pool2'
+      d.add_node! Pool, name: 'pool2'
 
-    d.run!(2)
+      d.add_edge! Edge, name: 'edge', from: 's1', to: 'pool2'
 
+      d.run!(2)
 
-    expect(d.get_node('s1').resources_added).to eq 0
-    expect(d.get_node('pool2').resources_added).to eq 2
-    expect(d.get_node('pool2').resources_removed).to eq 0
-    expect(d.get_node('s1').resources_removed).to eq 2
 
-  end
+      expect(d.get_node('s1').resources_added).to eq 0
+      expect(d.get_node('pool2').resources_added).to eq 2
+      expect(d.get_node('pool2').resources_removed).to eq 0
+      expect(d.get_node('s1').resources_removed).to eq 2
 
-  it "runs for two turns with two pools using PUSH and there's the correct amount of resources at the end" do
+    end
 
-    d = Diagram.new 'some_name'
+    it "runs for two turns with two pools using PUSH and there's the correct amount of resources at the end" do
 
-    d.add_node! Pool, name: 'pool1', initial_value: 5, mode: :push_any, activation: :automatic
+      d = Diagram.new 'some_name'
 
-    d.add_node! Pool, name: 'pool2'
+      d.add_node! Pool, name: 'pool1', initial_value: 5, mode: :push_any, activation: :automatic
 
-    d.add_edge! Edge, name: 'edge', from: 'pool1', to: 'pool2'
+      d.add_node! Pool, name: 'pool2'
 
-    d.run!(2)
+      d.add_edge! Edge, name: 'edge', from: 'pool1', to: 'pool2'
 
-    expect(d.get_node('pool1').resource_count).to eq 3
-    expect(d.get_node('pool2').resource_count).to eq 2
+      d.run!(2)
 
-  end
+      expect(d.get_node('pool1').resource_count).to eq 3
+      expect(d.get_node('pool2').resource_count).to eq 2
 
-  it "runs for a single turn with one source and two pools and there's the correct amount of resources at the end" do
-    p = Diagram.new('one source two pools')
+    end
 
-    p.add_node!(Source, {name: 'source'})
+    it "runs for a single turn with one source and two pools and there's the correct amount of resources at the end" do
+      p = Diagram.new('one source two pools')
 
-    p.add_node!(Pool, {name: 'pool1'})
+      p.add_node!(Source, {name: 'source'})
 
-    p.add_node!(Pool, {name: 'pool2', activation: :automatic})
+      p.add_node!(Pool, {name: 'pool1'})
 
-    p.add_edge!(Edge, {name: 'edge1', from: 'source', to: 'pool1'})
+      p.add_node!(Pool, {name: 'pool2', activation: :automatic})
 
-    p.add_edge!(Edge, {name: 'connector2', from: 'pool1', to: 'pool2'})
+      p.add_edge!(Edge, {name: 'edge1', from: 'source', to: 'pool1'})
 
-    p.run!(1)
+      p.add_edge!(Edge, {name: 'connector2', from: 'pool1', to: 'pool2'})
 
-    expect(p.get_node('pool1').resource_count).to eq 1
-    expect(p.get_node('pool2').resource_count).to eq 0
+      p.run!(1)
 
-  end
+      expect(p.get_node('pool1').resource_count).to eq 1
+      expect(p.get_node('pool2').resource_count).to eq 0
 
-  it 'takes staging and commit steps into account when run with 3 pools for 1 turn only' do
+    end
 
-    d = Diagram.new 'some_name'
+    it 'takes staging and commit steps into account when run with 3 pools for 1 turn only' do
 
-    d.add_node! Pool, name: 'pool1', initial_value: 2, mode: :push_any, activation: :automatic
+      d = Diagram.new
 
-    d.add_node! Pool, name: 'pool2'
+      d.add_node! Pool, name: 'pool1', initial_value: 2, mode: :push_any, activation: :automatic
 
-    d.add_node! Pool, name: 'pool3', activation: :automatic
+      d.add_node! Pool, name: 'pool2'
 
-    d.add_edge! Edge, name: 'edge1', from: 'pool1', to: 'pool2'
+      d.add_node! Pool, name: 'pool3', activation: :automatic
 
-    d.add_edge! Edge, name: 'edge2', from: 'pool2', to: 'pool3'
+      d.add_edge! Edge, name: 'edge1', from: 'pool1', to: 'pool2'
 
-    d.run!(1)
+      d.add_edge! Edge, name: 'edge2', from: 'pool2', to: 'pool3'
 
-    expect(d.get_node('pool1').resource_count).to eq 1
-    expect(d.get_node('pool2').resource_count).to eq 1
-    expect(d.get_node('pool3').resource_count).to eq 0
+      d.run!(1)
 
-  end
+      expect(d.get_node('pool1').resource_count).to eq 1
+      expect(d.get_node('pool2').resource_count).to eq 1
+      expect(d.get_node('pool3').resource_count).to eq 0
 
-  it 'takes staging and commit steps into account when run with 3 pools for 4 turns' do
+    end
 
-    d = Diagram.new 'some_name'
+    it 'takes staging and commit steps into account when run with 3 pools for 4 turns' do
 
-    d.add_node! Pool, name: 'pool1', initial_value: 10, mode: :push_any, activation: :automatic
+      d = Diagram.new
 
-    d.add_node! Pool, name: 'pool2'
+      d.add_node! Pool, name: 'pool1', initial_value: 10, mode: :push_any, activation: :automatic
 
-    d.add_node! Pool, name: 'pool3', activation: :automatic
+      d.add_node! Pool, name: 'pool2'
 
-    d.add_edge! Edge, name: 'edge1', from: 'pool1', to: 'pool2'
+      d.add_node! Pool, name: 'pool3', activation: :automatic
 
-    d.add_edge! Edge, name: 'edge2', from: 'pool2', to: 'pool3'
+      d.add_edge! Edge, name: 'edge1', from: 'pool1', to: 'pool2'
 
+      d.add_edge! Edge, name: 'edge2', from: 'pool2', to: 'pool3'
 
-    d.run!(4)
 
-    expect(d.get_node('pool1').resource_count).to eq 6
-    expect(d.get_node('pool2').resource_count).to eq 1
-    expect(d.get_node('pool3').resource_count).to eq 3
+      d.run!(4)
 
+      expect(d.get_node('pool1').resource_count).to eq 6
+      expect(d.get_node('pool2').resource_count).to eq 1
+      expect(d.get_node('pool3').resource_count).to eq 3
 
-  end
 
-  it 'runs with a source and a pool and have the expected amount of resources at the end' do
+    end
 
-    d=Diagram.new 'simple'
+    it 'runs with a source and a pool and have the expected amount of resources at the end' do
 
+      d=Diagram.new
 
-    d.add_node! Source, {
-        :name => 'source'
-    }
 
-    d.add_node! Pool, {
-        :name => 'deposit',
-    }
+      d.add_node! Source, {
+          :name => 'source'
+      }
 
-    d.add_edge! Edge, {
-        :name => 'connector',
-        :from => 'source',
-        :to => 'deposit'
-    }
+      d.add_node! Pool, {
+          :name => 'deposit',
+      }
 
-    d.run!(10)
+      d.add_edge! Edge, {
+          :name => 'connector',
+          :from => 'source',
+          :to => 'deposit'
+      }
 
-    expect(d.get_node('deposit').resource_count).to eq 10
+      d.run!(10)
 
-  end
+      expect(d.get_node('deposit').resource_count).to eq 10
 
-  it 'can be run until a given condition is true' do
-    d=Diagram.new 'simple'
-    d.add_node! Pool, {
-        :name => 'deposit',
-        :initial_value => 0
-    }
-    d.add_node! Source, {
-        :name => 'source'
-    }
-    d.add_edge! Edge, {
-        :name => 'connector',
-        :from => 'source',
-        :to => 'deposit'
-    }
-
-    d.run_while! { d.get_node('deposit').resource_count < 10 }
-    expect(d.get_node('deposit').resource_count).to eq 10
+    end
 
-  end
+    it 'can be run until a given condition is true' do
 
-  it 'aborts after specified turns as a safeguard against infinite loops given as stopping condition' do
+      d=Diagram.new
 
-    d=Diagram.new 'simple'
-    d.max_iterations=9
+      d.add_node! Pool, {
+          :name => 'deposit',
+          :initial_value => 0
+      }
+      d.add_node! Source, {
+          :name => 'source'
+      }
+      d.add_edge! Edge, {
+          :name => 'connector',
+          :from => 'source',
+          :to => 'deposit'
+      }
 
-    d.add_node! Pool, {
-        :name => 'deposit',
-        :initial_value => 0
-    }
-    d.add_node! Source, {
-        :name => 'source'
-    }
-    d.add_edge! Edge, {
-        :name => 'connector',
-        :from => 'source',
-        :to => 'deposit'
-    }
+      d.run_while! { d.get_node('deposit').resource_count < 10 }
+      expect(d.get_node('deposit').resource_count).to eq 10
 
-    d.run_while! { true == true }
+    end
 
-    #not hanging on forever is the success condition.
-    expect(d.get_node('deposit').resource_count).to eq 9
+    it 'aborts after specified turns as a safeguard against infinite loops given as stopping condition' do
 
-  end
+      d=Diagram.new
 
-  it 'does not raise errors when active pushes or pulls are not possible' do
+      d.max_iterations=9
 
-    d = Diagram.new 'no errors'
+      d.add_node! Pool, {
+          :name => 'deposit',
+          :initial_value => 0
+      }
+      d.add_node! Source, {
+          :name => 'source'
+      }
+      d.add_edge! Edge, {
+          :name => 'connector',
+          :from => 'source',
+          :to => 'deposit'
+      }
 
-    d.add_node! Pool, name: 'Poor fella', initial_value: 5
+      d.run_while! { true == true }
 
-    d.add_node! Pool, name: 'Hungry fella', activation: :automatic
+      #not hanging on forever is the success condition.
+      expect(d.get_node('deposit').resource_count).to eq 9
 
-    d.add_edge! Edge, name: 'edge1', from: 'Poor fella', to: 'Hungry fella'
+    end
 
-    expect { d.run! 10 }.not_to raise_error
+    it 'does not raise errors when active pushes or pulls are not possible' do
 
-    expect(d.get_node('Hungry fella').resource_count).to eq 5
+      d = Diagram.new 'no errors'
 
-  end
+      d.add_node! Pool, name: 'Poor fella', initial_value: 5
 
-  it "raises an error in case users try to access a node that doesn't exist" do
+      d.add_node! Pool, name: 'Hungry fella', activation: :automatic
 
-    p = Diagram.new('get invalid node')
+      d.add_edge! Edge, from: 'Poor fella', to: 'Hungry fella'
 
-    p.add_node! Source, name: 'source'
+      expect { d.run! 10 }.not_to raise_error
 
-    p.add_node! Pool, name: 'pool1'
+      expect(d.get_node('Hungry fella').resource_count).to eq 5
 
-    p.add_edge! Edge, {
-        name: 'connector1',
-        from: 'source',
-        to: 'pool1'
-    }
+    end
 
-    # use curly brackets instead of parentheses here.
-    expect { p.get_node('pool') }.to raise_error RuntimeError
+    it "raises an error in case users try to access a node that doesn't exist" do
 
-  end
+      p = Diagram.new('get invalid node')
 
-  it 'runs with typed nodes connected by typeless edges' do
+      p.add_node! Source, name: 'source'
 
-    p = Diagram.new('one source one pool typed')
+      p.add_node! Pool, name: 'pool1'
 
-    p.add_node!(Source, name: 'source', :type => Green)
-    p.add_node!(Pool, name: 'pool1', :types => [Green, Red])
-    p.add_edge!(Edge, name: 'connector1', from: 'source', to: 'pool1')
+      p.add_edge! Edge, {
+          name: 'connector1',
+          from: 'source',
+          to: 'pool1'
+      }
 
-    p.run!(5)
+      # use curly brackets instead of parentheses here.
+      expect { p.get_node('pool') }.to raise_error RuntimeError
 
-    expect(p.get_node('pool1').resource_count(Green)).to eq 5
-    expect(p.get_node('pool1').resource_count(Red)).to eq 0
+    end
 
-  end
+    it 'runs with typed nodes connected by typeless edges' do
 
-  it "allows untyped nodes to receive typed resources sent to them via untyped edges" do
+      p = Diagram.new('one source one pool typed')
 
-    p = Diagram.new 'balls'
+      p.add_node!(Source, name: 'source', :type => Green)
+      p.add_node!(Pool, name: 'pool1', :types => [Green, Red])
+      p.add_edge!(Edge, name: 'connector1', from: 'source', to: 'pool1')
 
-    p.add_node!(Source, name: 'source', :type => Football)
+      p.run!(5)
 
-    p.add_node!(Pool, name: 'pool1')
+      expect(p.get_node('pool1').resource_count(type: Green)).to eq 5
+      expect(p.get_node('pool1').resource_count(type: Red)).to eq 0
 
-    p.add_edge!(Edge, name: 'connector1', from: 'source', to: 'pool1')
+    end
 
-    p.run!(5)
+    it "allows untyped nodes to receive typed resources sent to them via untyped edges" do
 
-    expect(p.get_node('pool1').resource_count(Football)).to eq 5
+      p = Diagram.new 'balls'
 
-  end
+      p.add_node!(Source, name: 'source', :type => Football)
 
-  it "allows untyped nodes to receive typed resources sent to them via typed edges" do
+      p.add_node!(Pool, name: 'pool1')
 
-    p = Diagram.new 'fruits'
+      p.add_edge!(Edge, name: 'connector1', from: 'source', to: 'pool1')
 
-    #by declaring initial values, we're implicitly declaring types.
-    p.add_node! Pool, name: 'pool1', initial_value: {Peach => 20, Mango => 99}
+      p.run!(5)
 
-    p.add_node! Pool, name: 'pool2', activation: :automatic
+      expect(p.get_node('pool1').resource_count(type: Football)).to eq 5
 
-    p.add_edge!(Edge, name: 'connector1', from: 'pool1', to: 'pool2', types: [Peach])
+    end
 
-    p.run!(5)
+    it "allows untyped nodes to receive typed resources sent to them via typed edges" do
 
-    expect(p.get_node('pool1').resource_count(Peach)).to eq 15
-    expect(p.get_node('pool1').resource_count(Mango)).to eq 99
-    expect(p.get_node('pool2').resource_count(Peach)).to eq 5
+      p = Diagram.new 'fruits'
 
-  end
+      #by declaring initial values, we're implicitly declaring types.
+      p.add_node! Pool, name: 'pool1', initial_value: {Peach => 20, Mango => 99}
 
-  it "executes start nodes only once" do
+      p.add_node! Pool, name: 'pool2', activation: :automatic
 
-    d=Diagram.new 'simple'
+      p.add_edge!(Edge, name: 'connector1', from: 'pool1', to: 'pool2', types: [Peach])
 
-    d.add_node! Source, {
-        :name => 'source',
-        :activation => :start
-    }
+      p.run!(5)
 
-    d.add_node! Pool, {
-        :name => 'deposit',
-        :initial_value => 0
-    }
+      expect(p.get_node('pool1').resource_count(type: Peach)).to eq 15
+      expect(p.get_node('pool1').resource_count(type: Mango)).to eq 99
+      expect(p.get_node('pool2').resource_count(type: Peach)).to eq 5
 
-    d.add_edge! Edge, {
-        :name => 'connector',
-        :from => 'source',
-        :to => 'deposit'
-    }
+    end
 
-    d.run!(10)
+    it "executes start nodes only once" do
 
+      d=Diagram.new 'simple'
 
-    expect(d.get_node('deposit').resource_count).to eq 1
+      d.add_node! Source, {
+          :name => 'source',
+          :activation => :start
+      }
 
-  end
+      d.add_node! Pool, {
+          :name => 'deposit',
+          :initial_value => 0
+      }
 
+      d.add_edge! Edge, {
+          :name => 'connector',
+          :from => 'source',
+          :to => 'deposit'
+      }
 
+      d.run!(10)
+
+      expect(d.get_node('deposit').resource_count).to eq 1
+
+    end
 
-  context 'integration' do
 
     it ' makes a train run' do
 
       d = Diagram.new 'dia'
 
       d.add_node! Pool, {
-        name: 'p1',
-        mode: :push_any,
-        activation: :automatic,
-        initial_value: 8
+          name: 'p1',
+          mode: :push_any,
+          activation: :automatic,
+          initial_value: 8
       }
 
       d.add_node! Pool, {
-        name: 'p2',
-        mode: :push_any,
-        activation: :automatic
+          name: 'p2',
+          mode: :push_any,
+          activation: :automatic
       }
 
       d.add_node! Pool, {
-        name: 'p3',
-        mode: :push_any,
-        activation: :automatic
+          name: 'p3',
+          mode: :push_any,
+          activation: :automatic
       }
 
       d.add_node! Pool, {
-        name: 'p4',
-        mode: :push_any,
-        activation: :automatic
+          name: 'p4',
+          mode: :push_any,
+          activation: :automatic
       }
 
-      d.add_edge! Edge,{
+      d.add_edge! Edge, {
           name: 'e1',
           from: 'p1',
           to: 'p2'
       }
-       d.add_edge! Edge,{
+      d.add_edge! Edge, {
           name: 'e2',
           from: 'p2',
           to: 'p3'
       }
-       d.add_edge! Edge,{
+      d.add_edge! Edge, {
           name: 'e3',
           from: 'p3',
           to: 'p4'
@@ -413,9 +416,6 @@ describe Diagram do
 
     end
 
-  end
-
-  context 'simple converter behaviour' do
     it 'runs an untyped converter connected to two pools' do
 
       d=Diagram.new 'simple'
@@ -430,7 +430,7 @@ describe Diagram do
           :initial_value => 0
       }
 
-      d.add_node! Converter,{
+      d.add_node! Converter, {
           :name => 'c',
           :activation => :automatic
       }
@@ -453,8 +453,63 @@ describe Diagram do
 
     end
 
+    describe 'diagrams with probabilistic edges' do
 
-  end
+      it 'accepts random edges with percentages' do
+
+        d = Diagram.new
+
+        d.add_node! Source, name: 's'
+        d.add_node! Gate, name: 'g'
+        d.add_node! Pool, name: 'p'
+        d.add_edge! Edge, from: 's', to: 'g'
+        d.add_edge! Edge, from: 'g', to: 'p', label: 50.percent
+
+        d.run!(20)
+
+        expect(d.p.resource_count).to (be > 1).and(be < 20)
+
+      end
+    end
+
+
+    describe 'Comprehensive examples'do
+
+      it 'example using pull_all and activators' do
+
+        d = Diagram.new
+
+        d.add_node! Pool, mode: :pull_all, name: 'p1', activation: :automatic
+        d.add_node! Pool, name: 'p2', initial_value: 7
+        d.add_node! Pool, name: 'p3', initial_value: 2
+        d.add_node! Pool, name: 'p4', initial_value: 2
+        d.add_node! Pool, name: 'p5', activation: :automatic, initial_value: 6, mode: :push_any
+
+        d.add_edge! Edge, from: 'p2',to:'p1'
+        d.add_edge! Edge, from: 'p3',to:'p1'
+        d.add_edge! Edge, from: 'p4',to:'p1'
 
+        d.add_edge! Edge, from: 'p5',to:'p3'
+        d.add_edge! Edge, from: 'p5',to:'p4'
+
+        d.p5.attach_condition{ d.p3.resource_count < 1 && d.p4.resource_count < 1 }
+
+        d.run! 8
+
+        expect(d.p1.resource_count).to eq 15
+        expect(d.p2.resource_count).to eq 2
+        expect(d.p3.resource_count).to eq 0
+        expect(d.p4.resource_count).to eq 0
+        expect(d.p5.resource_count).to eq 0
+
+      end
+
+
+
+
+
+    end
+
+  end
 
 end