goat 0.2.12 → 0.3.0

data/lib/goat/html.rb

@@ -1,147 +1,265 @@
 module Goat
-  class HTMLBuilder
-    class ::String
-      def to_html(builder, comp)
-        builder.string_to_html(self, comp)
+  module DOMTools
+    class Traverser
+      def initialize(tree, dlg, transpose)
+        @tree = tree
+        @dlg = dlg
+        @transpose = transpose
       end
-    end
 
-    class ::Array
-      def to_html(builder, comp)
-        raise InvalidBodyError.new(self) if self.include?(nil)
-        builder.array_to_html(self, comp)
+      def dom_node?(node)
+        node.is_a?(Array) && node.first.is_a?(Symbol)
       end
-    end
 
-    class InvalidBodyError < RuntimeError
-      attr_reader :body
+      def tag(node); node[0]; end
+      def attrs(node); node[1] if node[1].is_a?(Hash); end
+      def body(node); node[1].is_a?(Hash) ? node[2..-1] : node[1..-1]; end
+      def domid(node); attrs(node) ? attrs(node)[:id] : nil; end
 
-      def initialize(body)
-        super("Invalid body: #{body.inspect}")
-        @body = body
+      def to_node(tag, attrs, body)
+        tag = [tag]
+        tag << attrs if attrs
+        tag << 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
+      def replacement_block
+        @rep = nil
+        @replacement_block ||= lambda {|new| @rep = new}
       end
 
-      def initialize(tag, attrs, body, comp)
-        @tag = tag
-        @attrs = attrs
-        @body = body
-        @comp = comp
+      def traverse(node)
+        if node.is_a?(String)
+          @dlg.string(node, &replacement_block)
+          @rep || node
+        elsif dom_node?(node)
+          @dlg.node(node, &replacement_block)
+          rep = @rep || node
+
+          if @transpose
+            if rep != node
+              rep
+            else
+              to_node(tag(node), attrs(node), traverse(body(node)))
+            end
+          else
+            traverse(body(node))
+          end
+        elsif node.is_a?(Array)
+          if node.include?(nil)
+            raise "Invalid array: #{node.inspect}"
+          end
 
-        rewrite_attrs
+          if node.size == 1
+            traverse(node.first)
+          else
+            if @transpose
+              node.map{|x| traverse(x)}
+            else
+              node.each{|x| traverse(x)}
+            end
+          end
+        elsif node.kind_of?(Component)
+          @dlg.component(node, &replacement_block)
+          @rep || node
+        else
+          raise "Unknown object in the dom: #{node.inspect}"
+        end
       end
 
-      def rewrite_attrs
-        new = {}
+      def traverse!
+        traverse(@tree)
+      end
 
-        @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]
+      class BlockTraverser
+        # would be infinitely nicer if you could just yield from a block
+        def initialize(blk, transpose)
+          @blk = blk
+          @transpose = transpose
+        end
 
-            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
+        def node(node, &blk)
+          if @transpose
+            @blk.call(node, blk)
+          else
+            @blk.call(node)
           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
+        def string(str, &blk)
+          if @transpose
+            @blk.call(str, blk)
+          else
+            @blk.call(str)
+          end
         end
-      end    
 
-      def identity
-        [@tag, @attrs, @body]
+        def component(c, &blk)
+          if @transpose
+            @blk.call(c, blk)
+          else 
+            @blk.call(c)
+          end
+        end
       end
-      
-      def dispatch
-        meth = "#{@tag}_tag".to_sym
 
-        if self.respond_to?(meth)
-          self.send(meth)
+      def self.traverse(tree, dlg=nil, transpose=false, &blk)
+        d = nil
+
+        if dlg
+          d = dlg
+        elsif blk
+          d = BlockTraverser.new(blk, transpose)
         else
-          identity
+          raise "Need a delegate"
         end
+
+        self.new(tree, d, transpose).traverse!
+      end
+
+      def self.transpose(tree, dlg=nil, &blk)
+        traverse(tree, dlg, true, &blk)
       end
     end
 
-    def standalone_tags
-      %w{br img input}
+    def self.traverse(tree, dlg=nil, &blk); Traverser.traverse(tree, dlg, &blk); end
+    def self.transpose(tree, dlg=nil, &blk); Traverser.transpose(tree, dlg, &blk); end
+
+    def self.expanded_dom(dom)
+      DOMTools.transpose(dom) do |elt, update|
+        if elt.kind_of?(Component)
+          raise "Component #{elt} has no ID: was super's initialize called?" unless elt.id
+          Dynamic[:expander].component_used(elt)
+          update.call(elt.component(elt.expanded_dom))
+        end
+      end
     end
 
-    def inject_prefix(attrs, id)
-      attrs.map_to_hash {|k, v| [k, v.prefix_ns(id)]}
+    def self.inject_prefixes(id, dom)
+      DOMTools.traverse(dom) do |elt|
+        if elt.kind_of?(Array) && elt.first.is_a?(Symbol) && elt[1].is_a?(Hash)
+          attrs = elt[1]
+          elt[1] = attrs.map_to_hash do |k, v|
+            if v.kind_of?(String)
+              [k, v.prefix_ns(id)]
+            elsif v.kind_of?(Array) && HTMLBuilder::ARRAY_ATTRS.include?(k)
+              [k, v]
+            else
+              raise "Invalid object #{v.inspect} to get a prefix in dom:\n#{dom.inspect}"
+            end
+          end
+        end
+      end
+      dom
+    end
+
+    class ::String
+      def to_html(builder)
+        builder.string_to_html(self)
+      end
     end
 
-    def attrs_to_html(attrs)
-      attrs.map {|k, v| "#{k}=\"#{v}\""}.join(' ')
+    class ::Array
+      def to_html(builder)
+        raise InvalidBodyError.new(self) if self.include?(nil)
+        builder.array_to_html(self)
+      end
     end
 
-    def string_to_html(str, comp)
-      str
+    class InvalidBodyError < RuntimeError
+      attr_reader :body
+
+      def initialize(body)
+        super("Invalid body: #{body.inspect}")
+        @body = body
+      end
     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]
+    class HTMLBuilder
+      ARRAY_ATTRS = [:class]
 
-        tag, attrs, body = TagBuilder.build(tag, attrs, body, comp)
-        attrs = inject_prefix(attrs, comp.id)
-        lonely = standalone_tags.include?(tag.to_s)
+      class TagBuilder
+        # TODO: gmail trick of only a single onclick() handler
 
-        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}>")
+        def self.build(tag, attrs, body)
+          self.new(tag, attrs, body).dispatch
+        end
+
+        def initialize(tag, attrs, body)
+          @tag = tag
+          @attrs = attrs
+          @body = body
+
+          rewrite_attrs
+        end
+
+        def rewrite_attrs
+          new = {}
+
+          @attrs.map_to_hash do |k, v|
+            if k == :class && v.kind_of?(Array)
+              new[:class] = @attrs[:class].join(' ')
+            else            
+              new[k] = v
+            end
+          end
+
+          @attrs = new
+        end
+        
+        def identity
+          [@tag, @attrs, @body]
+        end
+        
+        def dispatch
+          meth = "#{@tag}_tag".to_sym
 
-        "#{open_tag}#{body_html}#{close_tag}"
-      else
-        ar.map{|x| x.to_html(self, comp)}.join
+          if self.respond_to?(meth)
+            self.send(meth)
+          else
+            identity
+          end
+        end
       end
-    end
 
-    def initialize(component, input)
-      @input = input
-      @component = component
-    end
+      def standalone_tags
+        %w{br img input}
+      end
+
+      def attrs_to_html(attrs)
+        attrs.map {|k, v| "#{k}=\"#{v}\""}.join(' ')
+      end
+
+      def string_to_html(str)
+        str
+      end
+
+      def array_to_html(ar)
+        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]
 
-    def html
-      @input.to_html(self, @component)
+          tag, attrs, body = TagBuilder.build(tag, attrs, body)
+          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)}.join
+          close_tag = (lonely ? '' : "</#{tag}>")
+
+          "#{open_tag}#{body_html}#{close_tag}"
+        else
+          ar.map{|x| x.to_html(self)}.join
+        end
+      end
+
+      def initialize(input)
+        @input = input
+      end
+
+      def html
+        @input.to_html(self)
+      end
     end
   end
 end

data/lib/goat/js/component.js

@@ -1,29 +1,32 @@
 var Component = Class.extend({
-  init: function(cls, id) {
+  init: function(cls, id, args) {
     this.id = id;
     this.cls = cls;
+    this.loaded = false;
+
+    for(var k in args) {
+      this[k] = args[k]
+    }
   },
   
   onLoad: function() {
     this.node = $("#" + this.id);
   },
+
+  isLoaded: function() {
+    return this.loaded;
+  },
+
+  load: function() {
+    this.onLoad();
+    this.loaded = true;
+  },
   
-  rpc: function(name, args, callback, er) {
-    args['_id'] = this.id;
-    args['_rpc'] = name;
-    args['_component'] = this.cls;
-    $.ajax({
-      type: 'POST',
-      url: '/rpc',
-      data: args,
-      success: callback,
-      error: er,
-      dataType: 'json',
-      async: true
-    });
+  rpc: function(name) {
+    return new GoatRPC(this, name);
   },
   
   $: function(sel) {
     return $("#" + this.id + " " + sel);
   }
-});
+});

data/lib/goat/net-common.rb

@@ -0,0 +1,38 @@
+require 'term/ansicolor'
+
+module Log
+  def self.logname; File.basename($0); end
+  def self.logpath; "/tmp/#{logname}.log"; end
+  def self.lockpath; "/tmp/#{logname}.lock"; end
+  def self.logf; @log ||= File.open(logpath, 'a'); end
+
+  def self.log(lvl, msg, termmsg=nil)
+    logf.puts("#{Time.now.asctime} #{msg}")
+    logf.flush
+
+    termmsg ||= msg
+    $stderr.puts(termmsg[0..90])
+  end
+
+  def self.log_message(msg)
+    log("#{msg['type']} #{msg.inspect}", "#{Term::ANSIColor.green(msg['type'])}: #{msg.inspect}")
+  end
+end
+
+def log(lvl, msg, tmsg=nil); Log.log(lvl, msg, tmsg); end
+def logd(msg); log(:debug, msg); end
+def logw(msg); log(:warn, msg); end
+def loge(msg); log(:error, msg); end
+
+module Goat
+  # for use with EM::Connection
+  module JSONMessages
+    def send_message(type, msg)
+      send_data(msg.merge('type' => type).to_json + "\n")
+    end
+
+    def send_messages(msgs)
+      send_data(msgs.map{|msg| msg[1].merge('type' => msg[0])}.to_json + "\n")
+    end
+  end
+end