goat 0.2.12 → 0.3.0

data/bin/sync

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+module Goat
+  module Sync
+    NotifChannel = EM::Channel.new
+    
+    @viewports = {}
+    
+    class Viewport
+      attr_reader :created, :viewport, :components
+      
+      def initialize(v, cs)
+        @created = Time.now
+        @viewport = v
+        @components = cs
+      end
+    end
+
+    class ComponentServer < EM::Connection
+      def self.start(host='127.0.0.1', port=8010)
+        EM.start_server(host, port, self)
+      end
+
+      def viewport_components(v, cs)
+        @viewports[v] = Viewport.new(v, cs)
+      end
+      
+      def receive_line(line)
+        msg = JSON.load(line)
+        meth = msg['type']
+        args = msg['data']
+        self.send(meth.to_sym, *args)
+      end
+    end
+    
+    NotificationServer.subscribe() do |notif|
+      
+    end
+
+    class RecvServer < EM::Connection
+      include EM::P::LineText2
+
+      def self.start(host='127.0.0.1', port=8001)
+        EM.start_server(host, port, self)
+      end
+
+      def receive_line(line)
+        $stdout.puts "got #{line}" if $verbose
+        NotifChannel << line
+      end
+    end
+  end
+end

data/bin/yodel

@@ -9,7 +9,7 @@ $host = '127.0.0.1'
 
 def usage
   $stderr.puts <<-EOH
-#{__FILE__} [-b broadcast-port] [-r receive-port] [-h host]
+#{__FILE__} [-b broadcast-port] [-r receive-port] [-H host]
   EOH
 end
 

data/goat.gemspec

@@ -0,0 +1,37 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'goat'
+  s.version = '0.3.0'
+  s.summary = 'Pre-release beta version of Goat'
+  s.author = 'Patrick Collison'
+  s.email = 'patrick@collison.ie'
+  s.homepage = 'http://goatweb.org'
+  s.description = 'Sinatra live'
+  s.rubyforge_project = 'goat'
+  s.executables = %w{yodel}
+  s.require_paths = %w{lib}
+
+  s.files = %w{
+    README.md
+    bin/channel-srv
+    bin/press
+    bin/state-srv
+    bin/sync
+    bin/yodel
+    goat.gemspec
+    lib/goat/autobind.rb
+    lib/goat/common.rb
+    lib/goat/dynamic.rb
+    lib/goat/extn.rb
+    lib/goat/goat.js
+    lib/goat/html.rb
+    lib/goat/js/component.js
+    lib/goat/mongo.rb
+    lib/goat/net-common.rb
+    lib/goat/notifications.rb
+    lib/goat/state-srv.rb
+    lib/goat/static.rb
+    lib/goat/yodel.rb
+    lib/goat.rb
+    lib/views/plain_layout.erb
+  }
+end

data/lib/goat.rb

@@ -1,3 +1,12 @@
+#
+# Author: Patrick Collison <patrick@collison.ie>
+# Date: Spring-Fall 2010
+#
+# See http://goatweb.org
+#
+# License: GNU General Public License v2
+
+require 'rubygems'
 require 'set'
 require 'cgi'
 require 'json'
@@ -5,162 +14,99 @@ require 'eventmachine'
 require 'thin'
 require 'term/ansicolor'
 require 'tilt'
+require 'diff/lcs'
+require 'inline'
 
-%w{logger notifications extn html static autobind}.each do |file|
-  require File.join(File.dirname(__FILE__), 'goat', file)
-end
+$:.unshift(File.dirname(__FILE__))
 
-$verbose ||= ARGV.include?('-v')
+require 'goat/common'
+require 'goat/net-common'
+require 'goat/notifications'
+require 'goat/extn'
+require 'goat/html'
+require 'goat/static'
+require 'goat/autobind'
+require 'goat/state-srv'
+require 'goat/dynamic'
 
-class ActionHash < Hash; end
-class ActionProc < Proc; end
+$verbose ||= ARGV.include?('-v')
 
-def action(hash={})
-  hash
-  # ActionProc.new { hash }
-  # ActionHash[hash]
-end  
+class Profile
+  # TODO make sure not already defined
+  def self.in(*args); end
+  def self.out(*args); end
+  def self.request_start(*args); end
+  def self.request_end(*args); end
+end
 
-class Object
-  def self.make_me
-    meth = nil
-    if caller[1] =~ /`(.+)'/
-      meth = $1
-    end
-    
-    raise("Subclass #{self.name} should implement" + (meth ? " #{meth}" : ''))
-  end
 
-  def make_me; self.class.make_me end
-  
-  alias_method :old_kind_of?, :kind_of?
-      
-  def self.kind_of?(cls)
-    return true if self.old_kind_of?(Class) && cls == Class
-    self == cls || \
-      (self == Object ? \
-       false : \
-       (self.superclass && self.superclass != self && self.superclass.kind_of?(cls)))
-  end
-  
-  def glimpse(n=100)
-    ins = self.inspect
-    if ins =~ />$/ && ins.size > n
-      "#{ins[0..n]}...>"
-    else
-      ins
-    end
+class String
+  def prefix_ns(ns)
+    self.gsub(/^%(.+)$/, "#{ns}_\\1")
   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) }
+  def h!
+    # TODO is this even used any more?
+    Goat::HTMLString.new(self)
   end
-end
 
-class Set
-  def glimpse(n=100)
-    "#<Set: #{self.map{|x| x.glimpse(n)}.join(', ')}>"
+  def handle_request(req)
+    [200, {}, self]
   end
 end
 
-class Array
-  def glimpse(n=100)
-    "[" + self.map{|x| x.glimpse(n)}.join(', ') + "]"
-  end
+def h!(str)
+  Goat::HTMLString.new(str)
 end
 
-class Hash
-  def glimpse(n=100)
-    "{" + self.map{|k, v| k.glimpse + "=>" + v.glimpse}.join(', ') + "}"
-  end
-end
+module Goat
+  class HTMLString < String; end
 
-class Hash
-  def map_to_hash
-    h = {}
-    self.map do |k, v|
-      nk, nv = yield(k, v)
-      h[nk] = nv
+  class << self
+    inline do |builder|
+      builder.c 'VALUE new_without_initialize(VALUE klass) {
+        /* The 1 here is a special constant in ruby that corresponds to ID_ALLOCATOR */
+        return rb_funcall(klass, 1, 0, 0);
+      }'
     end
-    h
   end
-end
 
-class String
-  def prefix_ns(ns)
-    self.gsub(/^%(.+)$/, "#{ns}_\\1")
-  end
-end
-
-module Goat
   def self.version
-    if @version
-      @version
-    elsif !@tried_to_detect_version
-      @tried_to_detect_version = true
-      path = File.join(File.dirname(__FILE__), '../goat.gemspec')
-      if File.exists?(path)
-        v = File.read(path).split("\n").select{|l| l =~ /version/}.first
-        if v && v =~ /["']([0-9\.]+)["']/
-          @version = $1
-        end
-      elsif
-        dir = File.expand_path(File.dirname(__FILE__))
-        if dir =~ /goat-([0-9\.]+)\//
-          @version = $1
-        end
-      end
-    else
-      nil
-    end
+    specpath = File.join(File.dirname(__FILE__), '../goat.gemspec')
+    Gem::Specification.load(specpath).version.to_s
   end
-  
-  def self.goat_path(f); File.join(File.dirname(__FILE__), 'goat', f); end
 
-  def self.extend_sinatra
-    require goat_path('sinatra')
-  end
+  def self.goat_path(f); File.join(File.dirname(__FILE__), 'goat', f); end
 
   def self.extend_mongo
     require goat_path('mongo')
   end
-  
+
   def self.enable_notifications(opts={})
     NotificationCenter.configure(opts)
   end
-  
+
+  def self.enable_statesrv(opts={})
+    StateSrvClient.configure(opts)
+  end
+
+  def self.enable_appsrv(opts={})
+    UpdateDispatcher.enable
+  end
+
   def self.load_all(dir_fragment)
     dir = File.join(Goat.setting!(:root), dir_fragment)
     if File.directory?(dir)
       Dir.entries(dir).select{|f| f =~ /\.rb$/}.each {|f| require(File.join(dir, f))}
     end
   end
-  
+
   @settings = {}
   def self.setting(opt)
     @settings[opt]
   end
-  
-  def self.setting!(opt)  
+
+  def self.setting!(opt)
     if @settings.include?(opt)
       @settings[opt]
     else
@@ -169,63 +115,57 @@ module Goat
   end
 
   def self.settings; @settings; end
-  
+
   def self.add_component_helpers(modul)
     Goat::Component.send(:include, modul)
   end
 
   def self.configure(&blk)
     blk.call
-    
+
     load_all('components')
-    load_all('pages')      
-    
+    load_all('pages')
+
     Goat.extend_mongo if Goat.setting(:mongo)
-    Goat.extend_sinatra if Goat.setting(:sinatra)
-    
+
     if p = Goat.setting(:press)
       Goat::Static.press = p
     end
-    
+
     if Goat.setting(:debug)
       if defined?(Thin)
         Thin::Logging.debug = true
       end
-      
-      Goat::Logger.levels = [:debug, :error]
-    end    
-        
+    end
+
     NotificationCenter.configure(Goat.setting(:notifications)) if Goat.setting(:notifications)
   end
-  
+
   def self.rack_builder(app)
-    Rack::Builder.new do      
+    Rack::Builder.new do
       if cookies = Goat.setting(:cookies)
         use Rack::Session::Cookie, cookies
       end
-      
+
       if static = Goat.setting(:static)
         use Rack::Static, :urls => static.fetch(:urls), :root => static.fetch(:root)
       end
-      
+
       use Rack::Flash if defined?(Rack::Flash) # TODO hack
-      
-      if Goat.setting(:reload_files)
-        use Rack::Reloader
-      end      
-            
+      use Rack::CommonLogger
+
       run app
     end
   end
-  
+
   class NotFoundError < RuntimeError
     attr_reader :path
-    
+
     def initialize(path)
       @path = path
     end
   end
-  
+
   class ChannelPusher
     include EM::Deferrable
 
@@ -236,7 +176,7 @@ module Goat
       @messages = []
 
       self.errback do
-        Logger.log :live, "Channel closed"
+        logd "Channel closed"
         @finished = true
       end
 
@@ -279,26 +219,26 @@ module Goat
       @body_callback = blk
     end
   end
-  
+
   class Halt < Exception
     attr_reader :response
-    
+
     def initialize(response)
       @response = response
     end
   end
 
   class ReqHandler
-    
-    # we can't know this at initialize time because we start using 
+
+    # we can't know this at initialize time because we start using
     # the req handler in context of Goat::App, which would lead to
     # app = Goat::App, which is wrong
     attr_accessor :app_class
-        
+
     def initialize
       @around_handler_bindings = {}
     end
-    
+
     class ::Proc
       def handle_request(app)
         self.call(app)
@@ -329,7 +269,7 @@ module Goat
 
       mappings[method][path] = hook
     end
-    
+
     def around_handler_binding(handler, type)
       if type == :before
         @around_handler_bindings[handler] ||= App.bind(handler)
@@ -338,20 +278,20 @@ module Goat
       else
         raise 'bad handler type'
       end
-    end      
-    
+    end
+
     def run_around_handlers(app, type)
       app.class.around_handlers.select{|h| h.first == type}.each do |handler|
         around_handler_binding(handler[1], type).call(app)
       end
     end
-    
+
     def run_before_handlers(app); run_around_handlers(app, :before); end
     def run_after_handlers(app); run_around_handlers(app, :after); end
-    
-    def resp_for_error(e, app)      
+
+    def resp_for_error(e, app)
       resp = nil
-      
+
       if e.kind_of?(NotFoundError)
         # 404
         if app.class.not_found_handler
@@ -360,43 +300,58 @@ module Goat
         else
           resp = [404, {}, 'not found']
         end
-      else   
-        # not a 404 -- an actual problem   
+      else
+        # not a 404 -- an actual problem
         if app.class.error_handler
           @error_handler_binding ||= App.bind(app.class.error_handler)
           resp = @error_handler_binding.call(app, e)
         else
-          Logger.error(:req, e.inspect)
-          Logger.error(:req, e.backtrace.join("\n"))
-          
+          loge e.inspect
+          loge e.backtrace.join("\n")
+
           resp = Rack::Response.new
           resp.status = 500
-          resp['Content-Type'] = 'text/plain'              
+          resp['Content-Type'] = 'text/plain'
           resp.body = e.inspect + "\n" + e.backtrace.join("\n")
         end
       end
-      
+
       resp
     end
-        
-    def handle_request(env)      
+
+    def find_hook(meth, path)
+      hooks = mappings[meth.downcase.to_sym]
+      if h = hooks[path]
+        return h
+      else
+        hooks.each do |pathspec, hook|
+          if pathspec.kind_of?(Regexp) && pathspec =~ path
+            return hook
+          end
+        end
+      end
+
+      nil
+    end
+
+    def handle_request(env)
       path = env['PATH_INFO']
       meth = env['REQUEST_METHOD']
-      hook = mappings[meth.downcase.to_sym][path]
+      hook = find_hook(meth, path)
       hdrs = {}
       resp = nil
-      
+
       begin
-        req = Rack::Request.new(env)        
-                
+        req = Rack::Request.new(env)
+
         app = @app_class.new(req)
-        
+
         begin
           run_before_handlers(app)
         rescue Halt => halt
           return halt.response.to_a
         end
-        
+
         if hook
           resp = hook.handle_request(app)
         else
@@ -407,40 +362,40 @@ module Goat
       rescue Exception => e
         resp = resp_for_error(e, app)
       end
-      
+
       run_after_handlers(app)
 
       resp.to_a
     end
   end
-  
+
   module HTMLHelpers
     include Rack::Utils
     alias_method :h, :escape_html
     alias_method :e, :escape # for URIs
-    
-    def jsesc(x); x.gsub('\\', '\\\\\\').gsub('"', '\"'); end    
-  end  
-  
+
+    def jsesc(x); x.gsub('\\', '\\\\\\').gsub('"', '\"'); end
+  end
+
   module FlashHelper
     def flash
       request.env['x-rack.flash']
-    end    
-  end  
-  
+    end
+  end
+
   class ERBRunner
     include HTMLHelpers
     include FlashHelper
-    
+
     def initialize(req, resp, params)
       @request = req
       @response = resp
       @params = params
     end
-    
+
     attr_reader :request, :response, :params
     attr_accessor :delegate
-    
+
     def take_delegate_ivars
       @delegate.instance_variables.each do |ivar|
         unless self.instance_variables.include?(ivar)
@@ -448,7 +403,7 @@ module Goat
         end
       end
     end
-    
+
     def method_missing(meth, *args)
       if @delegate
         @delegate.send(meth, *args)
@@ -456,26 +411,26 @@ module Goat
         super
       end
     end
-    
+
     def erb(name, opts={}, &blk)
       take_delegate_ivars if @delegate
-      
+
       opts = {
         :partial => false,
         :layout => true,
         :locals => {}
       }.merge(opts)
-      
+
       if self.kind_of?(Page)
         opts[:locals][:page] ||= self
       end
-      
+
       partial = opts[:partial]
       use_layout = opts[:layout]
       locals = opts[:locals]
-      
+
       if partial
-        name = name.to_s      
+        name = name.to_s
         d = File.dirname(name)
         d = d == '.' ? '' : "#{d}/"
         f = File.basename(name)
@@ -483,19 +438,19 @@ module Goat
         # slashes are actually allowed in syms
         name = "#{d}_#{f}".to_sym
       end
-      
+
       if name =~ /\.erb$/ # allow an absolute path to be passed
         erbf = name
       else
         erbf = File.join(Goat.setting!(:root), 'views', "#{name}.erb")
       end
-      
+
       layf = File.join(Goat.setting!(:root), 'views', 'layout.erb')
       template = Tilt[:erb].new(erbf) { File.read(erbf) }
-            
+
       layout = File.read(layf) if File.exists?(layf) && !partial && use_layout
       out = template.render(self, locals, &blk)
-      
+
       if layout
         laytpl = Tilt[:erb].new(layf) { layout }
         laytpl.render(self, locals) { out }
@@ -503,32 +458,29 @@ module Goat
         out
       end
     end
-    
+
     def partial_erb(name, opts={})
       erb(name, {:partial => true}.merge(opts))
     end
-  end  
-      
+  end
+
   module AppHelpers
-    def halt
+    def halt(body=nil)
+      response.body = body if body
       raise Halt.new(response)
     end
-    
+
     def redirect(url)
       response.status = 302
       response['Location'] = url
       halt
     end
-    
+
     def session
       request.env['rack.session'] ||= {}
-    end    
-        
-    def render_component(c)
-      c.processed_html
     end
   end
-    
+
   class IndifferentHash < Hash
     def self.from_hash(hash)
       ih = self.new
@@ -537,56 +489,26 @@ module Goat
       end
       ih
     end
-    
+
     def [](k)
       if k.kind_of?(Symbol)
         k_sym = k
         k_str = k.to_s
         raise 'Invalid hash' if self.include?(k_sym) && self.include?(k_str)
-      
+
         self.include?(k_str) ? self.fetch(k_str) : self.fetch(k_sym, nil)
       else
         super(k)
       end
     end
   end
-  
+
   class App
     class << self
-      
-    MAX_ACTIVE_PAGES = 100
+
     @@error_handler = nil
     @@not_found_handler = nil
-    @@active_pages = {}
-    @@active_page_queue = Queue.new
     @@around_handlers = []
-    
-    def active_pages; @@active_pages; end    
-    def active_page_queue; @@active_page_queue; end
-
-    def add_active_page(pg)
-      pgid = pg.id
-      active_page_queue << pg.id
-      self.active_pages[pg.id] = pg
-    end
-    
-    def active_page_gc
-      deleted = 0
-      while active_page_queue.size > MAX_ACTIVE_PAGES
-        pgid = active_page_queue.pop
-        pg = active_pages[pgid]
-        pg.mark_dead!
-        NotificationCenter.delegate_gc
-        active_pages.delete(pgid)
-        Logger.log :gc, "Removing page #{pgid}"
-        deleted += 1
-      end
-      ObjectSpace.garbage_collect
-      Logger.log :gc, "Page GC ejected #{deleted} pages"
-    rescue Exception => e
-      Logger.error(:gc, e.inspect)
-      Logger.error(:gc, e.backtrace.join("\n"))
-    end
 
     def req_handler
       @@reqhandler ||= ReqHandler.new
@@ -605,13 +527,13 @@ module Goat
     def map(opts)
       req_handler.add_mapping(opts)
     end
-    
-    def around_handlers; @@around_handlers; end    
-        
+
+    def around_handlers; @@around_handlers; end
+
     def before(&blk)
       around_handlers << [:before, blk]
     end
-    
+
     def after(&blk)
       around_handlers << [:after, blk]
     end
@@ -619,145 +541,101 @@ module Goat
     def enable_notifications(opts={})
       NotificationCenter.configure(opts)
     end
-    
-    def debug_pages    
-      active_pages.each do |i, pg|
-        Logger.log :gc, [i, pg.dead?].inspect
-      end
-    end
-
-    def handle_channel(req)
-      id = req['_id']
-      jsonp = req['jsonp']
-      pg = active_pages[id]
-      
-      active_page_gc # we do GC here since a slight delay in opening channel is better than in loading page
-      
-      if !jsonp
-        respond_failed
-      end
-      
-      if pg
-        pg.mark_alive!
-        body = ChannelPusher.new(pg.channel, jsonp)
 
-        EM.next_tick do
-          req.env['async.callback'].call([200, {'Content-Type' => 'application/javascript'}, body])
-        end
-        
-        body.callback { pg.mark_dead! }
-        body.errback  { pg.mark_dead! }        
+    def respond_success; [200, {}, ['ok']]; end
+    def respond_failed; [500, {}, ['failed']]; end
 
-        Logger.log :req, 'respond'
+    def handle_rpc(app)
+      req = app.request
 
-        [-1, {}, []]
-      else
-        Logger.error(:req, "Couldn't find page #{id}")
+      cls = req['cls']
+      cid = req['id']
+      rpc = req['rpc']
+      txn = req['rttxn']
+      pgid = req['pgid']
+      reqargs = JSON.load(req['args'])
 
-        respond_failed
-      end
-    end
+      have_handler = false
+      resp = nil
 
-    def respond_success; [200, {}, ['ok']]; end
-    def respond_failed; [500, {}, ['failed']]; end
+      Goat::NotificationCenter.notify(
+        'type' => 'txn_start',
+        'txn' => txn,
+        'pgid' => pgid
+      )
 
-    def with_component_from_req(req)
-      id = req['_id']
-      compid = req['_component']
-
-      pg = active_pages[id]
-      if pg
-        comp = pg.components.detect{|x| x.id == compid}
-        Logger.error :req, "Couldn't find component #{compid.inspect}" unless comp
-        
-        if comp
-          yield comp
-        else
-          respond_failed
-        end
-      else
-        Logger.error(:req, "Couldn't find page #{id}")
+      if comp = Goat.rpc_handlers[cls]
+        if comp.include?(rpc)
+          Dynamic.let(:txn => txn, :txn_pgid => pgid) do
+            have_handler = true
+            opts = comp[rpc]
+            args = []
+            if opts[:live]
+              if skel = StateSrvClient.fetch_component(cid)
+                component = Kernel.fetch_class(cls).from_skel(skel)
+                component.deserialize(skel.state)
+
+                args << component
+              else
+                return respond_failed
+              end
+            end
 
-        respond_failed
-      end
-    end
+            args << IndifferentHash.from_hash(reqargs)
 
-    def handle_post(req)
-      with_component_from_req(req) do |comp|
-        comp.submitted(req)
-        respond_success
-      end
-    end
+            resp = app.respond_with_hook("rpc_#{rpc}", *args)
+            resp = opts[:is_get] ? resp.to_json : [200, {}, '']
 
-    def handle_dispatch(req)
-      with_component_from_req(req) do |comp|
-        k = req['_dispatch'];
-        if comp.callback_registered?(k)
-          comp.run_callback(k)
-          respond_success
-        else
-          Logger.error(:req, "Couldn't find handler #{k.inspect}")
-          respond_failed
-        end
-      end
-    end
-    
-    def handle_rpc(app)
-      req = app.request
-      
-      c = req['_component']
-      id = req['_id']
-      rpc = req['_rpc']
-      
-      if comp = Goat.rpc_handlers[c]
-        if comp[rpc]
-          return app.respond_with_hook("rpc_#{rpc}", IndifferentHash.from_hash(req.params))
+            if opts[:live]
+              component.update
+            end
+          end
         end
       end
-      
-      [500, {}, {'success' => false}.to_json]
+
+      Goat::NotificationCenter.notify(
+        'type' => 'txn_complete',
+        'txn' => txn
+      )
+
+      have_handler ? resp : [500, {}, {'success' => false}.to_json]
     end
-    
+
     def error(&blk)
       @@error_handler = blk
     end
-    
+
     def error_handler; @@error_handler; end
-    
+
     def not_found(&blk)
       @@not_found_handler = blk
     end
-    
+
     def not_found_handler; @@not_found_handler; end
-    
+
     end # end class << self
-    
+
     def self.call(env)
-      # TODO better place to put this?
-      NotificationCenter.init # will do nothing if not enabled
-      
       self.req_handler.app_class = self
-      
       self.req_handler.handle_request(env)
     end
-    
+
     include AppHelpers
     include FlashHelper
-    
+
     def self.bind(hook, name=nil, for_response=true)
       mname = name || String.random
-      
+
       lambda do |app, *args|
         kls = app.class
-        
+
         unless kls.instance_methods.include?(mname)
-          Logger.log :req, "defining #{mname} on #{kls}"
+          logd "defining #{mname} on #{kls}"
           kls.send(:define_method, mname, hook)
           hook = kls.instance_method(mname)
         end
-        
-        Logger.log :req, "running #{mname}"
-        if for_response                  
+
+        if for_response
           # sets the body
           app.respond_with_hook(mname, *args)
         else
@@ -765,35 +643,37 @@ module Goat
         end
       end
     end
-        
+
     def initialize(req, meth=nil)
       @req = req
       @meth = meth
       @response = Rack::Response.new
       @params = IndifferentHash.from_hash(req.params)
     end
-    
+
     def response; @response; end
     def request; @req; end
     def params; @params; end
-        
+
     def respond_with_hook(hook, *args)
       response.body = self.send(hook, *args) || ''
       response.finish
     end
-    
+
     def erb(name, opts={}, &blk)
       e = ERBRunner.new(@req, @response, @params)
       e.delegate = self
       e.erb(name, {:locals => {:page => nil}}.merge(opts), &blk)
     end
-    
-    map :path => '/channel', :metal => true, :hook => lambda {|app| handle_channel(app.request)}
-    map :path => '/post', :metal => true, :hook => lambda {|app| handle_post(app.request) }
-    map :path => '/dispatch', :metal => true, :hook => lambda {|app| handle_dispatch(app.request) }    
+
     map :path => '/rpc', :method => :post, :metal => true, :hook => lambda {|app| handle_rpc(app)}
   end
 
+  class BasicApp < App
+    get '/static/jquery.js', File.read(Goat.goat_path('../../examples/jq.js'))
+    get '/static/goat.js', File.read(Goat.goat_path('goat.js'))
+  end
+
   class Channel
     # thin wrapper for EM::Channel
 
@@ -804,331 +684,623 @@ module Goat
     end
 
     def send_message(msg)
-      Logger.log :live, "Pushing #{msg.inspect}"
       @emchannel.push(msg)
     end
   end
-  
+
   def self.rpc_handlers; @rpc_handlers ||= {}; end
 
+  class DOMDistiller
+    def initialize(dom, cs)
+      @dom = dom
+      @components = cs
+    end
+
+    def all_components
+      @components
+    end
+
+    def all_component_classes
+      @all_component_classes ||= \
+        all_components.map(&:class).uniq.\
+        map{|cls| cls.superclasses(Component)}.uniq.flatten
+    end
+
+    def ordered_component_classes
+      cs = all_component_classes
+
+      i = 0
+      # invariant: left of i has no superclasses to right
+      while i < cs.size
+        c = cs[i]
+        if cs[(i+1)..-1].any?{|sup| c.subclass_of?(sup)}
+          cs.delete(c)
+          cs << c
+        else
+          i += 1
+        end
+      end
+
+      cs
+    end
+
+    def unpressed_component_classes
+      ordered_component_classes.to_a.reject do |cls|
+        Goat.setting(:press) && Goat::Static.pressed?(cls)
+      end
+    end
+
+    def script
+      cs = unpressed_component_classes
+
+      [
+        cs.map(&:__script),
+        all_components.select{|c| c.class.wired?}.map(&:wire_script),
+        all_components.map(&:__script)
+      ].flatten.compact.join(';')
+    end
+
+    def style
+      unpressed_component_classes.select(&:__css).map(&:scoped_css).join
+    end
+  end
+
   class Page
     attr_reader :canvas, :request, :id, :canvas, :layout, :params, :channel
-            
+
     @live_updates = true
-    
+
     def self.disable_live_updates; @live_updates = false; end
     def self.enable_live_updates; @live_updates = true; end
     def self.live_updates_enabled?; @live_updates != false; end
-    
+
     include FlashHelper
-    
+
     def erb(name, opts={}, &blk)
       e = ERBRunner.new(@request, @response, @params)
       e.delegate = self
       e.erb(name, {:partial => false}.merge(opts), &blk)
     end
-    
+
     def self.handle_request(app)
-      pg = self.new(app)      
-      app.class.add_active_page(pg)
-      resp = pg.response
-      
-      # app.class.active_page_gc
-      
-      action_hashes = 0
-      
-      ObjectSpace.each_object do |obj|
-        if obj.kind_of?(Page) && obj.class != Class
-          #puts "Page: #{obj.glimpse}" 
-        elsif obj.kind_of?(Component) && obj.class != Class
-          #puts "Component: #{obj.glimpse}"
-        elsif obj.kind_of?(ActionProc) && obj.class != Class
-          action_hashes += 1
-        end
-      end      
-      
-      puts "ActionHashes: #{action_hashes}"
-      
-      resp
+      pg = self.new(app)
+      pg.response
     end
 
     def initialize(app)
       @request = app.request
       @channel = Channel.new
-      @canvas = PageCanvas.new
-      @id = String.random(10, :alpha => true)
+      @id = 'pg_' + String.random(10)
       @params = IndifferentHash.from_hash(request.params)
     end
-    
-    def components; @canvas.all_components; end
-    
+
     def empty_response
       Rack::Response.new
     end
-    
+
     def halt
       raise Halt.new(empty_response)
     end
-    
-    def dead?
-      components.first.dead?
-    end
-    
-    def mark_dead!
-      components.each(&:mark_dead!)
+
+    def register_page(distiller)
+      live = distiller.all_components.select(&:live_enabled?)
+      pg_spec = live.map do |c|
+        c.pgid = @id
+        c.skel
+      end
+
+      StateSrvClient.register_page(@id, pg_spec)
     end
-    
-    def mark_alive!
-      components.each(&:mark_alive!)
+
+    def html_from_erb
+      html = self.erb(@erb, :layout => false)
     end
-    
-    class CanvasDistiller
-      def initialize(canvas)
-        @canvas = canvas
-      end
-      
-      def all_component_classes
-        comp_classes = Set.new
-        @canvas.all_components.map(&:class).uniq.map do |cls|
-          c = cls
-          
-          while c
-            if c == Object
-              raise "Error traversing class hierarchy to find necessary JS"
-            end
-            
-            comp_classes << c
-            
-            if c == Component
-              break
-            else
-              c = c.superclass
-            end
-          end
-        end
-        
-        comp_classes
-      end
-      
-      def ordered_component_classes
-        cs = all_component_classes.to_a
-        
-        i = 0
-        # invariant: left of i has no superclasses to right
-        while i < cs.size 
-          c = cs[i]
-          if cs[(i+1)..-1].any?{|sup| c.kind_of?(sup)}
-            cs.delete(c)
-            cs << c
-          else
-            i += 1
-          end
-        end
-        
-        cs
-      end
-      
-      def unpressed_component_classes
-        ordered_component_classes.to_a.reject do |cls|
-          Goat.setting(:press) && Goat::Static.pressed?(cls)
-        end
-      end
-      
-      def script
-        cs = unpressed_component_classes
-                
-        [
-          cs.map(&:__script),
-          @canvas.all_components.select{|c| c.class.wired?}.map(&:wire_script),
-          @canvas.all_components.map(&:__script)
-        ].flatten.compact.join(';')
-      end
-      
-      def style
-        unpressed_component_classes.select(&:__css).map(&:scoped_css).join
+
+    def inject_html_from_dom(canvas)
+      exp = nil
+      helper = ExpansionHelper.new
+
+      Dynamic.let(:expander => helper) do
+        exp = DOMTools.expanded_dom(self.dom)
       end
+
+      distiller = DOMDistiller.new(exp, helper.components)
+
+      canvas.html = DOMTools::HTMLBuilder.new(exp).html
+      canvas.style << distiller.style
+      canvas.script << distiller.script
+
+      EM.next_tick { register_page(distiller) }
     end
-    
+
     def html
       layout = self.layout
-      
-      distiller = CanvasDistiller.new(@canvas)                        
-      html = nil
-      
-      if @canvas.erb        
-        html = self.erb(@canvas.erb, :layout => false)
-      elsif !@canvas.body.empty?
-        html = (@canvas.body.map do |item|
-          if item.kind_of?(Component)
-            item.processed_html
-          elsif item.kind_of?(String)
-            item
-          else
-            raise "Unknown body item: #{item.inspect}"
-          end
-        end).join          
+
+      canvas = PageCanvas.new
+      canvas.title = @title
+
+      if @erb
+        canvas.html = html_from_erb
+      elsif methods.include?('dom')
+        inject_html_from_dom(canvas)
       else
-        raise "You can define an erb or append to the body, but not both"
-      end      
-      
-      @canvas.style << distiller.style
-      @canvas.script << distiller.script
-      
-      render_to_layout(html, layout)      
+        raise "You should over-ride Page#dom or supply an erb template"
+      end
+
+      render_to_layout(canvas, layout)
     end
-    
-    def render_component(c)
-      canvas.components << c
-      c.processed_html
-    end    
+
+    #def render_component(c)
+    #  canvas.components << c
+    #  c.html
+    #end
 
     def response
       Rack::Response.new(self.html, 200, {})
     end
-    
-    def render_to_layout(body, layout)
+
+    def render_to_layout(canvas, layout)
       layout ||= File.join(File.dirname(__FILE__), 'views/plain_layout.erb')
-        
+
       erb(layout,
-        :locals => {:page => self},
+        :locals => {:page => self, :canvas => canvas},
         # don't want a layout in our layout so we can layout while we layout
-        :layout => false) do
-        body
-      end
-    end    
+        :layout => false) { canvas.html }
+    end
+
+    def erb=(erb); @erb = erb; #TODO make it work properly, but not support embenned components
+    end
+    def title=(title); @title = title; end
   end
 
   class PageCanvas
-    attr_accessor :body, :title, :components, :erb, :script, :style
+    attr_accessor :title, :script, :style, :html
 
     def initialize
-      @body = []
-      @components = []
       @script = []
       @style = []
     end
-    
+
     def flattened_style; @style.join; end
     def flattened_script; @script.join; end
-    
-    def all_components
-      cs = body.empty? ? @components : @body.select{|c| c.kind_of?(Component)}
-      cs.map(&:all_components).flatten
+  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}"
+
+      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
+    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
     end
   end
 
-  class Component
-    attr_reader :id, :handlers, :page, :params
-    
-    include HTMLHelpers # sure just shit it in with everything else
-    
-    def initialize(page)
-      @id = String.random(10, :alpha => true)
-      @page = page
-      @callbacks = {}
-      @params = page.params if page
-      @dead = false      
-    end
-    
-    def erb(*args, &blk)
-      ERBRunner.new(@page.request, nil, @params).erb(*args, &blk)
+  class ExpansionHelper
+    attr_reader :components
+
+    def initialize
+      @components = Set.new
     end
-    
-    def partial_erb(*args, &blk)
-      ERBRunner.new(@page.request, nil, @params).partial_erb(*args, &blk)
+
+    def component_used(c)
+      @components << c
     end
-    
-    def halt; @page.halt; end
+  end
 
-    def channel; @page.channel; end
-    def id; @id; end
+  class UpdateDispatcher
+    def self.enable
+      Goat::NotificationCenter.subscribe(self, :txn_start, 'type' => 'txn_start')
+      Goat::NotificationCenter.subscribe(self, :txn_complete, 'type' => 'txn_complete')
+    end
+
+    @active_txns = {}
+
+    def self.txn_start(n)
+      @active_txns[n['txn']] = {
+        :page_updates => [],
+        :other_updates => [],
+        :pgid => n['pgid']
+      }
+    end
+
+    def self.txn_complete(n)
+      finish_txn(n['txn'])
+    end
+
+    def self.finish_txn(txn_id)
+      if txn = @active_txns[txn_id]
+        pgid = txn[:pgid]
+        dispatch_updates(txn_id, pgid, txn[:page_updates])
+        txn[:other_updates].each{|u| dispatch_update(u)}
+      end
+    end
 
-    def render
-      page.channel.send_message(
-        :type => :update,
-        :id => id,
-        :html => processed_html
+    def self.dispatch_updates(txn, pgid, ups)
+      StateSrvClient.components_updated(
+        txn,
+        pgid,
+        ups
       )
     end
-    
-    def page_error(msg)
-      page.channel.send_message(
-        :type => :alert,
-        :message => msg
+
+    def self.dispatch_update(update)
+      StateSrvClient.component_updated(nil, update.skel.pgid, update)
+    end
+
+    def self.component_updated(pgid, update)
+      if Dynamic.variable?(:txn)
+        txn = Dynamic[:txn]
+        txn_pgid = Dynamic[:txn_pgid]
+        if updates = @active_txns[txn]
+          if pgid == txn_pgid
+            updates[:page_updates] << update
+          else
+            updates[:other_updates] << update
+          end
+        else
+          raise "Got an update for an un-started txn (#{txn.inspect}, #{pgid})"
+        end
+      else
+        dispatch_update(update)
+      end
+    end
+  end
+
+  class Component
+    attr_reader :id, :handlers, :page, :params, :initargs
+
+    include HTMLHelpers # sure just shit it in with everything else - TODO remove?
+
+    def self.live_enabled; @live_enabled = true; end
+    def self.live_enabled?; @live_enabled; end
+    def live_enabled?; self.class.live_enabled?; end
+
+    def self.rerender_and_update(spec)
+      cls = self.name
+
+      Profile.request_start
+
+      Profile.in(:render_and_update)
+      StateSrvClient.live_components(cls, spec).each do |skel|
+        Profile.in(:cls_rerender)
+        rerender(skel)
+        Profile.out(:cls_rerender)
+      end
+      Profile.out(:render_and_update)
+
+      Profile.request_end
+    end
+
+    def self.rerender(skel)
+      Profile.in(:create_component)
+      c = Kernel.fetch_class(skel.cls).from_skel(skel)
+      c.deserialize(skel.state)
+      Profile.out(:create_component)
+      
+      c.rerender
+    end
+
+    def update
+      rerender
+    end
+
+    def rerender
+      Profile.in(:rerender)
+
+      helper = ExpansionHelper.new
+
+      Profile.in(:expansion)
+      Dynamic.let(:expander => helper) do
+        @expanded_dom = self.expanded_dom
+      end
+      Profile.out(:expansion)
+
+      Profile.in(:diff)
+      diff = DOMDiff.diff(@old_dom, @expanded_dom, @id)
+      Profile.out(:diff)
+
+      if diff.size == 0
+        # pass
+        $stderr.puts "No changes"
+      elsif diff.size < 0 # TODO constant
+        rerender_partially(diff)
+      else
+        rerender_fully(helper.components)
+      end
+    rescue JustRerenderError # partial updater gave up
+      rerender_fully(helper.components)
+    ensure
+      Profile.out(:rerender)
+    end
+
+    def pgid=(id); @pgid = id; end
+
+    def skel
+      ComponentSkeleton.new(
+        @pgid,
+        self.class.name,
+        @id,
+        live_spec,
+        serialize,
+        @expanded_dom
       )
     end
 
-    def redirect(loc)
-      channel.send_message(
-        :type => :redirect,
-        :location => loc
+    def self.from_skel(skel)
+      inst = Goat.new_without_initialize(self)
+      inst.load_skel(skel)
+      inst
+    end
+
+    def load_skel(skel)
+      @id = skel.id
+      @pgid = skel.pgid
+      @old_dom = skel.dom
+      @live_spec = skel.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
       )
     end
-    
-    def mark_dead!
-      @dead = true
+
+    def rerender_fully(cs)
+      Profile.in(:distillation)
+      distiller = DOMDistiller.new(@expanded_dom, cs + [self])
+      js = distiller.script
+      css = distiller.style
+      Profile.out(:distillation)
+
+      Profile.in(:update_send)
+
+      UpdateDispatcher.component_updated(
+        @pgid,
+        ComponentUpdate.new(
+          self.skel,
+          [{'type' => 'rep',
+            'html' => dom_html(@expanded_dom),
+            'js' => js,
+            'css' => css,
+            'parent' => @id,
+            'position' => nil}]))
+
+      Profile.out(:update_send)
     end
-    
-    def mark_alive!
-      @dead = false
+
+    def initialize
+      @id = 'dom_' + String.random(10)
     end
-    
-    def dead?; @dead; end
 
-    def submit_form(name)
-      "Goat.submitForm('#{name.prefix_ns(@id)}')"
+    def live_for(spec)
+      @live_spec = spec
     end
 
-    def register_handler(target, selector)
-      register_callback { target.send(selector) }
+    def serialize
+      {}
     end
 
-    def callback_registered?(k); @callbacks.include?(k); end
+    def deserialize(state)
+    end
 
-    def run_callback(k)
-      # @callbacks[k].call
-      c = @callbacks[k].call
-      c[:target].send(c[:method], *c[:args])
+    def live_spec
+      @live_spec ? @live_spec : raise("No live_spec specified")
     end
-    
+
+    def erb(*args, &blk)
+      ERBRunner.new(nil, nil, @params).erb(*args, &blk)
+    end
+
+    def partial_erb(*args, &blk)
+      ERBRunner.new(nil, nil, @params).partial_erb(*args, &blk)
+    end
+
+    def id; @id; end
+
     def self.script(script); @script = AutoBind.process(script); end
     def script(script); @script = AutoBind.process(script); end
-    def self.__script; @script; end    
+    def self.__script; @script; end
     def __script; @script; end
-    
+
     def wire_script
       "Goat.wireComponent('#{id}', #{clientside_instance})"
     end
-    
+
     def self.css(css); @css = css; end
-    def css(css); @css = css; end    
+    def css(css); @css = css; end
     def self.__css; @css; end
-    def __css; @css; end    
-    
+    def __css; @css; end
+
     def self.clientside(js)
       script(js)
       @wired = true
     end
-    
+
     def self.wired?; @wired; end
-    
+
     def clientside_args; []; end
-    
+
     def clientside_instance
-      args = [id, *clientside_args].to_json[1..-2]
-      "new #{self.class.name}('#{self.class.name}', #{args})"
+      args = [id, clientside_args].to_json[1..-2]
+      "(new #{self.class.name}('#{self.class.name}', #{args}))"
     end
-        
-    def self.rpc(name, &blk)
+
+    def self.rpc(name, opts={}, &blk)
       Goat.rpc_handlers[self.name.to_s] ||= {}
-      Goat.rpc_handlers[self.name.to_s][name.to_s] = true
-      
-      App.send(:define_method, "rpc_inner_#{name}", blk)
-      App.send(:define_method, "rpc_#{name}") do |params|
-        self.send("rpc_inner_#{name}", params).to_json
-      end
+      Goat.rpc_handlers[self.name.to_s][name.to_s] = opts
+
+      App.send(:define_method, "rpc_#{name}", blk)
+    end
+
+    def self.live_rpc(name, opts={}, &blk)
+      rpc(name, opts.merge(:live => true), &blk)
+    end
+
+    def self.get_rpc(name, opts={}, &blk)
+      rpc(name, opts.merge(:is_get => true), &blk)
     end
-    
+
     def component_name_hierarchy(cls=self.class)
       if cls == Component
         []
@@ -1136,18 +1308,28 @@ module Goat
         component_name_hierarchy(cls.superclass) + [cls.name]
       end
     end
-    
+
+    def inject_prefixes(dom)
+      DOMTools.inject_prefixes(self.id, dom)
+    end
+
     def component(body)
-      [:div, {:id => id, :class => component_name_hierarchy.join(' ')}, body]
+      [:div, {:id => id, :class => component_name_hierarchy.join(' ')},
+        body]
+    end
+
+    def expanded_dom
+      @expanded_dom ||= DOMTools.expanded_dom(inject_prefixes(self.dom))
     end
 
-    def html; make_me; end
+    def dom_as_expanded
+      @expanded_dom
+    end
 
-    def processed_html
-      HTMLBuilder.new(self, component(self.html)).html + \
-        (__css ? "<style>#{scoped_css}</style>" : '')
+    def dom_html(dom)
+      DOMTools::HTMLBuilder.new(dom).html
     end
-    
+
     def self.scope_css(css, prefix, dot_or_hash)
       # #%foo, .%bar, etc
       rep = css.gsub(/(.)%(\w+)([\ \t\{])/) do |str|
@@ -1158,13 +1340,13 @@ module Goat
       end
       rep.gsub(/(^|\W)%([\W\{])/) do |str|
         "#{$1}#{dot_or_hash}#{prefix}#{$2}"
-      end      
+      end
     end
 
     def self.scoped_css
       scope_css(self.__css, self.name, '.')
     end
-    
+
     def scoped_css
       self.class.scope_css(self.__css, @id, '#')
     end
@@ -1172,7 +1354,7 @@ module Goat
     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}
@@ -1182,33 +1364,7 @@ module Goat
         key
       # end
     end
-    
-    def children; []; end
-    
-    def all_components
-      [self] + self.children
-    end
-    
-    def to_html(builder, comp)
-      processed_html # for html.rb
-    end
-    
-    script File.read(File.join(File.dirname(__FILE__), 'goat/js/component.js'))
-  end
-
-  class Model
-    def initialize
-      @delegates = Set.new
-    end
-
-    def data_changed(notif=nil)
-      delegates.each {|d| d.model_changed(self, notif)}
-    end
 
-    def delegates; @delegates; end
-
-    def add_delegate(d)
-      @delegates << d
-    end
+    script File.read(File.join(File.dirname(__FILE__), 'goat/js/component.js'))
   end
 end