goat 0.1.3

data/bin/yodel

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '../lib/goat/yodel')
+require 'optparse'
+
+$bport = 8000
+$rport = 8001
+$host = '127.0.0.1'
+
+def usage
+  $stderr.puts <<-EOH
+#{__FILE__} [-b broadcast-port] [-r receive-port] [-h host]
+  EOH
+end
+
+OptionParser.new do |opts|
+  # this is the jankiest optparser I've ever used
+  opts.on('-bMANDATORY', Integer) {|b| $bport = b}
+  opts.on('-rMANDATORY', Integer) {|r| $rport = r}
+  opts.on('-HMANDATORY', String) {|h| $host = h}
+  opts.on('-v') {} # suppress optparse wanting to use -v as version
+  opts.on('-h') {usage; exit 1}
+end.parse!(ARGV)
+
+EM.run do
+  Yodel::BroadcastServer.start($host, $bport)
+  Yodel::RecvServer.start($host, $rport)
+end

data/lib/goat.rb

@@ -0,0 +1,938 @@
+require 'set'
+require 'cgi'
+require 'json'
+require 'eventmachine'
+require 'thin'
+require 'term/ansicolor'
+require 'tilt'
+
+%w{logger notifications extn html}.each do |file|
+  require File.join(File.dirname(__FILE__), 'goat', file)
+end
+
+$verbose ||= ARGV.include?('-v')
+
+class ActionHash < Hash; end
+class ActionProc < Proc; end
+
+def action(hash={})
+  hash
+  # ActionProc.new { hash }
+  # ActionHash[hash]
+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
+      
+  def self.kind_of?(cls)
+    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
+  end
+end
+
+class Set
+  def glimpse(n=100)
+    "#<Set: #{self.map{|x| x.glimpse(n)}.join(', ')}>"
+  end
+end
+
+class Array
+  def glimpse(n=100)
+    "[" + self.map{|x| x.glimpse(n)}.join(', ') + "]"
+  end
+end
+
+class Hash
+  def glimpse(n=100)
+    "{" + self.map{|k, v| k.glimpse + "=>" + v.glimpse}.join(', ') + "}"
+  end
+end
+
+class Hash
+  def map_to_hash
+    h = {}
+    self.map do |k, v|
+      nk, nv = yield(k, v)
+      h[nk] = nv
+    end
+    h
+  end
+end
+
+class String
+  def prefix_ns(ns)
+    self.gsub(/^%(.+)$/, "#{ns}_\\1")
+  end
+end
+
+module Goat    
+  def self.goat_path(f); File.join(File.dirname(__FILE__), 'goat', f); end
+
+  def self.extend_sinatra
+    require goat_path('sinatra')
+  end
+
+  def self.extend_mongo
+    require goat_path('mongo')
+  end
+  
+  def self.enable_notifications(opts={})
+    NotificationCenter.configure(opts)
+  end
+  
+  def self.load_all(dir_fragment)
+    dir = File.join(File.dirname($0), 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)  
+    if @settings.include?(opt)
+      @settings[opt]
+    else
+      raise "#{opt} not set"
+    end
+  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')      
+    
+    Goat.extend_mongo if Goat.setting(:mongo)
+    Goat.extend_sinatra if Goat.setting(:sinatra)
+    
+    if Goat.setting(:debug)
+      if defined?(Thin)
+        Thin::Logging.debug = true
+      end
+      
+      Goat::Logger.levels = [:debug, :error]
+    end    
+        
+    NotificationCenter.configure(Goat.setting(:notifications)) if Goat.setting(:notifications)
+  end
+  
+  def self.rack_builder(app)
+    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::CommonLogger
+      use Rack::Flash if defined?(Rack::Flash) # TODO hack
+      
+      run app
+    end
+  end
+  
+  class NotFoundError < RuntimeError
+    attr_reader :path
+    
+    def initialize(path)
+      @path = path
+    end
+  end
+  
+  class ChannelPusher
+    include EM::Deferrable
+
+    def initialize(channel)
+      @channel = channel
+      @finished = false
+      @messages = []
+
+      self.errback do
+        Logger.log :live, "Channel closed"
+        @finished = true
+      end
+
+      self.callback do
+        @finished = true
+        @channel.emchannel.unsubscribe(@subscription) if @subscription
+      end
+
+      @subscription = @channel.emchannel.subscribe do |msg|
+        @messages << msg
+        # send on next tick so we get a batch of messages together, rather than a single message
+        EM.next_tick { self.send_and_finish }
+      end
+    end
+
+    def messages_without_duplicates
+      @ids = Set.new
+      @messages.select do |x|
+        if x.include?(:id)
+          id = x[:id]
+          if @ids.include?(id)
+            nil
+          else
+            @ids << id
+            x
+          end
+        else
+          x
+        end
+      end.compact
+    end
+
+    def send_and_finish
+      return if @finished # may be called several times
+      @body_callback.call({'messages' => messages_without_duplicates}.to_json)
+      succeed
+    end
+
+    def each(&blk)
+      @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 
+    # the req handler in context of Goat::App, which would lead to
+    # app = Goat::App, which is wrong
+    attr_accessor :app_class
+        
+    def initialize
+      @before_handler_bindings = {}
+    end
+    
+    class ::Proc
+      def handle_request(app)
+        self.call(app)
+      end
+    end
+
+    def mappings
+      @map ||= Hash.new {|h, k| h[k] = Hash.new}
+    end
+
+    def add_mapping(opts)
+      opts = {
+        :metal => false,
+        :method => :get
+      }.merge(opts)
+
+      %w{method path hook}.each do |key|
+        raise "#{key} must be set" unless opts[key.to_sym]
+      end
+
+      method = opts[:method]
+      path = opts[:path]
+      hook = opts[:hook]
+
+      if hook.kind_of?(Proc) && !opts[:metal]
+        hook = App.bind(opts[:hook])
+      end
+
+      mappings[method][path] = hook
+    end
+    
+    def before_handler_binding(handler)
+      @before_handler_bindings[handler] ||= App.bind(handler)
+    end
+    
+    def run_before_handlers(app)
+      app.class.before_handlers.each do |handler|
+        before_handler_binding(handler).call(app)
+      end
+    end
+    
+    def resp_for_error(e, app)      
+      resp = nil
+      
+      if e.kind_of?(NotFoundError)
+        # 404
+        if app.class.not_found_handler
+          @not_found_binding ||= App.bind(app.class.not_found_handler)
+          resp = @not_found_binding.call(app, e)
+        else
+          resp = [404, {}, 'not found']
+        end
+      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"))
+          
+          resp = Rack::Response.new
+          resp.status = 500
+          resp['Content-Type'] = 'text/plain'              
+          resp.body = e.inspect + "\n" + e.backtrace.join("\n")
+        end
+      end
+      
+      resp
+    end
+        
+    def handle_request(env)      
+      path = env['PATH_INFO']
+      meth = env['REQUEST_METHOD']
+      hook = mappings[meth.downcase.to_sym][path]
+      hdrs = {}
+      resp = nil
+      
+      begin
+        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
+          raise NotFoundError.new(path)
+        end
+      rescue Halt => halt
+        resp = halt.response
+      rescue Exception => e
+        resp = resp_for_error(e, app)
+      end
+
+      resp.to_a
+    end
+  end
+  
+  module ERBHelper
+    def erb(name, opts={}, &blk)
+      opts = {
+        :partial => false,
+        :layout => true,
+        :locals => {}
+      }.merge(opts)
+      
+      partial = opts[:partial]
+      use_layout = opts[:layout]
+      locals = opts[:locals]
+      
+      if partial
+        name = name.to_s      
+        d = File.dirname(name)
+        d = d == '.' ? '' : "#{d}/"
+        f = File.basename(name)
+
+        # 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 }
+      else
+        out
+      end
+    end
+    
+    def partial_erb(name, opts={})
+      erb(name, {:partial => true}.merge(opts))
+    end
+  end
+    
+  module AppHelpers
+    def halt
+      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
+  
+  module FlashHelper
+    def flash
+      request.env['x-rack.flash']
+    end    
+  end
+  
+  class IndifferentHash < Hash
+    def self.from_hash(hash)
+      ih = self.new
+      hash.each do |k, v|
+        ih[k] = v
+      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
+  
+  module HTMLHelpers
+    include Rack::Utils
+    alias_method :h, :escape_html
+    
+    def jsesc(x); x.gsub('\\', '\\\\\\').gsub('"', '\"'); end    
+  end
+
+  class App
+    class << self
+      
+    MAX_ACTIVE_PAGES = 100
+    @@error_handler = nil
+    @@not_found_handler = nil
+    @@active_pages = {}
+    @@active_page_queue = Queue.new
+    @@before_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
+    end
+
+    def get(path, hook=nil, &proc)
+      hook = proc unless proc.nil?
+      req_handler.add_mapping(:method => :get, :path => path, :hook => hook)
+    end
+
+    def post(path, hook=nil, &proc)
+      hook = proc unless proc.nil?
+      req_handler.add_mapping(:method => :post, :path => path, :hook => hook)
+    end
+
+    def map(opts)
+      req_handler.add_mapping(opts)
+    end
+    
+    def before_handlers; @@before_handlers; end    
+        
+    def before(&blk)
+      before_handlers << blk
+    end
+
+    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']
+      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 pg
+        pg.mark_alive!
+        body = ChannelPusher.new(pg.channel)
+
+        EM.next_tick do
+          req.env['async.callback'].call([200, {}, body])
+        end
+        
+        body.callback { pg.mark_dead! }
+        body.errback  { pg.mark_dead! }        
+
+        Logger.log :req, 'respond'
+
+        [-1, {}, []]
+      else
+        Logger.error(:req, "Couldn't find page #{id}")
+
+        respond_failed
+      end
+    end
+
+    def respond_success; [200, {}, ['ok']]; end
+    def respond_failed; [500, {}, ['failed']]; end
+
+    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
+        yield comp if comp
+      else
+        Logger.error(:req, "Couldn't find page #{id}")
+
+        respond_failed
+      end
+    end
+
+    def handle_post(req)
+      with_component_from_req(req) do |comp|
+        comp.submitted(req)
+        respond_success
+      end
+    end
+
+    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 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 ERBHelper
+    include FlashHelper
+    include AppHelpers
+    
+    def self.bind(hook)
+      mname = String.random
+      
+      lambda do |app, *args|
+        kls = app.class
+        
+        unless kls.instance_methods.include?(mname)
+          Logger.log :req, "defining #{mname} on #{kls}"
+          kls.send(:define_method, mname, hook)
+          hook = kls.instance_method(mname)
+        end
+        
+        Logger.log :req, "running #{mname}"
+        app.respond_with_hook(mname, *args)
+      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
+    
+    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) }    
+  end
+
+  class Channel
+    # thin wrapper for EM::Channel
+
+    attr_reader :emchannel
+
+    def initialize
+      @emchannel = EM::Channel.new
+    end
+
+    def send_message(msg)
+      Logger.log :live, "Pushing #{msg.inspect}"
+      @emchannel.push(msg)
+    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 ERBHelper
+    include HTMLHelpers
+    include FlashHelper
+    
+    alias_method :old_erb, :erb
+    
+    def erb(name, opts={}, &blk)
+      old_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
+    end
+
+    def initialize(app)
+      @request = app.request
+      @channel = Channel.new
+      @canvas = PageCanvas.new
+      @id = String.random(10, :alpha => true)
+      @params = IndifferentHash.from_hash(request.params)
+    end
+    
+    def components; @canvas.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!)
+    end
+    
+    def mark_alive!
+      components.each(&:mark_alive!)
+    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|
+          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)        
+      else
+        raise "You can define an erb or append to the body, but not both"
+      end      
+    end
+    
+    def render_component(c)
+      canvas.components << c
+      c.processed_html
+    end    
+
+    def response
+      Rack::Response.new(self.html, 200, {})
+    end
+    
+    def render_to_layout(body, layout)
+      layout ||= File.join(File.dirname(__FILE__), 'views/plain_layout.erb')
+        
+      erb(layout,
+        :locals => {:page => self},
+        # don't want a layout in our layout so we can layout while we layout
+        :layout => false) do
+        body
+      end
+    end    
+  end
+
+  class PageCanvas
+    attr_accessor :body, :title, :components, :erb
+
+    def initialize
+      @body = []
+      @components = []
+    end
+    
+    def components
+      if !body.empty?
+        @body.select{|c| c.kind_of?(Component)}.map(&:all_components).flatten
+      else
+        @components
+      end
+    end
+  end
+
+  class Component
+    attr_reader :id, :handlers, :page, :params
+    
+    include HTMLHelpers # sure just shit it in with everything else
+    include ERBHelper
+    
+    def initialize(page)      
+      @id = String.random(10, :alpha => true)
+      @page = page
+      @callbacks = {}
+      @params = page.params if page
+      @dead = false      
+    end
+    
+    def halt; @page.halt; end
+
+    def channel; @page.channel; end
+    def id; @id; end
+
+    def render
+      page.channel.send_message(
+        :type => :update,
+        :id => id,
+        :html => processed_html
+      )
+    end
+    
+    def page_error(msg)
+      page.channel.send_message(
+        :type => :alert,
+        :message => msg
+      )
+    end
+
+    def redirect(loc)
+      channel.send_message(
+        :type => :redirect,
+        :location => loc
+      )
+    end
+    
+    def mark_dead!
+      @dead = true
+    end
+    
+    def mark_alive!
+      @dead = false
+    end
+    
+    def dead?; @dead; end
+
+    def submit_form(name)
+      "Goat.submitForm('#{name.prefix_ns(@id)}')"
+    end
+
+    def register_handler(target, selector)
+      register_callback { target.send(selector) }
+    end
+
+    def callback_registered?(k); @callbacks.include?(k); end
+
+    def run_callback(k)
+      # @callbacks[k].call
+      c = @callbacks[k].call
+      c[:target].send(c[:method], *c[:args])
+    end
+
+    def js
+      <<-EOJ
+      $(document).ready(function(){
+        Goat.registerComponent('#{id}')
+      })
+      EOJ
+    end
+
+    def component(body)
+      [:div, {:id => id},
+        [:script, js],
+        body
+      ]
+    end
+
+    def html; make_me; end
+    def css; ''; end
+
+    def processed_html
+      HTMLBuilder.new(self, component(self.html)).html
+    end
+
+    def processed_css
+      css.gsub(/%(\w*)([\ \t\{])/) do |str|
+        m = $1
+        ws = $2
+        "#{@id}#{m.empty? ? '' : "_#{m}"}#{ws}"
+      end
+    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}
+      # else
+        key = String.random
+        @callbacks[key] = callback
+        key
+      # end
+    end
+    
+    def all_components
+      [self]
+    end
+  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
+  end
+end