flok 0.0.102 → 0.0.103

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

@@ -14,13 +14,17 @@ controller :my_controller do
     }
 
     on "hello", %{
-      var x = 3;
+      Goto("other");
     }
 
     my_macro
   end
 
   action :other do
+    on_entry %{
+      Embed("new_controller", "hello", {});
+    }
+
     on "test", %{
     }
   end
@@ -56,3 +60,11 @@ controller :my_other_controller do
     }
   end
 end
+
+controller :new_controller do
+  action :index do
+    on_entry %{
+      new_controller_base = __base__;
+    }
+  end
+end

data/spec/kern/assets/push_count.rb

@@ -0,0 +1,42 @@
+#1. If we're in home, we should just raise back_clicked
+#2. If we're in home, and push about, then we should pop
+#3. If we're in about (start), then we should raise back_clicked
+controller :my_controller do
+  macro :nav do
+    on "back_clicked", %{
+      if (push_count === 0) {
+        raised_back = true;
+      } else {
+        did_pop = true;
+      }
+    }
+  end
+
+  choose_action do
+    on_entry %{
+      if (context.starts_in_about) {
+        Goto("about");
+      } else {
+        Goto("home");
+      }
+    }
+  end
+
+  action :home do
+    on "about_clicked", %{
+      Push("about");
+    }
+    nav
+  end
+
+  #Don't use macro here to test inside of a function
+  action :about do
+    on "back_clicked", %{
+      if (push_count === 0) {
+        raised_back = true;
+      } else {
+        did_pop = true;
+      }
+    }
+  end
+end

data/spec/kern/controller_spec.rb

@@ -1001,4 +1001,38 @@ RSpec.describe "kern:controller_spec" do
     @driver.mexpect("if_event", [Integer, "action", {"from" => "home", "to" => "about"}])
     @driver.mexpect("if_event", [Integer, "action", {"from" => "about", "to" => "home"}])
   end
+
+  it "Does support using an action & macro that contains push_count" do
+    #1. If we're in home, we should just raise back_clicked
+    ctx = flok_new_user File.read('./spec/kern/assets/push_count.rb')
+    dump = ctx.evald %{
+      base = _embed("my_controller", 0, {}, null);
+
+      int_dispatch([3, "int_event", base, "back_clicked", {}]);
+    }
+    raised_back = ctx.eval("raised_back")
+    expect(raised_back).to eq(true)
+
+
+    #2. If we're in home, and push about, then we should pop
+    ctx = flok_new_user File.read('./spec/kern/assets/push_count.rb')
+    dump = ctx.evald %{
+      base = _embed("my_controller", 0, {}, null);
+
+      int_dispatch([3, "int_event", base, "about_clicked", {}]);
+      int_dispatch([3, "int_event", base, "back_clicked", {}]);
+    }
+    did_pop = ctx.eval("did_pop")
+    expect(did_pop).to eq(true)
+
+    #3. If we're in about (start), then we should raise back_clicked
+    ctx = flok_new_user File.read('./spec/kern/assets/push_count.rb')
+    dump = ctx.evald %{
+      base = _embed("my_controller", 0, {starts_in_about: true}, null);
+
+      int_dispatch([3, "int_event", base, "back_clicked", {}]);
+    }
+    raised_back = ctx.eval("raised_back")
+    expect(raised_back).to eq(true)
+  end
 end

data/spec/kern/find_view_spec.rb

@@ -0,0 +1,269 @@
+#Specifically about the find_view releated (selector) functions
+
+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'
+
+RSpec.describe "kern:find_view_spec" do
+  include_context "kern"
+
+  it "Can call the find_view function" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller0.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    base = ctx.eval("base")
+  end
+
+  it "The find_view returns the sub-controller's named basepointer" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller0.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller2_base = ctx.eval("JSON.stringify(my_controller2_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller2_base.to_i
+    }.to_json)
+  end
+
+  it "The find_view can return two subviews of different spots" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller1.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller2_base = ctx.eval("JSON.stringify(my_controller2_base)")
+    my_controller3_base = ctx.eval("JSON.stringify(my_controller3_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller2_base.to_i,
+      "foo2" => my_controller3_base.to_i
+    }.to_json)
+  end
+
+  it "The find_view can return two subviews of different spots at different points in the hierarchy" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller1a.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller2_base = ctx.eval("JSON.stringify(my_controller2_base)")
+    my_controller3_base = ctx.eval("JSON.stringify(my_controller3_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller2_base.to_i,
+      "foo2" => my_controller3_base.to_i
+    }.to_json)
+  end
+
+
+  it "The find_view can return an immediate ." do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller2.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller2_base = ctx.eval("JSON.stringify(my_controller2_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller2_base.to_i,
+    }.to_json)
+  end
+
+  it "The find_view can return a concrete nested followed by a ." do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller3.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller3_base = ctx.eval("JSON.stringify(my_controller3_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller3_base.to_i,
+    }.to_json)
+  end
+
+  it "The find_view can return a . followed by a concrete nested" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller4.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller3_base = ctx.eval("JSON.stringify(my_controller3_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller3_base.to_i,
+    }.to_json)
+  end
+
+
+  it "The find_view can return a + followed by a concrete nested for 4 views" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller5.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller4_base = ctx.eval("JSON.stringify(my_controller4_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller4_base.to_i,
+    }.to_json)
+  end
+
+  it "The find_view can return a + followed by a concrete nested for 3 views" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller6.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller3_base = ctx.eval("JSON.stringify(my_controller3_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller3_base.to_i,
+    }.to_json)
+  end
+
+  it "The find_view can return a + followed by a . match" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller7.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller3_base = ctx.eval("JSON.stringify(my_controller3_base)")
+
+    expect(find_view_res).to eq({
+      "foo" => my_controller3_base.to_i,
+    }.to_json)
+  end
+
+  it "The find_view can return a . followed by + followed by a . match" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller8.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller2_base = ctx.eval("JSON.stringify(my_controller2_base)")
+    my_controller4_base = ctx.eval("JSON.stringify(my_controller4_base)")
+
+    expect(find_view_res).to eq({
+      "foo1" => my_controller2_base.to_i,
+      "foo2" => my_controller4_base.to_i,
+    }.to_json)
+  end
+
+  it "The find_view can return a . . followed by + followed by a . match" do
+    #Compile the controller
+    ctx = flok_new_user File.read('./spec/kern/assets/find_view/controller9.rb')
+
+    #Run the embed function
+    ctx.eval %{
+      //Call embed on main root view
+      base = _embed("my_controller", 0, {}, null);
+
+      //Drain queue
+      int_dispatch([]);
+    }
+
+    find_view_res = ctx.eval("JSON.stringify(find_view_res)")
+    my_controller3_base = ctx.eval("JSON.stringify(my_controller3_base)")
+    my_controller5_base = ctx.eval("JSON.stringify(my_controller5_base)")
+
+    expect(find_view_res).to eq({
+      "foo1" => my_controller3_base.to_i,
+      "foo2" => my_controller5_base.to_i,
+    }.to_json)
+  end
+
+end

data/spec/kern/hook_entry_points_and_manifest_spec.rb

@@ -152,4 +152,64 @@ eof
     expect(dump["entry_params"]["old_action"]).to eq("choose_action")
     expect(dump["entry_params"]["new_action"]).to eq("index")
   end
+
+  it "Can hook the controller_did_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_did_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

@@ -136,4 +136,104 @@ RSpec.describe "kern:hook_user_geenrators_spec" do
     expect { @driver.ignore_up_to("if_hook_event", 0); @driver.get "if_hook_event", 0 }.not_to raise_error
   end
 
+  it "Can use goto to embed a pre and post selectors which will be returned in the hooking response" do
+    #Hook source code
+    hooks_src = %{
+      hook :goto => :goto do
+        controller "my_controller"
+        to_action_responds_to? "test"
+
+        before_views({
+          "." => {
+            "__leaf__" => "foo"
+          }
+        })
+
+        after_views({
+          "new_controller" => {
+            "__leaf__" => "foo2"
+          }
+        })
+
+      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
+    }
+
+
+    my_other_controller_base = ctx.eval("my_other_controller_base")
+    on_entry_base_pointer = ctx.eval("on_entry_base_pointer")
+
+    #Now we switch to an action and our last action contained a back click
+    @driver.int "int_event", [ on_entry_base_pointer, "hello", {} ] 
+    new_controller_base = ctx.eval("new_controller_base")
+
+    @driver.ignore_up_to("if_hook_event", 0)
+    hook_res = @driver.get "if_hook_event", 0
+
+    expect(hook_res[1]).to eq({
+      "views" => {
+        "foo" => my_other_controller_base,
+        "foo2" => new_controller_base
+      }
+    })
+  end
+
+  it "The goto does not free views via the module until after the completion event is received" do
+    #Hook source code
+    hooks_src = %{
+      hook :goto => :goto do
+        controller "my_controller"
+        to_action_responds_to? "test"
+      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
+    }
+
+
+    my_other_controller_base = ctx.eval("my_other_controller_base")
+    on_entry_base_pointer = ctx.eval("on_entry_base_pointer")
+
+    #Now we switch to an action and our last action contained a back click
+    @driver.int "int_event", [ on_entry_base_pointer, "hello", {} ] 
+    new_controller_base = ctx.eval("new_controller_base")
+
+    #Should not receive a free view here because we have not sent the completion handler back
+    expect {
+      @driver.ignore_up_to("if_free_view", 0)
+    }.to raise_error /Waited/
+
+    @driver.ignore_up_to("if_hook_event", 0)
+    hook_res = @driver.get "if_hook_event", 0
+
+    #We need to have a 'completion' tele-pointer to signal back
+    cep = hook_res[1]["cep"]
+    expect(cep).not_to eq(nil)
+
+    #Now we send the completion event
+    @driver.int "int_event", [cep, "", {}]
+
+    #Now we should have received our free views
+    @driver.ignore_up_to("if_free_view", 0)
+    free_view = @driver.get "if_free_view", 0
+    expect(free_view).to eq([
+      my_other_controller_base+1
+    ])
+  end
 end