rails_live_reload 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a12bfdd549b010582467b39ea3f897cd1576b6e85f9595893482cc6d9738a8bf
-  data.tar.gz: 0e1340b8b309f291c4e0eeae134ba70409c26bd483316c512670c815e056f738
+  metadata.gz: 98a01974fe3a99ed6546f43f777fc3a0e91d7f175179e561494740e95d3de9fe
+  data.tar.gz: b22be442a32123b9e09b2649993b9dc865276fd4157ff4f34cdfbc4891fb7745
 SHA512:
-  metadata.gz: 64ccc99a6ae7c6e858bc6b623aa38b2f52000b2aa4131e01e2f54438dd186913a625a8e6bc9a45ae80e72012d25ce4be3a701f5bd1df59eb8585ccccbd0ac8d1
-  data.tar.gz: dff2d37006b4316bcd4d5dcfd2fd97f5f116c300fe1fb2313082abe226b6f5443f883477338bc08ca19da795a4ef61c96849b20e4be3981903ebecf704956818
+  metadata.gz: a9b46ace63dbac0a9854e44676556799ad58e3a97f0c188e99dfec77a07cc36f550c7767b281946e9331a71aa870c8494c81b45ae9a7ddbed663fd5ab9a447d8
+  data.tar.gz: 1bb0e9c9bfe6c4d59e70ced62c591907f01ec058ef2733247cdc4be299d652898200e07aeff9cf9112a5df1cf18cc71579df637c9f7dc66a48631ed18458b71f

data/README.md

@@ -1,18 +1,23 @@
 # Rails Live Reload
 
-This is the simplest and probably the most robust way to add a support for a live reload to your Rails app.
+[![RailsJazz](https://github.com/igorkasyanchuk/rails_time_travel/blob/main/docs/my_other.svg?raw=true)](https://www.railsjazz.com)
 
-Just add the gem and thats all - congratulation, now you have a live reload.
+![RailsLiveReload](docs/rails_live_reload.gif)
+
+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.
 
 Works with:
 
-- views (EBR/HAML/SLIM) (reloading page only if you editing views which were rendered)
+- views (EBR/HAML/SLIM) (the page is reloaded only when changed views which were rendered on the page)
 - partials
 - CSS/JS
-- helpers, locales (if you configure)
-- on a "crash" page, so once you made a fix page it will be reloaded
+- helpers (if configured)
+- YAML locales (if configured)
+- on the "crash" page, so it will be reloaded as soon as you make a fix
 
-Page is reloaded with `window.location.reload()` so it's the most robust way to reload the page because of CSS/JS/etc.
+The page is reloaded fully with `window.location.reload()` to make sure that every chage will be displayed.
 
 ## Usage
 
@@ -35,31 +40,47 @@ $ bundle
 
 ## Configuration
 
-Default configuration `config/initializers/rails_live_reload.rb`:
+### 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.setup do |config|
-  config.url     = "/rails/live/reload"
-  config.timeout = 100
-
-  # Watched folders & files
-  config.watch %r{app/views/.+\.(erb|haml|slim)$}
-  config.watch %r{(app|vendor)/(assets|javascript)/\w+/(.+\.(css|js|html|png|jpg|ts|jsx)).*}, reload: :always
-  
+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
+
+  # Default watched folders & files
+  # config.watch %r{app/views/.+\.(erb|haml|slim)$}
+  # config.watch %r{(app|vendor)/(assets|javascript)/\w+/(.+\.(css|js|html|png|jpg|ts|jsx)).*}, reload: :always
+
   # More examples:
   # config.watch %r{app/helpers/.+\.rb}, reload: :always
   # config.watch %r{config/locales/.+\.yml}, reload: :always
-end
+end if defined?(RailsLiveReload)
 ```
 
 ## How it works
 
-There are 3 main pieces how it works:
+There are 3 main parts:
 
-1) listener for file changes using `listen` gem
+1) listener of file changes (using `listen` gem)
 2) collector of rendered views (see rails instrumentation)
-3) middleware which is responding to setInterval JS calls
+3) middleware which is responding to polling JS calls
+
+## Notes
+
+The default configuration assumes that you either use asset pipeline, or that your assets compile quickly (on most applications asset compilation takes around 50-200ms), so it watches for changes in `app/assets` and `app/javascript` folders, this will not be a problem for 99% of users, but in case your asset compilation takes couple of seconds, this might not work propperly, in that case we would recommend you to add configuration to watch output folder.
 
 ## Contributing
 
@@ -68,17 +89,19 @@ 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
-- check how it works with webpacker/importmaps/etc
-- maybe complex rules, e.g. if "user.rb" file is changed - automatically reload all "users" views
+- 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
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
 [<img src="https://github.com/igorkasyanchuk/rails_time_travel/blob/main/docs/more_gems.png?raw=true"
-/>](https://www.railsjazz.com/?utm_source=github&utm_medium=bottom&utm_campaign=rails_live_reload)
+/>](https://www.railsjazz.com/?utm_source=github&utm_medium=bottom&utm_campaign=rails_live_reload)

data/lib/rails_live_reload/checker.rb

@@ -5,22 +5,16 @@ module RailsLiveReload
       temp = []
 
       # all changed files
-      RailsLiveReload.files.each do |file, fdt|
+      RailsLiveReload.watcher.files.each do |file, fdt|
         temp << file if fdt && fdt > dt
       end
 
-     # ::Rails.logger.info "Changed: #{temp}"
-
       result = []
 
       temp.each do |file|
-       # ::Rails.logger.info "Checking: #{file}"
         RailsLiveReload.patterns.each do |pattern, rule|
-          #puts "pattern = #{pattern} & rule = #{rule}"
-          # 1. CSS, JS, yaml, helper .rb
-          # 2. checking if rendered file
-          rule_1 = file.match(pattern) && rule == :always
-          rule_2 = file.match(pattern) && rendered_files.include?(file)
+          rule_1 = file.match(pattern) && rule == :always # Used for CSS, JS, yaml, helpers, etc.
+          rule_2 = file.match(pattern) && rendered_files.include?(file) # Used to check if view was rendered
 
           if rule_1 || rule_2
             result << file

data/lib/rails_live_reload/client.rb

@@ -1,18 +1,58 @@
 module RailsLiveReload
-  class Client
+  module Client
 
-    def Client.js_code
-      %Q{
+    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};
-          setInterval(
+          const timer = setInterval(
             () => {
               const formData = new FormData();
               formData.append('dt', #{Time.now.to_i})
               formData.append('files', JSON.stringify(files))
-
               fetch(
-                "#{RailsLiveReload.url}", 
+                "#{RailsLiveReload.config.url}", 
                 {
                   method: "post",
                   headers: { 'Accept': 'application/json', },
@@ -22,14 +62,14 @@ module RailsLiveReload
                 .then(response => response.json())
                 .then(data => {
                   if(data['command'] === 'RELOAD') {
-                    window.location.reload()
+                    clearInterval(timer);
+                    window.location.reload();
                   }
                 })
-            }, #{RailsLiveReload.timeout}
+            }, #{RailsLiveReload.config.polling_interval}
           )
         </script>
-        }.html_safe
+      HTML
     end
-
   end
-end
+end

data/lib/rails_live_reload/command.rb

@@ -4,16 +4,22 @@ module RailsLiveReload
 
     def initialize(params)
       @dt    = params["dt"].to_i
-      @files = JSON.parse(params["files"])
+      @files = JSON.parse(params["files"]) rescue []
     end
 
-    def command
-      changes = RailsLiveReload::Checker.scan(dt, files)
+    def changes
+      RailsLiveReload::Checker.scan(dt, files)
+    end
 
-      if changes.size == 0
-        { command: "NO_CHANGES" }
-      else
+    def reload?
+      !changes.size.zero?
+    end
+
+    def payload
+      if reload?
         { command: "RELOAD" }
+      else
+        { command: "NO_CHANGES" }
       end
     end
 

data/lib/rails_live_reload/config.rb

@@ -0,0 +1,51 @@
+module RailsLiveReload
+  class << self
+    def configure
+      yield config
+    end
+
+    def config
+      @_config ||= Config.new
+    end
+
+    def patterns
+      config.patterns
+    end
+
+    def enabled?
+      config.enabled
+    end
+  end
+
+  class Config
+    attr_reader :patterns
+    attr_accessor :mode, :polling_interval, :timeout, :url, :watcher, :files, :enabled, :long_polling_sleep_duration
+
+    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)
+
+      # 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
+  end
+end

data/lib/rails_live_reload/engine.rb

@@ -1,26 +1,32 @@
 module RailsLiveReload
   class Railtie < ::Rails::Engine
 
-    initializer "rails_live_reload.middleware" do |app|
-      if ::Rails::VERSION::MAJOR.to_i >= 5
-        app.middleware.insert_after ActionDispatch::Executor, RailsLiveReload::Rails::Middleware
-      else
-        begin
-          app.middleware.insert_after ActionDispatch::Static, RailsLiveReload::Rails::Middleware
-        rescue
-          app.middleware.insert_after Rack::SendFile, RailsLiveReload::Rails::Middleware
+    if RailsLiveReload.enabled?
+      initializer "rails_live_reload.middleware" do |app|
+        if ::Rails::VERSION::MAJOR.to_i >= 5
+          app.middleware.insert_after ActionDispatch::Executor, RailsLiveReload.middleware
+        else
+          begin
+            app.middleware.insert_after ActionDispatch::Static, RailsLiveReload.middleware
+          rescue
+            app.middleware.insert_after Rack::SendFile, RailsLiveReload.middleware
+          end
         end
+
+        RailsLiveReload::Watcher.init
       end
 
-      RailsLiveReload::Watcher.init
-    end
+      initializer :configure_metrics, after: :initialize_logger do
+        ActiveSupport::Notifications.subscribe(
+          /\.action_view/,
+          RailsLiveReload::Instrument::MetricsCollector.new
+        )
+      end
 
-    initializer :configure_metrics, after: :initialize_logger do
-      ActiveSupport::Notifications.subscribe(
-        /\.action_view/,
-        RailsLiveReload::Instrument::MetricsCollector.new
-      )
+      initializer :reset_current_request, after: :initialize_logger do |app|
+        app.executor.to_run      { CurrentRequest.cleanup }
+        app.executor.to_complete { CurrentRequest.cleanup }
+      end
     end
-
   end
 end

data/lib/rails_live_reload/instrument/metrics_collector.rb

@@ -7,23 +7,3 @@ module RailsLiveReload
     end
   end
 end
-
-# render_template.action_view
-# {
-#   identifier: "/Users/adam/projects/notifications/app/views/posts/index.html.erb",
-#   layout: "layouts/application"
-# }
-# render_partial.action_view
-# {
-#   identifier: "/Users/adam/projects/notifications/app/views/posts/_form.html.erb"
-# }
-# render_collection.action_view
-# {
-#   identifier: "/Users/adam/projects/notifications/app/views/posts/_post.html.erb",
-#   count: 3,
-#   cache_hits: 0
-# }
-# render_layout.action_view
-# {
-#   identifier: "/Users/adam/projects/notifications/app/views/layouts/application.html.erb"
-# }

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,21 @@
+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

data/lib/rails_live_reload/version.rb

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

data/lib/rails_live_reload/watcher.rb

@@ -1,6 +1,6 @@
 module RailsLiveReload
   class Watcher
-    attr_reader :root
+    attr_reader :root, :files
 
     def Watcher.init
       watcher = new
@@ -9,12 +9,15 @@ module RailsLiveReload
 
     def initialize
       @root = ::Rails.application.root
+      @files = {}
+
       puts "Watching: #{root}"
       RailsLiveReload.patterns.each do |pattern, rule|
         puts "  #{pattern} => #{rule}" 
       end
-      self.build_tree
-      self.start_listener
+
+      build_tree
+      start_listener
     end
 
     def start_listener
@@ -22,7 +25,7 @@ module RailsLiveReload
         listener = Listen.to(root) do |modified, added, removed|
           all = modified + added + removed
           all.each do |file|
-            RailsLiveReload.files[file] = File.mtime(file).to_i rescue nil
+            files[file] = File.mtime(file).to_i rescue nil
           end
         end
         listener.start
@@ -31,8 +34,8 @@ module RailsLiveReload
 
     def build_tree
       Dir.glob(File.join(root, '**', '*')).select{|file| File.file?(file)}.each do |file|
-        RailsLiveReload.files[file] = File.mtime(file).to_i rescue nil
+        files[file] = File.mtime(file).to_i rescue nil
       end
     end
   end
-end
+end

data/lib/rails_live_reload.rb

@@ -1,8 +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"
+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/instrument/metrics_collector"
 require "rails_live_reload/thread/current_request"
 require "rails_live_reload/checker"
@@ -10,32 +13,13 @@ require "rails_live_reload/command"
 require "rails_live_reload/engine"
 
 module RailsLiveReload
-  mattr_accessor :files
-  @@files = {}
-
   mattr_accessor :watcher
-  @@watcher = nil
-
-  mattr_accessor :url
-  @@url = "/rails/live/reload"
-
-  mattr_accessor :patterns
-  @@patterns = {}
-
-  mattr_accessor :timeout
-  @@timeout = 100
+  @@watcher = {}
 
-  def self.setup
-    yield(self)
-  end
-
-  def self.watch(pattern, reload: :on_change)
-    RailsLiveReload.patterns[pattern] = reload
+  def self.middleware
+    case config.mode
+    when :polling then RailsLiveReload::Rails::Middleware::Polling
+    when :long_polling then RailsLiveReload::Rails::Middleware::LongPolling
+    end
   end
 end
-
-# default watch settings
-RailsLiveReload.setup do |config|
-  config.watch %r{app/views/.+\.(erb|haml|slim)$}
-  config.watch %r{(app|vendor)/(assets|javascript)/\w+/(.+\.(css|js|html|png|jpg|ts|jsx)).*}, reload: :always
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_live_reload
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Igor Kasyanchuk
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-29 00:00:00.000000000 Z
+date: 2022-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -125,9 +125,12 @@ files:
 - 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.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/thread/current_request.rb
 - lib/rails_live_reload/version.rb
 - lib/rails_live_reload/watcher.rb
@@ -150,7 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Ruby on Rails Live Reload

data/lib/rails_live_reload/rails/middleware.rb

@@ -1,54 +0,0 @@
-module RailsLiveReload
-  module Rails
-    class Middleware
-      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.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)
-        [
-          200,
-          { 'Content-Type' => 'application/json' },
-          [ RailsLiveReload::Command.new(request.params).command.to_json ]
-        ]
-      end
-
-      def make_new_response(body)
-        body.sub("</head>", "</head>#{RailsLiveReload::Client.js_code}")
-      end
-
-      def html?
-        @headers["Content-Type"].include?("text/html")
-      end
-
-    end
-  end
-end