cramp 0.11 → 0.12

data/lib/cramp.rb

@@ -11,8 +11,19 @@ require 'active_support/concern'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/buffered_logger'
 
+require 'rack'
+
 module Cramp
-  VERSION = '0.11'
+  VERSION = '0.12'
 
   mattr_accessor :logger
+
+  autoload :Action, "cramp/action"
+  autoload :Websocket, "cramp/websocket"
+  autoload :Body, "cramp/body"
+  autoload :PeriodicTimer, "cramp/periodic_timer"
+  autoload :KeepConnectionAlive, "cramp/keep_connection_alive"
+  autoload :Abstract, "cramp/abstract"
+  autoload :Callbacks, "cramp/callbacks"
+  autoload :TestCase, "cramp/test_case"
 end

data/lib/cramp/abstract.rb

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/hash/keys'
+
+module Cramp
+  class Abstract
+
+    include Callbacks
+
+    ASYNC_RESPONSE = [-1, {}, []].freeze
+
+    class << self
+      def call(env)
+        controller = new(env).process
+      end
+    end
+
+    def initialize(env)
+      @env = env
+    end
+
+    def process
+      EM.next_tick { before_start }
+      ASYNC_RESPONSE
+    end
+
+    def continue
+      init_async_body
+
+      status, headers = respond_with
+      send_initial_response(status, headers, @body)
+
+      EM.next_tick { start } if respond_to?(:start)
+      EM.next_tick { on_start }
+    end
+
+    def respond_with
+      [200, {'Content-Type' => 'text/html'}]
+    end
+
+    def init_async_body
+      @body = Body.new
+
+      if self.class.on_finish_callbacks.any?
+        @body.callback { on_finish }
+        @body.errback { on_finish }
+      end
+    end
+
+    def finish
+      @body.succeed
+    end
+
+    def send_initial_response(response_status, response_headers, response_body)
+      EM.next_tick { @env['async.callback'].call [response_status, response_headers, response_body] }
+    end
+
+    def halt(status, headers = {}, halt_body = '')
+      send_initial_response(status, headers, halt_body)
+    end
+
+    def request
+      @request ||= Rack::Request.new(@env)
+    end
+
+    def params
+      @params ||= request.params.update(route_params).symbolize_keys
+    end
+
+    def route_params
+      @env['router.params']||@env['usher.params']
+    end
+  end
+end

data/lib/cramp/action.rb

@@ -0,0 +1,12 @@
+module Cramp
+  class Action < Abstract
+
+    include PeriodicTimer
+    include KeepConnectionAlive
+
+    def render(body)
+      @body.call(body)
+    end
+
+  end
+end

data/lib/cramp/body.rb

@@ -0,0 +1,48 @@
+# Copyright 2008 James Tucker <raggi@rubyforge.org>.
+
+module Cramp
+  class Body
+    include EventMachine::Deferrable
+
+    def initialize
+      @queue = []
+
+      # Make sure to flush out the queue before closing the connection
+      callback { flush }
+    end
+
+    def call(body)
+      @queue << body
+      schedule_dequeue
+    end
+
+    def each &blk
+      @body_callback = blk
+      schedule_dequeue
+    end
+
+    def closed?
+      @deferred_status != :unknown
+    end
+
+    def flush
+      return unless @body_callback
+
+      until @queue.empty?
+        Array(@queue.shift).each {|chunk| @body_callback.call(chunk) }
+      end
+    end
+
+    def schedule_dequeue
+      return unless @body_callback
+
+      EventMachine.next_tick do
+        next unless body = @queue.shift
+
+        Array(body).each {|chunk| @body_callback.call(chunk) }
+        schedule_dequeue unless @queue.empty?
+      end
+    end
+
+  end
+end

data/lib/cramp/callbacks.rb

@@ -0,0 +1,48 @@
+module Cramp
+  module Callbacks
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_inheritable_accessor :before_start_callbacks, :on_finish_callbacks, :on_start_callback, :instance_reader => false
+      self.before_start_callbacks = []
+      self.on_finish_callbacks = []
+      self.on_start_callback = []
+    end
+
+    module ClassMethods
+      def before_start(*methods)
+        self.before_start_callbacks += methods
+      end
+
+      def on_finish(*methods)
+        self.on_finish_callbacks += methods
+      end
+
+      def on_start(*methods)
+        self.on_start_callback += methods
+      end
+    end
+
+    def before_start(n = 0)
+      if callback = self.class.before_start_callbacks[n]
+        EM.next_tick { send(callback) { before_start(n+1) } }
+      else
+        continue
+      end
+    end
+
+    def on_start
+      self.class.on_start_callback.each do |callback|
+        EM.next_tick { send(callback) }
+      end
+    end
+
+    def on_finish
+      self.class.on_finish_callbacks.each do |callback|
+        EM.next_tick { send(callback) }
+      end
+    end
+
+  end
+end

data/lib/cramp/keep_connection_alive.rb

@@ -0,0 +1,19 @@
+module Cramp
+  module KeepConnectionAlive
+
+    extend ActiveSupport::Concern
+    include PeriodicTimer
+
+    module ClassMethods
+      def keep_connection_alive(options = {})
+        options = { :every => 15 }.merge(options)
+        periodic_timer :keep_connection_alive, options
+      end
+    end
+
+    def keep_connection_alive
+      render " "
+    end
+
+  end
+end

data/lib/cramp/periodic_timer.rb

@@ -0,0 +1,49 @@
+module Cramp
+  module PeriodicTimer
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_inheritable_accessor :periodic_timers, :instance_reader => false
+      self.periodic_timers ||= []
+    end
+
+    module ClassMethods
+      def periodic_timer(method, options = {})
+        self.periodic_timers << [method, options]
+      end
+    end
+
+    def initialize(*)
+      super
+      @timers = []
+    end
+
+    def continue
+      super
+      EM.next_tick { start_periodic_timers }
+    end
+
+    def init_async_body
+      super
+
+      if self.class.periodic_timers.any?
+        @body.callback { stop_periodic_timers }
+        @body.errback { stop_periodic_timers }
+      end
+    end
+
+    private
+
+    def start_periodic_timers
+      self.class.periodic_timers.each do |method, options|
+        @timers << EventMachine::PeriodicTimer.new(options[:every] || 1) { send(method) }
+      end
+    end
+
+    def stop_periodic_timers
+      @timers.each {|t| t.cancel }
+    end
+
+  end
+end

data/lib/cramp/rendering.rb

@@ -0,0 +1,11 @@
+module Cramp
+  module Rendering
+
+    extend ActiveSupport::Concern
+
+    def render(body)
+      @body.call(body)
+    end
+
+  end
+end

data/lib/cramp/test_case.rb

@@ -0,0 +1,54 @@
+require 'active_support'
+require 'active_support/test_case'
+
+module Cramp
+  class TestCase < ::ActiveSupport::TestCase
+
+    setup :create_request
+
+    def create_request
+      @request = Rack::MockRequest.new(app)
+    end
+
+    def get(path, options = {}, headers = {}, &block)
+      callback = options.delete(:callback) || block
+      headers = headers.merge('async.callback' => callback)
+
+      EM.run { @request.get(path, headers) }
+    end
+
+    def get_body(path, options = {}, headers = {}, &block)
+      callback = options.delete(:callback) || block
+      response_callback = proc {|response| response[-1].each {|chunk| callback.call(chunk) } }
+      headers = headers.merge('async.callback' => response_callback)
+
+      EM.run { @request.get(path, headers) }
+    end
+
+    def get_body_chunks(path, options = {}, headers = {}, &block)
+      callback = options.delete(:callback) || block
+      count = options.delete(:count) || 1
+
+      stopping = false
+      chunks = []
+
+      get_body(path, options, headers) do |body_chunk|
+        chunks << body_chunk unless stopping
+
+        if chunks.count >= count
+          stopping = true
+          callback.call(chunks) if callback
+          EM.next_tick { EM.stop }
+        end
+      end
+    end
+
+    def app
+      raise "Please define a method called 'app' returning an async Rack Application"
+    end
+
+    def stop
+      EM.stop
+    end
+  end
+end

data/lib/cramp/websocket.rb

@@ -0,0 +1,84 @@
+module Cramp
+  module WebsocketExtension
+    WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
+
+    def websocket?
+      @env['HTTP_CONNECTION'] == 'Upgrade' && @env['HTTP_UPGRADE'] == 'WebSocket'
+    end
+
+    def websocket_upgrade_data
+      location  = "ws://#{@env['HTTP_HOST']}#{@env['REQUEST_PATH']}"
+      challenge = solve_challange(
+        @env['HTTP_SEC_WEBSOCKET_KEY1'],
+        @env['HTTP_SEC_WEBSOCKET_KEY2'],
+        @env['rack.input'].read
+      )
+
+      upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+      upgrade << "Upgrade: WebSocket\r\n"
+      upgrade << "Connection: Upgrade\r\n"
+      upgrade << "Sec-WebSocket-Origin: #{@env['HTTP_ORIGIN']}\r\n"
+      upgrade << "Sec-WebSocket-Location: #{location}\r\n\r\n"
+      upgrade << challenge
+
+      upgrade
+    end
+
+    def solve_challange(first, second, third)
+      # Refer to 5.2 4-9 of the draft 76
+      sum = 
+        [extract_nums(first) / count_spaces(first)].pack("N*") +
+        [extract_nums(second) / count_spaces(second)].pack("N*") +
+        third
+      Digest::MD5.digest(sum)
+    end
+
+    def extract_nums(string)
+      string.scan(/[0-9]/).join.to_i
+    end
+
+    def count_spaces(string)
+      string.scan(/ /).size 
+    end
+  end
+
+  class Websocket < Abstract
+    include PeriodicTimer
+
+    # TODO : Websockets shouldn't need this in an ideal world
+    include KeepConnectionAlive
+
+    class_inheritable_accessor :on_data_callbacks, :instance_reader => false
+    self.on_data_callbacks = []
+
+    class << self
+      def backend=(backend)
+        raise "Websocket backend #{backend} is unknown" unless [:thin, :rainbows].include?(backend.to_sym)
+        require "cramp/websocket/#{backend}_backend.rb"
+      end
+
+      def on_data(*methods)
+        self.on_data_callbacks += methods
+      end
+    end
+
+    def process
+      @env['websocket.receive_callback'] = method(:_on_data_receive)
+      super
+    end
+
+    def render(body)
+      @body.call("\x00#{body}\xff")
+    end
+
+    def _on_data_receive(data)
+      data = data.split(/\000([^\377]*)\377/).select{|d| !d.empty? }.collect{|d| d.gsub(/^\x00|\xff$/, '') }
+      self.class.on_data_callbacks.each do |callback|
+        data.each do |message|
+          EM.next_tick { send(callback, message) }
+        end
+      end
+    end
+    
+  end
+end

data/lib/cramp/{controller/websocket → websocket}/rainbows_backend.rb

@@ -1,7 +1,7 @@
 require 'rainbows'
 
 class Rainbows::EventMachine::Client
-  include Cramp::Controller::WebsocketExtension
+  include Cramp::WebsocketExtension
 
   def websocket_handshake!
     @state = :websocket

data/lib/cramp/{controller/websocket → websocket}/thin_backend.rb

@@ -30,7 +30,7 @@ class Thin::Connection
 end
 
 class Thin::Request
-  include Cramp::Controller::WebsocketExtension
+  include Cramp::WebsocketExtension
 end
 
 class Thin::Response