flok 0.0.40 → 0.0.41

data/spec/kern/assets/vm/pg_mem/config3.rb

@@ -0,0 +1,15 @@
+#Simple service config that uses built-in spec service to create a instance called 'spec'
+service_instance :vm, :vm, {
+  :pagers => [
+    {
+      :name => "pg_mem0",
+      :namespace => "local0",
+      :options => {}
+    },
+    {
+      :name => "pg_mem1",
+      :namespace => "local1",
+      :options => {}
+    }
+  ]
+}

data/spec/kern/assets/vm/pg_mem/write.rb

@@ -0,0 +1,23 @@
+controller :my_controller do
+  services :vm
+
+  action :my_action do
+    on_entry %{
+      var entry = {
+        hello: "world"
+      }
+
+      page = NewPage("test");
+      SetPageHead(page, "head");
+      SetPageNext(page, "next");
+      EntryInsert(page, 0, entry);
+
+      var write_info = {
+        ns: "local",
+        page: page
+      };
+
+      Request("vm", "write", write_info);
+    }
+  end
+end

data/spec/kern/assets/vm/pg_mem/write2.rb

@@ -0,0 +1,38 @@
+controller :my_controller do
+  services :vm
+
+  action :my_action do
+    on_entry %{
+      var entry = {
+        hello: "world"
+      }
+
+      var entry2 = {
+        hello: "world"
+      }
+
+
+      page = NewPage("test");
+      SetPageHead(page, "head");
+      SetPageNext(page, "next");
+      EntryInsert(page, 0, entry);
+
+      var write_info = {
+        ns: "local0",
+        page: page
+      };
+
+      page2 = CopyPage(page);
+      EntryInsert(page2, 0, entry);
+
+      var write_info2 = {
+        ns: "local1",
+        page: page2
+      };
+
+
+      Request("vm", "write", write_info);
+      Request("vm", "write", write_info2);
+    }
+  end
+end

data/spec/kern/assets/vm/pg_net_sim/config.rb

@@ -0,0 +1,10 @@
+#Simple service config that uses built-in spec service to create a instance called 'spec'
+service_instance :vm, :vm, {
+  :pagers => [
+    {
+      :name => "pg_net_sim",
+      :namespace => "net",
+      :options => {}
+    }
+  ]
+}

data/spec/kern/assets/vm/pg_net_sim/nothing.rb

@@ -0,0 +1,12 @@
+controller :my_controller do
+  services :vm
+
+  action :my_action do
+    on_entry %{
+    }
+
+    on "read_res", %{
+      read_res_params = params;
+    }
+  end
+end

data/spec/kern/assets/vm/pg_net_sim/pages.json

@@ -0,0 +1 @@
+[{"_head":null,"_next":"7f3d373","_id":"weight","entries":[],"_hash":"1822752852"},{"_head":"weight","_next":"9ffd52a","_id":"7f3d373","entries":[{"_id":"a85c876","_sig":"9349266","date":1434381745,"value":220},{"_id":"050bc6a","_sig":"f824a7b","date":0,"value":202},{"_id":"8977e46","_sig":"30d51c1","date":0,"value":203},{"_id":"99bbc39","_sig":"f868f7c","date":0,"value":208},{"_id":"ff6854e","_sig":"517513c","date":0,"value":224},{"_id":"8fb9997","_sig":"da00718","date":0,"value":212},{"_id":"0ff5e6c","_sig":"d336c63","date":0,"value":208},{"_id":"56c7036","_sig":"9d36d3a","date":0,"value":227},{"_id":"a94507a","_sig":"edd2a57","date":0,"value":223},{"_id":"80d494a","_sig":"7834992","date":0,"value":218}],"_hash":"140966661"}]

data/spec/kern/assets/vm/pg_net_sim/watch.rb

@@ -0,0 +1,18 @@
+controller :my_controller do
+  services :vm
+
+  action :my_action do
+    on_entry %{
+      var watch_info = {
+        ns: "net",
+        id: "weight", 
+      };
+
+      Request("vm", "watch", watch_info);
+    }
+
+    on "read_res", %{
+      read_res_params = params;
+    }
+  end
+end

data/spec/kern/callout_spec.rb

@@ -4,7 +4,7 @@ require './spec/lib/helpers.rb'
 require './spec/lib/io_extensions.rb'
 require './spec/lib/rspec_extensions.rb'
 
-RSpec.describe "kern:timer_service_spec" do
+RSpec.describe "kern:callout_spec" do
   include_context "kern"
 
 it "Can register for single-shot a callout event 1 tick in the future" do

data/spec/kern/controller_macro_spec.rb

@@ -12,7 +12,7 @@ require './spec/lib/rspec_extensions.rb'
 RSpec.describe "kern:controller_macro_spec" do
   include_context "kern"
 
-  it "Can use the NewPage macro" do
+  it "Can use the NewPage macro for an array" do
     #Compile the controller
     ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/new_page_c.rb')
     ctx.eval %{
@@ -26,11 +26,31 @@ RSpec.describe "kern:controller_macro_spec" do
       "_head" =>  nil,
       "_next" =>  nil,
       "entries" => [],
-      "_id" => nil
+      "_id" => nil,
+      "_type" => "array"
     })
   end
 
-  it "Can use the NewPage macro with id" do
+  it "Can use the NewPage macro for an hash" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/new_page_ch.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #Check the page variable 
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+    expect(page).to eq({
+      "_head" =>  nil,
+      "_next" =>  nil,
+      "entries" => {},
+      "_id" => nil,
+      "_type" => "hash"
+    })
+  end
+
+  it "Can use the NewPage macro with id for array" do
     #Compile the controller
     ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/new_page_c2.rb')
     ctx.eval %{
@@ -44,13 +64,36 @@ RSpec.describe "kern:controller_macro_spec" do
       "_head" =>  nil,
       "_next" =>  nil,
       "entries" => [],
-      "_id" => "test"
+      "_id" => "test",
+      "_type" => "array"
     })
   end
 
-  it "Can use the CopyPage macro" do
+  it "Can use the CopyPage macro for array" do
     #Compile the controller
     ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/copy_page_c.rb')
+    ctx.eval %{
+      base = _embed("controller", 1, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    not_copied_page = JSON.parse(ctx.eval("JSON.stringify(not_copied_page)"))
+    copied_page = JSON.parse(ctx.eval("JSON.stringify(copied_page)"))
+
+    #What the copied page should look like after a copy
+    copied_should_look_like = JSON.parse(original_page.to_json)
+    copied_should_look_like["_next"] = "test" #Set in controller
+    copied_should_look_like.delete "_hash"
+
+    expect(not_copied_page).to eq(original_page)
+    expect(copied_page).to eq(copied_should_look_like)
+  end
+
+  it "Can use the CopyPage macro for hash" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/copy_page_ch.rb')
     ctx.eval %{
       base = _embed("controller", 0, {}, null);
       int_dispatch([]);
@@ -70,7 +113,7 @@ RSpec.describe "kern:controller_macro_spec" do
     expect(copied_page).to eq(copied_should_look_like)
   end
 
-  it "Can use the EntryDel macro" do
+  it "Can use the EntryDel macro for an array" do
     #Compile the controller
     ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_del_c.rb')
     ctx.eval %{
@@ -86,6 +129,7 @@ RSpec.describe "kern:controller_macro_spec" do
       "_head" => "head",
       "_id" => "id",
       "_next" => "next",
+      "_type" => "array",
       "entries" => []
     })
 
@@ -96,11 +140,50 @@ RSpec.describe "kern:controller_macro_spec" do
       "entries" => [{
         "_id" => "id", "_sig" => "sig"
       }],
-      "_hash" => "hash"
+      "_hash" => "hash",
+      "_type" => "array"
     })
   end
 
-  it "Can use the EntryInsert macro" do
+  it "Can use the EntryDel macro for an hash" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_del_ch.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    #The new page, Making sure it's not referenced
+    expect(page).to eq({
+      "_head" => "head",
+      "_id" => "id",
+      "_next" => "next",
+      "_type" => "hash",
+      "entries" => {
+        "id1" => {
+        "_sig" => "sig2"
+        },
+      },
+    })
+
+    expect(original_page).to eq({
+      "_head" => "head",
+      "_id" => "id",
+      "_next" => "next",
+      "_hash" => "hash",
+      "_type" => "hash",
+      "entries" => {
+        "id0" => {"_sig" => "sig"},
+        "id1" => {"_sig" => "sig2"},
+      }
+    })
+  end
+
+  it "Can use the EntryInsert macro on an array" do
     #Compile the controller
     ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_insert_c.rb')
     ctx.eval %{
@@ -117,13 +200,38 @@ RSpec.describe "kern:controller_macro_spec" do
     expect(page["entries"][2]["hello"]).to eq("world2")
 
     expect(page["entries"][0]["_sig"]).not_to eq(nil)
+    expect(page["entries"][0]["_sig"]).not_to eq("sig")
     expect(page["entries"][0]["_sig"]).not_to eq(page["entries"][1]["_sig"])
     expect(page["entries"][0]["_id"]).not_to eq(nil)
     expect(page["entries"][2]["_id"]).not_to eq(page["entries"][0]["_id"])
     expect(page["entries"][2]["_id"]).not_to eq(page["entries"][1]["_id"])
   end
 
-  it "Can use the EntryMutable macro" do
+  it "Can use the EntryInsert macro on a hash" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_insert_ch.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
+
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
+
+    expect(page["entries"].keys.count).to eq(3)
+    expect(page["entries"]["id0"]["hello"]).to eq("world")
+    expect(page["entries"]["id2"]["hello"]).to eq("world2")
+
+    expect(page["entries"]["id0"]["_sig"]).not_to eq(nil)
+    expect(page["entries"]["id0"]["_sig"]).not_to eq("sig0")
+    expect(page["entries"]["id1"]["_sig"]).to eq("sig1")
+    expect(page["entries"]["id0"]["_sig"]).not_to eq(page["entries"]["id1"]["_sig"])
+    expect(page["entries"]["id2"]["_sig"]).not_to eq(nil)
+  end
+
+
+  it "Can use the EntryMutable macro for array" do
     #Compile the controller
     ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_mutable_c.rb')
     ctx.eval %{
@@ -135,23 +243,48 @@ RSpec.describe "kern:controller_macro_spec" do
     original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
     page = JSON.parse(ctx.eval("JSON.stringify(page)"))
 
+    #This should remain unchanged
+    expect(original_page["entries"]).to eq([
+      {"_id" => "id1", "_sig" => "sig1", "foo" => "bar"},
+      {"_id" => "id2", "_sig" => "sig2"},
+    ])
+
+    #New page
     entries = page["entries"]
-    original_entries = original_page["entries"]
     expect(entries[0]["hello"]).to eq("world")
+    expect(entries[0]["_sig"]).not_to eq("sig1")
     expect(entries[0]["foo"]).to eq(nil)
-    expect(entries[2]["hello"]).to eq("world")
-    expect(entries[2]["foo"]).to eq(nil)
+    expect(entries[1]["hello"]).to eq("world")
+    expect(entries[1]["_sig"]).not_to eq("sig2")
+    expect(entries[1]["foo"]).to eq(nil)
+  end
+
+  it "Can use the EntryMutable macro for hash" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/vm/macros/entry_mutable_ch.rb')
+    ctx.eval %{
+      base = _embed("controller", 0, {}, null);
+      int_dispatch([]);
+    }
 
-    #Shared
-    expect(entries[1]["foo"]).to eq("bar")
-    expect(entries[1]["hello"]).to eq(nil)
+    #not_copied page is just a reference to original_page, checked for sanity
+    original_page = JSON.parse(ctx.eval("JSON.stringify(original_page)"))
+    page = JSON.parse(ctx.eval("JSON.stringify(page)"))
 
     #This should remain unchanged
-    expect(original_page["entries"]).to eq([
-      {"_id" => "id", "_sig" => "sig"},
-      {"_id" => "id2", "_sig" => "sig2", "foo" => "bar"},
-      {"_id" => "id3", "_sig" => "sig3"},
-    ])
+    expect(original_page["entries"]).to eq({
+      "id1" => {"_sig" => "sig1", "foo" => "bar"},
+      "id2" => {"_sig" => "sig2"},
+    })
+
+    #New page
+    entries = page["entries"]
+    expect(entries["id1"]["hello"]).to eq("world")
+    expect(entries["id1"]["_sig"]).not_to eq("sig1")
+    expect(entries["id1"]["foo"]).to eq(nil)
+    expect(entries["id2"]["hello"]).to eq("world")
+    expect(entries["id2"]["_sig"]).not_to eq("sig2")
+    expect(entries["id2"]["foo"]).to eq(nil)
   end
 
   it "Can use the SetPageNext macro" do

data/spec/kern/controller_spec.rb

@@ -497,7 +497,7 @@ RSpec.describe "kern:controller_spec" do
     expect(raise_res_context).to eq({"secret" => "#{secret}", "hello" => "world"})
   end
 
- #Can signal a spot from a parent controller
+  #Can signal a spot from a parent controller
   it "Can signal a spot sub-controller and trigger an event" do
     #Compile the controller
     ctx = flok_new_user File.read('./spec/kern/assets/lower_event.rb')
@@ -517,4 +517,235 @@ RSpec.describe "kern:controller_spec" do
 
     expect(lower_request_called_with).to eq({"secret" => "#{secret}"})
   end
+
+  it "Does run the global on_entry function when it is present upon entering the first action" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/global_on_entry.rb')
+
+    #Run the embed function
+    secret = SecureRandom.hex
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    expect(ctx.eval("global_on_entry_called")).to eq(true)
+  end
+
+  it "Does run the global on_entry function only on the first action and not subsequent actions" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/global_on_entry2.rb')
+
+    #Run the embed function
+    secret = SecureRandom.hex
+    ctx.eval %{
+      global_on_entry_called_count = 0;
+
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([3, "int_event", base, "test", {}]);
+    }
+
+    expect(ctx.eval("global_on_entry_called_count")).to eq(1)
+  end
+
+  it "Does allow macros in the global on_entry function" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/global_on_entry3.rb')
+
+    #Run the embed function
+    secret = SecureRandom.hex
+    ctx.eval %{
+      global_on_entry_called_count = 0;
+
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([3, "int_event", base, "test", {}]);
+    }
+
+    base = ctx.eval("base")
+    expect(ctx.eval("global_on_entry_called_count")).to eq(1)
+    @driver.ignore_up_to "if_event"
+    @driver.mexpect("if_event", [base, "test", {}])
+  end
+
+  it "Does allow context in the global on_entry function" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/global_on_entry4.rb')
+
+    #Run the embed function
+    secret = SecureRandom.hex
+    ctx.eval %{
+      global_on_entry_called_count = 0;
+
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      int_dispatch([]);
+    }
+
+    base = ctx.eval("base")
+    @driver.ignore_up_to "if_event"
+    @driver.mexpect("if_event", [base, "context", {"base" => base, "secret" => "foo"}])
+  end
+
+  it "Does allow interval (every) events" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/interval.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+    }
+
+    base = ctx.eval("base")
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(1)
+    expect(ctx.eval("every_05_called_count")).to eq(0)
+    expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(2)
+    expect(ctx.eval("every_05_called_count")).to eq(1)
+    expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(3)
+    expect(ctx.eval("every_05_called_count")).to eq(1)
+    expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(4)
+    expect(ctx.eval("every_05_called_count")).to eq(2)
+    expect(ctx.eval("every_1_called_count")).to eq(1)
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(5)
+    expect(ctx.eval("every_05_called_count")).to eq(2)
+    expect(ctx.eval("every_1_called_count")).to eq(1)
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(6)
+    expect(ctx.eval("every_05_called_count")).to eq(3)
+    expect(ctx.eval("every_1_called_count")).to eq(1)
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(7)
+    expect(ctx.eval("every_05_called_count")).to eq(3)
+    expect(ctx.eval("every_1_called_count")).to eq(1)
+
+    @driver.int "int_timer"
+    expect(ctx.eval("every_025_called_count")).to eq(8)
+    expect(ctx.eval("every_05_called_count")).to eq(4)
+    expect(ctx.eval("every_1_called_count")).to eq(2)
+
+    #Ignore up to, block must pass as well; if_event would otherwise include action
+    @driver.ignore_up_to("if_event", 0) do |args|
+      args[1] == "025_message"
+    end
+
+    #Now we expect our if_event messages
+    8.times do
+      @driver.ignore_up_to("if_event")
+      @driver.mexpect "if_event", [base, "025_message", {}]
+    end
+  end
+
+  #See 0000 docs/known_problems.md
+  #it "Does not call intervals of other actions; and still works when switching back actions" do
+    ##Compile the controller
+    #ctx = flok_new_user File.read('./spec/kern/assets/interval2.rb')
+
+    ##Run the embed function
+    #ctx.eval %{
+      #//Call embed on main root view
+      #base = _embed("my_controller", 0, {}, null);
+    #}
+
+    #base = ctx.eval("base")
+
+    ##In first action, only 025 is enabled
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(1)
+    #expect(ctx.eval("every_05_called_count")).to eq(0)
+    #expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(2)
+    #expect(ctx.eval("every_05_called_count")).to eq(0)
+    #expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    ##Switch actions, only 05 and 01 are enabled
+    #ctx.eval %{ int_dispatch([base, "int_event", base, "next", {}]); }
+
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(2)
+    #expect(ctx.eval("every_05_called_count")).to eq(0)
+    #expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(2)
+    #expect(ctx.eval("every_05_called_count")).to eq(1)
+    #expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(2)
+    #expect(ctx.eval("every_05_called_count")).to eq(1)
+    #expect(ctx.eval("every_1_called_count")).to eq(0)
+
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(2)
+    #expect(ctx.eval("every_05_called_count")).to eq(2)
+    #expect(ctx.eval("every_1_called_count")).to eq(1)
+
+    ##Now switch back to first action again, only 025 is enabled
+    #ctx.eval %{ int_dispatch([base, "int_event", base, "back", {}]); }
+
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(3)
+    #expect(ctx.eval("every_05_called_count")).to eq(2)
+    #expect(ctx.eval("every_1_called_count")).to eq(1)
+
+    #@driver.int "int_timer"
+    #expect(ctx.eval("every_025_called_count")).to eq(4)
+    #expect(ctx.eval("every_05_called_count")).to eq(2)
+    #expect(ctx.eval("every_1_called_count")).to eq(1)
+  #end
+
+  it "Does not fire interval after leaving a controller" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/interval3.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+    }
+
+    base = ctx.eval("base")
+
+    @driver.int "int_timer"
+    expect(ctx.eval("timer_called")).to eq(1)
+    @driver.int "int_timer"
+    expect(ctx.eval("timer_called")).to eq(2)
+
+    #Switch controllers via Goto
+    ctx.eval %{ int_dispatch([base, "int_event", base, "next", {}]); }
+
+    #Now we expect our if_event messages
+    4.times do
+      @driver.int "int_timer"
+    end
+
+    expect(ctx.eval("timer_called")).to eq(2)
+  end
 end