crampy 0.15.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2011 Pratik Naik
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/cramp

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'cramp'
+require 'cramp/generators/application'
+
+if ['--version', '-v'].include?(ARGV.first)
+  puts "Cramp #{Cramp::VERSION}"
+  exit(0)
+end
+
+if ARGV.first != "new"
+  ARGV[0] = "--help"
+else
+  ARGV.shift
+end
+
+Cramp::Generators::Application.start

data/lib/cramp/abstract.rb

@@ -0,0 +1,104 @@
+require 'active_support/core_ext/hash/keys'
+
+module Cramp
+  class Abstract
+    include Callbacks
+    include FiberPool
+
+    class_attribute :transport
+    self.transport = :regular
+
+    class << self
+      def call(env)
+        new(env).process
+      end
+    end
+
+    def initialize(env)
+      @env = env
+      @finished = false
+
+      @_state = :init
+    end
+
+    def process
+      EM.next_tick { before_start }
+      throw :async
+    end
+
+    protected
+
+    def continue
+      init_async_body
+      send_headers
+
+      @_state = :started
+      EM.next_tick { on_start }
+    end
+
+    def send_headers
+      status, headers = build_headers
+      send_initial_response(status, headers, @body)
+    rescue StandardError, LoadError, SyntaxError => exception
+      handle_exception(exception)
+    end
+
+    def build_headers
+      status, headers = respond_to?(:respond_with, true) ? respond_with.dup : [200, {'Content-Type' => 'text/html'}]
+      headers['Connection'] ||= 'keep-alive'
+      [status, headers]
+    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 finished?
+      !!@finished
+    end
+
+    def finish
+      @_state = :finishing
+      @body.succeed if is_finishable?
+    ensure
+      @_state = :finished
+      @finished = true
+    end
+
+    def send_initial_response(response_status, response_headers, response_body)
+      send_response(response_status, response_headers, response_body)
+    end
+
+    def halt(status, headers = {}, halt_body = '')
+      send_response(status, headers, halt_body)
+    end
+
+    def send_response(response_status, response_headers, response_body)
+      @env['async.callback'].call [response_status, response_headers, response_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'] || {}
+    end
+
+    private
+
+    def is_finishable?
+      !finished? && @body && !@body.closed?
+    end
+
+  end
+end

data/lib/cramp/action.rb

@@ -0,0 +1,134 @@
+module Cramp
+  class Action < Abstract
+    include PeriodicTimer
+    include KeepConnectionAlive
+
+    def initialize(env)
+      super
+      
+      case
+      when Faye::EventSource.eventsource?(env)
+        # request has Accept: text/event-stream
+        # faye server adapter intercepts headers - need to send them in send_initial_response or use faye's implementation
+        @eventsource_detected = true
+        unless transport == :sse
+          err = "WARNING: Cramp got request with EventSource header on action with transport #{transport} (not sse)! Response may not contain valid http headers!"
+          Cramp.logger ? Cramp.logger.error(err) : $stderr.puts(err)
+        end
+      when Faye::WebSocket.websocket?(env)
+        @web_socket = Faye::WebSocket.new(env)
+        @web_socket.onmessage = lambda do |event|
+          message = event.data
+          _invoke_data_callbacks(message) if message.is_a?(String)
+        end
+      end
+    end
+
+    protected
+
+    def render(body, *args)
+      send(:"render_#{transport}", body, *args)
+    end
+
+    def send_initial_response(status, headers, body)
+      case transport
+      when :long_polling
+        # Dont send no initial response. Just cache it for later.
+        @_lp_status = status
+        @_lp_headers = headers
+      when :sse
+        super
+        if @eventsource_detected
+          # Reconstruct headers that were killed by faye server adapter:
+          @body.call("HTTP/1.1 200 OK\r\n#{headers.map{|(k,v)| "#{k}: #{v.is_a?(Time) ? v.httpdate : v.to_s}"}.join("\r\n")}\r\n\r\n")
+        end
+        # send retry? @body.call("retry: #{ (@retry * 1000).floor }\r\n\r\n")
+      else
+        super
+      end
+    end
+
+    class_attribute :default_sse_headers
+    self.default_sse_headers = {'Content-Type' => 'text/event-stream', 'Cache-Control' => 'no-cache, no-store', 'Connection' => 'keep-alive'}
+
+    class_attribute :default_chunked_headers
+    self.default_chunked_headers = {'Transfer-Encoding' => 'chunked', 'Connection' => 'keep-alive'}
+
+    def build_headers
+      case transport
+      when :sse
+        status, headers = respond_to?(:respond_with, true) ? respond_with : [200, {'Content-Type' => 'text/html'}]
+        [status, headers.merge(self.default_sse_headers)]
+      when :chunked
+        status, headers = respond_to?(:respond_with, true) ? respond_with : [200, {}]
+
+        headers = headers.merge(self.default_chunked_headers)
+        headers['Content-Type'] ||= 'text/html'
+        headers['Cache-Control'] ||= 'no-cache'
+
+        [status, headers]
+      else
+        super
+      end
+    end
+
+    def render_regular(body, *)
+      @body.call(body)
+    end
+
+    def render_long_polling(data, *)
+      @_lp_headers['Content-Length'] = data.size.to_s
+
+      send_response(@_lp_status, @_lp_headers, @body)
+      @body.call(data)
+
+      finish
+    end
+
+    def render_sse(data, options = {})
+      #TODO: Faye uses \r\n for newlines, some compatibility?
+      result = "id: #{sse_event_id}\n"
+      result << "event: #{options[:event]}\n" if options[:event]
+      result << "retry: #{options[:retry]}\n" if options[:retry]
+
+      data.split(/\n/).each {|d| result << "data: #{d}\n" }
+      result << "\n"
+
+      @body.call(result)
+    end
+
+    def render_websocket(body, *)
+      @web_socket.send(body)
+    end
+
+    CHUNKED_TERM = "\r\n"
+    CHUNKED_TAIL = "0#{CHUNKED_TERM}#{CHUNKED_TERM}"
+
+    def render_chunked(body, *)
+      data = [Rack::Utils.bytesize(body).to_s(16), CHUNKED_TERM, body, CHUNKED_TERM].join
+
+      @body.call(data)
+    end
+
+    # Used by SSE
+    def sse_event_id
+      @sse_event_id ||= Time.now.to_i
+    end
+
+    def encode(string, encoding = 'UTF-8')
+      string.respond_to?(:force_encoding) ? string.force_encoding(encoding) : string
+    end
+
+    protected
+
+    def finish
+      case transport
+      when :chunked
+        @body.call(CHUNKED_TAIL) if is_finishable?
+      end
+
+      super
+    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,92 @@
+module Cramp
+  module Callbacks
+
+    extend ActiveSupport::Concern
+
+    included do
+      #was class_inheritable_accessor
+      class_attribute :before_start_callbacks, :on_finish_callbacks, :on_start_callback, :on_data_callbacks, :instance_reader => false
+
+      self.before_start_callbacks = []
+      self.on_finish_callbacks = []
+      self.on_start_callback = []
+      self.on_data_callbacks = []
+    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
+
+      def on_data(*methods)
+        self.on_data_callbacks += methods
+      end
+    end
+
+    def before_start(n = 0)
+      if callback = self.class.before_start_callbacks[n]
+        callback_wrapper { send(callback) { before_start(n+1) } }
+      else
+        continue
+      end
+    end
+
+    def on_start
+      callback_wrapper { start } if respond_to?(:start)
+
+      self.class.on_start_callback.each do |callback|
+        callback_wrapper { send(callback) unless @finished }
+      end
+    end
+
+    def on_finish
+      self.class.on_finish_callbacks.each do |callback|
+        callback_wrapper { send(callback) }
+      end
+    end
+
+    def callback_wrapper
+      EM.next_tick do
+        begin
+          yield
+        rescue StandardError, LoadError, SyntaxError => exception
+          handle_exception(exception)
+        end
+      end
+    end
+
+    protected
+
+    def _invoke_data_callbacks(message)
+      self.class.on_data_callbacks.each do |callback|
+        callback_wrapper { send(callback, message) }
+      end
+    end
+
+    def handle_exception(exception)
+      handler = ExceptionHandler.new(@env, exception)
+
+      # Log the exception
+      unless ENV['RACK_ENV'] == 'test'
+        exception_body = handler.dump_exception
+        Cramp.logger ? Cramp.logger.error(exception_body) : $stderr.puts(exception_body)
+      end
+
+      case @_state
+      when :init
+        halt 500, {"Content-Type" => 'text/html'}, ENV['RACK_ENV'] == 'development' ? handler.pretty : 'Something went wrong'
+      else
+        finish
+      end
+    end
+
+  end
+end