goat 0.3.45 → 0.3.46

data/lib/goat/common.rb

@@ -54,23 +54,32 @@ module Goat
   end
 
   class ComponentUpdate
-    attr_reader :skel, :mutations
+    attr_reader :skel, :mutations, :added, :removed
     attr_accessor :version
 
-    def initialize(skel, mutations)
+    def initialize(skel, mutations, added, removed)
       @skel = skel
       @mutations = mutations
+      @added = added
+      @removed = removed
     end
 
     def to_hash
       {
         'skel' => @skel.to_hash,
-        'mutations' => @mutations
+        'mutations' => @mutations,
+        'added' => @added.map(&:to_hash),
+        'removed' => @removed
       }
     end
 
     def self.from_hash(h)
-      self.new(ComponentSkeleton.from_hash(h['skel']), h['mutations'])
+      self.new(
+        ComponentSkeleton.from_hash(h['skel']),
+        h['mutations'],
+        h['added'].map{|a| ComponentSkeleton.from_hash(a)},
+        h['removed']
+      )
     end
   end
 end

data/lib/goat/dom.rb

@@ -0,0 +1,627 @@
+require 'rack/utils'
+
+module Goat
+  module DOMTools
+    def tag(node); node[0]; end
+    def is_attrs?(x); x.kind_of?(Hash) || x.kind_of?(DOMAttrs); end
+    def attrs(node); node[1] if is_attrs?(node[1]); end
+    def body(node); is_attrs?(node[1]) ? node[2..-1] : node[1..-1]; end
+    def domid(node); attrs(node) ? attrs(node)[:id] : nil; end
+    def dom_node?(node); node.is_a?(Array) && node.first.is_a?(Symbol); end
+    def nested_body?(node); node.is_a?(Array) && !node.first.is_a?(Symbol); end
+    def normalized_tags(body); nested_body?(body) ? body.map{|b| normalized_tags(b)}.flatten(1) : [body]; end
+    def car_tag(tree)
+      if (b = tree).is_a?(Array)
+        b = b.first while b.is_a?(Array)
+        b
+      end
+    end
+
+    module_function :tag, :attrs, :body, :domid, :dom_node?, :is_attrs?, :nested_body?,
+      :normalized_tags, :car_tag
+
+    class Traverser
+      include DOMTools
+
+      def initialize(tree, dlg, transpose)
+        @tree = tree
+        @dlg = dlg
+        @transpose = transpose
+      end
+
+      def to_node(tag, attrs, body)
+        tag = [tag]
+        tag << attrs if attrs
+        tag += normalized_tags(body)
+      end
+
+      def replacement_block
+        @rep = nil
+        @replacement_block ||= lambda {|new| @rep = new}
+      end
+
+      def traverse(node)
+        if node.is_a?(String)
+          @dlg.string(node, &replacement_block)
+          @rep || node
+        elsif node == nil
+          @dlg.string('', &replacement_block)
+          @rep || nil
+        elsif dom_node?(node)
+          stay_traversing = @dlg.node(node, &replacement_block)
+          rep = @rep || node
+
+          if @transpose
+            if !rep.equal?(node)
+              if stay_traversing
+                to_node(tag(rep), attrs(rep), traverse(body(rep)))
+              else
+                rep
+              end
+            else
+              to_node(tag(node), attrs(node), traverse(body(node)))
+            end
+          else
+            traverse(body(node))
+          end
+        elsif node.is_a?(Array)
+          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 traverse!
+        traverse(@tree)
+      end
+
+      class BlockTraverser
+        # would be infinitely nicer if you could just yield from a block
+        def initialize(blk, transpose)
+          @blk = blk
+          @transpose = transpose
+        end
+
+        def node(node, &blk)
+          if @transpose
+            @blk.call(node, blk)
+          else
+            @blk.call(node)
+          end
+        end
+
+        def string(str, &blk)
+          if @transpose
+            @blk.call(str, blk)
+          else
+            @blk.call(str)
+          end
+        end
+
+        def component(c, &blk)
+          if @transpose
+            @blk.call(c, blk)
+          else
+            @blk.call(c)
+          end
+        end
+      end
+
+      def self.traverse(tree, dlg=nil, transpose=false, &blk)
+        d = nil
+
+        if dlg
+          d = dlg
+        elsif blk
+          d = BlockTraverser.new(blk, transpose)
+        else
+          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 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))
+        elsif dom_node?(elt)
+          tag = tag(elt)
+
+          if tag == :tbody
+            b = body(elt)
+            b = b.first while b.is_a?(Array)
+            if b == :tbody
+              update.call(expanded_dom(body(elt)))
+            end
+          elsif tag == :table
+            a = attrs(elt)
+            tbody_id = (a && a[:id]) ? "#{a[:id]}_tbody" : 'tbody_' + String.random
+            update.call([:table, a ? a : {}, [:tbody, {:id => tbody_id}, expanded_dom(body(elt))]])
+          end
+        end
+        true
+      end
+    end
+
+    def self.inject_prefixes(id, dom)
+      DOMTools.traverse(dom) do |elt|
+        if elt.kind_of?(Array) && elt.first.is_a?(Symbol) && elt[1].kind_of?(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]
+            elsif v.kind_of?(Integer) && HTMLBuilder::INTEGER_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
+
+    def self.dom_components(tree)
+      c = []
+      DOMTools.traverse(tree) do |elt|
+        # dom_\w{10} is the form of a component ID; anything more liberal might catch things like
+        # dom_xxxxxxxxxx_table_border
+        if dom_node?(elt) && (attrs = attrs(elt)) && attrs.include?(:id) && attrs[:id] =~ /^dom_\w{10}$/
+          c << attrs[:id]
+        end
+      end
+      c
+    end
+
+    def self.find_component(tree, id)
+      catch(:find_component) do
+        DOMTools.traverse(tree) do |elt|
+          if dom_node?(elt) & (attrs = attrs(elt)) && attrs[:id] == id
+            throw :find_component, elt
+          end
+          nil
+        end
+      end
+    end
+
+    class ::String
+      def to_html(builder)
+        Rack::Utils.escape_html(self)
+      end
+    end
+
+    class ::NilClass
+      def to_html(builder)
+        ''
+      end
+    end
+
+    class ::Goat::HTMLString < String
+      def to_html(builder)
+        self
+      end
+    end
+
+    class ::Array
+      def to_html(builder)
+        builder.array_to_html(self)
+      end
+    end
+
+    class InvalidBodyError < RuntimeError
+      attr_reader :body
+
+      def initialize(body)
+        super("Invalid body: #{body.inspect}")
+        @body = body
+      end
+    end
+
+    class HTMLBuilder
+      ARRAY_ATTRS = [:class]
+      INTEGER_ATTRS = [:colspan, :rowspan]
+
+      class TagBuilder
+        # TODO: gmail trick of only a single onclick() handler
+
+        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 build_node
+          [@tag, @attrs, @body]
+        end
+
+        def a_tag
+          unless @attrs.include?(:href)
+            @attrs[:href] = 'javascript:void(0)'
+          end
+
+          build_node
+        end
+
+        def input_tag
+          unless @attrs.include?(:name)
+            $stderr.puts "Warning: no name for <#{@tag} #{@attrs.inspect}>#{@body.inspect}</#{@tag}>"
+
+            # this is somewhat ungainly: we generate a name automatically by hashing the values of the
+            # other attrs. this may conflict - ideally would track per-page state for these.
+            # purpose is to have name-less inputs preserve their values when user goes back to page.
+            # webkit in safari 5 gets confused when inputs are nameless.
+            unless (vals = @attrs.values{|k, v| v.kind_of?(String)}).empty?
+              $stderr.puts "Generating a name automatically..."
+              @attrs[:name] = vals.join.md5[0..10]
+            end
+          end
+
+          build_node
+        end
+
+        def dispatch
+          meth = "#{@tag}_tag".to_sym
+
+          if self.respond_to?(meth)
+            self.send(meth)
+          else
+            build_node
+          end
+        end
+      end
+
+      def standalone_tags
+        %w{br img input}
+      end
+
+      def attrs_to_html(attrs)
+        attrs.map {|k, v| "#{k}=\"#{v}\""}.join(' ')
+      end
+
+      def array_to_html(ar)
+        if ar.first.kind_of?(Symbol)
+          tag = ar[0]
+          have_attrs = ar[1].kind_of?(Hash)
+          attrs = have_attrs ? ar[1] : {}
+          body = ar[(have_attrs ? 2 : 1)..-1]
+
+          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
+
+    class DOMAttrs < ::Hash
+      def self.from_hash(hash, id=nil)
+        d = self[hash]
+        d.id = id
+        d.clean
+        d
+      end
+
+      def deleted
+        @deleted ||= {}
+      end
+
+      def id=(id); @id = id; end
+
+      def clean
+        self.each do |k, v|
+          if v.kind_of?(String) && v.start_with?('dom_') && (!@id || v !~ /#{@id}/)
+            deleted[k] = v
+            self.delete(k)
+          end
+        end
+      end
+
+      def reconstitute
+        (deleted.keys - self.keys).each{|k| self[k] = deleted[k]}
+        self
+      end
+
+      def inspect
+        start = super[0..-2]
+        o = []
+        deleted.each do |k, v|
+          o << "#{k.inspect}=>**#{v.inspect}**"
+        end
+        
+        start + (o.empty? ? '' : ', ' + o.join(', ')) + '}'
+      end
+    end
+
+    class PartialUpdateFailed < StandardError; end
+
+    module DiffTools
+      class NoParentDOMID < PartialUpdateFailed; end
+      class TextualTranspose < PartialUpdateFailed; end
+
+      def type_of(x)
+        if x.is_a?(String)
+          :string
+        elsif x.is_a?(Array)
+          dom_node?(x) ? :node : :array
+        else
+          ('cls_' + x.class.name.downcase).to_sym
+        end
+      end
+
+      def dom_node?(node)
+        # TODO take from dom.rb
+        node.is_a?(Array) && node.first.is_a?(Symbol)
+      end
+
+      def lcs_is_replacement?(d1, d2)
+        d1 && d2 && d1.position == d2.position && (
+          (d1.action == '+' && d2.action == '-') ||
+          (d1.action == '-' && d2.action == '+'))
+      end
+
+      def lcs_old_and_new(d1, d2)
+        d1.action == '+' ? [d2, d1] : [d1, d2]
+      end
+
+      def added(obj, par, pos)
+        raise NoParentDOMID if par.nil?
+        raise TextualTranspose if obj.kind_of?(String)
+        [:add, par, pos, *normalized_tags(obj)]
+      end
+
+      def removed(obj, par, pos)
+        raise NoParentDOMID if par.nil?
+        raise TextualTranspose if obj.kind_of?(String)
+        [:rem, par, pos, *normalized_tags(obj)]
+      end
+
+      def lcs_is_addition?(diff); diff.action == '+'; end
+      def lcs_is_removal?(diff); diff.action == '-'; end
+    end
+
+
+    class DOMDiff
+      include DiffTools
+      include DOMTools
+      class << self; include DOMTools; end
+
+      # the constraints:
+      # - arrays might be tags or they might be arrays
+      # - we can't directly address textual entities; they must be addressed by their enclosing tag
+      #   (i.e. <li>foo</li> -> <li>bar</li> is a change to an li tag, not a change to the *contents*
+      #   of an li tag. Why, you ask? Here:
+      #   > $("#foo").innerHTML
+      #   "<span>blub</span>foo<span>qux</span>bar"
+      #   > $("#foo").children
+      #   [<span>blub</span>, <span>qux</span>]
+      #   Text isn't a thing in the DOM tree. So, in order to traverse, we have to restrict ourselves
+      #   to DOM nodes, i.e. tags, not raw textual elements in the tree. I don't know why the DOM
+      #   works this way.
+      # - we only try to deal with changes where the parent element of the changed element has a
+      #   [unique] ID. We could address by route through the tree, but we don't attempt to store
+      #   this.
+      # - we can't always tell in advance where we should make a change. For example,
+      #   [:ul, [:li, [:a, {:id => 'hello'}, [:b, 'test']]]] changing to:
+      #   [:ul, [:li, [:a, {:id => 'hello'}, [:b, 'blub']]]]
+      #   When we're looking at the ul, and before we know what exactly is different below us,
+      #   it *may* be the case that the change can be encapsulated more neatly somewhere
+      #   in the subtree, but it may not -- and even if the change is nice and isolated further
+      #   down, there might not be a parent ID for us to hook off. This is what NoParentDOMID
+      #   exceptions are used for.
+      # - we want to ignore artefacts from randomization of IDs. (i.e. cases where nothing has
+      #   changed except the dom_XXXXXXXX ID of some element. This is pretty easy intuitively, but a
+      #   bit more subtle in practice. The obvious thing to do is to use an alternate comparison
+      #   function, instead of ==, but this may be slow, and would (worse) need a lot of care to
+      #   make sure that your code (and outside libraries, such as Diff::LCS, which we use) never
+      #   call it. Next obvious thing is to create a subclass of Hash, make all hash attributes
+      #   ({:id => 'dom_XXXXXXX', :class => '...'}) instances of it, and then redefine == on the
+      #   subclass. This doesn't work, though, because ruby's crappy C implementation won't
+      #   dispatch to the subclass's == -- for hashes, arrays, etc., the comparison code is
+      #   wired in and can't be overridden. So instead, we have our subclass actually remove
+      #   the unwanted elements, and store them in a separate @deleted ivar. The crappy part of
+      #   this is that you need to manually go through the dom and stick them all back in the
+      #   "actual" hash once you've finished diffing.
+      # - we *don't* want to remove IDs that don't change. For example, during a rerender, we
+      #   preserve the ID of the rerendered-component (just not the IDs of any child components).
+      #   If we deleted the IDs of these, constraint #3 would mean we'd miss a lot of potential
+      #   diffs, since we'd think there were changes we couldn't make. (I.e. think a child's
+      #   parent doesn't have an ID when in fact it does.) One todo here is to make the differ
+      #   check the @deleted ivar of a DOMAttrs instance for IDs, since they're perfectly
+      #   valid hooks to use when removing or adding components. If you do this, conflicts become
+      #   much more likely though -- say you have multiple changes to apply; a node whose ID
+      #   you depend on may be removed.
+
+      def self.diff(old, new)
+        d = self.new(old, new).diff
+      end
+
+      def self.preproc(tree, id)
+        DOMTools.transpose(tree) do |elt, update|
+          if dom_node?(elt) && attrs(elt)
+            update.call([tag(elt), DOMAttrs.from_hash(attrs(elt), id), *normalized_tags(body(elt))])
+          end
+          true
+        end
+      end
+
+      def self.unproc(tree)
+        tree.flatten.each{|elt| elt.reconstitute if elt.is_a?(DOMAttrs)}
+        tree
+      end
+
+      def self.dom_diff(old, new, id)
+        trees = []
+        [old, new].each {|tree| trees << preproc(tree, id)}
+        diff(*trees).map do |diff|
+          if diff.first == :add
+            diff[0..-2] + [unproc(diff[3])]
+          else
+            diff
+          end
+        end
+      end
+
+      def initialize(old, new)
+        @old = old
+        @new = new
+      end
+
+      def diff
+        cmp(@old, @new, nil)
+      end
+
+      def transpose(old, new, par)
+        [removed(old, par, 0), added(new, par, 0)]
+      end
+
+      def cmp_node(old, new, par)
+        oattrs = attrs(old)
+        if tag(old) == tag(new) && \
+            oattrs == attrs(new)
+          begin
+            cmp(body(old), body(new), oattrs ? domid(old) : nil)
+          rescue NoParentDOMID => e
+            transpose(old, new, par)
+          rescue TextualTranspose => e
+            transpose(old, new, par)
+          end
+        else
+          transpose(old, new, par)
+        end
+      end
+
+      def cmp_array(old, new, par)
+        if old.size == 1 && new.size == 1
+          return cmp(old.first, new.first, par)
+        end
+
+        patch = Diff::LCS.diff(old, new).flatten(1)
+
+        left, right = patch
+        if patch.size == 2 && lcs_is_replacement?(left, right)
+          # if we're just replacing an element, maybe we can do it more elegantly. e.g.,
+          # [:p, [:li, 'foo'], [:li, 'bar']] -> [:p, [:li, 'foo'], [:li, 'bar'], [:li, 'baz']]
+          # can be represented as a replacement of the p tag itself, or the insertion of
+          # [:li, 'baz']. If the patch looks like a simple replacement, we delve deeper.
+          dold, dnew = lcs_old_and_new(left, right)
+          old, new = dold.element, dnew.element
+          begin
+            return cmp(old, new, domid(old))
+          rescue NoParentDOMID, TextualTranspose
+            # fine fine if you hate fun we can just continue on our merry way below
+          end
+        end
+
+        a, b, off = 0, 0, 0
+        chgs = patch.map do |ch|
+          if lcs_is_addition?(ch)
+            while b < ch.position
+              a += 1; b += 1; off += 1
+            end
+            b += 1
+
+            mut = [added(ch.element, par, off)]
+            off += 1
+            mut
+          elsif lcs_is_removal?(ch)
+            while a < ch.position
+              a += 1; b += 1; off += 1
+            end
+            a += 1
+
+            [removed(ch.element, par, off)]
+          else
+            raise "Bad diff: #{ch.inspect}"
+          end
+        end
+
+        chgs.flatten(1)
+      end
+
+      def cmp(old, new, par)
+        return [] if old == new
+
+        told, tnew = type_of(old), type_of(new)
+        if told != tnew
+          if told == :string || tnew == :string
+            raise TextualTranspose
+          else
+            return transpose(old, new, par)
+          end
+        end
+
+        if told == :string || tnew == :string && old != new
+          raise TextualTranspose
+        end
+
+        type = told
+
+        if type == :node
+          cmp_node(old, new, par)
+        elsif type == :array
+          cmp_array(old, new, par)
+        else
+          raise "Unknown thing: #{old.inspect}"
+        end
+      end
+    end
+  end
+end