goat 0.1.6 → 0.2.0

data/lib/goat.rb

@@ -6,7 +6,7 @@ require 'thin'
 require 'term/ansicolor'
 require 'tilt'
 
-%w{logger notifications extn html}.each do |file|
+%w{logger notifications extn html static autobind}.each do |file|
   require File.join(File.dirname(__FILE__), 'goat', file)
 end
 
@@ -50,6 +50,29 @@ class Object
   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) }
+  end
+end
+
 class Set
   def glimpse(n=100)
     "#<Set: #{self.map{|x| x.glimpse(n)}.join(', ')}>"
@@ -101,11 +124,11 @@ module Goat
   end
   
   def self.load_all(dir_fragment)
-    dir = File.join(File.dirname($0), 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      
+  end
   
   @settings = {}
   def self.setting(opt)
@@ -135,6 +158,10 @@ module Goat
     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
@@ -147,7 +174,7 @@ module Goat
   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
@@ -156,9 +183,12 @@ module Goat
         use Rack::Static, :urls => static.fetch(:urls), :root => static.fetch(:root)
       end
       
-      use Rack::CommonLogger
       use Rack::Flash if defined?(Rack::Flash) # TODO hack
       
+      if Goat.setting(:reload_files)
+        use Rack::Reloader
+      end      
+            
       run app
     end
   end
@@ -347,14 +377,62 @@ module Goat
     end
   end
   
-  module ERBHelper
+  module HTMLHelpers
+    include Rack::Utils
+    alias_method :h, :escape_html
+    alias_method :e, :escape # for URIs
+    
+    def jsesc(x); x.gsub('\\', '\\\\\\').gsub('"', '\"'); end    
+  end  
+  
+  module FlashHelper
+    def flash
+      request.env['x-rack.flash']
+    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)
+          self.instance_variable_set(ivar, @delegate.instance_variable_get(ivar))
+        end
+      end
+    end
+    
+    def method_missing(meth, *args)
+      if @delegate
+        @delegate.send(meth, *args)
+      else
+        super
+      end
+    end
+    
     def erb(name, opts={}, &blk)
+      take_delegate_ivars if @delegate
+      
       opts = {
         :partial => false,
         :layout => true,
-        :locals => self.kind_of?(Page) ? {:page => self} : {}
+        :locals => {}
       }.merge(opts)
       
+      if self.kind_of?(Page)
+        opts[:locals][:page] ||= self
+      end
+      
       partial = opts[:partial]
       use_layout = opts[:layout]
       locals = opts[:locals]
@@ -392,8 +470,8 @@ module Goat
     def partial_erb(name, opts={})
       erb(name, {:partial => true}.merge(opts))
     end
-  end
-    
+  end  
+      
   module AppHelpers
     def halt
       raise Halt.new(response)
@@ -413,13 +491,7 @@ module Goat
       c.processed_html
     end
   end
-  
-  module FlashHelper
-    def flash
-      request.env['x-rack.flash']
-    end    
-  end
-  
+    
   class IndifferentHash < Hash
     def self.from_hash(hash)
       ih = self.new
@@ -442,14 +514,6 @@ module Goat
     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
-
   class App
     class << self
       
@@ -458,7 +522,7 @@ module Goat
     @@not_found_handler = nil
     @@active_pages = {}
     @@active_page_queue = Queue.new
-    @@before_handlers = []
+    @@before_handlers = []    
     
     def active_pages; @@active_pages; end    
     def active_page_queue; @@active_page_queue; end
@@ -587,6 +651,24 @@ module Goat
       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]
+          resp = app.respond_with_hook("rpc_#{rpc}", req.params)
+          resp[2] = resp[2].to_json
+          return resp
+        end
+      end
+      
+      [500, {}, {'success' => false}.to_json]
+    end
+    
     def error(&blk)
       @@error_handler = blk
     end
@@ -600,7 +682,7 @@ module Goat
     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
@@ -610,12 +692,10 @@ module Goat
       self.req_handler.handle_request(env)
     end
     
-    include ERBHelper
-    include FlashHelper
     include AppHelpers
     
-    def self.bind(hook)
-      mname = String.random
+    def self.bind(hook, name=nil)
+      mname = name || String.random
       
       lambda do |app, *args|
         kls = app.class
@@ -647,9 +727,16 @@ module Goat
       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 Channel
@@ -666,6 +753,8 @@ module Goat
       @emchannel.push(msg)
     end
   end
+  
+  def self.rpc_handlers; @rpc_handlers ||= {}; end
 
   class Page
     attr_reader :canvas, :request, :id, :canvas, :layout, :params, :channel
@@ -676,14 +765,12 @@ module Goat
     def self.enable_live_updates; @live_updates = true; end
     def self.live_updates_enabled?; @live_updates != false; end
     
-    include ERBHelper
-    include HTMLHelpers
     include FlashHelper
     
-    alias_method :old_erb, :erb
-    
     def erb(name, opts={}, &blk)
-      old_erb(name, {:partial => false}.merge(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)
@@ -740,31 +827,89 @@ module Goat
       components.each(&:mark_alive!)
     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 script        
+        cs = all_component_classes.to_a.reject do |cls|
+          Goat.setting(:press) && Goat::Static.pressed?(cls)
+        end
+        
+        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.map(&:__script),
+          @canvas.all_components.select{|c| c.class.wired?}.map(&:wire_script),
+          @canvas.all_components.map(&:__script)
+        ].flatten.compact.join(';')
+      end
+      
+      def style
+        @canvas.all_components.map(&:class).uniq.select(&:__css).map(&:scoped_css).join
+      end
+    end
+    
     def html
       layout = self.layout
       
-      if @canvas.erb
-        body = self.erb(@canvas.erb, :layout => false)
-        style = @canvas.components.map(&:processed_css)
-        html = "<style>#{style}</style>#{body}"
-        
-        render_to_layout(html, layout)
-      elsif !canvas.body.empty?
-        body = @canvas.body.map do |item|
+      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)
-            "<style>#{item.processed_css}</style>" +
             item.processed_html
           elsif item.kind_of?(String)
             item
           else
             raise "Unknown body item: #{item.inspect}"
           end
-        end
-        
-        render_to_layout(body.join, layout)        
+        end).join          
       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)      
     end
     
     def render_component(c)
@@ -789,19 +934,21 @@ module Goat
   end
 
   class PageCanvas
-    attr_accessor :body, :title, :components, :erb
+    attr_accessor :body, :title, :components, :erb, :script, :style
 
     def initialize
       @body = []
       @components = []
+      @script = []
+      @style = []
     end
     
-    def components
-      if !body.empty?
-        @body.select{|c| c.kind_of?(Component)}.map(&:all_components).flatten
-      else
-        @components
-      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
   end
 
@@ -809,9 +956,8 @@ module Goat
     attr_reader :id, :handlers, :page, :params
     
     include HTMLHelpers # sure just shit it in with everything else
-    include ERBHelper
     
-    def initialize(page)      
+    def initialize(page)
       @id = String.random(10, :alpha => true)
       @page = page
       @callbacks = {}
@@ -819,6 +965,14 @@ module Goat
       @dead = false      
     end
     
+    def erb(*args, &blk)
+      ERBRunner.new(@page.request, nil, @params).erb(*args, &blk)
+    end
+    
+    def partial_erb(*args, &blk)
+      ERBRunner.new(@page.request, nil, @params).partial_erb(*args, &blk)
+    end
+    
     def halt; @page.halt; end
 
     def channel; @page.channel; end
@@ -871,35 +1025,72 @@ module Goat
       c = @callbacks[k].call
       c[:target].send(c[:method], *c[:args])
     end
-
-    def js
-      <<-EOJ
-      $(document).ready(function(){
-        Goat.registerComponent('#{id}')
-      })
-      EOJ
+    
+    def self.script(script); @script = AutoBind.process(script); end
+    def script(script); @script = AutoBind.process(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 self.__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})"
+    end
+        
+    def self.rpc(name, &blk)
+      Goat.rpc_handlers[self.name.to_s] ||= {}
+      Goat.rpc_handlers[self.name.to_s][name.to_s] = true
+      
+      App.send(:define_method, "rpc_#{name}", blk)
+    end
+    
     def component(body)
-      [:div, {:id => id},
-        [:script, js],
-        body
-      ]
+      [:div, {:id => id, :class => self.class.name}, body]
     end
 
     def html; make_me; end
-    def css; ''; end
 
     def processed_html
-      HTMLBuilder.new(self, component(self.html)).html
+      HTMLBuilder.new(self, component(self.html)).html + \
+        (__css ? "<style>#{scoped_css}</style>" : '')
     end
-
-    def processed_css
-      css.gsub(/%(\w*)([\ \t\{])/) do |str|
-        m = $1
-        ws = $2
-        "#{@id}#{m.empty? ? '' : "_#{m}"}#{ws}"
+    
+    def self.scope_css(css, prefix, dot_or_hash)
+      # #%foo, .%bar, etc
+      rep = css.gsub(/(.)%(\w+)([\ \t\{])/) do |str|
+        p = $1
+        m = $2
+        ws = $3
+        "#{p}#{prefix}_#{m}#{ws}"
       end
+      rep.gsub(/(^|\W)%([\W\{])/) do |str|
+        "#{$1}#{dot_or_hash}#{prefix}#{$2}"
+      end      
+    end
+
+    def self.scoped_css
+      scope_css(self.__css, self.name, '.')
+    end
+    
+    def scoped_css
+      self.class.scope_css(self.__css, @id, '#')
     end
 
     def model_changed(item, notif)
@@ -916,9 +1107,17 @@ module Goat
       # end
     end
     
+    def children; []; end
+    
     def all_components
-      [self]
+      [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

data/lib/goat/goat.js

@@ -92,7 +92,7 @@ $.extend(Goat, {
   },
 
   reopenChannel: function() {
-    console.error("reopenChannel()");
+    console.log("reopenChannel()");
     var fails = this.channelOpenFails;
     setTimeout(function() { Goat.openChannel(); }, (fails > 20) ? 20000 : (fails * 500));
     this.channelOpenFails++;
@@ -160,13 +160,73 @@ $.extend(Goat, {
     
     return false;
   },
-
-  registerComponent: function(id) {
-    this.components[id] = id;
+  
+  wireComponent: function(id, obj) {
+    this.components[id] = obj;
   }
 });
 
+(function(){
+  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
+  // The base Class implementation (does nothing)
+  this.Class = function(){};
+  
+  // Create a new Class that inherits from this class
+  Class.extend = function(prop) {
+    var _super = this.prototype;
+    
+    // Instantiate a base class (but only create the instance,
+    // don't run the init constructor)
+    initializing = true;
+    var prototype = new this();
+    initializing = false;
+    
+    // Copy the properties over onto the new prototype
+    for (var name in prop) {
+      // Check if we're overwriting an existing function
+      prototype[name] = typeof prop[name] == "function" && 
+        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
+        (function(name, fn){
+          return function() {
+            var tmp = this._super;
+            
+            // Add a new ._super() method that is the same method
+            // but on the super-class
+            this._super = _super[name];
+            
+            // The method only need to be bound temporarily, so we
+            // remove it when we're done executing
+            var ret = fn.apply(this, arguments);        
+            this._super = tmp;
+            
+            return ret;
+          };
+        })(name, prop[name]) :
+        prop[name];
+    }
+    
+    // The dummy class constructor
+    function Class() {
+      // All construction is actually done in the init method
+      if ( !initializing && this.init )
+        this.init.apply(this, arguments);
+    }
+    
+    // Populate our constructed prototype object
+    Class.prototype = prototype;
+    
+    // Enforce the constructor to be what we expect
+    Class.constructor = Class;
+
+    // And make this class extendable
+    Class.extend = arguments.callee;
+    
+    return Class;
+  };
+})();
+
 $(document).ready(function() {
+  $.each(Goat.components, function(_, c) { c.onLoad(); });
   setTimeout(function() { if(Goat.page_id) Goat.openChannel(); }, 1);
 });
 

data/lib/goat/notifications.rb

@@ -19,7 +19,7 @@ module Goat
       end
 
       def unbind
-        Logger.error :live, "Lost connection"
+        Logger.error :live, "Lost notification server connection"
         EM.add_timer(1) do
           NotificationCenter.start_receiver
         end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 6
-  version: 0.1.6
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Patrick Collison
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-06 00:00:00 +00:00
+date: 2010-09-20 00:00:00 +00:00
 default_executable: 
 dependencies: []