rails_live_reload 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98a01974fe3a99ed6546f43f777fc3a0e91d7f175179e561494740e95d3de9fe
-  data.tar.gz: b22be442a32123b9e09b2649993b9dc865276fd4157ff4f34cdfbc4891fb7745
+  metadata.gz: 88846a7af50ff0f2941eeb26795f7156ef4c92b8397453d9810d0196a27851ba
+  data.tar.gz: 70337f1ce69e0fab74a7272633629a565f6106a86e00590e4eb0f2d49e71281e
 SHA512:
-  metadata.gz: a9b46ace63dbac0a9854e44676556799ad58e3a97f0c188e99dfec77a07cc36f550c7767b281946e9331a71aa870c8494c81b45ae9a7ddbed663fd5ab9a447d8
-  data.tar.gz: 1bb0e9c9bfe6c4d59e70ced62c591907f01ec058ef2733247cdc4be299d652898200e07aeff9cf9112a5df1cf18cc71579df637c9f7dc66a48631ed18458b71f
+  metadata.gz: 5c4a756e0c3cd05ae4e8d75c5d221d2bd18ec17bd36d70ad8b720244f849a058d3788ec401d5f53eb88e99d0cfe8c5f09afd8610acaaf60e194b162465eb6bcf
+  data.tar.gz: e23b0b4b83ed08589cd9a11066419e91fb58f4d3cf2dff4724de276408877b328829b96c598edaf77f9c90b251d8993486472bdde4a7d1bd88f5ed7c27c5e68c

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,25 +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.
-
 ### Create initializer `config/initializers/rails_live_reload.rb`:
 
 
 ```ruby
 RailsLiveReload.configure do |config|
-  # config.url     = "/rails/live/reload"
-  # Available modes are: :long_polling (default) and :polling
-  # config.mode = :long_polling
-
-  # 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
+  # config.url = "/rails/live/reload"
 
   # Default watched folders & files
   # config.watch %r{app/views/.+\.(erb|haml|slim)$}
@@ -67,6 +54,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)
 ```
 
@@ -76,7 +65,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
 
@@ -89,15 +78,13 @@ 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
+- auto reload when rendered controller was changed
 
 ## License
 

data/lib/rails_live_reload/checker.rb

@@ -1,11 +1,18 @@
 module RailsLiveReload
   class Checker
+    def self.files
+      @files
+    end
+
+    def self.files=(files)
+      @files = files
+    end
 
     def self.scan(dt, rendered_files)
       temp = []
 
       # all changed files
-      RailsLiveReload.watcher.files.each do |file, fdt|
+      files.each do |file, fdt|
         temp << file if fdt && fdt > dt
       end
 
@@ -25,6 +32,5 @@ module RailsLiveReload
 
       result
     end
-
   end
-end
+end

data/lib/rails_live_reload/config.rb

@@ -19,17 +19,13 @@ module RailsLiveReload
 
   class Config
     attr_reader :patterns
-    attr_accessor :mode, :polling_interval, :timeout, :url, :watcher, :files, :enabled, :long_polling_sleep_duration
+    attr_accessor :url, :watcher, :files, :enabled
 
     def initialize
-      @mode = :long_polling
-      @timeout = 30
-      @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 = {
@@ -39,6 +35,10 @@ module RailsLiveReload
       @default_patterns_changed = false
     end
 
+    def root_path
+      @root_path ||= ::Rails.application.root
+    end
+
     def watch(pattern, reload: :on_change)
       unless @default_patterns_changed
         @default_patterns_changed = true
@@ -47,5 +47,9 @@ module RailsLiveReload
 
       patterns[pattern] = reload
     end
+
+    def socket_path
+      root_path.join('tmp/sockets/rails_live_reload.sock')
+    end
   end
 end

data/lib/rails_live_reload/engine.rb

@@ -1,32 +1,41 @@
 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
+          app.middleware.insert_after ActionDispatch::Executor, RailsLiveReload::Middleware::Base
         else
           begin
-            app.middleware.insert_after ActionDispatch::Static, RailsLiveReload.middleware
+            app.middleware.insert_after ActionDispatch::Static, RailsLiveReload::Middleware::Base
           rescue
-            app.middleware.insert_after Rack::SendFile, RailsLiveReload.middleware
+            app.middleware.insert_after Rack::SendFile, RailsLiveReload::Middleware::Base
           end
         end
+      end
 
+      initializer "rails_live_reload.watcher" do
         RailsLiveReload::Watcher.init
       end
 
-      initializer :configure_metrics, after: :initialize_logger do
+      initializer "rails_live_reload.configure_metrics", after: :initialize_logger do
         ActiveSupport::Notifications.subscribe(
           /\.action_view/,
           RailsLiveReload::Instrument::MetricsCollector.new
         )
       end
 
-      initializer :reset_current_request, after: :initialize_logger do |app|
+      initializer "rails_live_reload.reset_current_request", after: :initialize_logger do |app|
         app.executor.to_run      { CurrentRequest.cleanup }
         app.executor.to_complete { CurrentRequest.cleanup }
       end
+
+      initializer "rails_live_reload.routes" do
+        config.after_initialize do |app|
+          app.routes.prepend do
+            mount RailsLiveReload.server => RailsLiveReload.config.url, internal: true, anchor: true
+          end
+        end
+      end
     end
   end
 end

data/lib/rails_live_reload/javascript/websocket.js

@@ -0,0 +1,6 @@
+/*!
+  Rails Live Reload 0.3.0
+  Copyright © 2022 RailsJazz
+  https://railsjazz.com
+ */
+var RailsLiveReload=function(){"use strict";const t="RELOAD",e=["rails-live-reload-v1-json"];class n{static _instance;static get instance(){return n._instance||(n._instance=new this),n._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}=JSON.parse(this.optionsNode.textContent);this.files=t,this.time=e,this.url=n}fullReload(){window.location.reload()}get optionsNode(){const t=document.getElementById("rails-live-reload-options");if(!t)throw"Unable to find RailsLiveReload options";return t}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),e),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",(()=>{n.start()})),n}();

data/lib/rails_live_reload/middleware/base.rb

@@ -0,0 +1,55 @@
+module RailsLiveReload
+  module Middleware
+    class Base
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
+        if env["REQUEST_PATH"].starts_with?(RailsLiveReload.config.url)
+          ::Rails.logger.silence do
+            @app.call(env)
+          end
+        else
+          request = Rack::Request.new(env)
+          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
+      end
+
+      private
+
+      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
+            }.to_json}
+          </script>
+          </body>
+        HTML
+      end
+
+      def html?(headers)
+        headers["Content-Type"].to_s.include?("text/html")
+      end
+    end
+  end
+end

data/lib/rails_live_reload/server/base.rb

@@ -0,0 +1,72 @@
+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 Server
+    # This class is based on ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/server/base.rb
+    class Base
+      include RailsLiveReload::Server::Connections
+
+      attr_reader :mutex
+
+      def reload_all
+        @mutex.synchronize do
+          connections.each(&:reload)
+        end
+      end
+
+      def initialize
+        @mutex = Monitor.new
+        @event_loop = nil
+      end
+
+      # Called by Rack to set up the server.
+      def call(env)
+        case env["REQUEST_PATH"]
+        when RailsLiveReload.config.url
+          setup_socket
+          setup_heartbeat_timer
+          request = Rack::Request.new(env)
+          RailsLiveReload::WebSocket::Base.new(self, request).process
+        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
+          raise ActionController::RoutingError, 'Not found'
+        end
+      end
+
+      def client_javascript
+        @client_javascript || @mutex.synchronize { @client_javascript ||= File.open(File.join(File.dirname(__FILE__), "../javascript/websocket.js")).read }
+      end
+
+      def event_loop
+        @event_loop || @mutex.synchronize { @event_loop ||= RailsLiveReload::WebSocket::EventLoop.new }
+      end
+
+      def setup_socket
+        @socket ||= UNIXSocket.open(RailsLiveReload.config.socket_path).tap do |socket|
+          Thread.new do
+            loop do
+              data = JSON.parse socket.readline
+
+              case data["event"]
+              when RailsLiveReload::INTERNAL[:socket_events][:reload]
+                RailsLiveReload::Checker.files = data['files']
+
+                reload_all
+              else
+                raise NotImplementedError
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_live_reload/server/connections.rb

@@ -0,0 +1,27 @@
+module RailsLiveReload
+  module Server
+    # This class is strongly based on ActionCable
+    # https://github.com/rails/rails/blob/v7.0.3/actioncable/lib/action_cable/server/connections.rb
+    module Connections
+      BEAT_INTERVAL = 3
+
+      def connections
+        @connections || @mutex.synchronize { @connections ||= Concurrent::Array.new }
+      end
+
+      def add_connection(connection)
+        connections << connection
+      end
+
+      def remove_connection(connection)
+        connections.delete connection
+      end
+
+      def setup_heartbeat_timer
+        @heartbeat_timer ||= event_loop.timer(BEAT_INTERVAL) do
+          event_loop.post { connections.each(&:beat) }
+        end
+      end
+    end
+  end
+end

data/lib/rails_live_reload/version.rb

@@ -1,3 +1,3 @@
 module RailsLiveReload
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/lib/rails_live_reload/watcher.rb

@@ -1,6 +1,10 @@
 module RailsLiveReload
   class Watcher
-    attr_reader :root, :files
+    attr_reader :files, :sockets
+
+    def root
+      RailsLiveReload.config.root_path
+    end
 
     def Watcher.init
       watcher = new
@@ -8,15 +12,16 @@ module RailsLiveReload
     end
 
     def initialize
-      @root = ::Rails.application.root
       @files = {}
+      @sockets = []
 
       puts "Watching: #{root}"
       RailsLiveReload.patterns.each do |pattern, rule|
-        puts "  #{pattern} => #{rule}" 
+        puts "  #{pattern} => #{rule}"
       end
 
       build_tree
+      start_socket
       start_listener
     end
 
@@ -27,6 +32,7 @@ module RailsLiveReload
           all.each do |file|
             files[file] = File.mtime(file).to_i rescue nil
           end
+          reload_all
         end
         listener.start
       end
@@ -37,5 +43,35 @@ module RailsLiveReload
         files[file] = File.mtime(file).to_i rescue nil
       end
     end
+
+    def reload_all
+      data = {
+        event: RailsLiveReload::INTERNAL[:socket_events][:reload],
+        files: files
+      }.to_json
+
+      @sockets.each do |socket, _|
+        socket.puts data
+      end
+    end
+
+    def start_socket
+      Thread.new do
+        Socket.unix_server_socket(RailsLiveReload.config.socket_path.to_s) do |sock|
+          loop do
+            socket, _ = sock.accept
+            sockets << socket
+            Thread.new do
+              begin
+                socket.eof
+              ensure
+                socket.close
+                sockets.delete socket
+              end
+            end
+          end
+        end
+      end
+    end
   end
 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