flok 0.0.100 → 0.0.101

data/spec/etc/transition_complier_spec.rb

@@ -22,6 +22,10 @@ RSpec.describe "Transition compiler" do
     end
   end
 
+  it "Can insert a hook into ${controller_name}_will_goto and this hook is invoked" do
+
+  end
+
   it "Can load the ruby module" do
     compiler = Flok::TransitionCompiler
   end

data/spec/iface/driver/hook_spec.rb

@@ -0,0 +1,33 @@
+Dir.chdir File.join File.dirname(__FILE__), '../../../'
+require './spec/env/iface.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+
+RSpec.describe "iface:driver:hook" do
+  module_dep "hook"
+  include_context "iface:driver"
+
+  it "Can receive a hook event request with parameters" do
+    @ptr = SecureRandom.hex
+
+    #Simulate a hook event on the main queue
+    @pipe.puts [[0, 3, "if_hook_event", "test", {foo: "bar"}]].to_json
+
+    #Wait for response
+    @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+
+    #Get the value of the received event
+    @pipe.puts [[0, 1, "if_hook_spec_dump_rcvd_events"]].to_json
+
+    json = [
+      1,
+      "if_hook_spec_dump_rcvd_events_res",
+      [{
+        "name" => "test",
+        "info" => {"foo" => "bar"}
+      }]
+    ]
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(json, 5.seconds)
+  end
+end

data/spec/iface/kern/dlink_spec.rb

@@ -0,0 +1,25 @@
+Dir.chdir File.join File.dirname(__FILE__), '../../../'
+require './spec/env/iface.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+
+RSpec.describe "iface:kern:net" do
+  module_dep "net"
+  include_context "iface:kern"
+
+  #A callback was registered in the kernel for testing purposes
+  it "A mock URL notify does receive the correct information" do
+    #Wait for response
+    @pipe.puts [0, "ping"].to_json; @pipe.readline_timeout
+
+    @pipe.puts [2, "int_dlink_notify", "http://test.com/foo", {"foo" => "bar"}].to_json
+    @pipe.puts [0, "get_int_dlink_spec"].to_json
+
+    res = [
+      [0, 1, "get_int_dlink_spec", ["http://test.com/foo", {"foo"=>"bar"}]]
+    ]
+
+    expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+  end
+end

data/spec/kern/assets/dlink_service/config0.rb

@@ -0,0 +1,2 @@
+#Simple service config that uses built-in spec service to create a instance called 'spec'
+service_instance :dlink, :dlink

data/spec/kern/assets/dlink_service/controller0.rb

@@ -0,0 +1,16 @@
+controller :my_controller do
+  services :dlink
+
+  on_entry %{
+    dlink_res_params = null;
+  }
+
+  action :my_action do
+    on_entry %{
+    }
+
+    on "dlink_req", %{
+      dlink_res_params = params;
+    }
+  end
+end

data/spec/kern/assets/hook_entry_points/controller0.rb

@@ -0,0 +1,58 @@
+controller :my_controller do
+  spots "hello", "world"
+
+  macro :my_macro do
+    on "foo", %{
+    }
+
+  end
+
+  action :index do
+    on_entry %{
+      on_entry_base_pointer = __base__;
+      Embed("my_other_controller", "hello", {});
+    }
+
+    on "hello", %{
+      var x = 3;
+    }
+
+    my_macro
+  end
+
+  action :other do
+    on "test", %{
+    }
+  end
+end
+
+controller :my_other_controller do
+  action :index do
+    on_entry %{
+      my_other_controller_base = __base__;
+    }
+
+    on "back_clicked", %{
+      Goto("other");
+    }
+  end
+
+  action :other do
+    on "next_clicked", %{
+      Goto("other2");
+    }
+  end
+
+  action :other2 do
+    on "next_clicked", %{
+      Goto("has_back_also");
+    }
+  end
+
+
+  action :has_back_also do
+    on "back_clicked", %{
+      Goto("other");
+    }
+  end
+end

data/spec/kern/assets/hook_entry_points/controller0a.rb

@@ -0,0 +1,27 @@
+controller :my_controller do
+  spots "hello", "world"
+
+  macro :my_macro do
+    on "foo", %{
+    }
+
+  end
+
+  action :index do
+    on_entry %{
+      on_entry_base_pointer = __base__;
+    }
+
+    on "hello", %{
+      var x = 3;
+    }
+
+    my_macro
+  end
+
+  action :other do
+    on "test", %{
+      Goto("index");
+    }
+  end
+end

data/spec/kern/dlink_service_spec.rb

@@ -0,0 +1,50 @@
+#The dlink service
+
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+require 'zlib'
+
+RSpec.describe "kern:dlink_service" do
+  include Zlib
+  include_context "kern"
+
+  it "Can use dlink service" do
+    ctx = flok_new_user File.read('./spec/kern/assets/dlink_service/controller0.rb'), File.read("./spec/kern/assets/dlink_service/config0.rb") 
+    dump = ctx.evald %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+  end
+
+  it "Does send the controller the dlink_req when a dlink interrupt is sent" do
+    ctx = flok_new_user File.read('./spec/kern/assets/dlink_service/controller0.rb'), File.read("./spec/kern/assets/dlink_service/config0.rb") 
+    dump = ctx.evald %{
+      dump.base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    @driver.int "int_dlink_notify", [
+      "http://google.com/test", {"foo" => "bar"}
+    ]
+
+    #Should not exist yet because of defered event
+    dump = ctx.evald %{ dump.dlink_res_params = dlink_res_params; }
+    expect(dump["dlink_res_params"]).to eq(nil)
+
+    #Drain the defered queue and check again
+    ctx.eval %{ for (var i = 0; i < 100; ++i) { int_dispatch([]); } }
+    dump = ctx.evald %{ dump.dlink_res_params = dlink_res_params; }
+
+    expect(dump["dlink_res_params"]).to eq({
+      "url" => "http://google.com/test",
+      "params" => {"foo" => "bar"}
+    })
+  end
+end

data/spec/kern/hook_entry_points_and_manifest_spec.rb

@@ -0,0 +1,155 @@
+#Tests to make sure the hook entry points act as the are defined in hooks.md
+#and that the HookCompiler is able to correctly intercept them. Additionally,
+#there are some tests here to verify the operation of the hooks compiler it's-self
+#but the user-generated DSL related tests are in hook_user_generators_spec.rb
+
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+require './lib/flok/hooks_compiler.rb'
+require 'zlib'
+
+RSpec.describe "kern:hook_entry_points" do
+  include Zlib
+  include_context "kern"
+
+  it "Can use the HooksManifest & HooksManifestEntry to properly select and insert code into a hooks compatible javascript file" do
+    #Since we are only looking at the HooksManifest & HooksManifestEntry, this dosen't necessarily need to be 
+    #flok compatible things as only the compiler itself holds flok code. In this case, we are going to be replacing
+    #some of the hook entries with code that will insert into the order array. Any problems with identifying the correct
+    #hook entries will result in the order array being incorrect
+    src = <<eof
+//HOOK_ENTRY[first] {}
+//HOOK_ENTRY[foo] {"foos": ["a", "b", "c"]}
+//HOOK_ENTRY[bar] {"name": "los"}
+//HOOK_ENTRY[world] {"name": "los"}
+//HOOK_ENTRY[test] {"name": "los"}
+//HOOK_ENTRY[test2] {"name": "los2"}
+//HOOK_ENTRY[hello] {"foos": ["a"]}
+//HOOK_ENTRY[foo4] {"foos": ["a", "b", "c"]}
+//HOOK_ENTRY[foo6] {"world": ["a", "b", "c"], "test": ["bar"]}
+//HOOK_ENTRY[foo5] {}
+//HOOK_ENTRY[foo6] {"world": ["a", "b", "c"]}
+eof
+
+    #Create a new manifest which we will add all of our entries to
+    manifest = Flok::HooksManifest.new
+
+    ################################################################################
+    #Now we add some manifest entries to help process the above source
+    ################################################################################
+
+    manifest << Flok::HooksManifestEntry.new("first") {|params| next "1st"} #HOOK_ENTRY[first]
+    manifest << Flok::HooksManifestEntry.new("*", ->(p){p["foos"] and p["foos"].include? "b"}) {|params| next "2nd"} #'foos' containing 'b'
+    manifest << Flok::HooksManifestEntry.new("*", ->(p){p["name"] == "los" }) {|params| next "3rd"} #'name' == 'los'
+    manifest << Flok::HooksManifestEntry.new("test2", ->(p){p["name"] == "los2"}) {|params| next "4th"} #HOOK_ENTRY[test2] where 'name' == 'los'
+    manifest << Flok::HooksManifestEntry.new("*", ->(p){p["foos"] and p["foos"].include? "a"}) {|params| next "5th"} #'foos' containing 'a'
+    manifest << Flok::HooksManifestEntry.new("*", [->(p){p["world"] and p["world"].include? "a"}, ->(p){p["test"] and p["test"].include? "bar"}]) {|params| next "6th"} #'world' contains 'a' && 'test' contains 'bar'
+
+    #Process the src line-by-line with the manifesct
+    output_src = src.split("\n").map{|e| manifest.transform_line(e)}
+
+    expect(output_src.join("\n") + "\n").to eq(<<eof
+1st
+2nd
+5th
+3rd
+3rd
+3rd
+4th
+5th
+2nd
+5th
+6th
+//HOOK_ENTRY[foo5] {}
+//HOOK_ENTRY[foo6] {"world": ["a", "b", "c"]}
+eof
+)
+  end
+
+  it "Can use the HooksManifest & HooksManifestEntry to properly retrieve the correct set of parameters in the code block" do
+    #Here we are not testing the actual selection of proper hooks, but checking that once we have a selection
+    #does the code generator block get the correct static parameters? Specific parameters are tested in seperate
+    #tests for each hook
+    src = <<eof
+//HOOK_ENTRY[foo] {"foos": ["a", "b", "c"], "hello": "world"}
+eof
+
+    #Create a new manifest which we will add all of our entries to
+    manifest = Flok::HooksManifest.new
+
+    #Now we add our manifest entry that we will check parameters on
+    did_get = false
+    manifest << Flok::HooksManifestEntry.new("foo") do |params| 
+      did_get = true
+      expect(params.to_json).to eq({"foos" => ["a", "b", "c"], "hello" => "world"}.to_json)
+    end
+
+    #Process the src line-by-line with the manifesct
+    output_src = src.split("\n").map{|e| manifest.transform_line(e)}
+
+    #Make sure we actually triggered on the entry
+    expect(did_get).to eq(true)
+  end
+
+  it "Can hook the controller_will_goto event with the correct hook entry information and has the variables mentioned in the docs" do
+    info = flok_new_user_with_src File.read('./spec/kern/assets/hook_entry_points/controller0a.rb')
+    src = info[:src]
+    ctx = info[:ctx]
+
+    manifest = Flok::HooksManifest.new
+    will_gotos_found = 0
+    from_to_action_pairs_found = []
+    entry = Flok::HooksManifestEntry.new("controller_will_goto") do |hook_info|
+      will_gotos_found += 1
+      #Static parameters
+      expect(hook_info["controller_name"]).to eq("my_controller")
+      expect(hook_info["might_respond_to"].to_set).to eq(["foo", "hello", "test"].to_set)
+      from_to_action_pairs_found << {hook_info["from_action"] => hook_info["to_action"]}
+
+      #actions_responds_to looks like {"action1" => ["event_a", ..."], "action2" => }...
+      #where each action list contains all the events this action responds to
+      expect(hook_info["actions_responds_to"]).to eq({"index" => ["hello", "foo"], "other" => ["test"]})
+
+      #Variables included
+      next %{
+        entry_params = {
+          old_action: old_action,
+          new_action: __info__.action,
+        };
+      }
+    end
+    manifest << entry
+
+    #Recompile source (We do this manually as we supplied no `config/hooks.rb` file)
+    src = Flok::HooksCompiler.compile src, manifest
+    
+    #Expect to have found two will_goto entries given that there is one Goto request
+    #and one implicit Goto from the entry
+    expect(will_gotos_found).to eq(2)
+
+    #Expect to have gotten all the goto to/from action pairs
+    expect(from_to_action_pairs_found.to_set).to eq([{"other" => "index"}, {"choose_action" => "index"}].to_set)
+
+    #Re-evaluate the v8 instance
+    ctx = v8_flok
+    ctx.eval src
+
+    #Now load the controller
+    dump = ctx.evald %{
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+
+      dump.entry_params = entry_params;
+    }
+
+    #Verify the parametrs were set
+    expect(dump["entry_params"]).not_to eq(nil)
+    expect(dump["entry_params"]["old_action"]).to eq("choose_action")
+    expect(dump["entry_params"]["new_action"]).to eq("index")
+  end
+end

data/spec/kern/hook_user_generators_spec.rb

@@ -0,0 +1,139 @@
+#Relating to the conversion of the user's ./config/hooks.rb file into the equivalent HooksManifestEntrie(s) (This may cross-over into
+#the HooksCompiler itself because we need to test side-effects)
+
+Dir.chdir File.join File.dirname(__FILE__), '../../'
+require './spec/env/kern.rb'
+require './spec/lib/helpers.rb'
+require './spec/lib/io_extensions.rb'
+require './spec/lib/rspec_extensions.rb'
+require './lib/flok/hooks_compiler.rb'
+require 'zlib'
+
+RSpec.describe "kern:hook_user_geenrators_spec" do
+  include Zlib
+  include_context "kern"
+
+  it "Can use the :goto hook generator for all controllers (no matchers)" do
+    hooks_src = %{
+      hook :goto => :goto do
+        #Select all
+      end
+    }
+
+    #Just expect this not to blow up
+    info = flok_new_user_with_src File.read('./spec/kern/assets/hook_entry_points/controller0.rb'), nil, nil, hooks_src
+    ctx = info[:ctx]
+
+    #Run the embed function
+    ctx.evald %{
+      dump.base = _embed("my_controller", 0, {}, null); // Embed the controller
+      int_dispatch([]);                                 // Dispatch any events the are pending
+    }
+
+    #We should have sent out an event for the hook event twice as we have two controllers
+    @driver.ignore_up_to("if_hook_event", 0)
+    @driver.get "if_hook_event", 0
+    @driver.ignore_up_to("if_hook_event", 0)
+  end
+
+  it "Can use the :goto hook generator for a specific controller (by name) and receives a hook event" do
+    #Hook source code
+    hooks_src = %{
+      hook :goto => :goto do
+        controller "my_controller"
+      end
+    }
+
+    #Just expect this not to blow up
+    info = flok_new_user_with_src File.read('./spec/kern/assets/hook_entry_points/controller0.rb'), nil, nil, hooks_src
+    ctx = info[:ctx]
+
+    #Run the embed function
+    ctx.evald %{
+      dump.base = _embed("my_controller", 0, {}, null); // Embed the controller
+      int_dispatch([]);                                 // Dispatch any events the are pending
+    }
+
+    @driver.ignore_up_to("if_hook_event", 0); @driver.get "if_hook_event", 0 #We should have sent out an event for the hook event
+    expect { @driver.ignore_up_to("if_hook_event", 0) }.to raise_error(/Waited for/)  # At this point, we should have not received any events for if_hook_event, as we are not selecting the embedded controller
+  end
+
+  it "Can use the :goto hook generator for a controller with the to_action_responds_to constraint for various actions" do
+    #Hook source code
+    hooks_src = %{
+      hook :goto => :goto do
+        to_action_responds_to? "back_clicked"
+      end
+    }
+
+    #Get a new js context with the controllers source and the hooks source
+    info = flok_new_user_with_src File.read('./spec/kern/assets/hook_entry_points/controller0.rb'), nil, nil, hooks_src
+    File.write File.expand_path("~/Downloads/src.txt"), info[:src]
+    ctx = info[:ctx]
+
+    #Run the embed function
+    dump = ctx.evald %{
+      dump.base = _embed("my_controller", 0, {}, null);         // Embed the controller
+      int_dispatch([]);                                         // Dispatch any events the are pending
+      dump.my_other_controller_base = my_other_controller_base; // Grab the base address of 'my_other_controller'
+    }
+
+    #The index of my_other_controller contains the back_clicked event, 
+    #and since this is embedded in the my_controller's index, this should have created an event
+    @driver.ignore_up_to("if_hook_event", 0)
+    event = @driver.get "if_hook_event", 0
+
+    #Now we switch to an action that dosen't contain a back_clicked event for my_other_controller, so it shouldn't have triggered any hook event
+    @driver.int "int_event", [ dump["my_other_controller_base"], "back_clicked", {} ] 
+    expect { @driver.ignore_up_to("if_hook_event", 0) }.to raise_error(/Waited for/)
+
+    #Now we switch to the 3rd action which still contains no back_clicked
+    @driver.int "int_event", [ dump["my_other_controller_base"], "next_clicked", {} ]
+    expect { @driver.ignore_up_to("if_hook_event", 0) }.to raise_error(/Waited for/)
+
+    #Now we switch to the 4th action which *does* contains a back_clicked
+    @driver.int "int_event", [ dump["my_other_controller_base"], "next_clicked", {} ]
+    expect { @driver.ignore_up_to("if_hook_event", 0); @driver.get "if_hook_event", 0 }.not_to raise_error
+  end
+
+  it "Can use the :goto hook generator for a controller with the from_action_responds_to constraint for various actions" do
+    #Hook source code
+    hooks_src = %{
+      hook :goto => :goto do
+        from_action_responds_to? "back_clicked"
+      end
+    }
+
+    #Get a new js context with the controllers source and the hooks source
+    info = flok_new_user_with_src File.read('./spec/kern/assets/hook_entry_points/controller0.rb'), nil, nil, hooks_src
+    File.write File.expand_path("~/Downloads/src.txt"), info[:src]
+    ctx = info[:ctx]
+
+    #Run the embed function
+    dump = ctx.evald %{
+      dump.base = _embed("my_controller", 0, {}, null);         // Embed the controller
+      int_dispatch([]);                                         // Dispatch any events the are pending
+      dump.my_other_controller_base = my_other_controller_base; // Grab the base address of 'my_other_controller'
+    }
+
+    #Although the first action has a 'back_clicked', it is going to it so this shouldn't have raised an event
+    expect { @driver.ignore_up_to("if_hook_event", 0) }.to raise_error(/Waited for/)
+
+    #Now we switch to an action and our last action contained a back click
+    @driver.int "int_event", [ dump["my_other_controller_base"], "back_clicked", {} ] 
+    expect { @driver.ignore_up_to("if_hook_event", 0); @driver.get "if_hook_event", 0 }.not_to raise_error
+
+    #Now we switch to the 3rd action and the last action didn't contain a back clicke
+    @driver.int "int_event", [ dump["my_other_controller_base"], "next_clicked", {} ]
+    expect { @driver.ignore_up_to("if_hook_event", 0) }.to raise_error(/Waited for/)
+
+    #Now we switch to the 4th action and the last action did not contain a back click
+    @driver.int "int_event", [ dump["my_other_controller_base"], "next_clicked", {} ]
+    expect { @driver.ignore_up_to("if_hook_event", 0) }.to raise_error(/Waited for/)
+
+    #Now we switch to the 2nd action and the last action had a back clicked
+    @driver.int "int_event", [ dump["my_other_controller_base"], "back_clicked", {} ]
+    expect { @driver.ignore_up_to("if_hook_event", 0); @driver.get "if_hook_event", 0 }.not_to raise_error
+  end
+
+end