hotwire-spark 0.1.2

data/app/javascript/hotwire/spark/channels/consumer.js

@@ -0,0 +1,3 @@
+import { createConsumer } from "@rails/actioncable"
+
+export default createConsumer()

data/app/javascript/hotwire/spark/channels/monitoring_channel.js

@@ -0,0 +1,47 @@
+import consumer from "./consumer"
+import { assetNameFromPath } from "../helpers.js";
+import { HtmlReloader } from "../reloaders/html_reloader.js";
+import { CssReloader } from "../reloaders/css_reloader.js";
+import { StimulusReloader } from "../reloaders/stimulus_reloader.js";
+
+consumer.subscriptions.create({ channel: "Hotwire::Spark::Channel" }, {
+  connected() {
+    document.body.setAttribute("data-hotwire-spark-ready", "")
+  },
+
+  async received(message) {
+    try {
+      await this.dispatch(message)
+    } catch(error) {
+      console.log(`Error on ${message.action}`, error)
+    }
+  },
+
+  dispatch({ action, path }) {
+    const fileName = assetNameFromPath(path)
+
+    switch(action) {
+      case "reload_html":
+        return this.reloadHtml()
+      case "reload_css":
+        return this.reloadCss(fileName)
+      case "reload_stimulus":
+        return this.reloadStimulus(fileName)
+      default:
+        throw new Error(`Unknown action: ${action}`)
+    }
+  },
+
+  reloadHtml() {
+    return HtmlReloader.reload()
+  },
+
+  reloadCss(fileName) {
+    return CssReloader.reload(new RegExp(fileName))
+  },
+
+  reloadStimulus(fileName) {
+    return StimulusReloader.reload(new RegExp(fileName))
+  }
+})
+

data/app/javascript/hotwire/spark/helpers.js

@@ -0,0 +1,37 @@
+export function assetNameFromPath(path) {
+  return path.split("/").pop().split(".")[0]
+}
+
+export function pathWithoutAssetDigest(path) {
+  return path.replace(/-[a-z0-9]+\.(\w+)(\?.*)?$/, ".$1")
+}
+
+export function urlWithParams(urlString, params) {
+  const url = new URL(urlString, window.location.origin)
+  Object.entries(params).forEach(([ key, value ]) => {
+    url.searchParams.set(key, value)
+  })
+  return url.toString()
+}
+
+export function cacheBustedUrl(urlString) {
+  return urlWithParams(urlString, { reload: Date.now() })
+}
+
+export async function reloadHtmlDocument() {
+  let currentUrl = cacheBustedUrl(urlWithParams(window.location.href, { hotwire_spark: "true" }))
+  const response = await fetch(currentUrl)
+
+  if (!response.ok) {
+    throw new Error(`${response.status} when fetching ${currentUrl}`)
+  }
+
+  const fetchedHTML = await response.text()
+  const parser = new DOMParser()
+  return parser.parseFromString(fetchedHTML, "text/html")
+}
+
+export function getConfigurationProperty(name) {
+  return document.querySelector(`meta[name="hotwire-spark:${name}"]`)?.content
+}
+

data/app/javascript/hotwire/spark/index.js

@@ -0,0 +1,14 @@
+import "./channels/monitoring_channel.js"
+import { getConfigurationProperty } from "./helpers.js";
+
+const HotwireSpark = {
+  config: {
+    loggingEnabled: false 
+  }
+}
+
+document.addEventListener("DOMContentLoaded", function() {
+  HotwireSpark.config.loggingEnabled = getConfigurationProperty("logging");
+})
+
+export default HotwireSpark

data/app/javascript/hotwire/spark/logger.js

@@ -0,0 +1,8 @@
+import HotwireSpark from "./index.js"
+
+export function log(...args) {
+  if (HotwireSpark.config.loggingEnabled) {
+    console.log(`[hotwire_spark]`, ...args)
+  }
+}
+

data/app/javascript/hotwire/spark/reloaders/css_reloader.js

@@ -0,0 +1,65 @@
+import { log } from "../logger.js"
+import { cacheBustedUrl, reloadHtmlDocument, pathWithoutAssetDigest } from "../helpers.js"
+
+export class CssReloader {
+  static async reload(...params) {
+    return new CssReloader(...params).reload()
+  }
+
+  constructor(filePattern = /./) {
+    this.filePattern = filePattern
+  }
+
+  async reload() {
+    log("Reload css...")
+    await Promise.all(await this.#reloadAllLinks())
+  }
+
+  async #reloadAllLinks() {
+    const cssLinks = await this.#loadNewCssLinks();
+    return cssLinks.map(link => this.#reloadLinkIfNeeded(link))
+  }
+
+  async #loadNewCssLinks() {
+    const reloadedDocument = await reloadHtmlDocument()
+    return Array.from(reloadedDocument.head.querySelectorAll("link[rel='stylesheet']"))
+  }
+
+  #reloadLinkIfNeeded(link) {
+    if (this.#shouldReloadLink(link)) {
+      return this.#reloadLink(link)
+    } else {
+      return Promise.resolve()
+    }
+  }
+
+  #shouldReloadLink(link) {
+    return this.filePattern.test(link.getAttribute("href"))
+  }
+
+  async #reloadLink(link) {
+    return new Promise(resolve => {
+      const href = link.getAttribute("href")
+      const newLink = this.#findExistingLinkFor(link) || this.#appendNewLink(link)
+
+      newLink.setAttribute("href", cacheBustedUrl(link.getAttribute("href")))
+      newLink.onload = () => {
+        log(`\t${href}`)
+        resolve()
+      }
+    })
+  }
+
+  #findExistingLinkFor(link) {
+    return this.#cssLinks.find(newLink => pathWithoutAssetDigest(link.href) === pathWithoutAssetDigest(newLink.href))
+  }
+
+  get #cssLinks() {
+    return Array.from(document.querySelectorAll("link[rel='stylesheet']"))
+  }
+
+  #appendNewLink(link) {
+    document.head.append(link)
+    return link
+  }
+}

data/app/javascript/hotwire/spark/reloaders/html_reloader.js

@@ -0,0 +1,31 @@
+import { Idiomorph } from "idiomorph/dist/idiomorph.esm.js"
+import { log } from "../logger.js"
+import { reloadHtmlDocument } from "../helpers.js"
+import { StimulusReloader } from "./stimulus_reloader.js"
+
+export class HtmlReloader {
+  static async reload() {
+    return new HtmlReloader().reload()
+  }
+
+  async reload() {
+    const reloadedDocument = await this.#reloadHtml()
+    await this.#reloadStimulus(reloadedDocument)
+  }
+
+  async #reloadHtml() {
+    log("Reload html...")
+
+    const reloadedDocument = await reloadHtmlDocument()
+    this.#updateBody(reloadedDocument.body)
+    return reloadedDocument
+  }
+
+  #updateBody(newBody) {
+    Idiomorph.morph(document.body, newBody)
+  }
+
+  async #reloadStimulus(reloadedDocument) {
+    return new StimulusReloader(reloadedDocument).reload()
+  }
+}

data/app/javascript/hotwire/spark/reloaders/stimulus_reloader.js

@@ -0,0 +1,76 @@
+import { Application } from "@hotwired/stimulus"
+import { log } from "../logger.js"
+import { cacheBustedUrl, reloadHtmlDocument } from "../helpers.js"
+
+export class StimulusReloader {
+  static async reload(filePattern) {
+    const document = await reloadHtmlDocument()
+    return new StimulusReloader(document, filePattern).reload()
+  }
+
+  constructor(document, filePattern = /./) {
+    this.document = document
+    this.filePattern = filePattern
+    this.application = window.Stimulus || Application.start()
+  }
+
+  async reload() {
+    log("Reload Stimulus controllers...")
+
+    this.application.stop()
+    await this.#reloadStimulusControllers()
+    this.application.start()
+  }
+
+  async #reloadStimulusControllers() {
+    await Promise.all(
+      this.#stimulusControllerPaths.map(async moduleName => this.#reloadStimulusController(moduleName))
+    )
+  }
+
+  get #stimulusControllerPaths() {
+    return Object.keys(this.#stimulusPathsByModule).filter(path => path.endsWith("_controller") && this.#shouldReloadController(path))
+  }
+
+  #shouldReloadController(path) {
+    return this.filePattern.test(path)
+  }
+
+  get #stimulusPathsByModule() {
+    this.pathsByModule = this.pathsByModule || this.#parseImportmapJson()
+    return this.pathsByModule
+  }
+
+  #parseImportmapJson() {
+    const importmapScript = this.document.querySelector("script[type=importmap]")
+    return JSON.parse(importmapScript.text).imports
+  }
+
+  async #reloadStimulusController(moduleName) {
+    log(`\t${moduleName}`)
+
+    const controllerName = this.#extractControllerName(moduleName)
+    const path = cacheBustedUrl(this.#pathForModuleName(moduleName))
+
+    const module = await import(path)
+
+    this.#registerController(controllerName, module)
+  }
+
+  #pathForModuleName(moduleName) {
+    return this.#stimulusPathsByModule[moduleName]
+  }
+
+  #extractControllerName(path) {
+    return path
+      .replace(/^.*\//, "")
+      .replace("_controller", "")
+      .replace(/\//g, "--")
+      .replace(/_/g, "-")
+  }
+
+  #registerController(name, module) {
+    this.application.unload(name)
+    this.application.register(name, module.default)
+  }
+}

data/config/routes.rb

@@ -0,0 +1,2 @@
+Hotwire::Spark::Engine.routes.draw do
+end

data/lib/hotwire/spark/action_cable/persistent_cable_middleware.rb

@@ -0,0 +1,43 @@
+class Hotwire::Spark::ActionCable::PersistentCableMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+
+    if supress_action_cable_restarts?(request)
+      respond_suppressing_action_cable_restarts(env)
+    else
+      @app.call(env)
+    end
+  end
+
+  private
+    COOKIE_NAME = "hotwire_spark_disable_cable_restarts"
+    RESTARTS_SUPPRESSED_GRACE_PERIOD = 10.seconds
+
+    def supress_action_cable_restarts?(request)
+      request.params["hotwire_spark"] || request.cookies[COOKIE_NAME]
+    end
+
+    def respond_suppressing_action_cable_restarts(env)
+      status, headers, body = suppressing_action_cable_restarts { @app.call(env) }
+      headers["Set-Cookie"] = append_cookie_to_disable_cable_restarts(headers["Set-Cookie"])
+
+      [ status, headers, body ]
+    end
+
+    def suppressing_action_cable_restarts(&block)
+      ActionCable.server.without_restarting(&block)
+    end
+
+    def append_cookie_to_disable_cable_restarts(existing_cookies)
+      [ existing_cookies, cookie_to_disable_cable_restarts ].compact
+    end
+
+    def cookie_to_disable_cable_restarts
+      expiration = RESTARTS_SUPPRESSED_GRACE_PERIOD.from_now.utc
+      "#{COOKIE_NAME}=true; Path=/; Expires=#{expiration.httpdate}; HttpOnly"
+    end
+end

data/lib/hotwire/spark/action_cable/persistent_cable_server.rb

@@ -0,0 +1,25 @@
+module Hotwire::Spark::ActionCable::PersistentCableServer
+  def self.prepended(base)
+    base.class_eval do
+      thread_mattr_accessor :suppress_restarts
+    end
+  end
+
+  def restart
+    return if restarts_suppressed?
+
+    super
+  end
+
+  def without_restarting
+    old_suppress_restarts, self.suppress_restarts = self.suppress_restarts, true
+    yield
+  ensure
+    self.suppress_restarts = old_suppress_restarts
+  end
+
+  private
+    def restarts_suppressed?
+      suppress_restarts
+    end
+end

data/lib/hotwire/spark/action_cable/solid_cable_listener_with_safe_reloads.rb

@@ -0,0 +1,8 @@
+module Hotwire::Spark::ActionCable::SolidCableListenerWithSafeReloads
+  private
+    def broadcast_messages
+      Rails.application.executor.wrap  do
+        super
+      end
+    end
+end

data/lib/hotwire/spark/engine.rb

@@ -0,0 +1,25 @@
+require "action_cable/server/base"
+
+module Hotwire::Spark
+  class Engine < ::Rails::Engine
+    isolate_namespace Hotwire::Spark
+
+    config.hotwire = ActiveSupport::OrderedOptions.new unless config.respond_to?(:hotwire)
+    config.hotwire.spark = ActiveSupport::OrderedOptions.new
+    config.hotwire.spark.merge! \
+      enabled: Rails.env.development?,
+      css_paths: %w[ app/assets/stylesheets ],
+      html_paths: %w[ app/controllers app/helpers app/models app/views ],
+      stimulus_paths: %w[ app/javascript/controllers ]
+
+    initializer "hotwire_spark.config" do |app|
+      config.hotwire.spark.each do |key, value|
+        Hotwire::Spark.send("#{key}=", value)
+      end
+    end
+
+    initializer "hotwire_spark.install" do |application|
+      Hotwire::Spark.install_into application if Hotwire::Spark.enabled?
+    end
+  end
+end

data/lib/hotwire/spark/file_watcher.rb

@@ -0,0 +1,40 @@
+require "listen"
+
+class Hotwire::Spark::FileWatcher
+  def initialize
+    @callbacks_by_path = Hash.new { |hash, key| hash[key] = [] }
+  end
+
+  def monitor(paths, &callback)
+    Array(paths).each do |path|
+      @callbacks_by_path[expand_path(path)] << callback
+    end
+  end
+
+  def start
+    listener = Listen.to(*paths) do |modified, added, removed|
+      process_changed_files modified + added + removed
+    end
+
+    listener.start
+  end
+
+  private
+    def expand_path(path)
+      Rails.application.root.join(path)
+    end
+
+    def paths
+      @callbacks_by_path.keys
+    end
+
+    def process_changed_files(changed_files)
+      changed_files.each do |file|
+        @callbacks_by_path.each do |path, callbacks|
+          if file.to_s.start_with?(path.to_s)
+            callbacks.each { |callback| callback.call(file) }
+          end
+        end
+      end
+    end
+end

data/lib/hotwire/spark/installer.rb

@@ -0,0 +1,52 @@
+class Hotwire::Spark::Installer
+  attr_reader :file_watcher
+
+  def initialize(application)
+    @application = application
+  end
+
+  def install
+    configure_middleware
+    monitor_paths
+  end
+
+  def configure_middleware
+    ::ActionCable::Server::Base.prepend(Hotwire::Spark::ActionCable::PersistentCableServer)
+
+    middleware.insert_before ActionDispatch::Executor, Hotwire::Spark::ActionCable::PersistentCableMiddleware
+    middleware.use Hotwire::Spark::Middleware
+  end
+
+  private
+    attr_reader :application
+    delegate :middleware, to: :application
+
+    def monitor_paths
+      register_monitored_paths
+      file_watcher.start
+    end
+
+    def register_monitored_paths
+      monitor :css_paths, action: :reload_css
+      monitor :html_paths, action: :reload_html
+      monitor :stimulus_paths, action: :reload_stimulus
+    end
+
+    def monitor(paths_name, action:)
+      file_watcher.monitor Hotwire::Spark.public_send(paths_name) do |file_path|
+        broadcast_reload_action(action, file_path)
+      end
+    end
+
+    def broadcast_reload_action(action, file_path)
+      ActionCable.server.broadcast "hotwire_spark", reload_message_for(action, file_path)
+    end
+
+    def reload_message_for(action, file_path)
+      { action: action, path: file_path }
+    end
+
+    def file_watcher
+      @file_watches ||= Hotwire::Spark::FileWatcher.new
+    end
+end

data/lib/hotwire/spark/middleware.rb

@@ -0,0 +1,55 @@
+class Hotwire::Spark::Middleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    status, headers, response = @app.call(env)
+
+    if html_response?(headers)
+      html = html_from(response)
+      html = inject_javascript(html)
+      html = inject_options(html)
+      headers["Content-Length"] = html.bytesize.to_s if html
+      response = [ html ]
+    end
+
+    [ status, headers, response ]
+  end
+
+  private
+    def html_response?(headers)
+      headers["Content-Type"]&.include?("text/html")
+    end
+
+    def html_from(response)
+      response_body = []
+      response.each { |part| response_body << part }
+      response_body.join
+    end
+
+    def inject_javascript(html)
+      html.sub("</head>", "#{script_tag}</head>")
+    end
+
+    def script_tag
+      script_path = view_helpers.asset_path("hotwire_spark.js")
+      view_helpers.javascript_include_tag(script_path)
+    end
+
+    def view_helpers
+      ActionController::Base.helpers
+    end
+
+    def inject_options(html)
+      if Hotwire::Spark.logging
+        html.sub("</head>", "#{logging_option}</head>")
+      else
+        html
+      end
+    end
+
+    def logging_option
+      view_helpers.tag.meta(name: "hotwire-spark:logging", content: "true")
+    end
+end

data/lib/hotwire/spark/version.rb

@@ -0,0 +1,5 @@
+module Hotwire
+  module Spark
+    VERSION = "0.1.2"
+  end
+end

data/lib/hotwire-spark.rb

@@ -0,0 +1,26 @@
+require "hotwire/spark/version"
+require "hotwire/spark/engine"
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/hotwire-spark.rb")
+loader.setup
+
+module Hotwire::Spark
+  mattr_accessor :css_paths, default: []
+  mattr_accessor :html_paths, default: []
+  mattr_accessor :stimulus_paths, default: []
+  mattr_accessor :logging, default: false
+
+  mattr_accessor :enabled, default: Rails.env.development?
+
+  class << self
+    def install_into(application)
+      Installer.new(application).install
+    end
+
+    def enabled?
+      enabled
+    end
+  end
+end

data/lib/tasks/hotwire_spark_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :hotwire_spark do
+#   # Task goes here
+# end