cramp 0.15.1 → 0.15.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTU3MzczMjYwZmVjOWNlODI4MDViMDkzODFkYmRlNTI2ZGFmY2E3Yw==
+  data.tar.gz: !binary |-
+    ZmExZWQwMTJiMGRkMTNjZWVlNmJlY2FhZmNmNjNjYTMzMWFhZWI0ZA==
+SHA512:
+  metadata.gz: !binary |-
+    YjM0NjdiMDZjOWI0ZWZiMjBkMzg5ZDgwYWRhZWRiMjBjYjlhNTQwNGM2ODk3
+    ZmI4NzNhM2IyNmZjODBhMDIwNmZkODFjMTdhZmI0YWJjNTBmMzMyNzAwNzc2
+    NzJmOTMyMWEzZmI4OGNhOTEzZmM0MWQxODYyZWNmMjM1NmE4MjU=
+  data.tar.gz: !binary |-
+    MjA5NjZmN2I5NDAyNTNkYWM1YWU1NDliZTkwYzJlY2NlZTI5MzBhYmMzYzgz
+    ZmE4MzRlYTk0N2U5MThhNmFkZmY4YTlkYzlhMmUwZmE4YjVlOWQ1YmIyZGY0
+    MDM1ZDFjZTIyOTRmZGU1MmE5NzcwNDQwODQyYmFhZjQ2YTE5NTk=

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2010 Pratik Naik
+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

data/lib/cramp.rb

@@ -3,7 +3,6 @@ EM.epoll
 
 require 'active_support'
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/class/inheritable_attributes'
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/attribute_accessors'
@@ -14,6 +13,7 @@ require 'active_support/core_ext/hash/except'
 require 'active_support/buffered_logger'
 
 require 'rack'
+require 'faye/websocket'
 
 begin
   require 'fiber'
@@ -21,24 +21,24 @@ begin
 rescue LoadError
   # No fibers available!
 end
-  
+
 module Cramp
-  VERSION = '0.15.1'
+  VERSION = '0.15.2'
 
   mattr_accessor :logger
 
-  autoload :Action, "cramp/action"
-  autoload :Websocket, "cramp/websocket"
-  autoload :WebsocketExtension, "cramp/websocket/extension"
-  autoload :Protocol10FrameParser, "cramp/websocket/protocol10_frame_parser"
-  autoload :SSE, "cramp/sse"
-  autoload :LongPolling, "cramp/long_polling"
-  autoload :Body, "cramp/body"
-  autoload :PeriodicTimer, "cramp/periodic_timer"
-  autoload :KeepConnectionAlive, "cramp/keep_connection_alive"
-  autoload :Abstract, "cramp/abstract"
-  autoload :Callbacks, "cramp/callbacks"
-  autoload :FiberPool, "cramp/fiber_pool"
-  autoload :ExceptionHandler, "cramp/exception_handler"
-  autoload :TestCase, "cramp/test_case"
+  autoload :Action, 'cramp/action'
+  autoload :Websocket, 'cramp/websocket'
+  autoload :WebsocketExtension, 'cramp/websocket/extension'
+  autoload :Protocol10FrameParser, 'cramp/websocket/protocol10_frame_parser'
+  autoload :SSE, 'cramp/sse'
+  autoload :LongPolling, 'cramp/long_polling'
+  autoload :Body, 'cramp/body'
+  autoload :PeriodicTimer, 'cramp/periodic_timer'
+  autoload :KeepConnectionAlive, 'cramp/keep_connection_alive'
+  autoload :Abstract, 'cramp/abstract'
+  autoload :Callbacks, 'cramp/callbacks'
+  autoload :FiberPool, 'cramp/fiber_pool'
+  autoload :ExceptionHandler, 'cramp/exception_handler'
+  autoload :TestCase, 'cramp/test_case'
 end

data/lib/cramp/abstract.rb

@@ -63,6 +63,7 @@ module Cramp
     end
 
     def finish
+      @_state = :finishing
       @body.succeed if is_finishable?
     ensure
       @_state = :finished

data/lib/cramp/action.rb

@@ -5,7 +5,23 @@ module Cramp
 
     def initialize(env)
       super
-      @env['websocket.receive_callback'] = method(:_on_data_receive)
+      
+      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
@@ -20,13 +36,20 @@ module Cramp
         # 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', 'Connection' => 'keep-alive'}
+    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'}
@@ -63,7 +86,9 @@ module Cramp
     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" }
@@ -73,13 +98,7 @@ module Cramp
     end
 
     def render_websocket(body, *)
-      if websockets_protocol_10?
-        data = encode(protocol10_parser.send_text_frame(body), 'BINARY')
-      else
-        data = ["\x00", body, "\xFF"].map(&method(:encode)) * ''
-      end
-
-      @body.call(data)
+      @web_socket.send(body)
     end
 
     CHUNKED_TERM = "\r\n"
@@ -111,13 +130,5 @@ module Cramp
       super
     end
 
-    def websockets_protocol_10?
-      [7, 8, 9, 10].include?(@env['HTTP_SEC_WEBSOCKET_VERSION'].to_i)
-    end
-
-    def protocol10_parser
-      @protocol10_parser ||= Protocol10FrameParser.new
-    end
-
   end
 end

data/lib/cramp/callbacks.rb

@@ -4,7 +4,7 @@ module Cramp
     extend ActiveSupport::Concern
 
     included do
-      class_inheritable_accessor :before_start_callbacks, :on_finish_callbacks, :on_start_callback, :on_data_callbacks, :instance_reader => false
+      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 = []
@@ -62,26 +62,8 @@ module Cramp
       end
     end
 
-    def _on_data_receive(data)
-      websockets_protocol_10? ? _receive_protocol10_data(data) : _receive_protocol76_data(data)
-    end
-
     protected
 
-    def _receive_protocol10_data(data)
-      protocol10_parser.data << data
-
-      messages = @protocol10_parser.process_data
-      messages.each do |type, content|
-        _invoke_data_callbacks(content) if type == :text
-      end
-    end
-
-    def _receive_protocol76_data(data)
-      data = data.split(/\000([^\377]*)\377/).select{|d| !d.empty? }.collect{|d| d.gsub(/^\x00|\xff$/, '') }
-      data.each {|message| _invoke_data_callbacks(message) }
-    end
-
     def _invoke_data_callbacks(message)
       self.class.on_data_callbacks.each do |callback|
         callback_wrapper { send(callback, message) }
@@ -106,4 +88,4 @@ module Cramp
     end
 
   end
-end
+end

data/lib/cramp/periodic_timer.rb

@@ -4,13 +4,13 @@ module Cramp
     extend ActiveSupport::Concern
 
     included do
-      class_inheritable_accessor :periodic_timers, :instance_reader => false
+      class_attribute :periodic_timers, :instance_reader => false
       self.periodic_timers ||= []
     end
 
     module ClassMethods
       def periodic_timer(method, options = {})
-        self.periodic_timers << [method, options]
+        self.periodic_timers += [ [method, options] ]
       end
     end
 

data/lib/cramp/websocket.rb

@@ -5,7 +5,7 @@ module Cramp
     class << self
       def backend=(backend)
         raise "Websocket backend #{backend} is unknown" unless [:thin, :rainbows].include?(backend.to_sym)
-        require "cramp/websocket/#{backend}_backend.rb"
+        Faye::WebSocket.load_adapter(backend.to_s)
       end
     end
 

metadata

@@ -1,62 +1,90 @@
 --- !ruby/object:Gem::Specification
 name: cramp
 version: !ruby/object:Gem::Version
-  version: 0.15.1
-  prerelease: 
+  version: 0.15.2
 platform: ruby
 authors:
 - Pratik Naik
+- Lucas Allan Amorim
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-30 00:00:00.000000000 Z
+date: 2013-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2155605620 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.9
+        version: 3.2.16
   type: :runtime
   prerelease: false
-  version_requirements: *2155605620
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.16
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &2155604860 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.3.2
+        version: 1.5.2
   type: :runtime
   prerelease: false
-  version_requirements: *2155604860
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2155604140 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.3
+        version: 1.0.3
   type: :runtime
   prerelease: false
-  version_requirements: *2155604140
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2155603680 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.14.6
+        version: 0.18.0
   type: :runtime
   prerelease: false
-  version_requirements: *2155603680
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.0
 description: Cramp is a framework for developing asynchronous web applications.
-email: pratiknaik@gmail.com
+email:
+- pratiknaik@gmail.com
+- lucas.allan@gmail.com
 executables:
 - cramp
 extensions: []
@@ -82,37 +110,31 @@ files:
 - lib/cramp/rendering.rb
 - lib/cramp/sse.rb
 - lib/cramp/test_case.rb
-- lib/cramp/websocket/extension.rb
-- lib/cramp/websocket/protocol10_frame_parser.rb
-- lib/cramp/websocket/rainbows.rb
-- lib/cramp/websocket/rainbows_backend.rb
-- lib/cramp/websocket/thin_backend.rb
 - lib/cramp/websocket.rb
 - lib/cramp.rb
 - lib/vendor/fiber_pool.rb
 - bin/cramp
 homepage: http://cramp.in
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 2.1.9
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Asynchronous web framework.
 test_files: []

data/lib/cramp/websocket/extension.rb

@@ -1,92 +0,0 @@
-require 'base64'
-require 'digest/sha1'
-
-module Cramp
-  module WebsocketExtension
-    WEBSOCKET_RECEIVE_CALLBACK = 'websocket.receive_callback'.freeze
-
-    def protocol_class
-      @env['HTTP_SEC_WEBSOCKET_VERSION'] ? Protocol10 : Protocol76
-    end
-
-    def websocket?
-      ['WebSocket', 'websocket'].include?(@env['HTTP_UPGRADE'])
-    end
-
-    def secure_websocket?
-      if @env.has_key?('HTTP_X_FORWARDED_PROTO')
-        @env['HTTP_X_FORWARDED_PROTO'] == 'https' 
-      else
-        @env['HTTP_ORIGIN'] =~ /^https:/i
-      end
-    end
-
-    def websocket_url
-      scheme = secure_websocket? ? 'wss:' : 'ws:'
-      @env['websocket.url'] = "#{ scheme }//#{ @env['HTTP_HOST'] }#{ @env['REQUEST_URI'] }"
-    end
-
-    class WebSocketHandler
-      def initialize(env, websocket_url, body = nil)
-        @env = env
-        @websocket_url = websocket_url
-        @body = body
-      end
-    end
-
-    class Protocol10 < WebSocketHandler
-      MAGIC_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11".freeze
-
-      def handshake
-        digest = Base64.encode64(Digest::SHA1.digest("#{@env['HTTP_SEC_WEBSOCKET_KEY']}#{MAGIC_GUID}")).chomp
-        
-        upgrade =  "HTTP/1.1 101 Switching Protocols\r\n"
-        upgrade << "Upgrade: websocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "Sec-WebSocket-Accept: #{digest}\r\n\r\n"
-        upgrade
-      end
-    end
-
-    class Protocol76 < WebSocketHandler
-      def handshake
-        key1   = @env['HTTP_SEC_WEBSOCKET_KEY1']
-        value1 = number_from_key(key1) / spaces_in_key(key1)
-
-        key2   = @env['HTTP_SEC_WEBSOCKET_KEY2']
-        value2 = number_from_key(key2) / spaces_in_key(key2)
-
-        hash = Digest::MD5.digest(big_endian(value1) +
-                                  big_endian(value2) +
-                                  @body)
-
-        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: #{@websocket_url}\r\n\r\n"
-        upgrade << hash
-        upgrade
-      end
-
-      private
-
-      def number_from_key(key)
-        key.scan(/[0-9]/).join('').to_i(10)
-      end
-
-      def spaces_in_key(key)
-        key.scan(/ /).size
-      end
-
-      def big_endian(number)
-        string = ''
-        [24,16,8,0].each do |offset|
-          string << (number >> offset & 0xFF).chr
-        end
-        string
-      end
-    end
-
-  end
-end

data/lib/cramp/websocket/protocol10_frame_parser.rb

@@ -1,241 +0,0 @@
-# encoding: BINARY
-
-# The MIT License - Copyright (c) 2009 Ilya Grigorik
-# Thank you https://github.com/igrigorik/em-websocket
-#
-# Copyright (c) 2009 Ilya Grigorik
-# 
-# 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.
-
-module Cramp
-  class Protocol10FrameParser
-    class WebSocketError < RuntimeError; end
-
-    class MaskedString < String
-      # Read a 4 bit XOR mask - further requested bytes will be unmasked
-      def read_mask
-        if respond_to?(:encoding) && encoding.name != "ASCII-8BIT"
-          raise "MaskedString only operates on BINARY strings"
-        end
-        raise "Too short" if bytesize < 4 # TODO - change
-        @masking_key = String.new(self[0..3])
-      end
-
-      # Removes the mask, behaves like a normal string again
-      def unset_mask
-        @masking_key = nil
-      end
-
-      def slice_mask
-        slice!(0, 4)
-      end
-
-      def getbyte(index)
-        if @masking_key
-          masked_char = super
-          masked_char ? masked_char ^ @masking_key.getbyte(index % 4) : nil
-        else
-          super
-        end
-      end
-
-      def getbytes(start_index, count)
-        data = ''
-        count.times do |i|
-          data << getbyte(start_index + i)
-        end
-        data
-      end
-    end
-
-    attr_accessor :data
-
-    def initialize
-      @data = MaskedString.new
-      @application_data_buffer = '' # Used for MORE frames
-    end
-    
-    def process_data
-      messages = []
-      error = false
-
-      while !error && @data.size >= 2
-        pointer = 0
-
-        fin = (@data.getbyte(pointer) & 0b10000000) == 0b10000000
-        # Ignoring rsv1-3 for now
-        opcode = @data.getbyte(pointer) & 0b00001111
-        pointer += 1
-
-        mask = (@data.getbyte(pointer) & 0b10000000) == 0b10000000
-        length = @data.getbyte(pointer) & 0b01111111
-        pointer += 1
-
-        raise WebSocketError, 'Data from client must be masked' unless mask
-
-        payload_length = case length
-        when 127 # Length defined by 8 bytes
-          # Check buffer size
-          if @data.getbyte(pointer+8-1) == nil
-            debug [:buffer_incomplete, @data]
-            error = true
-            next
-          end
-          
-          # Only using the last 4 bytes for now, till I work out how to
-          # unpack 8 bytes. I'm sure 4GB frames will do for now :)
-          l = @data.getbytes(pointer+4, 4).unpack('N').first
-          pointer += 8
-          l
-        when 126 # Length defined by 2 bytes
-          # Check buffer size
-          if @data.getbyte(pointer+2-1) == nil
-            debug [:buffer_incomplete, @data]
-            error = true
-            next
-          end
-          
-          l = @data.getbytes(pointer, 2).unpack('n').first
-          pointer += 2
-          l
-        else
-          length
-        end
-
-        # Compute the expected frame length
-        frame_length = pointer + payload_length
-        frame_length += 4 if mask
-
-        # Check buffer size
-        if @data.getbyte(frame_length - 1) == nil
-          debug [:buffer_incomplete, @data]
-          error = true
-          next
-        end
-
-        # Remove frame header
-        @data.slice!(0...pointer)
-        pointer = 0
-
-        # Read application data (unmasked if required)
-        @data.read_mask if mask
-        pointer += 4 if mask
-        application_data = @data.getbytes(pointer, payload_length)
-        pointer += payload_length
-        @data.unset_mask if mask
-        
-        # Throw away data up to pointer
-        @data.slice!(0...pointer)
-
-        frame_type = opcode_to_type(opcode)
-
-        if frame_type == :continuation && !@frame_type
-          raise WebSocketError, 'Continuation frame not expected'
-        end
-
-        if !fin
-          debug [:moreframe, frame_type, application_data]
-          @application_data_buffer << application_data
-          @frame_type = frame_type
-        else
-          # Message is complete
-          if frame_type == :continuation
-            @application_data_buffer << application_data
-            messages << [@frame_type, @application_data_buffer]
-            @application_data_buffer = ''
-            @frame_type = nil
-          else
-            messages << [frame_type, application_data]
-          end
-        end
-      end # end while
-
-      messages
-    end
-    
-    def send_frame(frame_type, application_data)
-      debug [:sending_frame, frame_type, application_data]
-
-      # Protocol10FrameParser doesn't have any knowledge of :closing in Cramp
-      # if @state == :closing && data_frame?(frame_type)
-      #   raise WebSocketError, "Cannot send data frame since connection is closing"
-      # end
-
-      frame = ''
-
-      opcode = type_to_opcode(frame_type)
-      byte1 = opcode | 0b10000000 # fin bit set, rsv1-3 are 0
-      frame << byte1
-
-      length = application_data.size
-      if length <= 125
-        byte2 = length # since rsv4 is 0
-        frame << byte2
-      elsif length < 65536 # write 2 byte length
-        frame << 126
-        frame << [length].pack('n')
-      else # write 8 byte length
-        frame << 127
-        frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
-      end
-
-      frame << application_data
-    end
-
-    def send_text_frame(data)
-      send_frame(:text, data)
-    end
-
-    private
-
-    FRAME_TYPES = {
-      :continuation => 0,
-      :text => 1,
-      :binary => 2,
-      :close => 8,
-      :ping => 9,
-      :pong => 10,
-    }
-    FRAME_TYPES_INVERSE = FRAME_TYPES.invert
-    # Frames are either data frames or control frames
-    DATA_FRAMES = [:text, :binary, :continuation]
-
-    def type_to_opcode(frame_type)
-      FRAME_TYPES[frame_type] || raise("Unknown frame type")
-    end
-
-    def opcode_to_type(opcode)
-      FRAME_TYPES_INVERSE[opcode] || raise(DataError, "Unknown opcode")
-    end
-
-    def data_frame?(type)
-      DATA_FRAMES.include?(type)
-    end
-
-    def debug(*data)
-      if @debug
-        require 'pp'
-        pp data
-        puts
-      end
-    end
-
-  end
-end

data/lib/cramp/websocket/rainbows.rb

@@ -1,42 +0,0 @@
-class Cramp::Websocket::Rainbows < Rainbows::EventMachine::Client
-  include Cramp::WebsocketExtension
-
-  def receive_data(data)
-    case @state
-    when :websocket
-      callback = @env[WEBSOCKET_RECEIVE_CALLBACK]
-      callback.call(data) if callback
-    else
-      super
-    end
-  end
-
-  def on_read(data)
-    if @state == :headers
-      @hp.add_parse(data) or return want_more
-      @state = :body
-      if 0 == @hp.content_length && !websocket?
-        app_call NULL_IO # common case
-      else # nil or len > 0
-        prepare_request_body
-      end
-    elsif @state == :body && websocket? && @hp.body_eof?
-      @state = :websocket
-      @input.rewind
-
-      write(protocol_class.new(@env, websocket_url, @buf).handshake)
-      app_call NULL_IO
-    else
-      super
-    end
-  rescue => e
-    handle_error(e)
-  end
-
-  def write_response(status, headers, body, alive)
-    write_headers(status, headers, alive) unless websocket?
-    write_body_each(body)
-  ensure
-    body.close if body.respond_to?(:close)
-  end
-end

data/lib/cramp/websocket/rainbows_backend.rb

@@ -1,8 +0,0 @@
-# :enddoc:
-require "rainbows"
-class Cramp::Websocket
-  # we use autoload since Rainbows::EventMachine::Client should only be
-  # loaded in the worker proceses and we want to be preload_app-friendly
-  autoload :Rainbows, "cramp/websocket/rainbows"
-end
-Rainbows::O[:em_client_class] = "Cramp::Websocket::Rainbows"

data/lib/cramp/websocket/thin_backend.rb

@@ -1,53 +0,0 @@
-require 'thin'
-
-silence_warnings { Thin::Server::DEFAULT_TIMEOUT = 0 }
-
-class Thin::Connection
-  # Called when data is received from the client.
-  def receive_data(data)
-    trace { data }
-
-    case @serving
-    when :websocket
-      callback = @request.env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK]
-      callback.call(data) if callback
-    else
-      if @request.parse(data)
-        if @request.websocket?
-          @response.persistent!
-          @response.websocket_upgrade_data = @request.websocket_upgrade_data
-          @serving = :websocket
-        end
-
-        process
-      end
-    end
-  rescue Thin::InvalidRequest => e
-    log "!! Invalid request"
-    log_error e
-    close_connection
-  end
-end
-
-class Thin::Request
-  include Cramp::WebsocketExtension
-
-  def websocket_upgrade_data
-    protocol_class.new(@env, websocket_url, body.read).handshake
-  end
-
-end
-
-class Thin::Response
-  # Headers for sending Websocket upgrade
-  attr_accessor :websocket_upgrade_data
-
-  def each
-    websocket_upgrade_data ? yield(websocket_upgrade_data) : yield(head)
-    if @body.is_a?(String)
-      yield @body
-    else
-      @body.each { |chunk| yield chunk }
-    end
-  end
-end