flok 0.0.41 → 0.0.42

data/docs/services/vm/diff.md

@@ -0,0 +1,156 @@
+#VM Diff
+Information on the diff system of the vm service.
+
+##How a diff is created
+`vm_diff` embodies the creation of a diff. Some aspects of a diff, like a changed `_head` or a changed `_next` are just
+simple comparisons. Entry specific vm_diff_entry types, like `+`, need to be in a special order. The order is
+
+  * `vm_diff_entry` types where order is unimportant
+    * `M` - Modifications do not rely on index
+    * `HEAD_M` - Head can change whereever
+    * `NEXT_M` - Next can change wherever
+  * `vm_diff_entry` types in order they should be in the `vm_diff` log:
+    1. Deletions (`-`)
+    2. Moves (`>`)
+    3. Insetions (`+`)
+
+The order is special; imagine that we want to calculate a diff for a `from` list to a `to` list
+
+```ruby
+#from  to
+#---# #---#      
+#-A-# #-A-#    
+#-B-# #-D-#    
+#-F-# #-C-#    
+#-D-# #-B-#    
+#---# #-E-#    
+      #---#    
+```
+
+First we remove all entries in the `to` list that are not on the `from` list. All these entries are `+` entries, we take note of the index they were removed from.
+
+```ruby
+#Removed C at index 2 and E and index 4
+#to
+#---#
+#-A-#
+#-D-#
+#-B-#
+#---#
+```
+
+Second we remove all entries in the `from` list that are not in the `to` list. All the removed entries are `-` deletions.
+```ruby
+#Removed F
+#from
+#---#
+#-A-#
+#-B-#
+#-D-#
+#---# 
+```
+
+Last, we compare the `to` and `from` lists making note of how we could remove and re-insert items in the `to` list to re-create the `from` list
+```ruby
+#from    to
+#---#    #---#      
+#-A-#    #-A-#    
+#-B-# => #-D-#    
+#-D-#    #-B-#      
+#---#    #---#
+
+#1. Remove B and Insert at index 2 [">", "b_id", 2]
+#from
+#---#
+#-A-#
+#-D-#
+#-B-#
+#---#
+```
+Now we have all the pieces of the diff. If played in the order `delete`, `move`, and then `insert`, the resulting list will always be the same. `modifications` are position independent so they can be done at any time.
+
+####Example replay `from => to`
+```ruby
+#from   # diff
+#---#   # (-) F
+#-A-#   # (>) b_id to index:2
+#-B-#   # (+) C @ index 2
+#-F-#   # (+) E @ index 4
+#-D-#
+#---#
+
+#1) (-) F
+#---#
+#-A-#
+#-B-#
+#-D-#
+#---#
+
+#2) (>) b_id to index:2 
+#---#
+#-A-#
+#-D-#
+#-B-#
+#---#
+
+#3) (+) C @ index 2 
+#---#
+#-A-#
+#-D-#
+#-C-#
+#-B-#
+#---#
+
+#4) (+) E @ index 4 
+#---#
+#-A-#
+#-D-#
+#-C-#
+#-B-#
+#-E-#
+#---#
+
+Now `from` is the original `to`
+```
+
+##Helpers
+###Functional Kernel
+  * `vm_diff(old_page, new_page)` - Returns an array of type `vm_diff` w.r.t to the old page.  E.g. if A appears in `new_page`, but not `old_page`
+      then it is an insertion.
+  * `vm_diff_replay(page, diff)` - Will run the diff against the page; the page will be modified. This will have no effect on any changelists.
+
+##Data Types
+###`vm_diff`
+```ruby
+vm_diff_log_schema = [
+  <<vm_diff_entry>>,
+  <<vm_diff_entry>>,
+  ...
+]
+```
+
+###`vm_diff_entry`
+Each `vm_diff_entry` is an array with the form `[type_str, *args]`. The types are:
+```ruby
+#Entry Insertion
+#eindex - The index of the insertion.
+#ehash - A hash that contains the entry.
+["+", eindex, ehash]
+
+#Entry Deletion
+#eid - The id of the entry that was deleted.
+["-", eid]
+
+#Entry Modification
+#ehash - A hash that contains the new entry to replace the old entry.
+["M", ehash]
+
+#Entry Move
+#to_index - The index, an integer, that the entry should be insertad at
+#eid - The id of the entry to be moved to the to_index
+[">", to_index, eid]
+
+#Head or next pointer changed
+["HEAD_M", new_head_id]
+["NEXT_M", new_next_id]
+```

data/docs/services/vm/pagers.md

@@ -12,8 +12,6 @@ If you haven't already, read [VM Service](../vm.md) for context on pagers.
   * `$NAME_write(page)` - You should write this page, e.g. to network, and/or write to `vm_cache_write`.  Alternatively, you can write the page over the network and then let the response from that call `vm_cache_write` in what ever listening code you have.
     * `page` - A fully constructed page with correctly calculated `_hash` and _sigs on entries.
 
-
- 
 ##When are pagers invoked?
 Pagers handle all requests from controllers except for the following conditions:
   1. There is a `watch` request placed but a previous `watch` request already exists for the requested page. The pager is already aware of the page watch request and is already waiting for a response. Cached pages would have been returned to the controller that made the `watch` request.
@@ -56,3 +54,6 @@ This pager provides you with local memory that will be automatically cached to d
   * `watch` - Does nothing
   * `unwatch` - Does nothing
   * `write` - Writes the given page to `vm_cache_write`
+
+####Dummy pager | `pg_dummy0`
+This pager doesn't do anything. Used by some specs which manually write to the vm_cache in leu of the pager

data/lib/flok/user_compiler.rb

@@ -475,6 +475,9 @@ module Flok
       @macros = {}
       @_services = []
 
+      #Some macros expect controller instance
+      @controller = self
+
       self.instance_eval(&block)
     end
 

data/lib/flok/version.rb

@@ -1,3 +1,3 @@
 module Flok
-  VERSION = "0.0.41"
+  VERSION = "0.0.42"
 end

data/spec/env/kern.rb

@@ -27,6 +27,25 @@ shared_context "kern" do
 
       return JSON.parse(json_res)
     end
+
+    #Will return everything put into the 'dump' dictionary (pre-defined for your convenience)
+    def evald str
+      self.eval "dump = {}"
+      self.eval str
+      _dump = self.dump("dump")
+
+      return DumpHelper.new(_dump)
+    end
+  end
+
+  class DumpHelper
+    def initialize dump
+      @dump = dump
+    end
+
+    def [](index)
+      return @dump[index]
+    end
   end
 
   #Execute flok binary with a command

data/spec/etc/user_compiler/controller0bg.rb

@@ -0,0 +1,13 @@
+controller :my_controller do
+  spots "hello", "world"
+
+  on_entry %{
+    global_on_entry = true;
+  }
+
+  action :my_action do
+    on "hello", %{
+      var x = 3;
+    }
+  end
+end

data/spec/etc/user_compiler_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe "User compiler" do
     js_res = compiler.compile(js_src(fn))
     ctx = V8::Context.new
     ctx.eval js_res
-    ctx
+    return ctx, js_res
   end
 
   #Get the source for a file in  ./user_compiler/*.rb
@@ -29,59 +29,66 @@ RSpec.describe "User compiler" do
 
   it "Can compile a controller and give up the root 
   iew" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     root_view = ctx.eval "ctable.my_controller.root_view"
     expect(root_view).to eq("my_controller")
   end
 
   it "Can compile a controller and contain a list of actions" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     actions = ctx.eval "Object.keys(ctable.my_controller.actions).length"
     expect(actions).to eq(1)
   end
 
   it "Can compile a controller and contain an __init__ function" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     actions = ctx.eval "ctable.my_controller.__init__"
     expect(actions).not_to eq(nil)
   end
 
   it "Can compile a controller with an action that contains an on_entry" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     on_entry = ctx.eval "ctable.my_controller.actions.my_action.on_entry"
     expect(on_entry).not_to eq(nil)
   end
 
   it "Can compile a controller with an action that does not contains an on_entry" do
-    ctx = compile "controller0b"
+    ctx, js_src = compile "controller0b"
     on_entry = ctx.eval "ctable.my_controller.actions.my_action.on_entry"
     expect(on_entry).not_to eq(nil)
   end
 
+  it "Can compile a controller with a global on_entry" do
+    ctx, js_src = compile "controller0bg"
+    on_entry = ctx.eval "ctable.my_controller.on_entry"
+    expect(js_src).to include("global_on_entry")
+  end
+
+
   it "on_entry controller has more code than non on_entry controller" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     on_entry = ctx.eval "ctable.my_controller.actions.my_action.on_entry"
 
-    ctx2 = compile "controller0b"
+    ctx2, js_src = compile "controller0b"
     on_entry2 = ctx2.eval "ctable.my_controller.actions.my_action.on_entry"
     expect(on_entry2.to_s.length).to be < on_entry.to_s.length
   end
 
 
   it "Can compile a controller with an action that contains the name" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     on_entry = ctx.eval "ctable.my_controller.name"
     expect(on_entry).to eq("my_controller")
   end
 
   it "Can compile a controller with an action that contains an event that responds to hello" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     hello_event_function = ctx.eval "ctable.my_controller.actions.my_action.handlers.hello"
     expect(hello_event_function).not_to eq(nil)
   end
 
   it "Can compile a controller with spot names" do
-    ctx = compile "controller0"
+    ctx, js_src = compile "controller0"
     spot_names = JSON.parse(ctx.eval "JSON.stringify(ctable.my_controller.spots)")
     expect(spot_names).to include "hello"
     expect(spot_names).to include "world"
@@ -89,7 +96,7 @@ RSpec.describe "User compiler" do
   end
 
   it "Can compile a controller with an action containing a timer and set the appropriate every_handlers key" do
-    ctx = compile "controller0timer"
+    ctx, js_src = compile "controller0timer"
 
     function_names = JSON.parse(ctx.eval "JSON.stringify(Object.keys(ctable.my_controller.actions.my_action.handlers))")
     expect(function_names).to include("hello")

data/spec/kern/assets/global_on_entry5.rb

@@ -0,0 +1,28 @@
+controller :my_controller do
+  services "vm"
+
+  on_entry %{
+    context.secret = "foo";
+    context.base = __base__;
+
+    var page = NewPage("array", "test");
+    var info = {
+      page: page,
+      ns: "spec0",
+      id: "test"
+    }
+    Request("vm", "write", info);
+
+    Request("vm", "watch", info);
+  }
+
+  action :index do
+    on_entry %{
+      Send("context", context);
+    }
+
+    on "read_res", %{
+      read_res_called = true;
+    }
+  end
+end

data/spec/kern/assets/vm/controller0_diff.rb

@@ -0,0 +1,47 @@
+controller :my_controller do
+  services :vm
+
+  on_entry %{
+    entry_move_params = [];
+    entry_modify_params = [];
+    entry_del_params = [];
+    entry_ins_params = [];
+    next_changed_params = [];
+    head_changed_params = [];
+  }
+
+  action :my_action do
+    on_entry %{
+      var info = {ns: "dummy", id: "default"};
+      Request("vm", "watch", info);
+    }
+
+    on "entry_move", %{
+      entry_move_called = true;
+      entry_move_params.push(params);
+    }
+
+    on "entry_modify", %{
+      entry_modify_called = true;
+      entry_modify_params.push(params);
+    }
+
+    on "entry_del", %{
+      entry_del_called = true;
+      entry_del_params.push(params);
+    }
+
+    on "entry_ins", %{
+      entry_ins_called = true;
+      entry_ins_params.push(params);
+    }
+
+    on "head_changed", %{
+      head_changed_params.push(params);
+    }
+
+    on "next_changed", %{
+      next_changed_params.push(params);
+    }
+  end
+end

data/spec/kern/assets/vm/pg_dummy/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_dummy0",
+      :namespace => "dummy",
+      :options => {}
+    }
+  ]
+}

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

@@ -7,7 +7,7 @@ controller :my_controller do
         hello: "world"
       }
 
-      page = NewPage("test");
+      page = NewPage("array", "test");
       SetPageHead(page, "head");
       SetPageNext(page, "next");
       EntryInsert(page, 0, entry);

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

@@ -12,7 +12,7 @@ controller :my_controller do
       }
 
 
-      page = NewPage("test");
+      page = NewPage("array", "test");
       SetPageHead(page, "head");
       SetPageNext(page, "next");
       EntryInsert(page, 0, entry);

data/spec/kern/assets/vm/vm_commit_pages.js

@@ -0,0 +1,108 @@
+//Page Factor
+//////////////////////////////////////////////////////////////////////////////////////////
+function PageFactory(head, next) {
+  this.head = head;
+  this.next = next;
+  this.entries = [];
+}
+
+//Add an entry
+PageFactory.prototype.addEntry = function(eid, value) {
+  this.entries.push({_id: eid, _sig: value, value: value});
+}
+
+//This adds up to four entrys that can be represented as a square:
+//-------------
+//| id0 | id1 |
+//-------------
+//| id2 | id3 |
+//-------------
+//Leaving out parts of the values array will not add those entries, e.g. ["Square", null, null, "Triangle"]
+//--------------------|
+//| Square | null     |
+//--------------------| 
+//| null   | Triangle |
+//--------------------|
+//Where 'Square' is id0 and 'Triangle' is id3
+PageFactory.prototype.addEntryFourSquare = function(values) {
+  if (values.length != 4) {
+    throw "FourSquare requires for values. Make values null if you don't need them"
+  }
+
+  for (var i = 0; i < values.length; ++i) {
+    if (values[i]) {
+      this.addEntry("id"+i, values[i]);
+    }
+  }
+}
+
+//Returns a page
+PageFactory.prototype.compile = function() {
+  var page = vm_create_page("default");
+  page._head = this.head;
+  page._next = this.next;
+
+  page.entries = this.entries;
+
+  vm_rehash_page(page);
+  vm_reindex_page(page);
+
+  return page;
+}
+//////////////////////////////////////////////////////////////////////////////////////////
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["Triangle", "Square", "Z", null]);
+triangle_square_z_null = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["Triangle", "Circle", null, "Q"]);
+triangle_circle_null_q = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["Triangle", "Circle", null, "Q"]);
+triangle_circle_null_q = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["Q", null, "Circle", "Square"]);
+q_null_circle_square = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["P", "Circle", null, "Q"]);
+p_circle_null_q = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["P", "Circle", null, null]);
+p_circle_null_null  = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["P", null, null, "Q"]);
+p_null_null_q = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["P", "Square", null, null]);
+p_square_null_null  = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["Triangle", null, "A", "M"]);
+triangle_null_a_m = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["Triangle", "Square", null, null]);
+triangle_square_null_null = pf.compile();
+
+var pf = new PageFactory();
+pf.addEntryFourSquare(["Triangle", "Z", "Q", null]);
+triangle_z_q_null  = pf.compile();
+
+var pf = new PageFactory(null);
+head_null = pf.compile();
+
+var pf = new PageFactory("world");
+head_world = pf.compile();
+
+var pf = new PageFactory(null);
+next_null  = pf.compile();
+
+var pf = new PageFactory(null, "world");
+next_world = pf.compile();