flok 0.0.36 → 0.0.38

data/app/kern/services/test.rb

@@ -0,0 +1,7 @@
+service :test do
+  global %{
+    function <%= @name %>_function(x) {
+      <%= @name %>_function_args = x;
+    }
+  }
+end

data/app/kern/services/vm.rb

@@ -0,0 +1,141 @@
+service :vm do
+  global %{
+    //Cache contains a blank hash for each namespace
+    vm_cache = {
+      <% @options[:pagers].each do |p| %>
+        <%= p[:namespace] %>: {},
+      <% end %>
+    };
+
+    //Notification listeners, converts ns+key to an array of base pointers
+    vm_notify_map = {};
+
+    //Cache
+    function vm_cache_write(ns, key, value) {
+      vm_cache[ns][key] = value;
+    }
+
+    //Notification of a change
+    function vm_notify(ns, key) {
+      var a = vm_notify_map[ns];
+      if (a) {
+        var b = a[key];
+
+        if (b) {
+          for (var i = 0; i < b.length; ++i) {
+            <% @options[:pagers].each do |p| %>
+              if (ns === "<%= p[:namespace] %>") {
+                <%= p[:name] %>_read(ns, b[i], key);
+              }
+            <% end %>
+          }
+        }
+      }
+    }
+  }
+
+  on_wakeup %{
+    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
+
+    <% if @debug %>
+      vm_did_wakeup = true;
+    <% end %>
+
+
+    //Call init functions
+    <% @options[:pagers].each do |p| %>
+      <%= p[:name] %>_init(<%= (p[:options] || {}).to_json %>);
+    <% end %>
+  }
+
+  on_sleep %{
+  }
+
+  on_connect %{
+  }
+
+  on_disconnect %{
+  }
+
+  on "read_sync", %{
+    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
+
+    var cres = vm_cache[params.ns][params.key]; 
+    if (cres != undefined) {
+      int_event(bp, "read_res", {key: params.key, value: cres});
+      return;
+    }
+
+    <% @options[:pagers].each do |p| %>
+      if (params.ns === "<%= p[:namespace] %>") {
+        var res = <%= p[:name] %>_read_sync(params.ns, bp, params.key);
+      }
+    <% end %>
+    vm_read_sync_called = true;
+
+    int_event(bp, "read_sync_res", res);
+  }
+
+  on "read", %{
+    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
+
+    var cres = vm_cache[params.ns][params.key]; 
+    if (cres != undefined) {
+      int_event(bp, "read_res", {key: params.key, value: cres});
+    }
+
+    <% @options[:pagers].each do |p| %>
+      if (params.ns === "<%= p[:namespace] %>") {
+        <%= p[:name] %>_read(params.ns, bp, params.key);
+      }
+    <% end %>
+  }
+
+  on "write", %{
+    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
+
+    <% @options[:pagers].each do |p| %>
+      if (params.ns === "<%= p[:namespace] %>") {
+        <%= p[:name] %>_write(params.key, params.value);
+      }
+    <% end %>
+  }
+
+  on "watch", %{
+    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
+
+    //Ensure map exists
+    ////////////////////////////////////////////////
+    var a = vm_notify_map[params.ns];
+    if (!a) {
+      a = {};
+      vm_notify_map[params.ns] = a;
+    }
+
+    var b = a[params.key];
+    if (!b) {
+      b = [];
+      a[params.key] = b;
+    }
+
+    b.push(bp)
+    ////////////////////////////////////////////////
+
+    <% @options[:pagers].each do |p| %>
+      if (params.ns === "<%= p[:namespace] %>") {
+        <%= p[:name] %>_watch(params.ns, params.key);
+      }
+    <% end %>
+  }
+
+  on "unwatch", %{
+    <% raise "No pagers given in options for vm" unless @options[:pagers] %>
+
+    <% @options[:pagers].each do |p| %>
+      if (params.ns === "<%= p[:namespace] %>") {
+        <%= p[:name] %>_unwatch(params.ns, params.key);
+      }
+    <% end %>
+  }
+
+end

data/app/kern/spec_helper.js

@@ -0,0 +1,5 @@
+<% if @debug %>
+  <% if @defines['spec_test'] %>
+    //spec_helper_defines_spec_test
+  <% end %>
+<% end %>

data/bin/flok

@@ -23,7 +23,11 @@ class FlokCLI < Thor
     raise "$PLATFORM was not set" unless ENV['PLATFORM']
     platform = ENV['PLATFORM']
 
+    #Set the correct config.yml
+    ENV['FLOK_CONFIG'] = File.expand_path("./config/platforms/#{platform}/config.yml")
+
     #Create a products folder if it dosen't already exist
+    FileUtils.rm_r "./products" if File.directory? "./products"
     Dir.mkdir("./products") unless File.exists?("./products")
 
     #Go into the flok gem project
@@ -32,30 +36,48 @@ class FlokCLI < Thor
       #1. Use the rake task
       system('rake build:world')
 
-      #2. Copy everything in the gems ./flok/products/$PLATFORM -> $PROJECT/products/$PLATFORM
+      #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
+
+      #Copy built in services
+      Flok.src_glob("rb", "./app/kern/services", File.join(local_products_path, platform, "services/kern_services.rb"))
     end
 
     #3. Build the client's ./app/controllers/*.rb into './products/$PLATFORM/user_compiler.js'
     controller_glob_path = "#{local_products_path}/#{platform}/glob/controllers.rb" 
     Flok.src_glob("rb", './app/controllers', controller_glob_path)
     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"))
+
+    #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"))
 
+    #We are now inside the platform folder
     Dir.chdir File.join(local_products_path, platform) do
-      #3. Put user_compiler_js in glob folder
+      #3. Put user_compiler_js in glob folder and services into ./services/user_services.rb
       File.write "glob/user_compiler.js", user_compiler_js
 
-      #4. Move application.js to the glob folder
+      #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")
+
+      #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)
+      File.write "./glob/services.js", services_js
+
+      #6. Move application.js to the glob folder
       FileUtils.cp "application.js", "glob/application.js"
       FileUtils.rm "application.js"
 
-      #5. Combine application.js and user_compiler.js.erb
+      #7. Combine application.js and user_compiler.js.erb and services.js and scripts.js
       File.open "glob/application_user.js.erb", "w" do |f|
         f.puts File.read("glob/application.js")
         f.puts File.read("glob/user_compiler.js")
+        f.puts File.read("glob/services.js")
+        f.puts File.read("glob/scripts.js")
       end
 
-      #6. The `erb` files is then sent to `./products/$PLATFORM/glob/application_user.js` with the below `ERB` variables allowable.
+      #8. 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()

data/docs/callout.md

@@ -0,0 +1,8 @@
+#Callout - Kernel timer manager
+The function `callout_wakeup()` embodies the time management functions of the kernel; this includes maintaining periodic
+and interval timers and to send a custom event to the given port.
+
+##Registration
+You may register for a timer event via `reg_timeout(ep, ename, ticks)`. This will wait `ticks` before firing.
+To continually fire, you may use `reg_interval(ep, ename, ticks)` which will continue to fire every `ticks`. If `ep` is no longer in the `evt`, then
+the entry will no longer exist.

data/docs/client_api.md

@@ -4,7 +4,7 @@ Client API covers controller action event handlers.
 ### Controller MACROS
   * Embed(view_controller_name, spot_name, context) - Embed a view controller with the name `view_controller_name` inside the current view controller at the spot with a context
   * Goto(action_name) - Change actions
-  * Request(service_name, info, event_cb_name) - Initiate a service.  See [Services](./services.md) for more info.
+  * Request(service_insatnce_name, ename, params) Initiate a service.  See [Services](./services.md) for more info.  
   * Send(event_name, info) - Send a custom event on the main queue.
   * Raise(event_name, info) - Will send an event to the parent view controller (and it will bubble up, following `event_gw` which is set in `Embed` as the parent controller
   * Lower(spot_name, event_name, info) - Send an event to a particular spot

data/docs/compilation.md

@@ -13,14 +13,12 @@ as necessary.*
  1. `rake build` is run inside `./app/drivers/$PLATFORM` with the environmental variables set to BUILD_PATH=`./produts/$PLATFORM/driver` (and folder
  2. All js files in `./app/kern/config/*.js` are globbed togeather and sent to `./products/$PLATFORM/glob/1kern_config.js`
  3. All js files in `./app/kern/*.js` are globbed togeather and sent to `./products/$PLATFORM/glob/2kern.pre_macro.js`
- 4. All rb files inside `./app/kern/services/` are globbed into `./products/$PLATFORM/glob/kern_services.rb`
- 5. `./products/$PLATFORM/glob/kern_serivces.rb` is processed via `Flok::Services` and then exported as `./products/$PLATFORM/glob/kern_services.pre_macro.js`
- 6. All js files in `./products/$PLATFORM/glob/2kern.pre_macro.js` are run through `./app/kern/macro.rb's macro_process` and then sent to ./products/$PLATFORM/glob/2kern.js
- 7. All js files in `./products/$PLATFORM/glob/kern_services.pre_macro.js` are run through `./app/kern/macro.rb's macro_process` and then sent to ./products/$PLATFORM/glob/kern_services.js
- 8. All js files are globbed from `./products/$PLATFORM/glob` and combined into `./products/$PLATFORM/glob/application.js.erb`
- 9. Auto-generated code is placed at the end (like PLATFORM global)
- 10. The module specific code in `./kern/mod/.*js` are added when the name of the file (without the js part) is mentioned in the `./app/drivers/$PLATFORM/config.yml` `mods` section and appended to `glob/application.js.erb`
- 11. The compiled `glob/application.js.erb` file is run through the ERB compiler and formed into `application.js`
+ 4. All js files in `./app/kern/pagers/*.js` are globbed togeather and sent to `./products/$PLATFORM/glob/3kern.pre_macro.js`
+ 5. All js files in `./products/$PLATFORM/glob/{2,3}kern.pre_macro.js` are run through `./app/kern/macro.rb's macro_process` and then sent to `./products/$PLATFORM/glob/{2,3}kern.js`
+ 6. All js files are globbed from `./products/$PLATFORM/glob` and combined into `./products/$PLATFORM/glob/application.js.erb`
+ 7. Auto-generated code is placed at the end (like PLATFORM global)
+ 8. The module specific code in `./kern/mod/.*js` are added when the name of the file (without the js part) is mentioned in the `./app/drivers/$PLATFORM/config.yml` `mods` section and appended to `glob/application.js.erb`
+ 9. The compiled `glob/application.js.erb` file is run through the ERB compiler and formed into `application.js`
 
 ##Erb variables
 All kernel source files support embedded ERB code like `<% if DEBUG %>Code<% end %>`. These files include:
@@ -32,6 +30,7 @@ All kernel source files support embedded ERB code like `<% if DEBUG %>Code<% end
   * `@debug` - Set to `true` when FLOK_ENV=DEBUG
   * `@release` - Set to `true` FLOK_ENV=RELEASE
   * `@mods` - The set of modules supported by this platform and build configuration
+  * `@defines` - A hash that contains things under the `defines` section in a `config.yml`. Each item in the hash is `true`
 
 ```js
   //Example JS code for debug / release mode
@@ -40,4 +39,11 @@ All kernel source files support embedded ERB code like `<% if DEBUG %>Code<% end
   <% else %>
     //JS code for not debug mode
   <% end %>
+
+  <% if @defines['spec_test'] %>
+    //spec_helper_defines_spec_test
+  <% end %>
 ```
+
+####Spec Helpers
+The file contained in the kernel `./app/kern/spec_helper.js` is used to test things like variable setting from `config.yml`

data/docs/controllers.md

@@ -23,7 +23,8 @@ Let's write a `fuc` controller that has 2 tabs and a content area. The view is i
 
 ```ruby
 controller "tab_controller" do
-  spaces "content"
+  spots "content"
+  services "my_service" #See docs on services for what this means
 
   #You can also define macros for shared action traits
   macro "my_macro" do

data/docs/datatypes.md

@@ -11,7 +11,9 @@ ctable_entry {
   root_view,     //A constant string of the name of the view this controller sets as it's root view.
   actions,       //A dictionary [String:action_info] that corresponds to a dictionary of action_info object's based on the action's name.
   spots,         //An array fo spot names for this controller
-  name           //The name of the controller, useful for certain lookup operations, this is also the ctable key
+  name,          //The name of the controller, useful for certain lookup operations, this is also the ctable key
+  __init__,      //A function that is called when this controller is created. Signals service connection
+  __dealloc__    //A function that is called when this controller is destroyed via parent controller switching actions in Goto. Signals services d/c
 }
 ```
 

data/docs/environmentals.md

@@ -0,0 +1,6 @@
+#Environmentals
+
+Various environmental variables effect both the build, spec, and interface systems.  These environmentals include:
+  * `PLATFORM` - The current platform (driver stack) to use. E.g. `chrome`
+  * `FLOK_ENV` - Are we in `debug` or `release`
+  * `FLOK_CONFIG` - Absolute location of the config.yml, this config.yml must be usable for the the current `PLATFORM`

data/docs/interactive.md

@@ -8,7 +8,6 @@
     * `cd ./; rake pipe:server PLATFORM=$PLATFORM`
 
 ###What $stdout and $stdin does for pipes
-
   * Server
   	- `$stdin` => `int_dispatch`
   	- `if_dispatch` => `$stdout`
@@ -17,6 +16,12 @@
   	- `int_dispatch` => `$stdout`
   
 All communication *coming* from `$stdin` and *going* to `$stdout` is in un-escaped JSON formatting that follows the conventions mentioned in [Messaging](./messaging.md).
+If the driver `$stdin` receives the string `RESTART\n` by itself on a single line, then it should restart itself and then next reply should be
+`RESTART OK\n`
+it is fully restarted. All data should be destroyed except for things explicitly synchronously flushed like the `persist` module. When this pipe is
+opened, it is expected that no local data is retained; the only way to retain data is through explicit restarts. All data writes should be flushed
+(fsynced) when the pipe is restarted so that no data writes are lost. Some specs expect that setting data will be fsynced when it calls restart (which
+ is immediately after the set)
 
 The test suites assume particular behavior of the pipes. Please review [./spec/env/iface.rb](../spec/env/iface.rb) for the method named `pipe_suite` for the proper behavior.
 

data/docs/kernel_api.md

@@ -9,6 +9,9 @@
   * `tel_exists(tp)` - Returns true or false depending on whether there is a telepointer that matches
 instead.
 
+##CRC32
+  * `crc32(seed, str)` - Will calculate a CRC32 based on a seed and a string
+
 ##Events
   * `reg_evt(ep, f)` - Register a function to be called when an event is processed by `int_event`. The function will receive `(ep, event_name, info)`.
 

data/docs/mod/event.md

@@ -4,11 +4,15 @@
 `if_event(ep, event_name, event)` - Receive an event at some object located at `ep`.  This is a platform defined opaque pointer.
 
 ### Interrupts
-`int_event(ep, event_name, event)` - Send an event back to *Flok* through an event. The `ep` in this case is dependent on the sub-system. Dispatching is provided through the `evt` (event vector table). On the flok kernel, using, `reg_ivt` and `dereg_ivt` will determine what happens post int_event.  If `ep` is no longer valid, the event in ignored.
+`int_event(ep, event_name, event)` - Send an event back to *Flok* through an event. The `ep` in this case is dependent on the sub-system. Dispatching is provided through the `evt` (event vector table). On the flok kernel, using, `reg_evt` and `dereg_evt` will determine what happens post int_event.  If `ep` is no longer valid, the event in ignored. Returns `false` if the destination does not exist and `true` otherwise.
 For example, the `vc` (view controller) subsystem will receive any events sent when the `ep` is an opaque pointer to a
 ./app/driver/$PLATFORM/config.yml`)
 file is used to compile only the modules into the flok kernel that the driver supports.rface controller from `ui`.
 
+### Helper function
+`reg_evt(ep, f)` - Register a function to be called when `ep` is sent a message, function looks like function f(ep, ename, info)
+`dereg_evt(ep)` - Disable notifications to a function
+
 ### Kernel spec related
   * `spec_event_handler(ep, event_name, event)` - This function should send the message `spec_event_handler_res(ep, event_name, event)` if called
   * `int_spec_event_dereg` - This function should de-register 3848392 from being an event 

data/docs/mod/persist.md

@@ -1,36 +1,19 @@
 #Persist (persist.js)
-Persistance management. Storage of data, etc.  Loosely based on redis.  Refer to [redios.io](http://redis.io/commands) for more detailed
-descriptions.
+Persistance management. Loosely based on redis.
 
-###Messages
-`if_per_hdel key field [field...]` - Delete one or more hash fields
-`if_per_hmget key field [field...]` - Get the value of multiple fields
+###Driver messages
+`if_per_set(ns, key, value)` - Set a key and value
+`if_per_get(s, ns, key)` - Get a key's value, a message `int_get_res` will be sent back
+`if_per_del(ns, key)` - Delete a particular key
+`if_per_del_ns(ns)` - Delete an entire namespace
 
-###Spec related
-`if_ui_spec_init` - Setup anything necessary for the spec tests, this may include adding prototype views to your hierarchy, etc.
-`if_ui_spec_views_at_spot(p)` - Sends a packet back that contains a listing of all the view pointers inside of a spot. If 0 is passed, the view pointers are from the root node. `[N(vp*), "spec", vp*]`
-`if_ui_spec_view_exists(vp)` - Checks whether or not a view still exists `[1, "spec", true]`
-`if_ui_spec_view_is_visible(vp)` - Checks whether or not a view is visible `[1, "spec", true]`
+###TODO driver messages
+`if_per_set_f(ns, key, tp)` - Tell the driver to dereference the telepointer and to save it to disk.
 
-#####You must be able to accept the following prototypes names:
-`spec_blank` - A blank view with no spots
-`spec_one_spot` - "A blank view with with one spot named `content` that takes up the entire view"
-`spec_two_spot` - "A blank view with with one spot named `a` and one spot named `b`.
+For race conditions, e.g, an asynchronous set is followed by a synchronous get, it is undefined as to what that behavior that will be.
+It is expected that the kernel should manage the write-back cache and that the driver should not attempt a write back cache unless
+it is convenient to do so.
 
-------
-
-## Overview 
-
-This driver controls two things called a **view** and a **spot**. 
-
- 1. **View** - A **view** holds your content.
- 2. **Spot** - Views can have blank **Spot**s where other views can be placed.
-
-## Examples
-Here is an example for the `chrome` driver of a live view built from two views.
-![](../images/view_and_spot.png)
-
-
-
-###A note on free
-If `free` is called on a view, that view is always already detached. If a *view* receives `free`, that *view* must call `free` on all of it's children before itself.
+###Kernel interrupts
+`int_per_get_res(s, res)` - A response retrieved from `if_per_get` that contains the session key and result dictionary. If the key
+does not exist, null is returned.

data/docs/mod/timer.md

@@ -1,8 +1,10 @@
 #Timer (timer.js)
 
 ###Functions
-
-`if_timer_init(tps)` - Initiate a timer that calls `int_timer` N `tps` (ticsk per second)
+`if_timer_init(tps)` - Initiate a timer that calls `int_timer` N `tps` (ticsk per second). This is always called via the cpu scheduling class (3)
 
 ###Interrupts
 `int_timer` - Called by the device at the rate described in `tps`. This function lives inside the `timer` service's initialization portion.
+
+###Callout
+The kernel's `int_timer` function gets sent to `callout_wakeup()` located in `callout.js`.

data/docs/project.md

@@ -11,21 +11,32 @@ You create and build projects via the `flok` command. You must set the `$FLOK_EN
 ###Folder structure
   * `app/`
     * `controllers/` - All your controllers live here as `rb` files.
+    * `services/` - Service `rb` files
+    * `scripts/` - Scripts are ordinary javascript files that are merged with the main kernel.
   * `products/` - Autogenerated when you build
     * `$PLATFORM/` - A folder named after the platform you selected
       * `application_user.js` - The source for the flok application_user. Includes your application code statically linked
       * `drivers/` - Contains the driver code needed to implement the driver side interface
+  * `config/` - The configuration files
+    * `services.rb` - A list of service instances that are statically compiled into the kernel.  See [Services](./services.md) for details.
+    * `platforms/$PLATFORM/` - Platform dependent build options
+      * `config.yml` - Copied from the platform's config.yml folder in the kernel `./app/drivers/$PLATFORM/config.yml`. This is used when running
+          `flok build`
 
 ###application_user.js
 `application_user.js` is equivalent to the application_user build `application.js` except that it contains the users controllers statically linked (appended in *js*).
 
 ###User build process
   1. The gem is build via `build:world` using the platform given in build.
-  2. All files generated by the gem kernel and associated driver for the platform are placed in the project ./products/$PLATFORM
-  3. The controllers in `./app/controllers/*.rb` are run through the `user_compiler` in `./lib/flok/user_compiler.rb` and then saved to the projects `./products/$PLATFORM/glob/user_compiler.js`
-  4. `./products/$PLATFORM/application.js` is moved to `./products/$PLATFORM/glob/application.js`
-  5. The local project `./products/$PLATFORM/glob/application.js` and `./products/$PLATFORM/glob/user_compiler.js` are merged into `./products/$PLATFORM/glob/application_user.js.erb`.
-  6. The `erb` files is then sent to `./products/$PLATFORM/glob/application_user.js` with the below `ERB` variables allowable.
+  2. Copy everything in the gems ./flok/products/$PLATFORM -> $PROJECT/products/$PLATFORM and ./flok/app/kern/services/*.rb -> $PROJECT/products/$PLATFORM/services/kern_services.rb
+  3. The controllers in `./app/controllers/*.rb` are run through the `user_compiler` in `./lib/flok/user_compiler.rb` and then saved to the projects
+  `./products/$PLATFORM/glob/user_compiler.js` and the `./app/services/*.rb` are globbed into `./products/$PLATFORM/services/user_services.rb`
+  4. The `./products/$PLATFORM/services/*.rb` file are globbed into `./products/$PLATFORM/services/combined_services.rb`
+  5. The service configuration in `./config/services.rb` is read and run through `services_compiler` and files from
+  `./products/$PLATFORM/services/combined_services.rb`. The output of this file is moved to `./products/$PLATFORM/glob/services.js`
+  6. `./products/$PLATFORM/application.js` is moved to `./products/$PLATFORM/glob/application.js`
+  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`.
+  8. The `erb` files is then sent to `./products/$PLATFORM/glob/application_user.js` with the below `ERB` variables allowable.
 
 ####Supported variables
   * `@debug` - Set to `true` when FLOK_ENV=DEBUG