abandon guard, use a manual reloader for the dev server

Author: jneen

Gemfile

@@ -18,8 +18,6 @@ gem 'memory_profiler', require: false
 
 group :development do
   gem 'pry'
-  gem 'guard'
-  gem 'guard-puma'
 
   # Needed for a Rake task
   gem 'git'

config.ru

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'bundler'
-Bundler.require(:default, :development)
-
 require_relative 'spec/visual/app'
 
 run VisualTestApp

spec/visual/app.rb

@@ -3,14 +3,21 @@
 
 $VERBOSE = true
 
+require 'sinatra'
+require 'pry'
+
 # stdlib
 require 'pathname'
 
+require_relative 'rouge_reloader'
+
 class VisualTestApp < Sinatra::Application
   BASE = Pathname.new(__dir__)
   SAMPLES = BASE.join('samples')
   ROOT = BASE.parent.parent
 
+  RougeReloader.install!(:Rouge, ROOT.to_s, 'lib/rouge.rb')
+
   DEMOS = ROOT.join('lib/rouge/demos')
 
   def query_string
@@ -58,6 +65,7 @@ def as_boolean(value)
   end
 
   before do
+    RougeReloader.reload!
     Rouge::Lexer.enable_debug!
     Rouge::Formatter.enable_escape! if params[:escape]
 

spec/visual/rouge_reloader.rb

@@ -0,0 +1,91 @@
+require 'thread'
+
+# [jneen] this reloader is responsible for safely hot-loading Rouge in the dev server.
+# Previously, we were able to simply remove the Rouge constant and load lib/rouge.rb,
+# and all of Rouge would happily be reloaded. However, we have recently switched to
+# require_relative, which maintains its own global cache. Meaning that if we were to
+# remove the Rouge constant and load lib/rouge.rb, the line
+#
+# require_relative 'rouge/lexer'
+#
+# would be a no-op, and hence the constant Rouge::Lexer would not exist. As far as I
+# know there is no way to manually bust this cache, at least until Ruby::Box is stable.
+#
+# This reloader takes the fairly radical approach of replacing require_relative on
+# both main and Kernel with an equivalent implementation that allows us to manually
+# clear the cache. This way, when we load lib/rouge.rb, or trigger lazy { ... } loads
+# in lexers, the caching can be refreshed during reload.
+#
+# When require-ing files *outside* this project, however, it is important that we
+# fall back to the native require cache.
+#
+# Ideally this will all be replaced with an implementation based on Ruby::Box once
+# that is stable.
+class RougeReloader
+  MUTEX = Mutex.new
+
+  # the targets on which to replace the require_relative method
+  TARGETS = [TOPLEVEL_BINDING.receiver.singleton_class, Kernel]
+
+  def self.install!(const_name, root, path)
+    @instance = new(const_name, root, path)
+    @instance.install!
+  end
+
+  def self.reload!
+    @instance.reload!
+  end
+
+  def initialize(const_name, root, path)
+    @const_name = const_name
+    @root = root
+    @path = File.expand_path(path, root)
+    @cache = {}
+  end
+
+  def reload!
+    STDERR.puts "========= reloading #{@const_name} ========="
+
+    # remove the global constant
+    Object.send(:remove_const, @const_name) if Object.const_defined?(@const_name)
+
+    # clear the cache
+    @cache.clear
+
+    # load rouge.rb
+    Kernel.load(@path)
+  end
+
+  def install!
+    # closured variables for visibility in define_method
+    cache = @cache
+    root = @root
+
+    TARGETS.each do |target|
+      # undefine the original method to avoid the warning
+      target.send(:undef_method, :require_relative)
+
+      # somewhat re-implement require_relative
+      target.send(:define_method, :require_relative) do |path|
+        ref = File.dirname(caller[0].split(":")[0])
+
+        fullpath = File.expand_path(path, ref)
+        fullpath += '.rb' unless fullpath.end_with?('.rb')
+
+        # files outside the project root (e.g. inside of other gems / stdlib)
+        # use the global require cache
+        next require(fullpath) unless ref.start_with?(root)
+
+        # implement the cache check
+        first_load = MUTEX.synchronize do
+          next false if cache.key?(fullpath)
+          cache[fullpath] = true
+        end
+
+        # load the file if it is not in cache
+        Kernel.load(fullpath) if first_load
+      end
+    end
+  end
+end
+