rsence 2.0.0.0.pre

data/conf/local_conf.yaml

@@ -0,0 +1,14 @@
+--- 
+:plugin_paths:
+  - demos
+:http_server: 
+  :latency: 0
+  :rack_handler: 
+  :rack_require: mongrel
+  :bind_address: 0.0.0.0
+  :port: 8001
+:database: 
+  :ses_db: sqlite://var/db/rsence_ses.db
+:client_pkg:
+  :no_obfuscation: true
+  :no_whitespace_removal: true

data/conf/unicorn.conf

@@ -0,0 +1,78 @@
+# Sample configuration file for Unicorn (not Rack)
+#
+# See http://unicorn.bogomips.org/Unicorn/Configurator.html for complete
+# documentation.
+
+# Use at least one worker per core if you're on a dedicated server,
+# more will usually help for _short_ waits on databases/caches.
+worker_processes 1
+
+# Help ensure your application will always spawn in the symlinked
+# "current" directory that Capistrano sets up.
+# working_directory "/path/to/app/current" # available in 0.94.0+
+
+# listen on both a Unix domain socket and a TCP port,
+# we use a shorter backlog for quicker failover when busy
+# listen "/tmp/.sock", :backlog => 64
+# listen 8080, :tcp_nopush => true
+
+# nuke workers after 30 seconds instead of 60 seconds (the default)
+timeout 9999
+
+# feel free to point this anywhere accessible on the filesystem
+#pid "/path/to/app/shared/pids/unicorn.pid"
+
+# some applications/frameworks log to stderr or stdout, so prevent
+# them from going to /dev/null when daemonized here:
+#stderr_path "/path/to/app/shared/log/unicorn.stderr.log"
+#stdout_path "/path/to/app/shared/log/unicorn.stdout.log"
+
+# combine REE with "preload_app true" for memory savings
+# http://rubyenterpriseedition.com/faq.html#adapt_apps_for_cow
+preload_app true
+GC.respond_to?(:copy_on_write_friendly=) and
+  GC.copy_on_write_friendly = true
+
+# before_fork do |server, worker|
+#   # the following is highly recomended for Rails + "preload_app true"
+#   # as there's no need for the master process to hold a connection
+#   defined?(ActiveRecord::Base) and
+#     ActiveRecord::Base.connection.disconnect!
+# 
+#   # The following is only recommended for memory/DB-constrained
+#   # installations.  It is not needed if your system can house
+#   # twice as many worker_processes as you have configured.
+#   #
+#   # # This allows a new master process to incrementally
+#   # # phase out the old master process with SIGTTOU to avoid a
+#   # # thundering herd (especially in the "preload_app false" case)
+#   # # when doing a transparent upgrade.  The last worker spawned
+#   # # will then kill off the old master process with a SIGQUIT.
+#   # old_pid = "#{server.config[:pid]}.oldbin"
+#   # if old_pid != server.pid
+#   #   begin
+#   #     sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
+#   #     Process.kill(sig, File.read(old_pid).to_i)
+#   #   rescue Errno::ENOENT, Errno::ESRCH
+#   #   end
+#   # end
+#   #
+#   # # *optionally* throttle the master from forking too quickly by sleeping
+#   # sleep 1
+# end
+# 
+# after_fork do |server, worker|
+#   # per-process listener ports for debugging/admin/migrations
+#   # addr = "127.0.0.1:#{9293 + worker.nr}"
+#   # server.listen(addr, :tries => -1, :delay => 5, :tcp_nopush => true)
+# 
+#   # the following is *required* for Rails + "preload_app true",
+#   defined?(ActiveRecord::Base) and
+#     ActiveRecord::Base.establish_connection
+# 
+#   # if preload_app is true, then you may also want to check and
+#   # restart any other shared sockets/descriptors such as Memcached,
+#   # and Redis.  TokyoCabinet file handles are safe to reuse
+#   # between any number of forked children (assuming your kernel
+#   # correctly implements pread()/pwrite() system calls)
+# end

data/js/comm/comm/autosync/autosync.js

@@ -0,0 +1,18 @@
+/*   Riassence Framework
+ *   Copyright 2009 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+// Starts the synchronization upon page load.
+LOAD(
+  function(){
+    COMM.urlResponder=COMM.URLResponder.nu();
+    urlResponder=COMM.urlResponder; // backwards compatibility
+    COMM.Transporter.url=HCLIENT_HELLO;
+    COMM.Transporter.stop=false;
+    COMM.Transporter.sync();
+  }
+);

data/js/comm/comm/comm.js

@@ -0,0 +1,195 @@
+/*   Riassence Framework
+ *   Copyright 2009 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+
+/*** = Description
+  ** XMLHttpRequest abstractor, and handler and utilities.
+  ** The only public method is +request+
+  ** The namespace also holds the following services:
+  **
+  ** Service Name::          Service Description
+  ** +COMM.Queue+::          Singleton, used for queuing tasks
+  **                         awaiting asynchronous requests to complete.
+  ** +COMM.Session+::        Session key secure hashing service.
+  ** +COMM.SessionWatcher+:: Polls server at regular intervals by reporting
+  **                         the client's local time.
+  ** +COMM.Transporter+::    Automated synchronization service, pulls server
+  **                         data, tasks etc. The main server interface.
+  ** +COMM.Values+::         Data value manager, handles synchronized data in
+  **                         both directions (server-client-server).
+  ** +COMM.JSLoader+::       Loads Javascript libraries asynchronously.
+  ** +COMM.JSONRenderer+::   Constructs nodes from JSON structures as GUI
+  **                         tree structures. Lowers the learning curve of GUI
+  **                         development, because Javascript knowledge is not
+  **                         required to define user interfaces.
+  **                         The main purpose is to ease the development of
+  **                         user interfaces by defining them as data on the
+  **                         server, converting the data to JSON GUI trees and
+  **                         letting the client handle the rest. The end result
+  **                         is the same as defining the structures in
+  **                         JavaScript code.
+  **
+***/
+COMM = {
+  
+/** Displays an error alert, if the browser doesn't support XMLHttpRequests
+  **/
+  _FakeHttpRequest: function(){
+    alert("'ERROR: This web browser doesn't support XMLHttpRequest. Please upgrade; unable to continue.");
+  },
+  
+/** = Description
+  * Finds and calls the state responder method upon a readyState change to 4.
+  * - On readyStates other than 4 does nothing.
+  * - The default responder for a successful response code (between 200 to 299) is onSuccess.
+  * - The default responder for unsuccessful response codes is onFailure.
+  * - The responders are called with the request object as the parameter.
+  * - Custom response code handling is implemented as 'on' + status code,
+  *   eg. 'on404' for a 404 not found error.
+  **/
+  _stateChange: function(_this){
+    if(_this.X.readyState === 4){
+      var _status = _this.X.status,
+          _responderName = 'on'+_status,
+          _success = ((_status >= 200 && _status < 300) || (_status === 0));
+      _this[_responderName]?_this[_responderName](_this):_success?_this.onSuccess(_this):_this.onFailure(_this);
+    }
+  },
+  
+/** = Description
+  * Converts arrays to valid query strings.
+  *
+  * = Usage
+  * Returns 'productId=100&customerName=J-J%20Heinonen'
+  *   COMM._arrayToQueryString(['productId',100,'customerName','J-J Heinonen'])
+  *
+  **/
+  _arrayToQueryString: function(_params){
+    var i = 0,
+        _length = _params.length,
+        _queryString = '';
+    for(;i<_length;i++){
+      _queryString += encodeURIComponent(_params[i]);
+      _queryString += (i===_length-1)?'':(i%2===0)?'=':'&';
+    }
+    return _queryString;
+  },
+  
+/** = Description
+  * The main Request-handling object. Provides a general and fairly easy to use
+  * interface for making "Ajax" requests.
+  *
+  * = Parameters
+  * +_url+::        Full or relative url of the response handler
+  * +_options+::    An +Object+, see below for content:
+  *
+  *
+  * == Required properties for +_options+:
+  * +onSuccess+::   A function that is called on a successful response.
+  *                 Must accept one parameter: the request object.
+  * +onFailure+::   A function that is called on an unsuccessful response.
+  *                 Must accept one parameter: the request object.
+  *
+  * == Optional properties for +_options+:
+  * +method+::      The HTTP Request Method, usually 'POST' or 'GET', but will handle
+  *                 DAV and other extensions if the server supports them.
+  *                 Defaults to 'POST'.
+  * +async+::       Boolean; Uses asyncronous requests when true.
+  *                 Defaults to true.
+  * +params+::      Extra parameters to send, format: Array, see COMM._arrayToQueryString()
+  * +headers+::     Extra HTTP headers to send for POST requests, format: Hash.
+  * +body+::        The HTTP POST Body
+  * +username+::    Username for basic authentication
+  * +password+::    Password for basic authentication
+  * +contentType+:: The 'content-type' -header to send.
+  *                 Defaults to 'application/x-www-form-urlencoded'.
+  * +charset+::     The charset type to use. Defaults to 'UTF-8'.
+  *
+  * = Returns
+  * An +Object+ extended from the +_options+ given in the input.
+  *
+  **/
+  request: function(_url,_options){
+    var _comm = COMM,
+      
+        _this = _options?_options:{},
+      
+        _method = _options.method?_options.method.toUpperCase():'GET',
+        _async = (_options.async===undefined)?true:_options.async,
+        _params = _options.params?_options.params:[],
+        _headers = _options.headers?_options.headers:{},
+        _contentType = _options.contentType?_options.contentType:'application/x-www-form-urlencoded',
+        _charset = _options.charset?_options.charset:'UTF-8',
+        _username = _options.username?_options.username:null,
+        _password = _options.username?_options.password:null;
+    if(!_options.onFailure){
+      _this.onFailure = function(resp){console.log('No failure handler specified, response: ',resp);};
+    }
+    if(!_options.onSuccess){
+      _this.onSuccess = function(resp){console.log('No success handler specified, response: ',resp);};
+    }
+    _this.url = _url;
+    _this.options = _options;
+    _this.X   = _comm._XMLHttpRequest();
+    if(_method === 'GET' && _params.length !== 0){
+      _url += ((_url.indexOf('?')!==-1)?'&':'?')+_comm._arrayToQueryString(_params);
+    }
+    if(!_async){
+      console.log("WARNING: Synchronous "+_method+" request to "+_url+", these will fail on the Symbian web browser.");
+    }
+    _this.X.open(
+      _method,
+      _url,
+      _async,
+      _username,
+      _password
+    );
+    _this.X.onreadystatechange = function(){
+      _comm._stateChange(_this);
+    };
+    if(_method === 'POST'){
+      _headers['Content-Type'] = _contentType + '; charset=' + _charset;
+      var _body = _options.body?_options.body:'';
+      for(var _header in _headers){
+        _this.X.setRequestHeader(_header,_headers[_header]);
+      }
+      _this.X.send(_body);
+    }
+    else if(_method === 'GET'){
+      _this.X.send(null);
+    }
+    if(!_async){
+      _comm._stateChange(_this);
+    }
+    return _this;
+  }
+};
+
+/** = Description
+  * Creates a new instance of the XMLHttpRequest
+  * object supported by the browser. Evaluated only once,
+  * after that does its things without any extra statements
+  *
+  **/
+if(window['XMLHttpRequest']!==undefined){
+  COMM._XMLHttpRequest = function(){
+    return new XMLHttpRequest();
+  };
+}
+else if(BROWSER_TYPE.ie){
+  COMM._XMLHttpRequest = function(){
+    return new ActiveXObject("Msxml2.XMLHTTP");
+  };
+}
+else {
+  COMM._XMLHttpRequest = function(){
+    console.log("No XMLHttpRequest object types known. Can't Communicate.");
+    return new COMM._FakeHttpRequst();
+  };
+}
+

data/js/comm/comm/queue/queue.js

@@ -0,0 +1,183 @@
+/*   Riassence Framework
+ *   Copyright 2009 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+/*** = Description
+  ** COMM.Queue executes javascript blocks in a managed queue.
+  **
+  ** COMM.Queue is used by COMM.Transporter and JSLoader to continue
+  ** javascript command execution after a XMLHttpRequest finishes.
+  **
+  ** COMM.Queue runs as a single instance, dan't try to reconstruct it.
+***/
+COMM.Queue = HApplication.extend({
+  
+/** The constructor takes no arguments and starts queue flushing automatically.
+  **/
+  constructor: function(){
+    
+    // The queue itself, is packed with anonymous functions
+    this.commandQueue = [];
+    
+    // Flag to signal the pause and resume status.
+    this.paused = false;
+    
+    // Run with priority 10; not too demanding but not too sluggish either
+    this.base(10);
+  },
+  
+/** Checks periodically, if the queue needs flushing.
+  **/
+  onIdle: function(){
+    // Runs the flush operation, if the queue is not
+    // empty and the state is not resumed:
+    !this.paused && this.commandQueue.length !== 0 && this.flush();
+  },
+  
+/** = Description
+  * Pauses the queue.
+  *
+  * Use to stop execution, if some data or code needs to be loaded that the
+  * rest of the queue depends on.
+  * Typically called before an +XMLHttpRequest+ with the +onSuccess+
+  * event defined to call +resume+ when the request is done.
+  *
+  **/
+  pause: function(){
+    this.paused = true;
+  },
+  
+/** = Description
+  * Resumes queue flushing.
+  *
+  * Use to resume execuption, when some depending code for the rest
+  * of the queue has been loaded.
+  * Typically on an +XMLHttpRequest+ +onSuccess+ event.
+  *
+  **/
+  resume: function(){
+    this.paused = false;
+    this.flush();
+  },
+  
+/** A Group of localizable strings; errors and warnings.
+  **/
+  STRINGS: {
+    ERR: 'COMM.Queue Error: ',
+    JS_EXEC_FAIL: 'Failed to execute the Javascript function: ',
+    REASON: ' Reason:'
+  },
+  
+/** = Description
+  * Flushes the queue until stopped.
+  *
+  * Iterates through the +commandQueue+ and calls each function.
+  * Removes items from the queue after execution.
+  *
+  **/
+  flush: function(){
+    var i = 0, // current index in the for-loop.
+        _item, // the current item to execute
+        _function, // the function to run
+        _arguments, // the arguments of the function
+        _len = this.commandQueue.length; // the length of the queue
+    
+    // Iterates through the items.
+    for(;i<_len;i++){
+      
+      // Checks that the queue hasn't been paused.
+      if(this.paused){
+        break; // stops flushing, if paused.
+      }
+      
+      // The first item in the queue is removed from the queue.
+      _item = this.commandQueue.shift();
+      
+      // Execute the item, with arugments if the item
+      try{
+        if(typeof _item === 'function'){
+          _item.call();
+        }
+        else {
+          _function = _item[0];
+          _arguments = _item[1];
+          _function.apply(this,_arguments);
+        }
+      }
+      
+      // Displays an error message in the Javascript console, if failure.
+      catch(e){
+        var _strs = this.STRINGS;
+        console.log([
+          _strs.ERR_PREFIX,
+          _strs.JS_EXEC_FAIL,
+          _item,
+          _strs.REASON,
+          e.description
+        ].join(''));
+      }
+    }
+  },
+  
+/** = Description
+  * Adds an item to the beginning of the queue.
+  *
+  * Use to make the given +_function+ with its 
+  * optional +_arguments+ the next item to flush.
+  *
+  * = Parameters:
+  * +_function+::  An anonymous function. Contains the code to execute.
+  *
+  * +_arguments+:: _Optional_ arguments to pass on to the +_function+
+  **/
+  unshift: function(_function,_arguments){
+    if(_arguments!==undefined){
+      this.commandQueue.unshift([_function,_arguments]);
+    }
+    else {
+      this.commandQueue.unshift(_function);
+    }
+  },
+  
+/** = Description
+  * Adds an item to the end of the queue.
+  *
+  * Use to make the given +_function+ with its 
+  * optional +_arguments+ the last item to flush.
+  *
+  * = Parameters:
+  * +_function+::  An anonymous function. Contains the code to execute.
+  *
+  * +_arguments+:: _Optional_ arguments to pass on to the +_function+
+  **/
+  push: function(_function,_arguments){
+    if(_arguments!==undefined){
+      this.commandQueue.push([_function,_arguments]);
+    }
+    else {
+      this.commandQueue.push(_function);
+    }
+  },
+  
+/** Like +unshift+, but uses the code block as a string to be
+  * passed on as an evaluated anonymous function.
+  **/
+  unshiftEval: function(_evalStr,_arguments){
+    var _function;
+    eval('_function = function(){'+_evalStr+'}');
+    this.unshift(_function);
+  },
+  
+/** Like +push+, but uses the code block as a string to be
+  * passed on as an evaluated anonymous function.
+  **/
+  pushEval: function(_evalStr){
+    var _function;
+    eval('_function = function(){'+_evalStr+'}');
+    this.push(_function);
+  }
+}).nu();