rails_live_reload 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04c014926a43e8cba8e586fa5aca93a4e002357fffee35d2a553db0ec88f04a0
-  data.tar.gz: 7c5b64509ab169603cd32b62adc9390eb2f1d939d2e626e9bca960f325d45876
+  metadata.gz: 999e453ba10fc303a5f317609ad52abbb318972712802ea87606f17c89c2054a
+  data.tar.gz: 456e9df00f34d48e75a8cdbee655e035e68a0c98c468020946dc3ec6903848bb
 SHA512:
-  metadata.gz: 6e365d7ffad4d351c35c84f8839c4b55318c9769c2191c8aab53cd441253d26950cfabeb98f76c8b556e7bb80d9b329f0b6e5d81ce1c4b0841239d106b38a406
-  data.tar.gz: ec660e96b97075b0c7663e5d0b3be0e59d3a505805feda8c0e7262c2e9c7889f560f0a308edaecf1dc03aaeb7e3a987e709718196ae7b42d47b98df03074449f
+  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,8 @@ $ 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
@@ -78,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
 
@@ -91,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,11 +18,11 @@ module RailsLiveReload
   end
 
   class Config
-    attr_reader :patterns
-    attr_accessor :mode, :polling_interval, :timeout, :url, :watcher, :files, :enabled, :long_polling_sleep_duration
+    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
       @long_polling_sleep_duration = 0.1
       @polling_interval = 100
@@ -47,5 +47,25 @@ module RailsLiveReload
 
       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/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.2"
+  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

data/lib/rails_live_reload/web_socket/event_loop.rb

@@ -0,0 +1,131 @@
+require "nio"
+
+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/stream_event_loop.rb
+    class EventLoop
+      def initialize
+        @nio = @executor = @thread = nil
+        @map = {}
+        @stopping = false
+        @todo = Queue.new
+        @spawn_mutex = Mutex.new
+      end
+
+      def timer(interval, &block)
+        Concurrent::TimerTask.new(execution_interval: interval, &block).tap(&:execute)
+      end
+
+      def post(task = nil, &block)
+        task ||= block
+
+        spawn
+        @executor << task
+      end
+
+      def attach(io, stream)
+        @todo << lambda do
+          @map[io] = @nio.register(io, :r)
+          @map[io].value = stream
+        end
+        wakeup
+      end
+
+      def detach(io, stream)
+        @todo << lambda do
+          @nio.deregister io
+          @map.delete io
+          io.close
+        end
+        wakeup
+      end
+
+      def writes_pending(io)
+        @todo << lambda do
+          if monitor = @map[io]
+            monitor.interests = :rw
+          end
+        end
+        wakeup
+      end
+
+      def stop
+        @stopping = true
+        wakeup if @nio
+      end
+
+      private
+
+      def spawn
+        return if @thread && @thread.status
+
+        @spawn_mutex.synchronize do
+          return if @thread && @thread.status
+
+          @nio ||= NIO::Selector.new
+
+          @executor ||= Concurrent::ThreadPoolExecutor.new(
+            min_threads: 1,
+            max_threads: 10,
+            max_queue: 0,
+          )
+
+          @thread = Thread.new { run }
+
+          return true
+        end
+      end
+
+      def wakeup
+        spawn || @nio.wakeup
+      end
+
+      def run
+        loop do
+          if @stopping
+            @nio.close
+            break
+          end
+
+          until @todo.empty?
+            @todo.pop(true).call
+          end
+
+          next unless monitors = @nio.select
+
+          monitors.each do |monitor|
+            io = monitor.io
+            stream = monitor.value
+
+            begin
+              if monitor.writable?
+                if stream.flush_write_buffer
+                  monitor.interests = :r
+                end
+                next unless monitor.readable?
+              end
+
+              incoming = io.read_nonblock(4096, exception: false)
+              case incoming
+              when :wait_readable
+                next
+              when nil
+                stream.close
+              else
+                stream.receive incoming
+              end
+            rescue
+              begin
+                stream.close
+              rescue
+                @nio.deregister io
+                @map.delete io
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/message_buffer.rb

@@ -0,0 +1,53 @@
+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/message_buffer.rb
+    class MessageBuffer
+      def initialize(connection)
+        @connection = connection
+        @buffered_messages = []
+      end
+
+      def append(message)
+        if valid? message
+          if processing?
+            receive message
+          else
+            buffer message
+          end
+        else
+          raise ArgumentError, "Couldn't handle non-string message: #{message.class}"
+        end
+      end
+
+      def processing?
+        @processing
+      end
+
+      def process!
+        @processing = true
+        receive_buffered_messages
+      end
+
+      private
+
+      attr_reader :connection, :buffered_messages
+
+      def valid?(message)
+        message.is_a?(String)
+      end
+
+      def receive(message)
+        connection.receive message
+      end
+
+      def buffer(message)
+        buffered_messages << message
+      end
+
+      def receive_buffered_messages
+        receive buffered_messages.shift until buffered_messages.empty?
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/stream.rb

@@ -0,0 +1,109 @@
+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/stream.rb
+    class Stream
+      def initialize(event_loop, socket)
+        @event_loop    = event_loop
+        @socket_object = socket
+        @stream_send   = socket.env["stream.send"]
+
+        @rack_hijack_io = nil
+        @write_lock = Mutex.new
+
+        @write_head = nil
+        @write_buffer = Queue.new
+      end
+
+      def each(&callback)
+        @stream_send ||= callback
+      end
+
+      def close
+        shutdown
+        @socket_object.client_gone
+      end
+
+      def shutdown
+        clean_rack_hijack
+      end
+
+      def write(data)
+        if @stream_send
+          return @stream_send.call(data)
+        end
+
+        if @write_lock.try_lock
+          begin
+            if @write_head.nil? && @write_buffer.empty?
+              written = @rack_hijack_io.write_nonblock(data, exception: false)
+
+              case written
+              when :wait_writable
+              when data.bytesize
+                return data.bytesize
+              else
+                @write_head = data.byteslice(written, data.bytesize)
+                @event_loop.writes_pending @rack_hijack_io
+
+                return data.bytesize
+              end
+            end
+          ensure
+            @write_lock.unlock
+          end
+        end
+
+        @write_buffer << data
+        @event_loop.writes_pending @rack_hijack_io
+
+        data.bytesize
+      rescue EOFError, Errno::ECONNRESET
+        @socket_object.client_gone
+      end
+
+      def flush_write_buffer
+        @write_lock.synchronize do
+          loop do
+            if @write_head.nil?
+              return true if @write_buffer.empty?
+              @write_head = @write_buffer.pop
+            end
+
+            written = @rack_hijack_io.write_nonblock(@write_head, exception: false)
+            case written
+            when :wait_writable
+              return false
+            when @write_head.bytesize
+              @write_head = nil
+            else
+              @write_head = @write_head.byteslice(written, @write_head.bytesize)
+              return false
+            end
+          end
+        end
+      end
+
+      def receive(data)
+        @socket_object.parse(data)
+      end
+
+      def hijack_rack_socket
+        return unless @socket_object.env["rack.hijack"]
+
+        @rack_hijack_io = @socket_object.env["rack.hijack"].call
+        @rack_hijack_io ||= @socket_object.env["rack.hijack_io"]
+
+        @event_loop.attach(@rack_hijack_io, self)
+      end
+
+      private
+
+      def clean_rack_hijack
+        return unless @rack_hijack_io
+        @event_loop.detach(@rack_hijack_io, self)
+        @rack_hijack_io = nil
+      end
+    end
+  end
+end

data/lib/rails_live_reload/web_socket/wrapper.rb

@@ -0,0 +1,27 @@
+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/web_socket.rb
+    class Wrapper
+      delegate :transmit, :close, :protocol, :rack_response, to: :websocket
+
+      def initialize(env, event_target, event_loop, protocols: RailsLiveReload::INTERNAL[:protocols])
+        @websocket = ::WebSocket::Driver.websocket?(env) ? ClientSocket.new(env, event_target, event_loop, protocols) : nil
+      end
+
+      def possible?
+        websocket
+      end
+
+      def alive?
+        websocket && websocket.alive?
+      end
+
+      private
+
+      attr_reader :websocket
+    end
+  end
+end

data/lib/rails_live_reload.rb

@@ -1,11 +1,11 @@
 require "listen"
 require "rails_live_reload/version"
 require "rails_live_reload/config"
-require "rails_live_reload/client"
 require "rails_live_reload/watcher"
-require "rails_live_reload/rails/middleware/base"
-require "rails_live_reload/rails/middleware/long_polling"
-require "rails_live_reload/rails/middleware/polling"
+require "rails_live_reload/middleware/base"
+require "rails_live_reload/middleware/long_polling"
+require "rails_live_reload/middleware/web_socket"
+require "rails_live_reload/middleware/polling"
 require "rails_live_reload/instrument/metrics_collector"
 require "rails_live_reload/thread/current_request"
 require "rails_live_reload/checker"
@@ -16,10 +16,24 @@ module RailsLiveReload
   mattr_accessor :watcher
   @@watcher = {}
 
+  INTERNAL = {
+    message_types: {
+      welcome: "welcome",
+      disconnect: "disconnect",
+      ping: "ping",
+    },
+    disconnect_reasons: {
+      invalid_request: "invalid_request",
+      remote: "remote"
+    },
+    protocols: ["rails-live-reload-v1-json"].freeze
+  }
+
   def self.middleware
     case config.mode
-    when :polling then RailsLiveReload::Rails::Middleware::Polling
-    when :long_polling then RailsLiveReload::Rails::Middleware::LongPolling
+    when :polling then RailsLiveReload::Middleware::Polling
+    when :long_polling then RailsLiveReload::Middleware::LongPolling
+    when :websocket then RailsLiveReload::Middleware::WebSocket
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_live_reload
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Igor Kasyanchuk
@@ -9,10 +9,10 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-31 00:00:00.000000000 Z
+date: 2022-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,41 +40,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: websocket-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-nav
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -82,13 +54,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sprockets-rails
+  name: nio4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -123,17 +95,26 @@ files:
 - Rakefile
 - lib/rails_live_reload.rb
 - lib/rails_live_reload/checker.rb
-- lib/rails_live_reload/client.rb
 - lib/rails_live_reload/command.rb
 - lib/rails_live_reload/config.rb
 - lib/rails_live_reload/engine.rb
 - lib/rails_live_reload/instrument/metrics_collector.rb
-- lib/rails_live_reload/rails/middleware/base.rb
-- lib/rails_live_reload/rails/middleware/long_polling.rb
-- lib/rails_live_reload/rails/middleware/polling.rb
+- lib/rails_live_reload/javascript/long_polling.js
+- lib/rails_live_reload/javascript/polling.js
+- lib/rails_live_reload/javascript/websocket.js
+- lib/rails_live_reload/middleware/base.rb
+- lib/rails_live_reload/middleware/long_polling.rb
+- lib/rails_live_reload/middleware/polling.rb
+- lib/rails_live_reload/middleware/web_socket.rb
 - lib/rails_live_reload/thread/current_request.rb
 - lib/rails_live_reload/version.rb
 - lib/rails_live_reload/watcher.rb
+- lib/rails_live_reload/web_socket/base.rb
+- lib/rails_live_reload/web_socket/client_socket.rb
+- lib/rails_live_reload/web_socket/event_loop.rb
+- lib/rails_live_reload/web_socket/message_buffer.rb
+- lib/rails_live_reload/web_socket/stream.rb
+- lib/rails_live_reload/web_socket/wrapper.rb
 homepage: https://github.com/railsjazz/rails_live_reload
 licenses:
 - MIT

data/lib/rails_live_reload/client.rb

@@ -1,75 +0,0 @@
-module RailsLiveReload
-  module Client
-
-    def Client.long_polling_js
-      <<~HTML.html_safe
-        <script>
-          (function() {
-            const files = #{CurrentRequest.current.data.to_a.to_json};
-            let retries_count = 0;
-            function poll() {
-              const formData = new FormData();
-              formData.append('dt', #{Time.now.to_i})
-              formData.append('files', JSON.stringify(files))
-
-              fetch(
-                "#{RailsLiveReload.config.url}", 
-                {
-                  method: "post",
-                  headers: { 'Accept': 'application/json', },
-                  body: formData
-                }
-              )
-                .then(response => response.json())
-                .then(data => {
-                  retries_count = 0;
-                  if(data['command'] === 'RELOAD') {
-                    window.location.reload();
-                  } else {
-                    poll();
-                  }
-                }).catch(() => {
-                  retries_count++;
-
-                  if(retries_count < 10) {
-                    setTimeout(poll, 5000)
-                  }
-                })
-            }
-            poll();
-          })();
-        </script>
-      HTML
-    end
-
-    def Client.polling_js
-      <<~HTML.html_safe
-        <script>
-          const files = #{CurrentRequest.current.data.to_a.to_json};
-          const timer = setInterval(
-            () => {
-              const formData = new FormData();
-              formData.append('dt', #{Time.now.to_i})
-              formData.append('files', JSON.stringify(files))
-              fetch(
-                "#{RailsLiveReload.config.url}", 
-                {
-                  method: "post",
-                  headers: { 'Accept': 'application/json', },
-                  body: formData
-                }
-              )
-                .then(response => response.json())
-                .then(data => {
-                  if(data['command'] === 'RELOAD') {
-                    clearInterval(timer);
-                    window.location.reload();
-                  }
-                })
-            }, #{RailsLiveReload.config.polling_interval}
-          )
-        </script>
-      HTML
-    end
-  end
-end

data/lib/rails_live_reload/rails/middleware/base.rb

@@ -1,63 +0,0 @@
-module RailsLiveReload
-  module Rails
-    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)
-
-          if env["REQUEST_PATH"] == RailsLiveReload.config.url
-            rails_live_response(request)
-          else
-            @status, @headers, @response = @app.call(env)
-
-            if html? && @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 rails_live_response(request)
-          raise NotImplementedError
-        end
-
-        def client_javascript(request)
-          raise NotImplementedError
-        end
-
-        def make_new_response(body)
-          body.sub("</head>", "</head>#{client_javascript}")
-        end
-
-        def html?
-          @headers["Content-Type"].to_s.include?("text/html")
-        end
-
-        def new_thread
-          Thread.new {
-            t2 = Thread.current
-            t2.abort_on_exception = true
-            yield
-          }
-        end
-      end
-    end
-  end
-end

data/lib/rails_live_reload/rails/middleware/long_polling.rb

@@ -1,51 +0,0 @@
-module RailsLiveReload
-  module Rails
-    module Middleware
-      class LongPolling < Base
-        private
-
-        def 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 client_javascript
-          RailsLiveReload::Client.long_polling_js
-        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
-end

data/lib/rails_live_reload/rails/middleware/polling.rb

@@ -1,21 +0,0 @@
-module RailsLiveReload
-  module Rails
-    module Middleware
-      class Polling < Base
-        private
-
-        def rails_live_response(request)
-          [
-            200,
-            { 'Content-Type' => 'application/json' },
-            [ RailsLiveReload::Command.new(request.params).payload.to_json ]
-          ]
-        end
-
-        def client_javascript
-          RailsLiveReload::Client.polling_js
-        end
-      end
-    end
-  end
-end