goat 0.1.3

data/lib/goat/extn.rb

@@ -0,0 +1,26 @@
+require 'securerandom'
+
+class Symbol
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+end
+
+class Integer
+  def times_collect
+    (1..self).collect {|n| yield}
+  end
+end
+
+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
+    end
+  end
+end

data/lib/goat/goat.js

@@ -0,0 +1,172 @@
+var Goat = {
+  channelOpenFails: 0,
+  activeChannel: null,
+  components: {},
+  page_id: null
+}
+
+function closure(target, fn) {
+  return function() {
+    return fn.apply(target, arguments);
+  }
+}
+
+$.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);
+    }
+  },
+  
+  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();
+  },
+  
+  showAlert: function(m) {
+    alert_msg = m['message'];
+    alert(alert_msg);
+  },
+
+  messageReceived: function(m) {
+    var t = m['type'];
+    if(t == 'update') {
+      var id = m['id'];
+      var html = m['html'];
+      this.node(id).html(html);
+    } 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 == 'alert') {
+      this.showAlert(m);
+    } else {
+      console.log("Unknown message type: " + m);
+    }
+  },
+
+  channelDataReceived: function(data) {
+    if(data == "") {
+      this.reopenChannel();
+      return;
+    }
+
+    // console.warn("channel data: " + data);
+    data = $.evalJSON(data);
+
+    this.channelOpenFails = 0;
+    
+    if(this.messageReceivedDelegate)
+      this.messageReceivedDelegate(data);
+
+    if(data['messages']) {
+      $(data['messages']).each(this.closure(function(i, m) { this.messageReceived(m) }));
+      this.openChannel();
+    } else {
+      console.error("Bad channel data: " + data)
+    }
+  },
+
+  reopenChannel: function() {
+    console.error("reopenChannel()");
+    var fails = this.channelOpenFails;
+    setTimeout(function() { Goat.openChannel(); }, (fails > 20) ? 20000 : (fails * 500));
+    this.channelOpenFails++;
+  },
+
+  openChannel: function() {
+    console.log("opening channel");
+
+    if(this.activeChannel) {
+      console.error("can't open channel: channel already open");
+      return;
+    }
+
+    this.activeChannel = $.ajax({
+      url: '/channel',
+      async: true,
+      data: {_id: Goat.page_id},
+      cache: false,
+      timeout: 1000000,
+      success: this.closure(function(data) {
+        this.activeChannel = null;
+        this.channelDataReceived(data);
+      }),
+      error: this.closure(function(req, status, err) {
+        this.activeChannel = null;
+        console.error("ajax channel error");
+        console.error({req: req, status: status, err: err});
+        this.reopenChannel();
+      })
+    });
+  },
+
+  submitForm: function(id) {
+    var data = {};
+    var appendValue = function(i, input){ data[input.name] = $(input).val(); };
+    $("#" + id + " input").each(appendValue);
+    $("#" + id + " textarea").each(appendValue);
+    data['_id'] = Goat.page_id;
+    $.ajax({
+      url: '/post',
+      async: true,
+      data: data,
+      cache: false,
+      success: function(data) {},
+      error: function(req, stat, err) {
+        console.log("submit form error");
+        console.log({req: req, status: stat, err: err});
+      }
+    });
+
+    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;
+  },
+
+  registerComponent: function(id) {
+    this.components[id] = id;
+  }
+});
+
+$(document).ready(function() {
+  setTimeout(function() { if(Goat.page_id) Goat.openChannel(); }, 1);
+});
+

data/lib/goat/html.rb

@@ -0,0 +1,147 @@
+module Goat
+  class HTMLBuilder
+    class ::String
+      def to_html(builder, comp)
+        builder.string_to_html(self, comp)
+      end
+    end
+
+    class ::Array
+      def to_html(builder, comp)
+        raise InvalidBodyError.new(self) if self.include?(nil)
+        builder.array_to_html(self, comp)
+      end
+    end
+
+    class InvalidBodyError < RuntimeError
+      attr_reader :body
+
+      def initialize(body)
+        super("Invalid body: #{body.inspect}")
+        @body = body
+      end
+    end
+
+    class TagBuilder
+      # TODO: gmail trick of only a single onclick() handler
+
+      def self.build(tag, attrs, body, comp)
+        self.new(tag, attrs, body, comp).dispatch
+      end
+
+      def initialize(tag, attrs, body, comp)
+        @tag = tag
+        @attrs = attrs
+        @body = body
+        @comp = comp
+
+        rewrite_attrs
+      end
+
+      def rewrite_attrs
+        new = {}
+
+        @attrs.map_to_hash do |k, v|
+          if k == :onclick && v.kind_of?(Hash)
+            raise "Invalid onclick" unless v.include?(:target) && v.include?(:selector)
+            target = v[:target]
+            sel = v[:selector]
+
+            key = @comp.register_handler(target, sel)
+            new[k] = "Goat.remoteDispatch('#{@comp.id}', '#{key}')"
+            new[:href] = "#"
+          elsif k == :class && v.kind_of?(Array)          
+            new[:class] = @attrs[:class].join(' ')
+          else            
+            new[k] = v
+          end
+        end
+
+        @attrs = new
+      end
+
+      def form_tag
+        target = @attrs.delete(:target)
+        [:form, @attrs, @body + [[:input, {:type => 'hidden', :name => '_component', :value => @comp.id}]]]
+      end
+      
+      def a_tag
+        if action = @attrs.delete(:action)
+          # [:a, {}, 'dead']
+          # key = @comp.register_callback(action)
+          # @attrs[:onclick] = "Goat.remoteDispatch('#{@comp.id}', '#{key}')"
+          # @attrs[:href] = '#'
+          # [:a, @attrs, @body]
+          action[:target] ||= @comp
+          action[:args] ||= []
+          key = @comp.register_callback(ActionProc.new { action })
+          @attrs[:onclick] = "return Goat.remoteDispatch('#{@comp.id}', '#{key}')"
+          @attrs[:href] = '#'
+          [:a, @attrs, @body]          
+        else
+          identity
+        end
+      end    
+
+      def identity
+        [@tag, @attrs, @body]
+      end
+      
+      def dispatch
+        meth = "#{@tag}_tag".to_sym
+
+        if self.respond_to?(meth)
+          self.send(meth)
+        else
+          identity
+        end
+      end
+    end
+
+    def standalone_tags
+      %w{br img input}
+    end
+
+    def inject_prefix(attrs, id)
+      attrs.map_to_hash {|k, v| [k, v.prefix_ns(id)]}
+    end
+
+    def attrs_to_html(attrs)
+      attrs.map {|k, v| "#{k}=\"#{v}\""}.join(' ')
+    end
+
+    def string_to_html(str, comp)
+      str
+    end
+
+    def array_to_html(ar, comp)
+      if ar.first.kind_of?(Symbol)
+        tag = ar[0]
+        have_attrs = ar[1].is_a?(Hash)
+        attrs = have_attrs ? ar[1] : {}
+        body = ar[(have_attrs ? 2 : 1)..-1]
+
+        tag, attrs, body = TagBuilder.build(tag, attrs, body, comp)
+        attrs = inject_prefix(attrs, comp.id)
+        lonely = standalone_tags.include?(tag.to_s)
+
+        open_tag = "<#{tag}#{attrs.empty? ? '' : (' ' + attrs_to_html(attrs))}>"
+        body_html = body.empty? ? '' : body.map{|x| x.to_html(self, comp)}.join
+        close_tag = (lonely ? '' : "</#{tag}>")
+
+        "#{open_tag}#{body_html}#{close_tag}"
+      else
+        ar.map{|x| x.to_html(self, comp)}.join
+      end
+    end
+
+    def initialize(component, input)
+      @input = input
+      @component = component
+    end
+
+    def html
+      @input.to_html(self, @component)
+    end
+  end
+end

data/lib/goat/logger.rb

@@ -0,0 +1,39 @@
+require 'term/ansicolor'
+
+module Goat
+  class Logger
+    class << self
+      def init
+        @levels = [:error]
+        @categories = nil
+      end
+    
+      def levels=(types)
+        @levels = types
+      end
+    
+      def categories=(cats)
+        @categories = cats
+      end
+    
+      def error(cat, str)
+        log(cat, str, :error)
+      end      
+    
+      def log(cat, str, level = :debug)
+        if @categories.kind_of?(Array) && level != :error
+          return unless @categories.include?(cat)
+        end
+      
+        return unless @levels.include?(level)
+      
+        levelstr = level.to_s.ljust(13)
+        colorlevel = level == :error ? Term::ANSIColor.red(levelstr) : levelstr
+      
+        $stderr.puts "#{colorlevel} [#{Time.now.strftime("%d/%b/%Y %H:%M:%S")}] #{Term::ANSIColor.green(str)}"
+      end
+    end
+    
+    init
+  end  
+end

data/lib/goat/mongo.rb

@@ -0,0 +1,28 @@
+require 'mongo'
+
+module Mongo
+  class Collection
+    alias_method :old_save, :save
+    alias_method :old_update, :update
+
+    def notify_update_or_save(more_info)
+      notif = more_info.merge(
+        'type' => 'mongo_change',
+        'db' => self.db.name,
+        'collection' => self.name
+      )
+
+      Goat::NotificationCenter.notify(notif)
+    end
+
+    def save(doc, opts={})
+      id = old_save(doc, opts)
+      notify_update_or_save('_id' => id)
+    end
+
+    def update(sel, doc, opts={})
+     old_update(sel, doc, opts)
+     notify_update_or_save(sel)
+    end
+  end
+end

data/lib/goat/notifications.rb

@@ -0,0 +1,121 @@
+require 'eventmachine'
+
+require File.join(File.dirname(__FILE__), 'logger')
+
+module Goat
+  module NotificationCenter
+    class Receiver < EM::Connection
+      include EM::P::LineText2
+
+      def self.start(host, port)
+        EM.connect(host, port, self)
+      rescue RuntimeError => e
+        Logger.error :live, "Couldn't connect to notification server at #{host}:#{port}"
+        raise e
+      end
+
+      def receive_line(line)
+        NotificationCenter.receive(line)
+      end
+
+      def unbind
+        Logger.error :live, "Lost connection"
+        EM.add_timer(1) do
+          NotificationCenter.start_receiver
+        end
+      end
+    end
+
+    def self.init
+      unless @running
+        start if @configured
+      end
+    end
+    
+    def self.start_receiver
+      Receiver.start(@host, @recv_port)
+    end
+
+    def self.start
+      start_receiver
+      @running = true
+    end
+
+    def self.configure(opts={})
+      opts = {:host => '127.0.0.1', :recv_port => 8000, :send_port => 8001}.merge(opts)
+      @configured = true
+      @host = opts[:host]
+      @recv_port = opts[:recv_port]
+      @send_port = opts[:send_port]
+
+      @subscribers = Set.new
+    end
+
+    def self.wants_notification(sub, notif)
+      wants = true
+      sub[:sig].each do |k, v|
+        wants = false unless notif[k] == v
+      end
+      wants
+    end
+
+    def self.load_notif(notif)
+      JSON.load(notif)
+    end
+
+    def self.notif_to_json(notif)
+      notif.to_json
+    end
+    
+    def self.delegate_gc
+      kill_list = Set.new
+      Logger.log :gc, "Delegate gc"
+      @subscribers.each do |sub|
+        # $stderr.puts "Testing removal of #{sub.inspect}"
+        dlg = sub[:delegate]        
+        # $stderr.puts "Responds to dead? #{dlg.respond_to?(:dead?)}"
+        if dlg.respond_to?(:dead?) && dlg.dead?
+          Logger.log :gc, "Dead"
+          kill_list << sub
+          next
+        end        
+      end
+      # $stderr.puts "Removing #{kill_list.inspect}"
+      kill_list.each {|sub| @subscribers.delete(sub)}      
+      # $stderr.puts "subscribers now: #{@subscribers.map{|x| x.inspect[0..50]}.inspect}"
+    end
+
+    def self.receive(line)
+      notif = load_notif(line)
+      Logger.log :live, "received notif #{notif.inspect}" if $verbose
+      
+      delegate_gc
+
+      @subscribers.each do |sub|
+        blk = sub[:block]
+        if wants_notification(sub, notif)
+          blk.arity == 1 ? blk.call(notif) : blk.call
+        end
+      end
+    end
+
+    def self.notify(notif)
+      if EM.reactor_running?
+        EM.connect(@host, @send_port) do |c|
+          # TODO: alert if this fails
+          c.send_data(notif_to_json(notif) + "\n")
+          # TODO: 2 secs right here?
+          EM.add_timer(2) { c.close_connection }
+        end
+      else
+        s = TCPSocket.open(@host, @send_port)
+        s.write(notif_to_json(notif) + "\n")
+        s.close
+      end
+    end
+
+    def self.subscribe(obj, sig, &blk)
+      @subscribers << {:sig => sig, :block => blk, :delegate => obj}
+    end
+  end
+end