rachinations 0.0.1

data/testing/simulations/noreporting.rb

@@ -0,0 +1,51 @@
+require_relative '../../domain/diagrams/diagram'
+require_relative '../../domain/nodes/pool'
+require_relative '../../domain/edges/edge'
+
+generator = Diagram.new('1to2')
+
+generator.add_node! Pool, {
+    name: 'g1',
+    activation: :automatic,
+    initial_value: 5,
+    mode: :push
+}
+
+generator.add_node! Pool, {
+    name: 'g2',
+    activation: :automatic,
+    mode: :push
+}
+
+generator.add_node! Pool, {
+    name: 'g3'
+}
+
+generator.add_edge! Edge, {
+    name: 'c1',
+    from: 'g1',
+    to: 'g2'
+}
+
+generator.add_edge! Edge, {
+    name: 'c2',
+    from: 'g1',
+    to: 'g3',
+}
+
+
+generator.add_edge! Edge, {
+    name: 'c3',
+    from: 'g2',
+    to: 'g1',
+}
+
+# I want to check the initial state
+puts "#### Estado inicial ####"
+puts generator
+
+# run and get the end
+generator.run!(10)
+
+puts "#### Estado final ####"
+puts generator

data/testing/simulations/sequencial.rb

@@ -0,0 +1,19 @@
+require_relative '../../domain/diagrams/diagram'
+require_relative '../../dsl/dsl'
+require_relative '../../domain/nodes/pool'
+require_relative '../../domain/edges/edge'
+include DSL
+
+n=diagram 'test_diagram', :verbose do
+  node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8
+  node 'p2', Pool, mode: :push, activation: :automatic
+  node 'p3', Pool, mode: :push, activation: :automatic
+  node 'p4', Pool, mode: :push, activation: :automatic
+  edge 'e1', Edge, 'p1', 'p2'
+  edge 'e2', Edge, 'p2', 'p3'
+  edge 'e3', Edge, 'p3', 'p4'
+end
+
+n.run!(5)
+
+puts n

data/testing/simulations/sobonito.rb

@@ -0,0 +1,28 @@
+require_relative '../../domain/diagrams/diagram'
+require_relative '../../dsl/dsl'
+require_relative '../../domain/nodes/pool'
+require_relative '../../domain/edges/edge'
+
+include DSL
+
+n=diagram 'test_diagram',:verbose do
+  node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8
+  node 'p2', Pool, mode: :push, activation: :automatic
+  node 'p3', Pool, mode: :push, activation: :automatic
+  node 'p4', Pool, mode: :push, activation: :automatic
+  edge 'e1', Edge, 'p1', 'p2'
+  edge 'e2', Edge, 'p2', 'p1'
+  edge 'e3', Edge, 'p1', 'p3'
+  edge 'e4', Edge, 'p3', 'p1'
+  edge 'e5', Edge, 'p4', 'p2'
+  edge 'e6', Edge, 'p2', 'p4'
+  edge 'e7', Edge, 'p4', 'p3'
+  edge 'e8', Edge, 'p3', 'p4'
+end
+
+d = Diagram.new('bonitinho')
+
+n.run!(20)
+
+
+

data/testing/simulations/sobonitowhile.rb

@@ -0,0 +1,28 @@
+require_relative '../../domain/diagrams/diagram'
+require_relative '../../dsl/dsl'
+require_relative '../../domain/nodes/pool'
+require_relative '../../domain/edges/edge'
+include DSL
+
+n=diagram 'test_diagram', :verbose do
+  node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8
+  node 'p2', Pool, mode: :push, activation: :automatic
+  node 'p3', Pool, mode: :push, activation: :automatic
+  node 'p4', Pool, mode: :push, activation: :automatic
+  edge 'e1', Edge, 'p1', 'p2'
+  edge 'e2', Edge, 'p2', 'p1'
+  edge 'e3', Edge, 'p1', 'p3'
+  edge 'e4', Edge, 'p3', 'p1'
+  edge 'e5', Edge, 'p4', 'p2'
+  edge 'e6', Edge, 'p2', 'p4'
+  edge 'e7', Edge, 'p4', 'p3'
+  edge 'e8', Edge, 'p3', 'p4'
+end
+
+d = Diagram.new('bonitinho')
+
+n.run_while! do
+  not (n.get_node("p1").resource_count == 2 and n.get_node("p4").resource_count == 2)
+end
+
+

data/testing/simulations/whatIwish1.rb

@@ -0,0 +1,20 @@
+require_relative '../domain/diagram'
+require_relative '../dsl/dsl.rb'
+include DSL
+
+n=diagram 'test_diagram' do
+  node 'source', Source
+  node 'pool1', Pool
+  edge 'edge1', Edge, 'source', 'pool1'
+  node 'pool2', Pool,
+  converter 'c1' , Converter
+  node 'e3' , Edge , 'pool2' , 'c1'
+  trigger 't1' , Trigger , 'pool1' , 'pool2' , { |ExtendedNode p| p.resouces>0 }
+end
+
+n.run!(5,report=true)
+
+
+
+
+

data/testing/spec/canon/converter_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+describe 'Converter canonical behavior' do
+
+  context "there's just one pool on each side" do
+
+    before(:each) {
+      @d = Diagram.new 'foo'
+      @d.add_node! Pool, name: 'p9', initial_value: 9
+      @d.add_node! Pool, name: 'p0'
+      @d.add_node! Converter, name: 'c', mode: :pull_any
+      @d.add_edge! Edge, name:'e1', from: 'p9', to: 'c'
+      @d.add_edge! Edge, name:'e2',from: 'c', to: 'p0'
+    }
+    it 'is triggered by itself' do
+      c = @d.get_node 'c'
+      p0 = @d.get_node('p0')
+      p9 = @d.get_node('p9')
+
+      5.times{ c.trigger! }
+
+      # to unlock the resources
+      @d.get_node('p0').commit!
+      @d.get_node('p9').commit!
+
+      expect(@d.get_node('p0').resource_count).to eq 5
+      expect(@d.get_node('p9').resource_count).to eq 4
+
+
+    end
+
+  end
+end

data/testing/spec/canon/pool_spec.rb

@@ -0,0 +1,68 @@
+require_relative '../spec_helper'
+
+describe 'Pool canonical behaviour' do
+
+  context 'untyped pools' do
+
+    context 'push_any' do
+
+      before(:each) do
+
+        @p1 = Pool.new name: 'p1', initial_value: 2, mode: :push_any
+        @p2 = Pool.new name: 'p2'
+
+        @e = Edge.new name: 'e', from: @p1, to: @p2
+        @p1.attach_edge!(@e)
+        @p2.attach_edge!(@e)
+
+      end
+
+      it 'pushes one' do
+
+        @p1.trigger!
+
+        expect(@p1.resource_count).to eq 1
+
+        # because it's just received the resource, it'll be blocked
+        expect(@p2.instant_resource_count).to eq 1
+
+      end
+
+    end
+
+    context 'pull_any' do
+
+      before(:each) do
+        @p1 = Pool.new name: 'p1', mode: :pull_any
+        @p2 = Pool.new name: 'p2', initial_value: 2
+
+        @e = Edge.new name: 'e', from: @p2, to: @p1
+        @p1.attach_edge!(@e)
+        @p2.attach_edge!(@e)
+
+
+      end
+
+      it 'pulls one' do
+        @p1.trigger!
+
+        expect(@p2.resource_count).to eq 1
+
+        # # because it's just received the resource, it'll be blocked
+        expect(@p1.instant_resource_count).to eq 1
+
+      end
+
+    end
+
+    context 'push_all' do
+
+    end
+
+    context 'pull_all' do
+
+    end
+
+  end
+
+end

data/testing/spec/conditions_spec.rb

@@ -0,0 +1,10 @@
+require_relative 'spec_helper'
+
+describe 'Nodes that can be given conditions' do
+
+  it 'does something' do
+
+    skip "will test conditions later"
+
+  end
+end

data/testing/spec/converter_spec.rb

@@ -0,0 +1,223 @@
+require_relative 'spec_helper'
+
+describe Converter do
+
+
+  it 'is created with name as single argument' do
+
+    expect { Converter.new name: 'foo' }.not_to raise_error
+
+  end
+
+  it 'is added into a diagram' do
+
+    d = Diagram.new 'd'
+
+    d.add_node! Converter, name: 'conv'
+
+    expect(d.get_node('conv')).to be_a Converter
+
+  end
+
+  it 'is connected to one edge in and one edge out' do
+
+    c = Converter.new name: 'c'
+
+    c.attach_edge(double(:from => c, :to => double()))
+
+    c.attach_edge(double(:from => double(), :to => c))
+
+  end
+
+
+  describe '#trigger!' do
+
+    context 'simple' do
+
+      before(:each) do
+
+        @c = Converter.new name: 'c'
+        @edge_in = instance_double(Edge, from: double(), to: @c, label: 1, pull_expression: proc{true==true})
+        @edge_out = instance_double(Edge, from: @c, to: double(), label: 1,push_expression: proc{true==true})
+        @c.attach_edge!(@edge_in).attach_edge!(@edge_out)
+
+      end
+
+      it 'asks incoming edges for their pull_expressions' do
+
+        expect(@edge_in).to receive(:pull_expression)
+        expect(@edge_in).to receive(:pull!)
+        @edge_out.as_null_object
+        @c.trigger!
+
+      end
+
+      it "doesn't ping outgoing edges if incoming edge cannot pull" do
+
+        expect(@edge_in).to receive(:pull_expression).and_raise(RuntimeError)
+        expect(@edge_out).not_to receive(:push!)
+
+        @c.trigger!
+
+      end
+
+    end
+
+    context 'when pull_any' do
+
+      before(:each) do
+
+        @c = Converter.new name: 'c', mode: :pull_any
+        @edge_in = instance_double(Edge, from: double(), to: @c,label:1)
+        @edge_out = instance_double(Edge, from: @c, to: double(),label:1)
+        @c.attach_edge!(@edge_in).attach_edge!(@edge_out)
+
+      end
+
+      it 'does not push when resource contributions are not met' do
+
+        expect(@edge_in).to receive(:pull_expression).and_return(proc{true})
+
+        expect(@edge_in).to receive(:pull!)
+
+        expect(@edge_out).not_to receive(:push_expression)
+
+        expect(@c).to receive(:in_conditions_met?).and_return(false)
+
+        @c.trigger!
+
+
+      end
+
+      it 'does cause a push when resource contribution is met, even if across turns' do
+        expect(@edge_in).to receive(:pull_expression).and_raise(RuntimeError)
+
+        expect(@edge_in).not_to receive(:pull!)
+
+        expect(@c).to receive(:in_conditions_met?).and_return(true)
+
+
+        expect(@edge_out).to receive(:test_push?).and_return(true)
+        expect(@edge_out).to receive(:push_expression).and_return(proc{true})
+        expect(@edge_out).to receive(:push!)
+
+        @c.trigger!
+      end
+
+    end
+
+    context 'when pull_all' do
+
+      before(:each) do
+        @c = Converter.new name: 'c', mode: :pull_all
+        @edge_in = instance_double(Edge, from: double(), to: @c, label:1,pull_expression: proc{true})
+        @edge_in2 = instance_double(Edge, from: double(), to: @c, label: 1,pull_expression: proc{true})
+        @edge_out = instance_double(Edge, from: @c, to: double(), label: 1,push_expression: proc{true})
+        @c.attach_edge!(@edge_in).attach_edge!(@edge_in2).attach_edge!(@edge_out)
+      end
+
+
+      it 'pushes and pulls if all edges (incoming and outgoing) can push and pull, respectively' do
+
+        expect(@edge_in).to receive(:test_pull?).with(true).and_return(true)
+        expect(@edge_in).to receive(:pull!)
+
+        expect(@edge_in2).to receive(:test_pull?).with(true).and_return(true)
+        expect(@edge_in2).to receive(:pull!)
+
+        expect(@edge_out).to receive(:test_push?).with(true).and_return(true)
+        expect(@edge_out).to receive(:push!)
+
+
+        @c.trigger!
+
+      end
+
+
+      it 'does not pull or push if at least one incoming edge cannot pull ' do
+
+        # they are shuffled and we stop sending test_ping? to edges
+        # once one has returned false. Therefore we do not know which
+        # edges will receive the message so we have to allow all to.
+
+        allow(@edge_in).to receive_messages(:test_pull? => false)
+        allow(@edge_in2).to receive_messages(:test_pull? => false)
+        allow(@edge_out).to receive_messages(:test_push? => false)
+
+        # but none outgoing will get pinged
+        expect(@edge_in).not_to receive(:pull!)
+        expect(@edge_in2).not_to receive(:pull!)
+        expect(@edge_out).not_to receive(:push!)
+
+
+        @c.trigger!
+
+      end
+
+      it 'also does not pull or push if at least one outgoing edge cannot push' do
+
+      end
+
+    end
+
+  end
+
+  describe '#put_resource!' do
+
+    before(:each) do
+      @c = Converter.new name: 'c'
+      @edge_in = instance_double(Edge, from: double(), to: @c, label: 1)
+      @edge_out = instance_double(Edge, from: @c, to: double(), label: 1)
+      @c.attach_edge!(@edge_out)
+      @c.attach_edge!(@edge_in)
+    end
+
+    it 'does not ping incoming edges' do
+
+      expect(@edge_in).not_to receive(:test_pull?)
+      expect(@edge_out).to receive(:push_expression).and_return(proc{true})
+      @edge_out.as_null_object
+      @c.put_resource!(double(), @edge_in)
+    end
+
+
+  end
+
+  describe '#take_resource!' do
+
+    before(:each) do
+
+      # TODO
+    end
+
+    it 'something'  do
+
+    end
+
+
+  end
+
+  describe '#attach_edge' do
+
+    before(:each) do
+      @c = Converter.new name: 'c'
+      @e = Edge.new name: 'e', from: double(), to: @c
+
+    end
+
+    it 'adds attached edge to resources_contributed hash' do
+
+      hsh = Hash.new
+
+      expect(@c).to receive(:resources_contributed).and_return(hsh)
+
+      expect(hsh).to receive(:store)
+
+      @c.attach_edge!(@e)
+
+
+    end
+
+  end
+
+end