flok 0.0.103 → 0.0.105

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d3dd5275337abe10712fa3347a698c60819ff78
-  data.tar.gz: e126f18d24e069176e485f6db5327c407dafad71
+  metadata.gz: cfece198a3be15554aab6d41361b5b222120ee89
+  data.tar.gz: b569fe8e0348b521274f81fdbb4fa270552ff7f3
 SHA512:
-  metadata.gz: baaa0fb3c2b68b3460e892d0f8d1c084e2d20eea45baaf29ff1ed8232bacd67cbd1aa0362a6fc725fd57be77519593c56021042c48d17a6b22c3b1d52ae2f1e3
-  data.tar.gz: ee1f06e6d0210adf94dbb9a7780945a4f9a9c37a1b39ac15d1b85512c2cecb678fdb064f9248da5406e49ccf9f5071383e32b7c60ceda860d86705cd93adc42e
+  metadata.gz: 1bdedc72f399bfb4184e18fe6273a2553e4103121ad42d0e86ee883a015b96419e7439e71b5cc909aa67d749a25e0947a028a71a3d9838b53b92e70dd2900e1f
+  data.tar.gz: 4723773078ca280a6916a7c9f7e12e3273e571972da4edc3fb159bedb0e288bafa3f28d2363befe79c264e92e7e119b67bb0aa6f54fcc2781c35d0908805b56e

data/app/drivers/chrome/config.yml

@@ -13,6 +13,7 @@ DEBUG:
     - rtc
     - hook
     - dlink
+    - about
   defines:
     - mem_pager
     - sockio_pager
@@ -29,6 +30,7 @@ RELEASE:
     - rtc
     - hook
     - dlink
+    - about
   defines:
     - mem_pager
     - sockio_pager

data/app/drivers/chrome/src/about.js

@@ -0,0 +1,14 @@
+
+function if_about_poll() {
+  var udid = localStorage.getItem("__flok_udid"); 
+  if (udid === null) {
+    udid = __flok_chrome_guid()
+    localStorage.setItem("__flok_udid", udid);
+  }
+
+  int_dispatch([1, "int_about_poll_cb", {
+    "platform": navigator.userAgent,
+    "language": navigator.language,
+    "udid": udid,
+  }]);
+}

data/app/drivers/chrome/src/guid.js

@@ -0,0 +1,9 @@
+function __flok_chrome_guid() {
+  function s4() {
+    return Math.floor((1 + Math.random()) * 0x10000)
+      .toString(16)
+      .substring(1);
+  }
+  return s4() + s4() + '-' + s4() + '-' + s4() + '-' +
+    s4() + '-' + s4() + s4() + s4();
+}

data/app/drivers/chrome/src/net.js

@@ -8,11 +8,33 @@ if_net_req = function(verb, url, params, tp_base) {
     method: verb,
     data: params,
     dataType: "json",
-    success: function(data) {
-      int_dispatch([3, "int_net_cb", tp_base, true, data]);
+    success: function(data, textStatus, xhr) {
+      int_dispatch([3, "int_net_cb", tp_base, xhr.status, data]);
     },
   error: function(xhr, textStatus, err) {
-    int_dispatch([3, "int_net_cb", tp_base, false, textStatus]);
+    int_dispatch([3, "int_net_cb", tp_base, -1, textStatus]);
   }
 })
 }
+
+//A basic get request that supports callbacks
+if_net_req2 = function(verb, headers, url, params, tp_base) {
+  $.ajax({
+    url: url,
+    method: verb,
+    data: params,
+    beforeSend: function (xhr) {
+      for (var name in headers) {
+        var value = headers[name];
+        xhr.setRequestHeader(name, value);
+      }
+    },
+    success: function(data, textStatus, xhr) {
+      int_dispatch([3, "int_net_cb", tp_base, xhr.status, data]);
+    },
+  error: function(xhr, textStatus, err) {
+    int_dispatch([3, "int_net_cb", tp_base, -1, textStatus]);
+  }
+})
+}
+

data/app/kern/mod/about.js

@@ -0,0 +1,19 @@
+__flok_platform = null;
+
+function int_about_poll_cb(info) {
+  __flok_platform = info.platform;
+  __flok_language = info.language;
+  __flok_udid = info.udid;
+}
+
+function get_platform() {
+  return __flok_platform;
+}
+
+function get_udid() {
+  return __flok_udid;
+}
+
+function get_language() {
+  return __flok_language;
+}

data/app/kern/mod/hook.js

@@ -1,5 +1,5 @@
-//goto hook generator expects this callback to be received usually for completion
-function hook_goto_completion_cb(ep, ename, info) {
+//goto hook generator expects this callback to be received usually for completion (goto & pop)
+function hook_completion_cb(ep, ename, info) {
   var views_to_free_id = ep;
   var our_views_to_free = views_to_free[ep];
 

data/app/kern/mod/udid.js

@@ -0,0 +1,9 @@
+__flok_udid = "<no-udid-set>";
+
+function int_udid_init(udid) {
+  __flok_udid = udid;
+}
+
+function get_udid() {
+  return __flok_udid;
+}

data/app/kern/services/rest.rb

@@ -1,19 +1,55 @@
 service :rest do
   global %{
-    rest_in_flight = {}
-
-    function rest_cb(tp, success, info) {
-      var e = rest_in_flight[tp];
-      var bp = e[0];
-      var path = e[1];
+    function rest_cb(tp, code, info) {
+      var e = rest_pending_requests[tp];
+      var bp = e.bp;
+      var path = e.path;
 
       int_event(bp, "rest_res", {
         path: path,
+        code: code,
         res: info
       });
 
       tel_del(tp);
+
+      if (code > 0) {
+        delete rest_pending_requests[tp];
+        delete rest_bp_to_tps[bp][tp];
+      } else {
+        failed_requests_tp.push(tp);
+      }
+    }
+
+    function rest_retry_failed() {
+      for (var i = 0; i < failed_requests_tp.length; ++i) {
+        var old_tp = failed_requests_tp[i];
+        var info = rest_pending_requests[old_tp];
+
+        if (info != null) {
+          //Make a new telepointer as old is no longer valid to net driver
+          var tp = tel_reg(rest_cb);
+          SEND("net", "if_net_req", info.verb, info.url, info.params, tp);
+
+          //Swap them out
+          rest_pending_requests[tp] = info;
+          rest_bp_to_tps[info.bp][tp] = true;
+          delete rest_pending_requests[old_tp];
+          delete rest_bp_to_tps[info.bp][old_tp];
+        }
+      }
+
+      failed_requests_tp = [];
     }
+
+    //Maps tp into enough information to make a request
+    var rest_pending_requests = {};
+
+    //Maps base-pointer into listing of current tele-pointers (disguised as an always true set for easy lookup)
+    //for that controller [Int:[Int:Bool]]
+    var rest_bp_to_tps = {};
+
+    var failed_requests_tp = [];
   }
 
   on_wakeup %{
@@ -23,6 +59,7 @@ service :rest do
   }
 
   on_connect %{
+    rest_bp_to_tps[bp] = [];
   }
 
   on "get", %{
@@ -37,10 +74,32 @@ service :rest do
     <% end %>
 
     var tp = tel_reg(rest_cb);
-    rest_in_flight[tp] = [bp, params.path];
-    SEND("net", "if_net_req", "GET", "<%= @options[:base_url] %>"+params.path, params.params, tp);
+    rest_bp_to_tps[bp].push(tp);
+    var url = "<%= @options[:base_url] %>"+params.path;
+
+    SEND("net", "if_net_req", "GET", url, params.params, tp);
+
+    rest_pending_requests[tp] = {
+      verb: "GET",
+      url: url,
+      params: params.params,
+      path: params.path,
+      bp: bp,
+    }
   }
 
   on_disconnect %{
+    //Get all active tele-pointers for this view and destroy them
+    //so we don't retry network requests
+    var tps = Object.keys(rest_bp_to_tps[bp]);
+    for (var i = 0; i < tps.length; ++i) {
+      delete rest_pending_requests[tps[i]];
+    }
+    delete rest_bp_to_tps[bp];
+  }
+
+  every 2.seconds, %{
+    //Re-try failed requests
+    rest_retry_failed();
   }
 end

data/bin/flok

@@ -36,6 +36,8 @@ class FlokCLI < Thor
       #1. Use the rake task
       system('rake build:world')
 
+      puts "a"
+
       #2. Copy everything in the gems ./flok/products/$PLATFORM -> $PROJECT/products/$PLATFORM and ./flok/app/kern/services/*.rb -> #$PROJECT/products/$PLATFORM/services
       FileUtils.cp_r "./products/#{platform}", local_products_path
 
@@ -47,15 +49,19 @@ class FlokCLI < Thor
     controller_glob_path = "#{local_products_path}/#{platform}/glob/controllers.rb" 
     Flok.src_glob_r("rb", './app/controllers', controller_glob_path)
 
+      puts "b"
     user_compiler_js = Flok::UserCompiler.compile File.read(controller_glob_path)
     services_config_js = File.read "./config/services.rb"
     Flok.src_glob("rb", './app/services', File.join(local_products_path, platform, "./services/user_services.rb"))
 
+      puts "c"
     #4. Move ./app/scripts/*.js into `./products/$PLATFORM/./glob/scripts.js`
     Flok.src_glob("js", './app/scripts', File.join(local_products_path, platform, "./glob/scripts.js"))
 
+      puts "d"
     #Save the current local user's project directory to reference
     user_project_dir = Dir.pwd
+      puts "e"
 
     #We are now inside the platform folder
     Dir.chdir File.join(local_products_path, platform) do
@@ -64,6 +70,7 @@ class FlokCLI < Thor
 
       #4. The `./products/$PLATFORM/services/*.rb` file are globbed into `./products/$PLATFORM/services/combined_services.rb`
       Flok.src_glob("rb", "./services/", "./services/combined_services.rb")
+      puts "f"
 
       #5. The service configuration in `./config/services.rb` is read and run through `services_compiler` and files from `./products/$PLATFORM/services/combined_services.rb` and write to ./glob/services.js
       services_js = Flok::ServicesCompiler.compile(File.read("./services/combined_services.rb"), services_config_js)
@@ -72,6 +79,7 @@ class FlokCLI < Thor
       #6. Move application.js to the glob folder
       FileUtils.cp "application.js", "glob/application.js"
       FileUtils.rm "application.js"
+      puts "g"
 
       #7. The local project `./products/$PLATFORM/glob/application.js` and `./products/$PLATFORM/glob/user_compiler.js` and `./products/$PLATFORM/glob/services.js` and `./products/$PLATFORM/glob/scripts.js`  are merged into `./products/$PLATFORM/glob/application_user.js.erb.hooks`.
       File.open "glob/application_user.js.erb.hooks", "w" do |f|
@@ -81,18 +89,24 @@ class FlokCLI < Thor
         f.puts File.read("glob/scripts.js")
       end
 
+      puts "h"
       #9. The `hooks` compiler then runs over the source injecting any necessary hook code into the special comments by going through `./config/hooks.rb` in the user's project.
       erb_hooks_src = File.read "glob/application_user.js.erb.hooks"
+      puts "hh"
       manifest = Flok::UserHooksToManifestOrchestrator.convert_hooks_to_manifest File.read("#{user_project_dir}/config/hooks.rb")
+      puts "hg"
       erb_src = Flok::HooksCompiler.compile erb_hooks_src, manifest
+      puts "hi"
       File.write "glob/application_user.js.erb", erb_src
 
+      puts "i"
       #9. The `erb` files is then sent to `./products/$PLATFORM/glob/application_user.js` with the below `ERB` variables allowable.
       erb_src = File.read "glob/application_user.js.erb"
       renderr = ERB.new(erb_src)
       context = ERBUserApplicationContext.new()
       new_src = renderr.result(context.get_binding)
       File.write "application_user.js", new_src
+      puts "j"
     end
   end
 

data/docs/mod/about.md

@@ -0,0 +1,19 @@
+#About
+The about module returns information such as the best identifier and platform-names in a standardized way.  This is useful for things like analytics
+tracking.
+
+###Driver messages
+`if_about_pull()` - A message to the driver that it should send a complaint message back to the `int_about_pull_cb` endpoint. with one parameter of a dictionary.
+
+###Kernel messages
+`int_about_pull_cb(info)` - `info` is a dictionary that contains the following values:
+
+  * `udid` - A string that represents, to the device's best capabilities, a unique application bound identifier.
+  * `platform` - A string that represents this platform, i.e. `iOS iPhone 4S 9.0`, `5.0 (Macintosh: Intem lMac...Safari)`
+  * `language` - A string that represents the locale, e.g. `en-us`
+
+###Kernel access
+You may access the udid via the global functions:
+  * `get_udid` - Retrieves the udid
+  * `get_platform` - Retrieves the platform string
+  * `get_language` - Retrieves the language

data/docs/mod/net.md

@@ -3,15 +3,20 @@
 ###Functions
 
 **@telepathy[2]**
-`"if_net_req"(verb, url, params, tp_base)` - Perform an HTTP network request with the given VERB. Assign the network request with the correct telepathy pointer.
+`"if_net_req(verb, url, params, tp_base)` - Perform an HTTP network request with the given VERB. Assign the network request with the correct telepathy pointer.
+`"if_net_req2(verb, headers, url, params, tp_base)`" - Perform an HTTP network request, but accept some HTTP headers in the form of a dictionary.  Useful for authentication or requesting content types.
 
 ###Interrupts
-`int_net_cb(tp, success, info)` - An interrupt that a network request has completed (or failed). `success` is a bool vealue. `info` is a JSON value, `tp` is the pointer that started it
+`int_net_cb(tp, code, info)` - An interrupt that a network request has completed (or failed). 
+
+  * `tp` - The original tele-pointer given for the request passed in for `if_net_req`
+  * `code` - an integer vealue that indicates whether the request could be completed or not.  If it's greater than 0, it's an HTTP code response from the server. if it's -1, then it's a failed response.
+  * `info` - If the response was succesful, i.e. `code > 0` then the info here should be an arbitrary JSON dictionary containing the server's response. If the network request failed, then this contains a internal error message.
+
 `get_int_net_cb_spec()` - Sends [[0, 1, "get_int_net_cb_spec", int_net_cb_spec]]
 
-when successful and a string with an error message (string thats not false) when `success` is false. `tp` is the telepathy pointer passed in via `if_net_req`
 
-###Behavior, when int_net_cb is called, it should make a function request to `tp` and pass `tp`, success` and `info` to this function. Additionally, the
+###Behavior, when int_net_cb is called, it should make a function request to `tp` and pass `tp`, code` and `info` to this function. Additionally, the
 kernel should set `function(tp, a, b) { int_net_cb_spec = [tp, a, b]; }` at address integer `-3209284741`.
 
 ------

data/docs/mod/ui.md

@@ -7,7 +7,7 @@
 (main)>if_init_view('nav_container', {title: "Home"}, 333, ["root", "content"]);
 ```
 
-`if_free_view(vp)` - Destroy a view with a `view pointer`.
+`if_free_view(vp)` - Destroy a view with a `view pointer`. This should be allowed to fail.  There are certain circumstances, such as when a hooked transition takes pace, where a view may have a delayed destroy.  If during this period the view's parent is destroyed, then the delayed destroy message will be received as a free andc we can safely ignore it. Flok shouldn't handle this internally because we don't keep track of the entire hierarchy for performance reasons.
 
 `if_attach_view(vp, p)` - A request to embed a view (`vp`) into the top of a view or spot located at `vp`|`sp` provided during `if_init_view`. If `p` is a `view pointer`, then `vp` is placed **ontop** of `p`.  If `p` is a `spot pointer`, then `vp` is placed **inside** of `p`.  If *p* is 0, then you should place this **inside** of the root view.
 

data/docs/services/rest.md

@@ -19,8 +19,30 @@ Request("<service name>", "get", info);
 You will then receive the event `rest_res`.
 
 For sucessful requests, `rest_res` will be sent as an event. This event
-will contain `path` and `res` where `path` is the `path` given in th
-request and `res` is the results of the request.
+will look like one of two things, for a successful request it will look like:
+```ruby
+{
+  path: "/original/path",
+  code: 200,
+  res: {
+    <<response from server>>
+  }
+}
+```
+
+For a failed request, e.g. network connection not available, not necessarily a succesful request, the parameters will look like:
+```
+{
+  path: "/original/path",
+  code: -1,
+  res: "",
+}
+```
+> *This will be retried until the network request is succesful so be prepared to get multiple `rest_res` repsonses*
+
+
+We say *not necessarily a succesful request* because even if the request goes through, if it's not
+a `2XX` it may still not be succesful but that's a contract between you and your server.
 
 ###Globals
   * `rest_in_flight` - A hash that maps `rest_in_flight[tp_base] => bp` where `[bp, path]` is the requesting entity for the original request and

data/docs/services/vm.md

@@ -1,8 +1,12 @@
 #Virtual Memory (vm.js)
 Virtual memory provides something akin to operating system virtual memory systems with an emphasis on the paging infrastructure.  Unlike an operating system, flok has the concept of a grand-unified namespaced address space that extends the concepts of caching and semantics across asynchronous and even networked systems.  This vm systems is increadibly powerful because it allows you to create custom paging devices; this allows you to use one set of semantics to perform very complicated activities like pulling a news feed or list; having that news feed cached to disk automatically; etc.
 
+This system has borrowed design concepts from `Git`'s distributed commit system for the synchronization mechanism, `FreeBSD's` layout of the `vm` paging-demand system, and Bell Lab's *Plan 9* operating system concept of networked files for communication.
+
 Additionally, flok introduces a notification system that works with the demand paging schemes and caching schemes that allow you to grab data *now* and then be notified whenever a fresh copy is available from the server.
 
+Notifications also extend naturally to controllers; use pages to perform `'ipc'` across controllers. This alows you to push information around your application in ways that the hierarchy may not take kind to.
+
 Each pager belongs to a *namespace*; page faults hit a namespace and then the pager takes over. The pager can choose to service a request; or even throw an exception if a certain semantic is not supported in it's namespace; for example, you may want to disable write semantics for a network pager you called `net` because you expect people to make ordinary network requests.
 
 Fun aside; Because of the hashing schemantics; this paging system solves the age old problem of ... how do you show that data has changed *now* when to be assured that you have perferctly synchronized data with the server?;... you need to do a 3-way handshake with the updates.  You could have a network server pager that supports writes but dosen't forward those to the network. That way, you can locally modify the page and then if the modifications were guessed correctly, the server would not even send back a page modification update! (Locally, the page would have been propogated as well).  In the meantime, after modifying the local page, you would send a real network request to the server which would in turn update it's own paging system but at that point, the server would check in with you about your pages, but miraculously, because you gussed the updated page correctly, no modifications will need to be made. You could even purposefully put a 'not_synced' key in and actually show the user when the page was correctly synchronized.

data/docs/user_handbook/hooks.md

@@ -68,11 +68,14 @@ handleHook("supports_back_clicked", function(hookInfo) {
 
 ## Hook generators
 
-  * `goto` - Intercept `Goto` transitions and when a controller first loads (by virtue that a controller runs `Goto` when it first is initialized)
+  * `goto` - Intercept `Goto` transitions, unable to intercept first-load transition?
     * `DSL Selectors`
       * `to_action_responds_to? "event_name"` - Whenever a controller switches **to** an action that contains an `on "event_name", %{...}` handler
       * `from_action_responds_to? "event_name"` - Whenever a controller switches **from** an action that contains an `on "event_name", %{...}` handler
+      * `to_action "action_name"` - The name(s) of the action you are going to
+      * `from_action "action_name"` - The name(s) of the action you are coming from
       * `controller "controller_name"` - Only applies to controllers with the name `"controller_name"`
+      * `triggered_by "event_name"` - The event that caused this segue to occurr
     * `Completion`
       * The `completion` event is expected to be raised via `int_event` for all goto events. This is because the old view is not destroyed until the `completion` event is called
         to allow you to use the view in animations.
@@ -80,7 +83,29 @@ handleHook("supports_back_clicked", function(hookInfo) {
       * Unlike other semantics, `Goto` has issues with *cancellation* because the old views are destroyed. In order to work around this, you must call, after the completion
         event, the `back` segue that you have described checking whether or not a transition was in progress (interactive) based on the view-controller itself.
     * `info`:
-      * `ctp` - Completion telepointer, you should raise an `int_event` with this base-pointer.
+      * `ctp` - Completion telepointer, you should raise an `int_event` with this base-pointer. Views will not be removed until this is called
+      * `views` - A `[String:Int]` mapping spider-selected view names to their base pointers
+  * `push` - Intercept `Push` transitions
+    * `DSL Selectors`
+      * `to_action_responds_to? "event_name"` - Whenever a controller switches **to** an action that contains an `on "event_name", %{...}` handler
+      * `from_action_responds_to? "event_name"` - Whenever a controller switches **from** an action that contains an `on "event_name", %{...}` handler
+      * `to_action "action_name"` - The name(s) of the action you are pushing to
+      * `from_action "action_name"` - The name(s) of the action you are pushing from
+      * `controller "controller_name"` - Only applies to controllers with the name `"controller_name"`
+      * `triggered_by "event_name"` - The event that caused this segue to occurr
+    * `info`:
+      * `views` - A `[String:Int]` mapping spider-selected view names to their base pointers
+  * `pop` - Intercept `Pop` transitions
+    * `DSL Selectors`
+      * `to_action_responds_to? "event_name"` - Whenever a controller switches **to** an action that contains an `on "event_name", %{...}` handler
+      * `from_action_responds_to? "event_name"` - Whenever a controller switches **from** an action that contains an `on "event_name", %{...}` handler
+      * `to_action "action_name"` - The name(s) of the action you are pushing to
+      * `from_action "action_name"` - The name(s) of the action you are pushing from
+      * `controller "controller_name"` - Only applies to controllers with the name `"controller_name"`
+      * `triggered_by "event_name"` - The event that caused this segue to occurr
+    * `info`:
+      * `views` - A `[String:Int]` mapping spider-selected view names to their base pointers
+      * `ctp` - Completion telepointer, you should raise an `int_event` with this base-pointer. Views will not be removed until this is called
 
 ## How the hook generators are defined & hooking internals
 See [Kernel Handbook | Hooks](../kernel_handbook/hooks.md)
@@ -104,17 +129,48 @@ The name is the hook name and the params is context specific inforamtion the com
 
   * `controller_will_goto` - The controller is about to invoke the Goto macro and switch actions or it has just entered the first action from choose_action (which is a Goto).
     * params (static generated in the hook info)
+      * `might_respond_to` - List of events this controller can respond to dependening on the action
       * `controller_name` - The controller name that this entry effects
       * `from_action` - The name of the action we are coming from
       * `to_action` - The name of the action we are going to
-    * Useful (dynamic/local JS) variables
-      * `old_action` - The previous action, equal to `from_action` but in dynamic form. If there is no action, this is set to `choose_action`. Not sure why you would use this
-      * `__info__.action` - The name of the new action
+      * `handling_event_named` - The event name this originated from if applicable
   * `controller_did_goto` - The controller has completed the goto switch
     * params (static)
+      * `might_respond_to` - List of events this controller can respond to dependening on the action
       * `controller_name` - The controller name that this entry effects
       * `from_action` - The name of the action we are coming from
       * `to_action` - The name of the action we are going to
+      * `handling_event_named` - The event name this originated from if applicable
+  * `controller_will_push` - The controller is about to invoke the Push macro and switch actions
+    * params (static generated in the hook info)
+      * `controller_name` - The controller name that this entry effects
+      * `from_action` - The name of the action we are pushing from
+      * `to_action` - The name of the action we are pushing to
+      * `actions_respond_to` - Hash of action_name to array of events each action responds to
+      * `might_respond_to` - List of actions this controller can respond to (same info as of actions_respond_to)
+      * `handling_event_named` - The event name this originated from if applicable
+  * `controller_did_push` - The controller has completed the push
+    * params (static)
+      * `controller_name` - The controller name that this entry effects
+      * `from_action` - The name of the action we are pushing from
+      * `to_action` - The name of the action we are pushing to
+      * `actions_respond_to` - Hash of action_name to array of events each action responds to
+      * `might_respond_to` - List of actions this controller can respond to (same info as of actions_respond_to)
+      * `handling_event_named` - The event name this originated from if applicable
+  * `controller_will_pop` - The controller is about to invoke the Pop macro and switch actions
+    * params (static generated in the hook info)
+      * `controller_name` - The controller name that this entry effects
+      * `from_action` - The name of the action we are popping from
+      * `actions_respond_to` - Hash of action_name to array of events each action responds to
+      * `might_respond_to` - List of actions this controller can respond to (same info as of actions_respond_to)
+      * `handling_event_named` - The event name this originated from if applicable
+  * `controller_did_pop` - The controller has completed the pop
+    * params (static)
+      * `controller_name` - The controller name that this entry effects
+      * `from_action` - The name of the action we are popping from
+      * `actions_respond_to` - Hash of action_name to array of events each action responds to
+      * `might_respond_to` - List of actions this controller can respond to (same info as of actions_respond_to)
+      * `handling_event_named` - The event name this originated from if applicable
 
 ##Hooks Compiler
 The hooks compiler is able to take the hook entry points and inject code into them via a set of `HooksManifestEntries` which are bound togeather via a `HooksManifest`. The actual