flok 0.0.103 → 0.0.105

data/lib/flok/hooks_compiler.rb

@@ -6,12 +6,15 @@ module Flok
   module HooksCompiler
     #Returns a new copy of the source transformed as described by the manifest
     def self.compile(src, manifest)
+      puts "a0"
       new_src = src.split("\n").map{|e| manifest.transform_line(e) }.join("\n")
 
       #Re-process macros
+      puts "a1"
       new_src = Flok.macro_process new_src
 
 
+      puts "a2"
       return new_src
     end
   end
@@ -28,13 +31,16 @@ module Flok
     #be inserted there, this will return the inserted code (which may then be multiple lines)
     #And will also remove the comment itself
     def transform_line line
+      puts "a3"
       #Get all the matched HooksManifestEntry(s) 
       injected_code = @manifest_entries.select{|e| e.does_match? line}.map{|e| e.code_for_line(line)}
 
+      puts "an"
       #If there is a match of at least one hook, remove the original line and replace it
       #with all the newly found code from the HooksManifestEntry(s)
       return injected_code.join("\n") if injected_code.count > 0
 
+      puts "a4"
       #Else, nothing was found, keep moving along and don't transform the line
       return line
     end

data/lib/flok/user_compiler.rb

@@ -184,12 +184,12 @@ module Flok
             __info__.action = "#{action_name}";
 
             var __free_asap = true;
-            //HOOK_ENTRY[controller_will_goto] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "to_action" => action_name}.to_json}
+            //HOOK_ENTRY[controller_will_goto] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "to_action" => action_name, "handling_event_named" => @handling_event_named}.to_json}
 
             //If views are configured to not free right away, set up a new stack of views to free
             //This is usually picked up by the hook GOTO
             if (__free_asap === false) {
-              var views_to_free_id = gen_id();
+              var views_to_free_id = tels(1);
               views_to_free[views_to_free_id] = views_to_free[views_to_free_id] || [];
             }
 
@@ -237,7 +237,7 @@ module Flok
             //located in ctable
             __info__.cte.actions[__info__.action].on_entry(__base__)
 
-            //HOOK_ENTRY[controller_did_goto] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "to_action" => action_name}.to_json}
+            //HOOK_ENTRY[controller_did_goto] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "to_action" => action_name, "handling_event_named" => @handling_event_named}.to_json}
             //'choose_action' pseudo-action will be sent as 'null' as it's the initial state
             if (old_action === "choose_action") {
               old_action = null;
@@ -269,6 +269,9 @@ module Flok
 
             __info__.action = "#{action_name}";
 
+            //HOOK_ENTRY[controller_will_push] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "to_action" => action_name, "handling_event_named" => @handling_event_named}.to_json}
+
+
             //Prep embeds array, embeds[0] refers to the spot bp+2 (bp is vc, bp+1 is main)
             __info__.embeds = [];
             for (var i = 1; i < #{@controller.spots.count}; ++i) {
@@ -279,6 +282,8 @@ module Flok
             //located in ctable
             __info__.cte.actions[__info__.action].on_entry(__base__)
 
+            //HOOK_ENTRY[controller_did_push] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "to_action" => action_name, "handling_event_named" => @handling_event_named}.to_json}
+
             //Send off event for action change
             main_q.push([3, "if_event", __base__, "action", {
               from: old_action,
@@ -303,6 +308,16 @@ module Flok
             //Save the old action
             //var old_action = __info__.action;
 
+            var __free_asap = true;
+            //HOOK_ENTRY[controller_will_pop] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "handling_event_named" => @handling_event_named}.to_json}
+
+            //If views are configured to not free right away, set up a new stack of views to free
+            //This is usually picked up by the hook GOTO
+            if (__free_asap === false) {
+              var views_to_free_id = tels(1);
+              views_to_free[views_to_free_id] = views_to_free[views_to_free_id] || [];
+            }
+
             //Restore the action we pushed from
             __info__.action = orig_action;
 
@@ -312,7 +327,12 @@ module Flok
             for (var i = 0; i < __info__.embeds.length; ++i) {
               for (var j = 0; j < __info__.embeds[i].length; ++j) {
                 //Free +1 because that will be the 'main' view
-                main_q.push([1, "if_free_view", embeds[i][j]+1]);
+                //Free if 'free_asap' is not set, this is usually configured via the 'goto' hook
+                if (__free_asap === true) {
+                  main_q.push([1, "if_free_view", embeds[i][j]+1]);
+                } else {
+                  views_to_free[views_to_free_id].push(embeds[i][j]+1);
+                }
 
                 //Call dealloc on the controller
                 tel_deref(embeds[i][j]).cte.__dealloc__(embeds[i][j]);
@@ -321,6 +341,9 @@ module Flok
 
             //Restore embeds
             __info__.embeds = orig_embeds;
+
+            //HOOK_ENTRY[controller_did_pop] #{{"controller_name" => @controller.name, "might_respond_to" => @ctx.might_respond_to, "actions_responds_to" => @ctx.actions_respond_to, "from_action" => @name, "handling_event_named" => @handling_event_named}.to_json}
+
           }
 
           out.puts res
@@ -580,7 +603,12 @@ module Flok
       #prior-knowledge of controller-level information like all possible events in all actions for hooks
       unless @__ons_did_build
         @__ons_did_build = true
-        @__ons = @_ons.map{|e| {:name => e[:name], :src => _macro(e[:src])}}
+        @__ons = @_ons.map do |e|
+          @handling_event_named = e[:name]
+          src = _macro(e[:src])
+          @handling_event_named = nil
+          {:name => e[:name], :src => src}
+        end
       end
 
       @__ons_is_building = false

data/lib/flok/user_hook_generators/goto.rb

@@ -1,5 +1,3 @@
-require_relative 'helpers'
-
 module Flok
   class GotoHooksDSLEnv
     attr_accessor :selectors, :before_view_spider, :after_view_spider
@@ -34,6 +32,13 @@ module Flok
       end
     end
 
+    def triggered_by event_name
+      @selectors << lambda do |params|
+        handling_event_named = params["handling_event_named"]
+        next handling_event_named == event_name
+      end
+    end
+
     def to_action_responds_to? responds
       @selectors << lambda do |params|
         to_action = params["to_action"]
@@ -51,6 +56,23 @@ module Flok
         next false
       end
     end
+
+    def to_action *names
+      @selectors << lambda do |params|
+        to_action = params["to_action"]
+
+        next names.include? to_action
+      end
+    end
+
+    def from_action *names
+      @selectors << lambda do |params|
+        from_action = params["from_action"]
+
+        next names.include? from_action
+      end
+    end
+
     #################################################################################
 
     def before_views spider
@@ -85,7 +107,7 @@ module Flok
     manifest << HooksManifestEntry.new("controller_did_goto", dsl_env.selectors) do |entry_hook_params|
       next %{
         //The completion callback will share a pointer to the views_to_free key index
-        reg_evt(views_to_free_id, hook_goto_completion_cb);
+        reg_evt(views_to_free_id, hook_completion_cb);
 
         var #{ns}_after_views = find_view(__base__, #{dsl_env.after_view_spider.to_json});
         var #{ns}_info = {

data/lib/flok/user_hook_generators/pop.rb

@@ -0,0 +1,99 @@
+module Flok
+  class PopHooksDSLEnv
+    attr_accessor :selectors, :before_view_spider, :after_view_spider
+
+    def initialize
+      @selectors = []
+      @before_view_spider = {}
+      @after_view_spider = {}
+    end
+
+    def controller name
+      @selectors << ->(p) { p["controller_name"] and p["controller_name"] == name.to_s }
+    end
+
+    #The previous / next action contains an event handler for...
+    #################################################################################
+    def from_action_responds_to? responds
+      @selectors << lambda do |params|
+        from_action = params["from_action"]
+        actions_respond_to = params["actions_responds_to"] #This is a hash that maps all actions to sensetivity lists
+
+        #Get the sensetivity list if possible for this action (this is the list of events this action responds to)
+        if actions_respond_to[from_action]
+          sensetivity_list = actions_respond_to[from_action]
+
+          #Does the sensetivity list include the event we are interested in?
+          next sensetivity_list.include? responds
+        end
+
+        #The action wasn't even listed on the list, i.e. it has no sensetivity list
+        next false
+      end
+    end
+
+    def from_action *names
+      @selectors << lambda do |params|
+        from_action = params["from_action"]
+
+        next names.include? from_action
+      end
+    end
+
+    def triggered_by event_name
+      @selectors << lambda do |params|
+        handling_event_named = params["handling_event_named"]
+        next handling_event_named == event_name
+      end
+    end
+
+
+    #################################################################################
+
+    def before_views spider
+      @before_view_spider = spider
+    end
+
+    def after_views spider
+      @after_view_spider = spider
+    end
+  end
+
+  UserHooksToManifestOrchestrator.register_hook_gen :pop do |manifest, params|
+    hook_event_name = params[:hook_event_name]
+
+    #Evaluate User given DSL (params[:block]) which comes from `./confg/hooks.rb`
+    #to retrieve a set of selectors which we will pass the hooks compiler
+    block = params[:block]
+    dsl_env = PopHooksDSLEnv.new
+    dsl_env.instance_eval(&block)
+
+    ns = "_#{SecureRandom.hex[0..5]}"
+
+    #Inject into HOOK_ENTRY[controller_will_pop] that match the given selectors from the DSL
+    #based on the hook entry static parameters
+    manifest << HooksManifestEntry.new("controller_will_pop", dsl_env.selectors) do |entry_hook_params|
+      next %{
+        var #{ns}_before_views = find_view(__base__, #{dsl_env.before_view_spider.to_json});
+        __free_asap = false;
+      }
+    end
+
+    manifest << HooksManifestEntry.new("controller_did_pop", dsl_env.selectors) do |entry_hook_params|
+      next %{
+        //The completion callback will share a pointer to the views_to_free key index
+        reg_evt(views_to_free_id, hook_completion_cb);
+
+        var #{ns}_after_views = find_view(__base__, #{dsl_env.after_view_spider.to_json});
+        var #{ns}_info = {
+          views: #{ns}_after_views,
+          cep: views_to_free_id
+        };
+        for (var k in #{ns}_before_views) {
+          #{ns}_info.views[k] = #{ns}_before_views[k];
+        }
+        SEND("main", "if_hook_event", "#{hook_event_name}", #{ns}_info);
+      }
+    end
+  end
+end

data/lib/flok/user_hook_generators/push.rb

@@ -0,0 +1,119 @@
+module Flok
+  class PushHooksDSLEnv
+    attr_accessor :selectors, :before_view_spider, :after_view_spider
+
+    def initialize
+      @selectors = []
+      @before_view_spider = {}
+      @after_view_spider = {}
+    end
+
+    def controller name
+      @selectors << ->(p) { p["controller_name"] and p["controller_name"] == name.to_s }
+    end
+
+    #The previous / next action contains an event handler for...
+    #################################################################################
+    def from_action_responds_to? responds
+      @selectors << lambda do |params|
+        from_action = params["from_action"]
+        actions_respond_to = params["actions_responds_to"] #This is a hash that maps all actions to sensetivity lists
+
+        #Get the sensetivity list if possible for this action (this is the list of events this action responds to)
+        if actions_respond_to[from_action]
+          sensetivity_list = actions_respond_to[from_action]
+
+          #Does the sensetivity list include the event we are interested in?
+          next sensetivity_list.include? responds
+        end
+
+        #The action wasn't even listed on the list, i.e. it has no sensetivity list
+        next false
+      end
+    end
+
+    def to_action_responds_to? responds
+      @selectors << lambda do |params|
+        to_action = params["to_action"]
+        actions_respond_to = params["actions_responds_to"] #This is a hash that maps all actions to sensetivity lists
+
+        #Get the sensetivity list if possible for this action (this is the list of events this action responds to)
+        if actions_respond_to[to_action]
+          sensetivity_list = actions_respond_to[to_action]
+
+          #Does the sensetivity list include the event we are interested in?
+          next sensetivity_list.include? responds
+        end
+
+        #The action wasn't even listed on the list, i.e. it has no sensetivity list
+        next false
+      end
+    end
+
+    def to_action *names
+      @selectors << lambda do |params|
+        to_action = params["to_action"]
+
+        next names.include? to_action
+      end
+    end
+
+    def from_action *names
+      @selectors << lambda do |params|
+        from_action = params["from_action"]
+
+        next names.include? from_action
+      end
+    end
+
+    def triggered_by event_name
+      @selectors << lambda do |params|
+        handling_event_named = params["handling_event_named"]
+        next handling_event_named == event_name
+      end
+    end
+
+    #################################################################################
+
+    def before_views spider
+      @before_view_spider = spider
+    end
+
+    def after_views spider
+      @after_view_spider = spider
+    end
+  end
+
+  UserHooksToManifestOrchestrator.register_hook_gen :push do |manifest, params|
+    hook_event_name = params[:hook_event_name]
+
+    #Evaluate User given DSL (params[:block]) which comes from `./confg/hooks.rb`
+    #to retrieve a set of selectors which we will pass the hooks compiler
+    block = params[:block]
+    dsl_env = PushHooksDSLEnv.new
+    dsl_env.instance_eval(&block)
+
+    ns = "_#{SecureRandom.hex[0..5]}"
+
+    #Inject into HOOK_ENTRY[controller_will_push] that match the given selectors from the DSL
+    #based on the hook entry static parameters
+    manifest << HooksManifestEntry.new("controller_will_push", dsl_env.selectors) do |entry_hook_params|
+      next %{
+        var #{ns}_before_views = find_view(__base__, #{dsl_env.before_view_spider.to_json});
+      }
+    end
+
+    manifest << HooksManifestEntry.new("controller_did_push", dsl_env.selectors) do |entry_hook_params|
+      next %{
+        var #{ns}_after_views = find_view(__base__, #{dsl_env.after_view_spider.to_json});
+        var #{ns}_info = {
+          views: #{ns}_after_views
+        };
+        for (var k in #{ns}_before_views) {
+          #{ns}_info.views[k] = #{ns}_before_views[k];
+        }
+        SEND("main", "if_hook_event", "#{hook_event_name}", #{ns}_info);
+      }
+    end
+  end
+end

data/lib/flok/version.rb

@@ -1,3 +1,3 @@
 module Flok
-  VERSION = "0.0.103"
+  VERSION = "0.0.105"
 end

data/spec/iface/driver/about_spec.rb

@@ -0,0 +1,14 @@
+Dir.chdir File.join File.dirname(__FILE__), '../../../'
+require './spec/env/iface.rb'
+
+RSpec.describe "iface:driver:about" do
+  include_context "iface:driver"
+
+  it "supports about" do
+    @pipe.puts [[0, 0, "if_about_poll"]].to_json
+    res =  @pipe.readline
+    expect(res["platform"].class).to eq(String)
+    expect(res["language"].class).to eq(String)
+    expect(res["udid"].class).to eq(String)
+  end
+end

data/spec/iface/driver/net_spec.rb

@@ -65,7 +65,7 @@ RSpec.describe "iface:driver:net" do
       @ptr = rand(9999999)
       @pipe.puts [[1, 4, "if_net_req", "GET", "http://127.0.0.1:#{web.port}", {'secret' => @secret}, @ptr]].to_json
 
-      res = [3, "int_net_cb", @ptr, true, @secret2msg]
+      res = [3, "int_net_cb", @ptr, 200, @secret2msg]
       expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
     ensure
       web.kill
@@ -80,10 +80,99 @@ RSpec.describe "iface:driver:net" do
     matcher = proc do |x|
       x = JSON.parse(x)
       a = ->(e){e.class == String && e.length > 0} #Error message should be a string that's not blank
-      expect(x).to look_like [3, "int_net_cb", @ptr, false, a]
+      expect(x).to look_like [3, "int_net_cb", @ptr, -1, a]
       true
     end
 
     expect(@pipe).to readline_and_equal_proc_x_within_y_seconds(matcher, 5.seconds)
   end
+
+  it "Can call a network request with headers" do
+    begin
+      web = Webbing.get "/" do |params, headers|
+        expect(headers["content-type"]).to eq("json")
+        @hit = true
+        {}
+      end
+
+      @ptr = rand(9999999)
+      @pipe.puts [[1, 5, "if_net_req2", "GET", {"content-type" => "json"}, "http://127.0.0.1:#{web.port}", {}, @ptr]].to_json
+
+
+      #Wait for response
+      @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+      sleep 1
+
+      expect(@hit).to eq(true)
+    ensure
+      web.kill
+    end
+  end
+
+
+  it "Can call a network request with parameters and a header" do
+    begin
+      @secret = SecureRandom.hex
+      web = Webbing.get "/" do |params, headers|
+        @headers = headers
+        @rcv_secret = params['secret']
+        {}
+      end
+
+      @ptr = rand(9999999)
+      @pipe.puts [[1, 5, "if_net_req2", "GET", {"content-type" => "blah"}, "http://127.0.0.1:#{web.port}", {'secret' => @secret}, @ptr]].to_json
+
+      #Wait for response
+      @pipe.puts [[0, 0, "ping"]].to_json; @pipe.readline_timeout
+      sleep 2
+
+      expect(@rcv_secret).to eq(@secret)
+      expect(@headers["content-type"]).to eq(["blah"])
+    ensure
+      web.kill
+    end
+  end
+
+
+  it "Does send a network interupt int_net_cb with success and the correct payload with headers" do
+    begin
+      @secret = SecureRandom.hex
+      @secret2 = SecureRandom.hex
+      @secret2msg = {"secret2" => @secret2}
+      web = Webbing.get "/" do |params, headers|
+        $stderr.puts headers
+        expect(headers["content-type"]).to eq("json")
+        @rcv_secret = params['secret']
+
+        @secret2msg
+      end
+
+      #Wait for response
+      @ptr = rand(9999999)
+      @pipe.puts [[1, 5, "if_net_req2", "GET", {"content-type" => "json"}, "http://127.0.0.1:#{web.port}", {'secret' => @secret}, @ptr]].to_json
+
+      res = [3, "int_net_cb", @ptr, 200, @secret2msg]
+      expect(@pipe).to readline_and_equal_json_x_within_y_seconds(res, 5.seconds)
+    ensure
+      web.kill
+    end
+  end
+
+
+  it "Does send a network interupt int_net_cb with error and the correct payload and headers" do
+    #Wait for response
+      @ptr = rand(9999999)
+    @pipe.puts [[1, 5, "if_net_req2", "GET", {}, "http://no_such_url#{SecureRandom.hex}.com", {}, @ptr]].to_json
+
+    matcher = proc do |x|
+      x = JSON.parse(x)
+      a = ->(e){e.class == String && e.length > 0} #Error message should be a string that's not blank
+      expect(x).to look_like [3, "int_net_cb", @ptr, -1, a]
+      true
+    end
+
+    expect(@pipe).to readline_and_equal_proc_x_within_y_seconds(matcher, 5.seconds)
+  end
+
+
 end