rails_live_reload 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 453d155a64c2869fea44301e05aa33cf32274ff501cfdb6a7eb1c061bb5cffa1
-  data.tar.gz: b7e734f2649d12365e8e346e2656fd386aea36187d6a295f19f8643460138d6d
+  metadata.gz: 999e453ba10fc303a5f317609ad52abbb318972712802ea87606f17c89c2054a
+  data.tar.gz: 456e9df00f34d48e75a8cdbee655e035e68a0c98c468020946dc3ec6903848bb
 SHA512:
-  metadata.gz: 7519b3b746a4c58eb412e97743a24db2b39ae7e99351bff81edcfe69df682478e0c250f5b9f5a08022fd1c086f571df0bc52cfaa530bf0c1996c1d1240456ea7
-  data.tar.gz: 347cae5497f229eb42a38cd9e62f3fc8c33b1c2f03542af5546a156a54f80fff7e5fa4a16e3253e69a44b6e5df9ebe25e5930fd03e19a9d941d2be7a43fb431b
+  metadata.gz: 9d3e4ddad3250f1cb40b06d0f17c69b537d25c26ebe90b3844f942540af27286c9d2f66d4a29562d2ffd9c725d0286b028da8a645ad43126ac57099a13b567bd
+  data.tar.gz: a7ac90c951252374f0d6cd357d822c33d8c2a330f2b2b487f3e048551b439168474a4da4dd822228644ea7d1cfdbfdc04e5064efab9957c6a55c8a455b1f1d1f

data/README.md

@@ -6,7 +6,7 @@
 
 This is the simplest and probably the most robust way to add live reloading to your Rails app.
 
-Just add the gem and thats it, now you have a live reloading. No 3rd party dependencies.
+Just add the gem and thats it, now you have a live reloading. **You don't need anything other than this gem for live reloading to work**.
 
 Works with:
 
@@ -40,9 +40,12 @@ $ bundle
 
 ## Configuration
 
-### There are two modes:
-1. `:long_polling` - This is a default mode, it uses [long polling](https://javascript.info/long-polling) techunique, client opens a connection that will hang until either change is detected, or timeout happens, if later, a new connection is oppened
-2. `:polling` - This mode will use regular polling to detect changes, you can configure custom `polling_interval` (default is 100ms). We recommend using `:long_polling` as it makes much less requests to the server.
+### There are three modes:
+1. `:websocket` - This is a default mode which uses websockets to trigger page reloading.
+2. `:long_polling` - **[Deprecated]** This mode uses [long polling](https://javascript.info/long-polling) techunique, client opens a connection that will hang until either change is detected, or timeout happens, if later, a new connection is oppened.
+3. `:polling` - **[Deprecated]** This mode will use regular polling to detect changes, you can configure custom `polling_interval` (default is 100ms). We recommend using `:long_polling` as it makes much less requests to the server.
+
+Keep in mind that `mode` configuration is **deprecated** and will be removed in the future, with `:websocket` be the only one available, in case you think that modes like `:long_polling` or `:polling` should be preserved feel free to open an issue.
 
 ### Create initializer `config/initializers/rails_live_reload.rb`:
 
@@ -50,8 +53,12 @@ $ bundle
 ```ruby
 RailsLiveReload.configure do |config|
   # config.url     = "/rails/live/reload"
-  # Available modes are: :long_polling (default) and :polling
-  # config.mode = :long_polling
+  # Available modes are: :websocket (default), :long_polling and :polling
+  # config.mode = :websocket
+
+  # This is used with :long_polling mode
+  # config.timeout = 30
+  # config.long_polling_sleep_duration = 0.1
 
   # This is used with :polling mode
   # config.polling_interval = 100
@@ -63,6 +70,8 @@ RailsLiveReload.configure do |config|
   # More examples:
   # config.watch %r{app/helpers/.+\.rb}, reload: :always
   # config.watch %r{config/locales/.+\.yml}, reload: :always
+
+  # config.enabled = Rails.env.development?
 end if defined?(RailsLiveReload)
 ```
 
@@ -72,7 +81,7 @@ There are 3 main parts:
 
 1) listener of file changes (using `listen` gem)
 2) collector of rendered views (see rails instrumentation)
-3) middleware which is responding to polling JS calls
+3) JavaScript client that communicates with server and triggers reloading when needed
 
 ## Notes
 
@@ -85,15 +94,12 @@ You are welcome to contribute. See list of `TODO's` below.
 ## TODO
 
 - reload CSS without reloading the whole page?
-- add `:websocket` mode?
 - smarter reload if there is a change in helper (check methods from rendered views?)
 - generator for initializer
 - more complex rules? e.g. if "user.rb" file is changed - reload all pages with rendered "users" views
 - check with older Rails versions
 - tests or specs
 - CI (github actions)
-- improve how JS code is injected into HTML
-- improve work with turbo, turbolinks
 
 ## License
 

data/lib/rails_live_reload/config.rb

@@ -18,22 +18,54 @@ module RailsLiveReload
   end
 
   class Config
-    attr_reader :patterns
-    attr_accessor :mode, :polling_interval, :timeout, :url, :watcher, :files, :enabled
+    attr_reader :patterns, :polling_interval, :timeout, :mode, :long_polling_sleep_duration
+    attr_accessor :url, :watcher, :files, :enabled
 
     def initialize
-      @mode = :long_polling
+      @mode = :websocket
       @timeout = 30
-      @patterns = {}
+      @long_polling_sleep_duration = 0.1
       @polling_interval = 100
       @url = "/rails/live/reload"
       @watcher = nil
       @files = {}
-      @enabled = ::Rails.env.development? && !defined?(Rails::Console)
+      @enabled = ::Rails.env.development?
+
+      # These configs work for 95% apps, see README for more info
+      @patterns = {
+        %r{app/views/.+\.(erb|haml|slim)$} => :on_change,
+        %r{(app|vendor)/(assets|javascript)/\w+/(.+\.(css|js|html|png|jpg|ts|jsx)).*} => :always
+      }
+      @default_patterns_changed = false
     end
 
     def watch(pattern, reload: :on_change)
+      unless @default_patterns_changed
+        @default_patterns_changed = true
+        @patterns = {}
+      end
+
       patterns[pattern] = reload
     end
+
+    def mode=(mode)
+      warn "[DEPRECATION] RailsLiveReload 'mode' configuration is deprecated and will be removed in future versions #{caller.first}"
+      @mode = mode
+    end
+
+    def polling_interval=(polling_interval)
+      warn "[DEPRECATION] RailsLiveReload 'polling_interval' configuration is deprecated and will be removed in future versions #{caller.first}"
+      @polling_interval = polling_interval
+    end
+
+    def timeout=(timeout)
+      warn "[DEPRECATION] RailsLiveReload 'timeout' configuration is deprecated and will be removed in future versions #{caller.first}"
+      @timeout = timeout
+    end
+
+    def long_polling_sleep_duration=(long_polling_sleep_duration)
+      warn "[DEPRECATION] RailsLiveReload 'long_polling_sleep_duration' configuration is deprecated and will be removed in future versions #{caller.first}"
+      @long_polling_sleep_duration = long_polling_sleep_duration
+    end
   end
 end

data/lib/rails_live_reload/engine.rb

@@ -1,7 +1,7 @@
 module RailsLiveReload
   class Railtie < ::Rails::Engine
 
-    if RailsLiveReload.enabled?
+    if RailsLiveReload.enabled? && defined?(::Rails::Server)
       initializer "rails_live_reload.middleware" do |app|
         if ::Rails::VERSION::MAJOR.to_i >= 5
           app.middleware.insert_after ActionDispatch::Executor, RailsLiveReload.middleware

data/lib/rails_live_reload/javascript/long_polling.js

@@ -0,0 +1,6 @@
+/*!
+  Rails Live Reload 0.2.0
+  Copyright © 2022 RailsJazz
+  https://railsjazz.com
+ */
+var RailsLiveReload=function(){"use strict";const t="RELOAD";class e{static _instance;static get instance(){return e._instance||(e._instance=new this),e._instance}static start(){this.instance.start()}constructor(){this.initialize(),document.addEventListener("turbo:render",(()=>{document.documentElement.hasAttribute("data-turbo-preview")||this.restart()})),document.addEventListener("turbolinks:render",(()=>{document.documentElement.hasAttribute("data-turbolinks-preview")||this.restart()}))}initialize(){const{files:t,time:e,url:s,options:i}=JSON.parse(this.optionsNode.textContent);this.files=t,this.time=e,this.url=s,this.options=i}start(){throw"This should be implemented in subclass"}stop(){throw"This should be implemented in subclass"}restart(){this.stop(),this.initialize(),this.start()}fullReload(){window.location.reload()}get optionsNode(){const t=document.getElementById("rails-live-reload-options");if(!t)throw"Unable to find RailsLiveReload options";return t}}class s extends e{start(){this.retriesCount=0,this.timestamp=new Date,this.poll(this.timestamp)}stop(){this.timestamp=void 0}async poll(e){if(this.timestamp===e)try{const s=new FormData;s.append("dt",this.time),s.append("files",JSON.stringify(this.files));const i=await fetch(this.url,{method:"post",headers:{Accept:"application/json"},body:s}),n=await i.json();if(this.timestamp!==e)return;this.retriesCount=0,n.command===t?this.fullReload():this.poll(e)}catch(t){if(this.timestamp!==e)return;this.retriesCount++,this.retriesCount<10?setTimeout((()=>this.poll(e)),5e3):this.stop()}}}return document.addEventListener("DOMContentLoaded",(()=>{s.start()})),s}();

data/lib/rails_live_reload/javascript/polling.js

@@ -0,0 +1,6 @@
+/*!
+  Rails Live Reload 0.2.0
+  Copyright © 2022 RailsJazz
+  https://railsjazz.com
+ */
+var RailsLiveReload=function(){"use strict";const t="RELOAD";class e{static _instance;static get instance(){return e._instance||(e._instance=new this),e._instance}static start(){this.instance.start()}constructor(){this.initialize(),document.addEventListener("turbo:render",(()=>{document.documentElement.hasAttribute("data-turbo-preview")||this.restart()})),document.addEventListener("turbolinks:render",(()=>{document.documentElement.hasAttribute("data-turbolinks-preview")||this.restart()}))}initialize(){const{files:t,time:e,url:i,options:s}=JSON.parse(this.optionsNode.textContent);this.files=t,this.time=e,this.url=i,this.options=s}start(){throw"This should be implemented in subclass"}stop(){throw"This should be implemented in subclass"}restart(){this.stop(),this.initialize(),this.start()}fullReload(){window.location.reload()}get optionsNode(){const t=document.getElementById("rails-live-reload-options");if(!t)throw"Unable to find RailsLiveReload options";return t}}class i extends e{start(){this.interval||(this.interval=setInterval((async()=>{const e=new FormData;e.append("dt",this.time),e.append("files",JSON.stringify(this.files));const i=await fetch(this.url,{method:"post",headers:{Accept:"application/json"},body:e});(await i.json()).command===t&&(this.stop(),this.fullReload())}),this.options.polling_interval))}restart(){this.initialize()}stop(){clearInterval(this.interval),this.interval=void 0}}return document.addEventListener("DOMContentLoaded",(()=>{i.start()})),i}();

data/lib/rails_live_reload/javascript/websocket.js

@@ -0,0 +1,6 @@
+/*!
+  Rails Live Reload 0.2.0
+  Copyright © 2022 RailsJazz
+  https://railsjazz.com
+ */
+var RailsLiveReload=function(){"use strict";const t="RELOAD";class e{static _instance;static get instance(){return e._instance||(e._instance=new this),e._instance}static start(){this.instance.start()}constructor(){this.initialize(),document.addEventListener("turbo:render",(()=>{document.documentElement.hasAttribute("data-turbo-preview")||this.restart()})),document.addEventListener("turbolinks:render",(()=>{document.documentElement.hasAttribute("data-turbolinks-preview")||this.restart()}))}initialize(){const{files:t,time:e,url:n,options:i}=JSON.parse(this.optionsNode.textContent);this.files=t,this.time=e,this.url=n,this.options=i}start(){throw"This should be implemented in subclass"}stop(){throw"This should be implemented in subclass"}restart(){this.stop(),this.initialize(),this.start()}fullReload(){window.location.reload()}get optionsNode(){const t=document.getElementById("rails-live-reload-options");if(!t)throw"Unable to find RailsLiveReload options";return t}}const n=["rails-live-reload-v1-json"];class i extends e{start(){this.connection||(this.connection=new WebSocket(function(t){if("function"==typeof t&&(t=t()),t&&!/^wss?:/i.test(t)){const e=document.createElement("a");return e.href=t,e.href=e.href,e.protocol=e.protocol.replace("http","ws"),e.href}return t}(this.url),n),this.connection.onmessage=this.handleMessage.bind(this),this.connection.onopen=this.handleConnectionOpen.bind(this),this.connection.onclose=this.handleConnectionClosed.bind(this))}stop(){this.connection.close()}restart(){this.initialize(),this.setupConnection()}setupConnection(){this.connection.send(JSON.stringify({event:"setup",options:{files:this.files,dt:this.time}}))}handleConnectionOpen(t){this.retriesCount=0,this.setupConnection()}handleMessage(e){JSON.parse(e.data).command===t&&this.fullReload()}handleConnectionClosed(t){this.connection=void 0,!t.wasClean&&this.retriesCount<=10&&(this.retriesCount++,setTimeout((()=>{this.start()}),1e3*this.retriesCount))}}return document.addEventListener("DOMContentLoaded",(()=>{i.start()})),i}();

data/lib/rails_live_reload/middleware/base.rb

@@ -0,0 +1,75 @@
+module RailsLiveReload
+  module Middleware
+    class Base
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
+        request = Rack::Request.new(env)
+
+        case env["REQUEST_PATH"]
+        when RailsLiveReload.config.url
+          main_rails_live_response(request)
+        when "#{RailsLiveReload.config.url}/script"
+          content = client_javascript
+          [200, {'Content-Type' => 'application/javascript', 'Content-Length' => content.size.to_s, 'Cache-Control' => 'no-store'}, [content]]
+        else
+          status, headers, response = @app.call(env)
+
+          if html?(headers) && response.respond_to?(:[]) && (status == 500 || (status.to_s =~ /20./ && request.get?))
+            new_response = make_new_response(response[0])
+            headers['Content-Length'] = new_response.bytesize.to_s
+            response = [new_response]
+          end
+
+          [status, headers, response]
+        end
+      rescue Exception => ex
+        puts ex.message
+        puts ex.backtrace.take(10)
+        raise ex
+      end
+
+      private
+
+      def main_rails_live_response(request)
+        raise NotImplementedError
+      end
+
+      def client_javascript
+        @client_javascript ||= File.open(File.join(File.dirname(__FILE__), "../javascript/#{RailsLiveReload.config.mode}.js")).read
+      end
+
+      def make_new_response(body)
+        body = body.sub("</head>", <<~HTML.html_safe)
+          <script defer type="text/javascript" src="#{RailsLiveReload.config.url}/script"></script>
+          </head>
+        HTML
+        body.sub("</body>", <<~HTML.html_safe)
+          <script id="rails-live-reload-options" type="application/json">
+            #{{
+              files: CurrentRequest.current.data.to_a,
+              time: Time.now.to_i,
+              url: RailsLiveReload.config.url,
+              options: javascript_options
+            }.to_json}
+          </script>
+          </body>
+        HTML
+      end
+
+      def javascript_options
+        {}
+      end
+
+      def html?(headers)
+        headers["Content-Type"].to_s.include?("text/html")
+      end
+    end
+  end
+end

data/lib/rails_live_reload/middleware/long_polling.rb

@@ -0,0 +1,45 @@
+module RailsLiveReload
+  module Middleware
+    class LongPolling < Base
+      private
+
+      def main_rails_live_response(request)
+        params = request.params
+        body = lambda do |stream|
+          new_thread do
+            counter = 0
+
+            loop do
+              command = RailsLiveReload::Command.new(params)
+
+              if command.reload?
+                stream.write(command.payload.to_json) and break
+              end
+
+              sleep(RailsLiveReload.config.long_polling_sleep_duration)
+              counter += 1
+
+              stream.write(command.payload.to_json) and break if counter >= max_sleeps_count
+            end
+          ensure
+            stream.close
+          end
+        end
+
+        [ 200, { 'Content-Type' => 'application/json', 'rack.hijack' => body }, nil ]
+      end
+
+      def max_sleeps_count
+        RailsLiveReload.config.timeout * (1 / RailsLiveReload.config.long_polling_sleep_duration)
+      end
+
+      def new_thread
+        Thread.new {
+          t2 = Thread.current
+          t2.abort_on_exception = true
+          yield
+        }
+      end
+    end
+  end
+end

data/lib/rails_live_reload/middleware/polling.rb

@@ -0,0 +1,19 @@
+module RailsLiveReload
+  module Middleware
+    class Polling < Base
+      private
+
+      def main_rails_live_response(request)
+        [
+          200,
+          { 'Content-Type' => 'application/json' },
+          [ RailsLiveReload::Command.new(request.params).payload.to_json ]
+        ]
+      end
+
+      def javascript_options
+        { polling_interval: RailsLiveReload.config.polling_interval }
+      end
+    end
+  end
+end

data/lib/rails_live_reload/middleware/web_socket.rb

@@ -0,0 +1,51 @@
+require 'rails_live_reload/web_socket/event_loop'
+require 'rails_live_reload/web_socket/message_buffer'
+require 'rails_live_reload/web_socket/wrapper'
+require 'rails_live_reload/web_socket/client_socket'
+require 'rails_live_reload/web_socket/stream'
+require 'rails_live_reload/web_socket/base'
+
+module RailsLiveReload
+  module Middleware
+    class WebSocket < Base
+      attr_reader :mutex, :event_loop
+
+      delegate :connections, :add_connection, :remove_connection, to: :class
+
+      class << self
+        def connections
+          @connections ||= []
+        end
+
+        def add_connection(connection)
+          connections << connection
+        end
+  
+        def remove_connection(connection)
+          connections.delete connection
+        end  
+      end
+
+      def initialize(env)
+        @mutex = Monitor.new
+        @event_loop = nil
+        super
+      end
+
+      def main_rails_live_response(request)
+        setup_heartbeat_timer
+        RailsLiveReload::WebSocket::Base.new(self, request).process
+      end
+
+      def setup_heartbeat_timer
+        @heartbeat_timer ||= event_loop.timer(3) do
+          event_loop.post { connections.each(&:beat) }
+        end
+      end
+
+      def event_loop
+        @event_loop || @mutex.synchronize { @event_loop ||= RailsLiveReload::WebSocket::EventLoop.new }
+      end
+    end
+  end
+end

data/lib/rails_live_reload/version.rb

@@ -1,3 +1,3 @@
 module RailsLiveReload
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/rails_live_reload/watcher.rb

@@ -27,6 +27,7 @@ module RailsLiveReload
           all.each do |file|
             files[file] = File.mtime(file).to_i rescue nil
           end
+          RailsLiveReload::Middleware::WebSocket.connections.each(&:reload)
         end
         listener.start
       end

data/lib/rails_live_reload/web_socket/base.rb

@@ -0,0 +1,116 @@
+module RailsLiveReload
+  module WebSocket
+    # This class is strongly based on ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/connection/base.rb
+    class Base
+      attr_reader :server, :env, :protocol, :request
+      attr_reader :dt, :files
+
+      delegate :event_loop, to: :server
+
+      def initialize(server, request)
+        @server, @request = server, request
+        @env = request.env
+        @websocket = RailsLiveReload::WebSocket::Wrapper.new(env, self, event_loop)
+        @message_buffer = RailsLiveReload::WebSocket::MessageBuffer.new(self)
+      end
+
+      def process
+        if websocket.possible?
+          respond_to_successful_request
+        else
+          respond_to_invalid_request
+        end
+      end
+
+      def receive(websocket_message)
+        if websocket.alive?
+          handle_channel_command decode(websocket_message)
+        end
+      end
+
+      def handle_channel_command(payload)
+        case payload['event']
+        when 'setup'
+          setup payload['options']
+        else
+          raise NotImplementedError          
+        end
+      end
+
+      def reload
+        return if dt.nil? || files.nil? || RailsLiveReload::Checker.scan(dt, files).size.zero?
+  
+        transmit({command: "RELOAD"})
+      end  
+
+      def transmit(cable_message)
+        websocket.transmit encode(cable_message)
+      end
+
+      def close(reason: nil)
+        transmit({
+          type: RailsLiveReload::INTERNAL[:message_types][:disconnect],
+          reason: reason
+        })
+        websocket.close
+      end
+
+      def beat
+        transmit type: RailsLiveReload::INTERNAL[:message_types][:ping], message: Time.now.to_i
+      end
+
+      def on_open
+        @protocol = websocket.protocol
+        send_welcome_message
+
+        message_buffer.process!
+        server.add_connection(self)
+      end
+
+      def on_message(message)
+        message_buffer.append message
+      end
+
+      def on_error(message)
+        raise message
+      end
+
+      def on_close(reason, code)
+        server.remove_connection(self)
+      end
+
+      private
+
+      attr_reader :websocket
+      attr_reader :message_buffer
+
+      def setup(options)
+        @dt = options['dt']
+        @files = options['files']
+      end  
+
+      def encode(message)
+        message.to_json
+      end
+
+      def decode(message)
+        JSON.parse message
+      end
+
+      def send_welcome_message
+        transmit type: RailsLiveReload::INTERNAL[:message_types][:welcome]
+      end
+
+      def respond_to_successful_request
+        websocket.rack_response
+      end
+
+      def respond_to_invalid_request
+        close(reason: RailsLiveReload::INTERNAL[:disconnect_reasons][:invalid_request]) if websocket.alive?
+
+        [ 404, { "Content-Type" => "text/plain" }, [ "Page not found" ] ]
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/client_socket.rb

@@ -0,0 +1,153 @@
+require "websocket/driver"
+
+module RailsLiveReload
+  module WebSocket
+    # This class is basically copied from ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/connection/client_socket.rb
+    class ClientSocket
+      def self.determine_url(env)
+        scheme = secure_request?(env) ? "wss:" : "ws:"
+        "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+      end
+
+      def self.secure_request?(env)
+        return true if env["HTTPS"] == "on"
+        return true if env["HTTP_X_FORWARDED_SSL"] == "on"
+        return true if env["HTTP_X_FORWARDED_SCHEME"] == "https"
+        return true if env["HTTP_X_FORWARDED_PROTO"] == "https"
+        return true if env["rack.url_scheme"] == "https"
+
+        false
+      end
+
+      CONNECTING = 0
+      OPEN       = 1
+      CLOSING    = 2
+      CLOSED     = 3
+
+      attr_reader :env, :url
+
+      def initialize(env, event_target, event_loop, protocols)
+        @env          = env
+        @event_target = event_target
+        @event_loop   = event_loop
+
+        @url = ClientSocket.determine_url(@env)
+
+        @driver = @driver_started = nil
+        @close_params = ["", 1006]
+
+        @ready_state = CONNECTING
+
+        @driver = ::WebSocket::Driver.rack(self, protocols: protocols)
+
+        @driver.on(:open)    { |e| open }
+        @driver.on(:message) { |e| receive_message(e.data) }
+        @driver.on(:close)   { |e| begin_close(e.reason, e.code) }
+        @driver.on(:error)   { |e| emit_error(e.message) }
+
+        @stream = RailsLiveReload::WebSocket::Stream.new(@event_loop, self)
+      end
+
+      def start_driver
+        return if @driver.nil? || @driver_started
+        @stream.hijack_rack_socket
+
+        if callback = @env["async.callback"]
+          callback.call([101, {}, @stream])
+        end
+
+        @driver_started = true
+        @driver.start
+      end
+
+      def rack_response
+        start_driver
+        [ -1, {}, [] ]
+      end
+
+      def write(data)
+        @stream.write(data)
+      rescue => e
+        emit_error e.message
+      end
+
+      def transmit(message)
+        return false if @ready_state > OPEN
+        case message
+        when Numeric then @driver.text(message.to_s)
+        when String  then @driver.text(message)
+        when Array   then @driver.binary(message)
+        else false
+        end
+      end
+
+      def close(code = nil, reason = nil)
+        code   ||= 1000
+        reason ||= ""
+
+        unless code == 1000 || (code >= 3000 && code <= 4999)
+          raise ArgumentError, "Failed to execute 'close' on WebSocket: " \
+                               "The code must be either 1000, or between 3000 and 4999. " \
+                               "#{code} is neither."
+        end
+
+        @ready_state = CLOSING unless @ready_state == CLOSED
+        @driver.close(reason, code)
+      end
+
+      def parse(data)
+        @driver.parse(data)
+      end
+
+      def client_gone
+        finalize_close
+      end
+
+      def alive?
+        @ready_state == OPEN
+      end
+
+      def protocol
+        @driver.protocol
+      end
+
+      private
+
+      def open
+        return unless @ready_state == CONNECTING
+        @ready_state = OPEN
+
+        @event_target.on_open
+      end
+
+      def receive_message(data)
+        return unless @ready_state == OPEN
+
+        @event_target.on_message(data)
+      end
+
+      def emit_error(message)
+        return if @ready_state >= CLOSING
+
+        @event_target.on_error(message)
+      end
+
+      def begin_close(reason, code)
+        return if @ready_state == CLOSED
+        @ready_state = CLOSING
+        @close_params = [reason, code]
+
+        @stream.shutdown if @stream
+        finalize_close
+      end
+
+      def finalize_close
+        return if @ready_state == CLOSED
+        @ready_state = CLOSED
+
+        @event_target.on_close(*@close_params)
+      end
+    end
+  end
+end