goat 0.3.45 → 0.3.46

data/bin/state-srv

@@ -223,6 +223,24 @@ module Goat
           nil
         end
 
+        def components_updated(msg)
+          ensure_keys(msg, %w{txn pgid updates})
+
+          pgid = msg['pgid']
+          txn = msg['txn']
+          updates = msg['updates'].map{|u| ComponentUpdate.from_hash(u)}
+
+          updates.map(&:added).flatten(1).each do |c|
+            @registry.add_component(pgid, c)
+          end
+          updates.map(&:removed).flatten.each{|c| @registry.delete_component(c)}
+
+          updates.each {|u| handle_component_update(txn, u)}
+          send_updates(pgid)
+
+          {'type' => 'update_ack', 'components' => updates.map{|u| u.skel.id}}
+        end
+
         def live_components(msg)
           ensure_keys(msg, %w{class spec})
 
@@ -239,7 +257,11 @@ module Goat
         def fetch_component(msg)
           ensure_keys(msg, %w{id})
 
-          @registry.find_id(msg['id']).to_hash
+          if c = @registry.find_id(msg['id'])
+            c.to_hash
+          else
+            raise "Couldn't find component #{msg['id']}"
+          end
         end
 
         def send_message(chsrv_id, type, msg)
@@ -307,16 +329,6 @@ module Goat
           end
         end
 
-        def components_updated(msg)
-          ensure_keys(msg, %w{txn pgid updates})
-
-          txn = msg['txn']
-          msg['updates'].each{|u| handle_component_update(txn, ComponentUpdate.from_hash(u))}
-          send_updates(msg['pgid'])
-
-          nil
-        end
-
         def page_connected(msg)
           ensure_keys(msg, %w{pgid chsrv version})
 

data/goat.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'goat'
-  s.version = '0.3.45'
+  s.version = '0.3.46'
   s.summary = 'Pre-release beta version of Goat'
   s.author = 'Patrick Collison'
   s.email = 'patrick@collison.ie'
@@ -31,7 +31,7 @@ spec = Gem::Specification.new do |s|
     lib/goat/dynamic.rb
     lib/goat/extn.rb
     lib/goat/goat.js
-    lib/goat/html.rb
+    lib/goat/dom.rb
     lib/goat/js/component.js
     lib/goat/mongo.rb
     lib/goat/net-common.rb

data/lib/goat.rb

@@ -24,7 +24,7 @@ require 'goat/common'
 require 'goat/net-common'
 require 'goat/notifications'
 require 'goat/extn'
-require 'goat/html'
+require 'goat/dom'
 require 'goat/static'
 require 'goat/autobind'
 require 'goat/state-srv'
@@ -806,10 +806,7 @@ module Goat
 
     def register_page(distiller)
       live = distiller.all_components.select(&:live_enabled?)
-      pg_spec = live.map do |c|
-        c.pgid = @id
-        c.skel
-      end
+      pg_spec = live.map(&:skel)
 
       StateSrvClient.register_page(@id, self.user, pg_spec)
     end
@@ -822,7 +819,7 @@ module Goat
 
     def inject_html_from_dom(canvas)
       exp = nil
-      helper = ExpansionHelper.new
+      helper = ExpansionHelper.new(@id)
 
       Dynamic.let(:expander => helper) do
         exp = DOMTools.expanded_dom(self._dom)
@@ -856,11 +853,6 @@ module Goat
       render_to_layout(canvas, layout)
     end
 
-    #def render_component(c)
-    #  canvas.components << c
-    #  c.html
-    #end
-
     def response
       Rack::Response.new(self.html, 200, {})
     end
@@ -898,183 +890,25 @@ module Goat
     end
   end
 
-  class JustRerenderError < RuntimeError; end
-
-  class DOMDiff
-    def self.diff(old, new, id)
-      self.new(old, new, id).diff
-    end
-
-    def initialize(old, new, id)
-      @old = old
-      @new = new
-      @id = id
-      @diffs = []
-    end
-
-    def diff
-      nested_application(minimized_changes(desc(@old, @new, @id)))
-    end
-
-    def nested_application(ch)
-      applied = Set.new
-
-      ch.sort_by{|x| x[3]}.each do |c|
-        if (c[0] == :rem || c[0] == :add) && !applied.include?(c)
-          if n = ch.detect{|x| x != c && x[2] == c[2] && x[3] >= c[3]}
-            n[3] += (c[0] == :rem) ? -1 : 1
-          end
-        end
-
-        applied << c
-      end
-
-      ch
-    end
-
-    def minimized_changes(ch)
-      new = []
-      merged = Set.new
-      ch.each do |c|
-        if c[0] == :rem
-          if n = ch.detect{|x| x[0] == :add && x[2] == c[2] && x[3] == c[3]}
-            new << [:rep, *n[1..3]]
-            merged << n
-          else
-            new << c
-          end
-        else
-          new << c
-        end
-      end
-      new.reject{|c| merged.include?(c)}
-    end
-
-    def added(new, par, pos=nil); [:add, new, par, pos]; end
-    def removed(old, par, pos=nil); [:rem, old, par, pos]; end
-
-    def dom_node?(node)
-      node.is_a?(Array) && node.first.is_a?(Symbol)
-    end
-    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 localized_change(dold, dnew, par, changes)
-      old = dold.element
-      new = dnew.element
-      #$stderr.puts "changes: #{changes.inspect} / #{old.inspect} / #{par.inspect}"
-      if changes.all?{|ch| ch[2].nil?} && par
-        [added(new, par, dold.position), removed(old, par, dnew.position)]
-      else
-        changes
-      end
-    end
-
-    def is_replacement?(d1, d2)
-      d1 && d2 && (
-        (d1.action == '+' && d2.action == '-') ||
-        (d1.action == '-' && d2.action == '+'))
-    end
-
-    def old_and_new(d1, d2)
-      d1.action == '+' ? [d2, d1] : [d1, d2]
-    end
-
-    def array_desc(old, new, par)
-      #$stderr.puts "array_desc #{old.inspect} #{new.inspect} #{par.inspect}"
-
-      chgs = Diff::LCS.diff(old, new).map do |diff|
-        #$stderr.puts "diff: #{diff.inspect}"
-        if is_replacement?(diff[0], diff[1])
-          dold, dnew = old_and_new(diff[0], diff[1])
-          old = dold.element
-          new = dnew.element
-          if dom_node?(old) && dom_node?(new) && tag(old) == tag(new) && compare_attrs(old, new)
-            localized_change(dold, dnew, par, desc(body(old), body(new), domid(old)))
-          elsif old.is_a?(Array) && new.is_a?(Array) #&& old.all?{|x| !dom_node?(x)} && new.all?{|x| !dom_node?(x)}
-            array_desc(old, new, par)
-          else
-            [added(new, par, diff[1].position), removed(old, par, diff[0].position)]
-          end
-        else
-          if diff.size == 1
-            diff = diff[0]
-            if diff.action == '+'
-              [added(diff.element, par, diff.position)]
-            elsif diff.action == '-'
-              [removed(diff.element, par, diff.position)]
-            else
-              raise "Don't understand diff in a bad way"
-            end
-          else
-            $stderr.puts "Don't understand diff"
-            #$stderr.puts "Diff failed"
-            raise JustRerenderError
-          end
-        end
-      end
-
-      chgs.flatten(1)
-    end
-
-    def compare_attrs(a, b)
-      if a.is_a?(Hash) && b.is_a?(Hash)
-        a_, b_ = a.clone, b.clone
-        a.select{|k,v| a_.delete(k) if v =~ /^dom_/}
-        b.select{|k,v| b_.delete(k) if v =~ /^dom_/}
-        a_ == b_
-      else
-        false
-      end
-    end
-
-    def node_desc(old, new, par)
-      #$stderr.puts "node_desc #{old.inspect} #{new.inspect} #{par.inspect}"
+  class ExpansionHelper
+    attr_reader :components
 
-      if tag(old) != tag(new) || !compare_attrs(old, new)
-        [removed(old, par), added(new, par)]
-      else # only body changed (maybe)
-        bold = body(old)
-        bnew = body(new)
-        if bold && bnew
-          desc(bold, bnew, domid(old))
-        elsif bold && !bnew
-          [removed(bold, domid(old))]
-        else
-          [added(bnew, domid(old))]
-        end
-      end
+    def initialize(pgid)
+      @components = {}
+      @pgid = pgid
     end
 
-    def desc(old, new, par)
-      #$stderr.puts "desc #{old.inspect} #{new.inspect} #{par.inspect}"
-      #$stderr.puts "desc #{self.class.name} #{par.inspect}"
-
-      if old.class != new.class
-        [added(new, par), removed(old, par)]
-      elsif old.is_a?(Array)
-        dom_node?(old) ? node_desc(old, new, domid(old)) : array_desc(old, new, par)
-      elsif old.is_a?(String)
-        if old != new
-          [added(new, par), removed(old, par)]
-        end
-      else
-        raise TypeError.new("Unknown object in the DOM: #{old.class} #{new.class}")
-      end
+    def component_used(c)
+      @components[c.id] = c
+      c.pgid = @pgid
     end
-  end
 
-  class ExpansionHelper
-    attr_reader :components
-
-    def initialize
-      @components = Set.new
+    def component(id)
+      @components[id]
     end
 
-    def component_used(c)
-      @components << c
+    def components
+      @components.values
     end
   end
 
@@ -1107,6 +941,11 @@ module Goat
     end
 
     def self.dispatch_updates(txn, pgid, ups)
+      pgups = ups.map{|u| u.skel.pgid}.uniq
+      if pgups.size > 1
+        raise "Got updates for different pages: #{pgups.inspect}"
+      end
+
       StateSrvClient.components_updated(
         txn,
         pgid,
@@ -1150,7 +989,8 @@ module Goat
     def self.rerender_and_update_inner(to_process)
       # send updates as we calculate them; don't wait to compute everything
       unless to_process.empty?
-        rerender(to_process.shift)
+        skel = to_process.shift
+        rerender(skel)
         unless to_process.empty?
           EM.next_tick { rerender_and_update_inner(to_process) }
         end
@@ -1179,7 +1019,7 @@ module Goat
     def rerender
       Profile.in(:rerender)
 
-      helper = ExpansionHelper.new
+      helper = ExpansionHelper.new(@pgid)
 
       Profile.in(:expansion)
       Dynamic.let(:expander => helper) do
@@ -1188,19 +1028,21 @@ module Goat
       Profile.out(:expansion)
 
       Profile.in(:diff)
-      diff = DOMDiff.diff(@old_dom, @expanded_dom, @id)
+      diff = DOMTools::DOMDiff.dom_diff(@old_dom, @expanded_dom, @id)
       Profile.out(:diff)
 
+      Goat.logd "#{self.class}/#{self.id} diff: " + diff.inspect
+
       if diff.size == 0
         # pass
-        $stderr.puts "No changes"
-      elsif diff.size < 0 # TODO constant
-        rerender_partially(diff)
+      elsif diff.size <= 3
+        rerender_partially(helper, diff)
       else
-        rerender_fully(helper.components)
+        rerender_fully(helper, helper.components)
       end
-    rescue JustRerenderError # partial updater gave up
-      rerender_fully(helper.components)
+    rescue Goat::DOMTools::PartialUpdateFailed
+      Goat.logw "Partial update failed; falling back on a full rerender"
+      rerender_fully(helper, helper.components)
     ensure
       Profile.out(:rerender)
     end
@@ -1231,16 +1073,48 @@ module Goat
       @live_spec = skel.live_spec
     end
 
-    def rerender_partially(diff)
-      $stderr.puts "should do #{diff.inspect} in #{self.class.name}/#{@id}"
-      StateSrvClient.component_updated(
-        self.class.name,
-        @id,
-        @expanded_dom
-      )
+    def rerender_partially(expander, diff)
+      updates = []
+
+      added, removed = [], []
+
+      diff.each do |d|
+        type, par, pos, tree, id = d
+        cs = []
+        u = {
+          'type' => type.to_s,
+          'parent' => par,
+          'position' => pos
+        }
+
+        if type == :add
+          added += DOMTools.dom_components(tree).map{|cid| expander.component(cid)}
+
+          distiller = DOMDistiller.new(tree, added + [self])
+          u['html'] = dom_html(tree)
+          u['js'] = distiller.script
+          u['css'] = distiller.style
+        elsif type == :rem
+          b = DOMTools.body(tree).first
+          u['tag'] = DOMTools.tag(b).to_s if DOMTools.dom_node?(b)
+          u['id'] = DOMTools.attrs(tree) ? DOMTools.attrs(tree)[:id] : nil
+
+          removed += DOMTools.dom_components(tree) # just want the raw IDs
+        else
+          raise "Bad diff: #{d.inspect}"
+        end
+
+        raise "Bad position" unless u['position'].kind_of?(Integer)
+
+        updates << u
+      end
+
+      UpdateDispatcher.component_updated(
+        @pgid,
+        ComponentUpdate.new(self.skel, updates, added.map(&:skel), removed))
     end
 
-    def rerender_fully(cs)
+    def rerender_fully(expander, cs)
       Profile.in(:distillation)
       distiller = DOMDistiller.new(@expanded_dom, cs + [self])
       js = distiller.script
@@ -1249,16 +1123,19 @@ module Goat
 
       Profile.in(:update_send)
 
+      added = (DOMTools.dom_components(@expanded_dom) - DOMTools.dom_components(@old_dom)).map{|cid| expander.component(cid)}
+      removed = DOMTools.dom_components(@old_dom) - DOMTools.dom_components(@expanded_dom)
+
       UpdateDispatcher.component_updated(
         @pgid,
         ComponentUpdate.new(
           self.skel,
           [{'type' => 'rep',
-            'html' => dom_html(@expanded_dom),
+            'html' => dom_html(component(@expanded_dom)),
             'js' => js,
             'css' => css,
             'parent' => @id,
-            'position' => nil}]))
+            'position' => nil}], added.map(&:skel), removed))
 
       Profile.out(:update_send)
     end
@@ -1354,13 +1231,28 @@ module Goat
       DOMTools.inject_prefixes(self.id, dom)
     end
 
-    def component(body)
+    def component(tree)
+      # if the first element of the tree is a tbody tag, we don't enclose it in
+      # a div (as we usually do for almost all components), since we'll likely
+      # end up in an (illegal) <table><div><tbody> situation. Instead, we use
+      # the tbody itself as the container. In doing so, we clobber existing
+      # attributes on the tbody: if you have a top-level tbody tag in a Component,
+      # we're stealing it for our own uses.
+
       attrs = {:id => id, :class => component_name_hierarchy.join(' ')}
 
-      if body.kind_of?(Array) && body.first == :tbody
-        [:tbody, attrs, body[1..-1]]
+      if DOMTools.car_tag(tree) == :tbody
+        [:tbody, attrs, DOMTools.body(DOMTools.normalized_tags(tree).first)]
       else
-        [:div, attrs, body]
+        [:div, attrs, tree]
+      end
+    end
+
+    def unencapsulated(tree)
+      if DOMTools.car_tag(tree) == :tbody
+        DOMTools.body(DOMTools.normalized_tags(tree).first)
+      else
+        tree
       end
     end
 
@@ -1405,10 +1297,6 @@ module Goat
       self.class.scope_css(self.__css, @id, '#')
     end
 
-    def model_changed(item, notif)
-      render
-    end
-
     def register_callback(callback)
       # if @callbacks.values.include?(callback)
       #   @callbacks.to_a.detect{|k, v| k if v == callback}