flok 0.0.36 → 0.0.38

data/lib/flok/platform.rb

@@ -12,17 +12,40 @@ module Flok
     end
 
     #Get a list of modules for a particular environment for a platform
-    def self.mods platform, environment
+    def self.mods environment
       #Create array that looks like a javascript array with single quotes
-      mods = self.config_yml(platform, environment)['mods']
+      mods = self.config_yml(environment)['mods']
     end
 
-    #Get all config.yml information for a platform
-    def self.config_yml platform, environment
-      driver_config = YAML.load_file("./app/drivers/#{platform}/config.yml")
-      raise "No config.yml found in your 'platform: #{platform}' driver" unless driver_config
+    def self.defines environment
+      #Just converting an array into a hash of true values for easier lookup
+      hash = {}
+      defines_arr = self.config_yml(environment)['defines']
+      if defines_arr
+        defines_arr.each do |e|
+          hash[e] = true
+        end
+      end
+
+      return hash
+    end
+
+    #Get all config.yml information for a config_yml file based on FLOK_CONFIG
+    def self.config_yml environment
+      #Get the config.yml path
+      config_yml_path = ENV['FLOK_CONFIG']
+      if config_yml_path
+        raise "You didn't pass a FLOK_CONFIG variable for the config.yml" unless config_yml_path
+        raise "The FLOK_CONFIG given: #{config_yml_path.inspect} does not contain a file (config.yml)" unless File.exists?(config_yml_path)
+      else
+        #$stderr.puts "Warning: You didn't specify FLOK_CONFIG, Using default config of ./app/drivers/#{ENV['PLATFORM']}/config.yml"
+        config_yml_path = "./app/drivers/#{ENV['PLATFORM']}/config.yml"
+      end
+
+      driver_config = YAML.load_file(config_yml_path)
       return driver_config[environment]
     end
+
   end
 
   #Alias

data/lib/flok/project_template/app/scripts/script.js

@@ -0,0 +1,3 @@
+//You shouldn't have many scripts in here, but any javascript files in ./app/scripts/*.js could be 
+//used if you need access to (small amounts) of static data, etc. These files are merged with the final
+//kernel binary.

data/lib/flok/project_template/app/services/service.rb

@@ -0,0 +1 @@
+#Your services should go into this file, you may name your files anything and delete this file

data/lib/flok/project_template/config/config.yml

@@ -0,0 +1 @@
+<%= File.read("./app/drivers/ENV['PLATFORM']/")

data/lib/flok/project_template/config/platforms/chrome/config.yml

@@ -0,0 +1 @@
+<%= File.read(File.join(File.dirname(__FILE__), "../../../app/drivers/#{ENV['PLATFORM']}/config.yml")) %>

data/lib/flok/project_template/config/services.rb

@@ -0,0 +1 @@
+#Services

data/lib/flok/service_compiler_templates/services.js.erb

@@ -1,13 +1,82 @@
 <% @services.each do |s| %>
-  //////////////////////////////////////////////////
-  //Start of <%= s.name %> on_init
-  <%= s.get_on_init %>
-  //////////////////////////////////////////////////
+  //Variables
+  var <%= s.name %>_sessions = {};  //Currently connected clients
+  var <%= s.name %>_n_sessions = 0;  //Number of sessions
 
-  //////////////////////////////////////////////////
-  //Start of <%= s.name %> on_request
-  function service_<%= s.name %>_req(info, ep, ename) {
-    <%= s.get_on_request %>
+  //Static global
+  <%= s._global %>
+
+  //Start of <%= s.name %> on_wakeup
+  function <%= s.name %>_on_wakeup() {
+    //Timer related
+    /////////////////////////////////////////////////////////////////////////////////////
+    //The timer base pointer for incomming callout events
+    <%= s.name %>_timer_bp = tels(1);
+    reg_evt(<%= s.name %>_timer_bp, <%= s.name %>_handle_timer_events);
+
+    //Tell the timer to notify our timer event handlers
+    //The name is randomly generated for each one
+    <% s.every_handlers.each do |h| %>
+        reg_interval(<%= s.name %>_timer_bp, '<%= h[:name] %>', <%= h[:ticks] %>);
+    <% end %>
+    /////////////////////////////////////////////////////////////////////////////////////
+
+    <%= s._on_wakeup %>
+  }
+
+  function <%= s.name %>_on_sleep() {
+    //Do not receive anymore timer events
+    dereg_evt(<%= s.name %>_timer_bp);
+
+    <%= s._on_sleep %>
+  }
+
+  function <%= s.name %>_on_connect(bp) {
+    var sessions = <%= s.name %>_sessions;
+    <%= s.name %>_n_sessions += 1;
+
+    //First connection
+    if (<%= s.name %>_n_sessions === 1) {
+      <%= s.name %>_on_wakeup();
+    }
+
+    sessions[bp] = true;
+    <%= s._on_connect %>
+  }
+
+  function <%= s.name %>_on_disconnect(bp) {
+    var sessions = <%= s.name %>_sessions;
+
+    <%= s.name %>_n_sessions -= 1;
+    delete sessions[bp];
+
+    <%= s._on_disconnect %>
+
+    //No more connections
+    if (<%= s.name %>_n_sessions === 0) {
+      <%= s.name %>_on_sleep();
+    }
+
+  }
+  
+  //'Event' handlers
+  <% s.event_handlers.each do |h| %>
+    function <%= s.name %>_on_<%= h[:name] %>(bp, params) {
+      var sessions = <%= s.name %>_sessions;
+      <%= h[:str] %>
+    }
+  <% end %>
+
+  //Timer receivers
+  /////////////////////////////////////////////////////////////////////
+  function <%= s.name %>_handle_timer_events(ep, ename, info) {
+    var sessions = <%= s.name %>_sessions;
+
+    <% s.every_handlers.each do |h| %>
+        if (ename === '<%= h[:name] %>') {
+          <%= h[:str] %>
+        }
+    <% end %>
   }
-  //////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////////
 <% end %>

data/lib/flok/services_compiler.rb

@@ -1,22 +1,28 @@
 #Compile a controller ruby file into a javascript string
+require 'active_support'
+require 'active_support/core_ext/numeric'
 
 require 'erb'
 module Flok
   module ServicesCompiler
     #Compile a ruby file containing flok controller definitions (from the services)
-    def self.compile rb_src
+    #The config is outlined in the documentation under docs/services.md
+    def self.compile rb_src, rb_config
+      #Execute the configuration file first
+      config_context = ServicesCompilerConfigContext.new
+      config_context.instance_eval(rb_config, __FILE__, __LINE__)
+
       #Execute code in this context, the context will hold all the information
       #that is used to then generate code
-      context = ServicesCompilerContext.new
+      context = ServicesCompilerContext.new(config_context)
       context.instance_eval(rb_src, __FILE__, __LINE__)
+      context.ready
 
       @src = ""
       services_erb = File.read File.join(File.dirname(__FILE__), "./service_compiler_templates/services.js.erb")
       services_renderer = ERB.new(services_erb)
       @src << services_renderer.result(context.get_binding)
 
-      #puts @src
-
       return @src
     end
   end
@@ -24,29 +30,71 @@ end
 
 #Compiler executes all rb code inside this context
 module Flok
-  class ServicesCompilerContext
-    attr_accessor :services
+  class ServicesCompilerConfigContext
+    #Each service instance contains a :instance_name and :class
+    attr_accessor :service_instances
 
     def initialize
+      @service_instances = []
+    end
+
+    def service_instance instance_name, name, options={}
+      @service_instances.push({
+        :instance_name => instance_name,
+        :class => name,
+        :options => options
+      })
+    end
+  end
+
+ class ServicesCompilerContext
+    attr_accessor :services, :config
+
+    def initialize config_context
+      @config = config_context
+
+      #A hash containing the 'class' name of the service to a block that can be used with Service.new
+      @_services = {}
+
       @services = []
     end
 
+    def ready
+      #Create an array from the service_instances where each element in the array is the full code of the service
+      @config.service_instances.each do |i|
+        #Get the instance name and class name of the service, normally defined in a ./config/services.rb file
+        sname = i[:instance_name]
+        sclass = i[:class]
+        soptions = i[:options]
+
+        sblock = @_services[sclass]
+        raise "No service found for service_name: #{sclass.inspect} when trying to create service with instance name #{sname.inspect}. @_services contained: #{@_services.inspect} \n@config.service_instances contained: #{@config.service_instances.inspect}" unless sblock
+        service = Service.new(sname, soptions)
+        service.instance_eval(&sblock)
+        @services << service
+      end
+    end
+
     def get_binding
       return binding
     end
 
     def service name, &block
-      @services << Service.new(name, &block)
+      @_services[name] = block
     end
   end
 
   class Service
-    attr_accessor :name
-    def initialize name, &block
+    attr_accessor :name, :_global, :_on_wakeup, :_on_sleep, :_on_connect, :_on_disconnect, :event_handlers, :every_handlers, :options
+    def initialize name, options
       @name = name
-      @block = block
+      @options = options
+
+      #These are the 'on' handlers
+      @event_handlers = []
 
-      self.instance_eval(&block)
+      #These are for every 5.seconds
+      @every_handlers = []
     end
 
     def get_on_init
@@ -57,18 +105,67 @@ module Flok
       return @on_request
     end
 
-    def on_init str
-      @on_init = macro(str)
+    def global(str)
+      render = ERB.new(str)
+      str = render.result(binding)
+      @_global = str
+    end
+
+    def on_wakeup(str) 
+      render = ERB.new(str)
+      str = render.result(binding)
+      @_on_wakeup  = str
+    end
+
+    def on_sleep(str) 
+      render = ERB.new(str)
+      str = render.result(binding)
+
+      @_on_sleep = str
+    end
+
+    def on_connect(str) 
+      render = ERB.new(str)
+      str = render.result(binding)
+      @_on_connect = str
     end
 
-    def on_request str
-      @on_request = macro(str)
+    def on_disconnect(str) 
+      render = ERB.new(str)
+      str = render.result(binding)
+      @_on_disconnect = str
+    end
+
+    def on(name, str)
+      render = ERB.new(str)
+      str = render.result(binding)
+
+      @event_handlers << {
+        :name => name,
+        :str => str
+      }
+    end
+
+    def every(seconds, str)
+      @every_handlers << {
+        :name => "#{seconds}_sec_#{SecureRandom.hex[0..6]}",
+        :ticks => seconds*4,
+        :str => str
+      }
+    end
+
+    def type str
+      @_type = str.to_s
+      unless ["daemon", "agent"].include? @_type
+        raise "You gave a type for the service, #{@_type.inspect} but this wasn't a valid type of service. Should be \
+        either 'daemon' or 'agent'"
+      end
     end
 
     def macro text
-      out = StringIO.new
+      #out = StringIO.new
 
-      text.split("\n").each do |l|
+      #text.split("\n").each do |l|
         ##Request(vc_name, spot_name, context) macro
         #if l =~ /Request/
           #l.strip!
@@ -84,11 +181,11 @@ module Flok
           #out << %{
           #}
         #else
-          out.puts l
+          #out.puts l
         #end
-      end
+      #end
 
-      return out.string
+      #return out.string
     end
   end
 end

data/lib/flok/user_compiler.rb

@@ -15,8 +15,6 @@ module Flok
       ctable_renderer = ERB.new(ctable_erb)
       @src << ctable_renderer.result(context.get_binding)
 
-      #puts @src
-
       return @src
     end
   end
@@ -194,6 +192,9 @@ module Flok
                 //Free +1 because that will be the 'main' view
                 main_q.push([1, "if_free_view", embeds[i][j]+1]);
 
+                //Call dealloc on the controller
+                tel_deref(embeds[i][j]).cte.__dealloc__(embeds[i][j]);
+
                 <% if @debug %>
                   var vp = embeds[i][j]+1;
                   //First locate spot this view belongs to in reverse hash
@@ -228,7 +229,7 @@ module Flok
             }]);
           }
           out.puts res
-        #Request(service_name, payload, event_name_cb)
+        #Request(service_instance_name, ename, info)
         elsif l =~ /Request/
           l.strip!
           l.gsub!(/Request\(/, "")
@@ -237,11 +238,13 @@ module Flok
           o = l.split(",").map{|e| e.strip}
 
           name = o.shift.gsub(/"/, "")
+          ename = o.shift.gsub(/"/, "")
           info = o.shift.gsub(/"/, "")
-          event_name = o.shift
+
+          raise "You tried to Request the service #{name.inspect}, but you haven't added that to your 'services' for this controller (#{@controller.name.inspect})" unless @controller._services.include? name
 
           out << %{
-            service_#{name}_req(#{info}, __base__, #{event_name});
+            #{name}_on_#{ename}(__base__, #{info});
           }
         else
           out.puts l
@@ -265,12 +268,13 @@ module Flok
   end
 
   class UserCompilerController
-    attr_accessor :name, :spots, :macros
+    attr_accessor :name, :spots, :macros, :_services
     def initialize name, ctx, &block
       @name = name
       @ctx = ctx
       @spots = ['main']
       @macros = {}
+      @_services = []
 
       self.instance_eval(&block)
     end
@@ -285,6 +289,10 @@ module Flok
       @spots += spots
     end
 
+    def services *instance_names
+      @_services = instance_names.map{|e| e.to_s}
+    end
+
     #Pass through action
     def action name, &block
       @ctx.action self, name, &block

data/lib/flok/user_compiler_templates/ctable.js.erb

@@ -1,6 +1,16 @@
 ctable = {
   <% @controllers.each do |c| %>
       <%= c.name %>: {
+        __init__: function(__base__) {
+          <% c._services.each do |s| %>
+              <%= s %>_on_connect(__base__);
+          <% end %>
+        },
+        __dealloc__: function(__base__) {
+          <% c._services.each do |s| %>
+              <%= s %>_on_disconnect(__base__);
+          <% end %>
+        },
         name: '<%= c.name %>',
         root_view: '<%= c.name %>',
         spots: <%= c.spots.to_json %>,

data/lib/flok/version.rb

@@ -1,3 +1,3 @@
 module Flok
-  VERSION = "0.0.36"
+  VERSION = "0.0.38"
 end