goat 0.2.12 → 0.3.0

data/lib/goat/common.rb

@@ -0,0 +1,53 @@
+module Goat
+  class ComponentSkeleton
+    attr_reader :pgid, :id, :spec
+    attr_accessor :dom, :state
+
+    def cls; @class; end
+
+    def initialize(pgid, cls, id, spec, state, dom)
+      @pgid = pgid
+      @class = cls
+      @id = id
+      @state = state
+      @dom = dom
+      @spec = spec
+    end
+
+    def self.from_hash(h)
+      self.new(h['pgid'], h['class'], h['id'], h['spec'], h['state'], Marshal.load(h['dom']))
+    end
+
+    def to_hash
+      {
+        'pgid' => @pgid,
+        'class' => @class,
+        'id' => @id,
+        'spec' => @spec,
+        'state' => @state,
+        'dom' => Marshal.dump(@dom),
+      }
+    end
+  end
+
+  class ComponentUpdate
+    attr_reader :skel, :mutations
+    attr_accessor :version
+
+    def initialize(skel, mutations)
+      @skel = skel
+      @mutations = mutations
+    end
+
+    def to_hash
+      {
+        'skel' => @skel.to_hash,
+        'mutations' => @mutations
+      }
+    end
+
+    def self.from_hash(h)
+      self.new(ComponentSkeleton.from_hash(h['skel']), h['mutations'])
+    end
+  end
+end

data/lib/goat/dynamic.rb

@@ -0,0 +1,91 @@
+# This library was created by Christian Neukirchen in the context of
+# EuRuKo 2005 and is licensed under the same terms as Ruby.
+#
+# It provides dynamically scoped variables. It is used within ContextR to
+# store the current, thread-wide activated layers.
+#
+# For more information see the corresponding slides at
+# http://chneukirchen.org/talks/euruko-2005/chneukirchen-euruko2005-contextr.pdf
+#
+# (c) 2005 - Christian Neukirchen - http://chneukirchen.org
+module Dynamic
+  module ClassMethods #:nodoc:
+    Thread.main[:DYNAMIC] = Hash.new { |hash, key|
+      raise NameError, "no such dynamic variable: #{key}"
+    }
+
+    def here!
+      Thread.current[:DYNAMIC] = Hash.new { |hash, key|
+        raise NameError, "no such dynamic variable: #{key}"
+      }.update Thread.main[:DYNAMIC]
+    end
+
+    def variable?(v)
+      variables.include?(v)
+    end
+
+    def variables
+      Thread.current[:DYNAMIC] or here!
+    end
+
+    def variable(definition)
+      case definition
+      when Symbol
+        #if variables.has_key? definition
+        #  raise NameError, "dynamic variable `#{definition}' already exists"
+        #end
+        variables[definition] = nil
+      when Hash
+        definition.each { |key, value|
+          if variables.has_key? key
+            raise NameError, "dynamic variable `#{key}' already exists"
+          end
+          variables[key] = value
+        }
+      else
+        raise ArgumentError,
+        "can't create a new dynamic variable from #{definition.class}"
+      end
+    end
+
+    def [](key)
+      variables[key]
+    end
+
+    def []=(key, value)
+      variables[key] = value
+    end
+
+    def undefine(*keys)
+      keys.each { |key|
+        self[key]
+        variables.delete key
+      }
+    end
+
+    def let(bindings, &block)
+      save = {}
+      save_keys = variables.keys
+      bindings.to_hash.collect { |key, value|
+        self.variable(key)
+        save[key] = self[key]
+        self[key] = value
+      }
+      block.call
+    ensure
+      variables.update save
+      undefine(*(variables.keys - save_keys))
+    end
+
+    def method_missing(name, *args)
+      if match = /=\Z/.match(name.to_s)    # setter?
+        raise ArgumentError, "invalid setter call"  unless args.size == 1
+        self[match.pre_match.intern] = args.first
+      else
+        raise ArgumentError, "invalid getter call"  unless args.empty?
+        self[name]
+      end
+    end
+  end
+  extend ClassMethods
+end

data/lib/goat/extn.rb

@@ -16,11 +16,100 @@ class String
   unless self.instance_methods.include?('random')    
     def self.random(len=10, opts={})
       opts = {:alpha => false}.merge(opts)
-      chars = ["a".."z", "A".."Z"]
-      chars << ("0".."9") unless opts[:alpha]
 
-      flat = chars.map(&:to_a).flatten
-      len.times_collect {flat[SecureRandom.random_number(flat.size)]}.join
+      regexp = opts[:alpha] ? /[^A-Za-z]/ : /[^A-Za-z0-9]/ 
+
+        str = SecureRandom.random_bytes(len * 8).gsub(regexp, '')
+      if str.size >= len
+        str[0..(len-1)]
+      else
+        # should basically never happen
+        random(len, opts)
+      end
+    end
+  end
+end
+
+class Object
+  def self.superclasses(upto=Object)
+    cs = []
+    c = self
+    start = self
+
+    while c
+      cs << c
+      return cs if c == upto
+      raise "#{upto} isn't in the hierachy of #{start.inspect}" if c == Object && upto != Object
+
+      c = c.superclass
+    end
+  end
+
+  def subclass_of?(cls)
+    self == cls || \
+      (self == Object ? \
+       false : \
+       (self.superclass && self.superclass != self && self.superclass.subclass_of?(cls)))
+  end
+
+  def glimpse(n=100)
+    ins = self.inspect
+    if ins =~ />$/ && ins.size > n
+      "#{ins[0..n]}...>"
+    else
+      ins
     end
   end
-end
+end
+
+module Kernel
+  # from http://redcorundum.blogspot.com/2006/05/kernelqualifiedconstget.html
+  def fetch_class(str)
+    path = str.to_s.split('::')
+    from_root = path[0].empty?
+    if from_root
+      from_root = []
+      path = path[1..-1]
+    else
+      start_ns = ((Class === self)||(Module === self)) ? self : self.class
+      from_root = start_ns.to_s.split('::')
+    end
+    until from_root.empty?
+      begin
+        return (from_root+path).inject(Object) { |ns,name| ns.const_get(name) }
+      rescue NameError
+        from_root.delete_at(-1)
+      end
+    end
+    path.inject(Object) { |ns,name| ns.const_get(name) }
+  end
+end
+
+class Set
+  def glimpse(n=100)
+    "#<Set: #{self.map{|x| x.glimpse(n)}.join(', ')}>"
+  end
+end
+
+class Array
+  def glimpse(n=100)
+    "[" + self.map{|x| x.glimpse(n)}.join(', ') + "]"
+  end
+end
+
+class Hash
+  def glimpse(n=100)
+    "{" + self.map{|k, v| k.glimpse + "=>" + v.glimpse}.join(', ') + "}"
+  end
+end
+
+class Hash
+  def map_to_hash
+    h = {}
+    self.map do |k, v|
+      nk, nv = yield(k, v)
+      h[nk] = nv
+    end
+    h
+  end
+end

data/lib/goat/goat.js

@@ -1,6 +1,322 @@
+(function(){
+  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
+  // The base Class implementation (does nothing)
+  this.Class = function(){};
+  
+  // Create a new Class that inherits from this class
+  Class.extend = function(prop) {
+    var _super = this.prototype;
+    
+    // Instantiate a base class (but only create the instance,
+    // don't run the init constructor)
+    initializing = true;
+    var prototype = new this();
+    initializing = false;
+    
+    // Copy the properties over onto the new prototype
+    for (var name in prop) {
+      // Check if we're overwriting an existing function
+      prototype[name] = typeof prop[name] == "function" && 
+        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
+        (function(name, fn){
+          return function() {
+            var tmp = this._super;
+            
+            // Add a new ._super() method that is the same method
+            // but on the super-class
+            this._super = _super[name];
+            
+            // The method only need to be bound temporarily, so we
+            // remove it when we're done executing
+            var ret = fn.apply(this, arguments);        
+            this._super = tmp;
+            
+            return ret;
+          };
+        })(name, prop[name]) :
+        prop[name];
+    }
+    
+    // The dummy class constructor
+    function Class() {
+      // All construction is actually done in the init method
+      if ( !initializing && this.init )
+        this.init.apply(this, arguments);
+    }
+    
+    // Populate our constructed prototype object
+    Class.prototype = prototype;
+    
+    // Enforce the constructor to be what we expect
+    Class.constructor = Class;
+
+    // And make this class extendable
+    Class.extend = arguments.callee;
+    
+    return Class;
+  };
+})();
+
+String.random = function string_random(len, pref) {
+  var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
+  var str = '';
+  for (var i=0; i < len; i++) {
+    var r = Math.floor(Math.random() * chars.length);
+    str += chars.substring(r, r+1);
+  }
+  return pref ? (pref + '_' + str) : str;
+}
+
+$(document).ready(function() {
+  Goat.loadComponents();
+  setTimeout(function() { if(Goat.page_id) Goat.openChannel(); }, 1000);
+});
+
+var GoatRT = {
+  version: 0,
+  pendingTxns: {},
+  ops: {}
+};
+
+(function(rt) {
+  function updateFailed(msg) {
+    console.error(msg);
+  }
+
+  function node(par, pos) {
+    if(pos === null)
+      return $('#' + par);
+    else
+      return $("#" + par + " > :nth-child(" + (pos + 1) + ")");
+  }
+
+  function removeNode(par, pos, html) {
+    node(par, pos).remove();
+  }
+
+  function addNode(par, pos, html) {
+    node(par, pos).before(html);
+  }
+
+  function replaceNode(par, pos, html) {
+    console.log("rep " + par + " " + pos);
+    console.log(node(par, pos));
+    node(par, pos).html(html);
+    if(pos === null)
+      delete Goat.components[par];
+  }
+
+  function applyUpdate(up) {
+    var t = up.type;
+    var par = up.parent;
+    var pos = up.position;
+    var html = up.html;
+    var js = up.js;
+    var css = up.css;
+
+    if(t == "rem") {
+      removeNode(par, pos, html);
+    } else if(t == "add") {
+      addNode(par, pos, html);
+    } else if(t == "rep") {
+      replaceNode(par, pos, html);
+    }
+
+    addCSS(css);
+    addJS(js);
+  }
+
+  function addToHead(elt) {
+    var head = document.getElementsByTagName('head')[0];
+    head.appendChild(elt);
+  }
+
+  function addCSS(css) {
+    var style = document.createElement('style');
+    style.innerHTML = css;
+    addToHead(style);
+  }
+
+  function addJS(js) {
+    var script = document.createElement('script');
+    script.innerHTML = js;
+    addToHead(script);
+    Goat.loadComponents();
+    /*console.log("Eval " + js);
+    eval(js);*/
+  }
+
+  function updateReceived(m) {
+    var id = m.id;
+    var version = m.version;
+    var updates = m.updates;
+
+    if(m.version == rt.version + 1) {
+      $(updates).each(function(_,u) {
+        applyUpdate(u);
+      });
+      rt.version++;
+    } else if(m.version <= rt.version) {
+      // fine, we already have this 
+    } else {
+      updateFailed("Tried to apply update " + version + ", but I'm only at version " + rt.version);
+    }
+  }
+
+  function showSpinner() {
+    $("#menu").prepend(GoatRT.spinner);
+  }
+
+  function hideSpinner() {
+    $("#spinner").remove();
+  }
+
+  function newTxn() {
+    var op = new RTTxn();
+    rt.ops[op.code] = op;
+    return op;
+  }
+
+  function beginTxn(txn) {
+    rt.pendingTxns[txn.code] = true;
+  }
+
+  function pendingCount() {
+    var pending = 0;
+    for(var k in rt.pendingTxns) pending++;
+    return pending;
+  }
+
+  function completeTxn(txn) {
+    if(rt.pendingTxns[txn]) {
+      delete rt.pendingTxns[txn];
+
+      if(pendingCount() == 0) {
+        if(!txn.start) hideSpinner();
+        if(txn.complete) txn.complete();
+      }
+    } else {
+      console.error("Can't complete txn " + txn + ": no such txn was started");
+    }
+  }
+
+  function txnCompleteMsg(msg) {
+    console.log('txnCompleteMsg');
+    console.log(msg);
+    completeTxn(msg['txn']);
+  }
+
+  rt.updateReceived = updateReceived;
+  rt.node = node;
+  rt.newTxn = newTxn;
+  rt.beginTxn = beginTxn;
+  rt.txnCompleteMsg = txnCompleteMsg;
+  rt.spinner = $("<img id=\"spinner\" style=\"position: relative; float: left; top: 50px; left: 20px;\" src=\"/static/img/spinner.gif\">");
+  rt.showSpinner = showSpinner;
+
+  return rt;
+})(GoatRT);
+
+var RTTxn = Class.extend({
+  init: function() {
+    this.code = String.random(8, 'txn');
+  },
+
+  onStart: function(s) {
+    this.start = s;
+  },
+
+  onComplete: function(c) {
+    this.complete = c;
+  }
+});
+
+var GoatRPC = Class.extend({
+  init: function(c, n) {
+    this.component = c;
+    this.name = n;
+  },
+
+  args: function(a) {
+    this.args = a;
+    return this;
+  },
+
+  data: function(d) {
+    this.data = d;
+    return this;
+  },
+
+  onRPCComplete: function(s) {
+    this.rpcComplete = s;
+    return this;
+  },
+
+  onRPCError: function(f) {
+    this.rpcError = f;
+    return this;
+  },
+
+  rpcSuccess: function(data) {
+    if(this.rpcComplete) this.rpcComplete(data, this);
+  },
+
+  rpcFailure: function() {
+    if(this.rpcError) this.rpcError(this);
+  },
+
+  onStart: function(start) {
+    this.start = start;
+    return this;
+  },
+
+  onUpdateComplete: function(c) {
+    this.updateComplete = c;
+    return this;
+  },
+
+  send: function() {
+    var data = this.data;
+
+    data['cls'] = this.component.cls;
+    data['id'] = this.component.id;
+    data['rpc'] = this.name;
+    data['pgid'] = Goat.page_id;
+    data['args'] = JSON.stringify(this.args);
+
+    if(this.rt) {
+      var txn = GoatRT.newTxn();
+      data['rttxn'] = txn.code;
+      txn.onComplete(this.updateComplete);
+      GoatRT.beginTxn(txn);
+    }
+
+    if(this.start) this.start()
+    else if(this.rt) GoatRT.showSpinner();
+
+    $.ajax({
+      type: 'POST',
+      url: '/rpc',
+      data: data,
+      success: closure(this, this.rpcSuccess),
+      error: closure(this, this.rpcFailure),
+      dataType: 'script',
+      async: true
+    });
+
+    return this;
+  },
+
+  rtUpdate: function() {
+    this.rt = true;
+    return this;
+  }
+});
+
 var Goat = {
   channelOpenFails: 0,
   activeChannel: null,
+  pageDead: false,
   components: {},
   page_id: null
 }
@@ -14,33 +330,15 @@ function closure(target, fn) {
 $.extend(Goat, {
   closure: function(fn) { return closure(this, fn); },
   
-  node: function(str) {
-    return $('#' + str);
-  },
-  
-  createNode: function(m) {
-    var after = m['after'];
-    var html = m['html'];
-    
-    if(after) {
-      var anode = this.node(after);
-      if(anode.size() == 0)
-        console.error("Couldn't find node " + after + " to insert after");
-      else
-        anode.after(html);
-    } else {
-      $(document).after(html);
-    }
+  channelURL: function() {
+    if(window.location.host.match(/127\./))
+      return 'http://127.0.0.1:8050/channel';
+    else
+      return '/channel';
   },
   
-  removeNode: function(m) {
-    var id = m['id'];
-    var html = m['html'];
-    var rm = this.node(id);
-    if(rm.size() == 0)
-      console.error("Couldn't find node " + id + " to remove");
-    else
-      rm.remove();
+  node: function(str) {
+    return $('#' + str);
   },
   
   showAlert: function(m) {
@@ -49,19 +347,20 @@ $.extend(Goat, {
   },
 
   messageReceived: function(m) {
+    console.log(m);
+
     var t = m['type'];
-    if(t == 'update') {
-      var id = m['id'];
-      var html = m['html'];
-      this.node(id).html(html);
+    if(t == 'component_updated') {
+      GoatRT.updateReceived(m);
     } else if(t == 'redirect') {
       console.log("Redirecting to " + m['location']);
       sleep(2);
       window.location = m['location'];
-    } else if (t == 'create') {
-      this.createNode(m);
-    } else if (t == 'remove') {
-      this.removeNode(m);
+    } else if(t == 'page_expired') {
+      alert("Due to inactivity, you'll need to refresh this page.");
+      Goat.pageDead = true;
+    } else if(t == 'txn_complete') {
+      GoatRT.txnCompleteMsg(m);
     } else if(t == 'alert') {
       this.showAlert(m);
     } else {
@@ -78,9 +377,6 @@ $.extend(Goat, {
     
     this.channelOpenFails = 0;
     
-    if(this.messageReceivedDelegate)
-      this.messageReceivedDelegate(data);
-
     if(data['messages']) {
       $(data['messages']).each(this.closure(function(i, m) { this.messageReceived(m) }));
     } else {
@@ -91,11 +387,16 @@ $.extend(Goat, {
   reopenChannel: function() {
     console.log("reopenChannel()");
     var fails = this.channelOpenFails;
-    setTimeout(function() { Goat.openChannel(); }, Math.min(30000, Math.pow(1.5, fails)));
+    setTimeout(function() { Goat.openChannel(); }, Math.min(30000, Math.max(1000, Math.pow(1.5, fails))));
     this.channelOpenFails++;
   },
 
   openChannel: function() {
+    if(Goat.pageDead) {
+      console.log("not opening channel: page dead");
+      return;
+    }
+
     console.log("opening channel");
     
     if(this.activeChannel) {
@@ -122,8 +423,9 @@ $.extend(Goat, {
       var logError = closure(this, function() {
         console.error("Goat: error loading " + src);
       });
-      
-      var src = '/channel?_id=' + Goat.page_id + '&jsonp=' + jsonp;
+
+      var base = Goat.channelURL();
+      var src = base + '?_id=' + Goat.page_id + '&jsonp=' + jsonp + '&version=' + GoatRT.version;
       
       scriptTag.addEventListener('load', function() { cleanup(); Goat.reopenChannel(); }, false);
       scriptTag.addEventListener('error', function() { cleanup(); logError(); Goat.reopenChannel(); }, false);
@@ -157,88 +459,15 @@ $.extend(Goat, {
 
     return false;
   },
-
-  remoteDispatch: function(c, k) {
-    $.ajax({
-      url: '/dispatch',
-      async: true,
-      data: {_id: Goat.page_id, _component: c, _dispatch: k},
-      success: function(data) {},
-      error: function(req, stat, err) {
-        console.log("remote dispatch error");
-        console.log({req: req, status: stat, err: err});
-      }
-    });
-    
-    return false;
-  },
   
   wireComponent: function(id, obj) {
     this.components[id] = obj;
-  }
-});
-
-(function(){
-  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
-  // The base Class implementation (does nothing)
-  this.Class = function(){};
-  
-  // Create a new Class that inherits from this class
-  Class.extend = function(prop) {
-    var _super = this.prototype;
-    
-    // Instantiate a base class (but only create the instance,
-    // don't run the init constructor)
-    initializing = true;
-    var prototype = new this();
-    initializing = false;
-    
-    // Copy the properties over onto the new prototype
-    for (var name in prop) {
-      // Check if we're overwriting an existing function
-      prototype[name] = typeof prop[name] == "function" && 
-        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
-        (function(name, fn){
-          return function() {
-            var tmp = this._super;
-            
-            // Add a new ._super() method that is the same method
-            // but on the super-class
-            this._super = _super[name];
-            
-            // The method only need to be bound temporarily, so we
-            // remove it when we're done executing
-            var ret = fn.apply(this, arguments);        
-            this._super = tmp;
-            
-            return ret;
-          };
-        })(name, prop[name]) :
-        prop[name];
-    }
-    
-    // The dummy class constructor
-    function Class() {
-      // All construction is actually done in the init method
-      if ( !initializing && this.init )
-        this.init.apply(this, arguments);
-    }
-    
-    // Populate our constructed prototype object
-    Class.prototype = prototype;
-    
-    // Enforce the constructor to be what we expect
-    Class.constructor = Class;
-
-    // And make this class extendable
-    Class.extend = arguments.callee;
-    
-    return Class;
-  };
-})();
+  },
 
-$(document).ready(function() {
-  $.each(Goat.components, function(_, c) { c.onLoad(); });
-  setTimeout(function() { if(Goat.page_id) Goat.openChannel(); }, 1000);
+  loadComponents: function() {
+    $.each(Goat.components, function(_, c) {
+      if(!c.isLoaded())
+        c.load();
+    });
+  }
 });
-