hotwire-spark 0.1.8 → 0.1.10

data/app/controllers/hotwire/spark/source_files_controller.rb

@@ -0,0 +1,14 @@
+class Hotwire::Spark::SourceFilesController < ActionController::Base
+  def show
+    if File.exist?(path_param)
+      render plain: File.read(path_param)
+    else
+      head :not_found
+    end
+  end
+
+  private
+    def path_param
+      Rails.root.join params[:path]
+    end
+end

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

@@ -1,8 +1,9 @@
 import consumer from "./consumer"
 import { assetNameFromPath } from "../helpers.js";
-import { HtmlReloader } from "../reloaders/html_reloader.js";
+import { MorphHtmlReloader } from "../reloaders/morph_html_reloader.js";
 import { CssReloader } from "../reloaders/css_reloader.js";
 import { StimulusReloader } from "../reloaders/stimulus_reloader.js";
+import { ReplaceHtmlReloader } from "../reloaders/replace_html_reloader.js";
 
 consumer.subscriptions.create({ channel: "Hotwire::Spark::Channel" }, {
   connected() {
@@ -18,30 +19,30 @@ consumer.subscriptions.create({ channel: "Hotwire::Spark::Channel" }, {
   },
 
   dispatch({ action, path }) {
-    const fileName = assetNameFromPath(path)
-
     switch(action) {
       case "reload_html":
         return this.reloadHtml()
       case "reload_css":
-        return this.reloadCss(fileName)
+        return this.reloadCss(path)
       case "reload_stimulus":
-        return this.reloadStimulus(fileName)
+        return this.reloadStimulus(path)
       default:
         throw new Error(`Unknown action: ${action}`)
     }
   },
 
   reloadHtml() {
-    return HtmlReloader.reload()
+    const htmlReloader = HotwireSpark.config.htmlReloadMethod == "morph" ? MorphHtmlReloader : ReplaceHtmlReloader
+    return htmlReloader.reload()
   },
 
-  reloadCss(fileName) {
+  reloadCss(path) {
+    const fileName = assetNameFromPath(path)
     return CssReloader.reload(new RegExp(fileName))
   },
 
-  reloadStimulus(fileName) {
-    return StimulusReloader.reload(new RegExp(fileName))
+  reloadStimulus(path) {
+    return StimulusReloader.reload(path)
   }
 })
 

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

@@ -3,12 +3,20 @@ import { getConfigurationProperty } from "./helpers.js";
 
 const HotwireSpark = {
   config: {
-    loggingEnabled: false 
+    loggingEnabled: false,
+    htmlReloadMethod: "morph"
   }
 }
 
+const configProperties = {
+  loggingEnabled: "logging",
+  htmlReloadMethod: "html-reload-method",
+}
+
 document.addEventListener("DOMContentLoaded", function() {
-  HotwireSpark.config.loggingEnabled = getConfigurationProperty("logging");
+  Object.entries(configProperties).forEach(([key, property]) => {
+    HotwireSpark.config[key] = getConfigurationProperty(property)
+  })
 })
 
 export default HotwireSpark

data/app/javascript/hotwire/spark/reloaders/{html_reloader.js → morph_html_reloader.js}

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

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

@@ -0,0 +1,31 @@
+import { log } from "../logger.js"
+
+export class ReplaceHtmlReloader {
+  static async reload() {
+    return new ReplaceHtmlReloader().reload()
+  }
+
+  async reload() {
+    await this.#reloadHtml()
+  }
+
+  async #reloadHtml() {
+    log("Reload html with Turbo...")
+
+    this.#maintainScrollPosition()
+    await this.#visitCurrentPage()
+  }
+
+  #maintainScrollPosition() {
+    document.addEventListener("turbo:before-render", () => {
+      Turbo.navigator.currentVisit.scrolled = true
+    }, { once: true })
+  }
+
+  #visitCurrentPage() {
+    return new Promise(resolve => {
+      document.addEventListener("turbo:load", () => resolve(document), { once: true })
+      window.Turbo.visit(window.location)
+    })
+  }
+}

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

@@ -1,17 +1,22 @@
-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()
+  static async reload(path) {
+    return new StimulusReloader(path).reload()
   }
 
-  constructor(document, filePattern = /./) {
-    this.document = document
-    this.filePattern = filePattern
-    this.application = window.Stimulus || Application.start()
+  static async reloadAll() {
+    Stimulus.controllers.forEach(controller => {
+      Stimulus.unload(controller.identifier)
+      Stimulus.register(controller.identifier, controller.constructor)
+    })
+
+    return Promise.resolve()
+  }
+
+  constructor(changedPath) {
+    this.changedPath = changedPath
+    this.application = window.Stimulus
   }
 
   async reload() {
@@ -19,70 +24,45 @@ export class StimulusReloader {
 
     this.application.stop()
 
-    await this.#reloadChangedStimulusControllers()
-    this.#unloadDeletedStimulusControllers()
+    try {
+      await this.#reloadChangedController()
+    }
+    catch(error) {
+      if (error instanceof SourceFileNotFound) {
+        this.#deregisterChangedController()
+      } else {
+        console.error("Error reloading controller", error)
+      }
+    }
 
     this.application.start()
   }
 
-  async #reloadChangedStimulusControllers() {
-    await Promise.all(
-      this.#stimulusControllerPathsToReload.map(async moduleName => this.#reloadStimulusController(moduleName))
-    )
-  }
-
-  get #stimulusControllerPathsToReload() {
-    this.controllerPathsToReload = this.controllerPathsToReload || this.#stimulusControllerPaths.filter(path => this.#shouldReloadController(path))
-    return this.controllerPathsToReload
-  }
-
-  get #stimulusControllerPaths() {
-    return Object.keys(this.#stimulusPathsByModule).filter(path => path.endsWith("_controller"))
-  }
-
-  #shouldReloadController(path) {
-    return this.filePattern.test(path)
-  }
-
-  get #stimulusPathsByModule() {
-    this.pathsByModule = this.pathsByModule || this.#parseImportmapJson()
-    return this.pathsByModule
+  async #reloadChangedController() {
+    const module = await this.#importControllerFromSource(this.changedPath)
+    await this.#registerController(this.#changedControllerIdentifier, module)
   }
 
-  #parseImportmapJson() {
-    const importmapScript = this.document.querySelector("script[type=importmap]")
-    return JSON.parse(importmapScript.text).imports
-  }
-
-  async #reloadStimulusController(moduleName) {
-    log(`\t${moduleName}`)
+  async #importControllerFromSource(path) {
+    const response = await fetch(`/spark/source_files/?path=${path}`)
 
-    const controllerName = this.#extractControllerName(moduleName)
-    const path = cacheBustedUrl(this.#pathForModuleName(moduleName))
+    if (response.status === 404) {
+      throw new SourceFileNotFound(`Source file not found: ${path}`)
+    }
 
-    const module = await import(path)
+    const sourceCode = await response.text()
 
-    this.#registerController(controllerName, module)
-  }
+    const blob = new Blob([sourceCode], { type: "application/javascript" })
+    const moduleUrl = URL.createObjectURL(blob)
+    const module = await import(moduleUrl)
+    URL.revokeObjectURL(moduleUrl)
 
-  #unloadDeletedStimulusControllers() {
-    this.#controllersToUnload.forEach(controller => this.#deregisterController(controller.identifier))
-  }
-
-  get #controllersToUnload() {
-    if (this.#didChangeTriggerAReload) {
-      return []
-    } else {
-      return this.application.controllers.filter(controller => this.filePattern.test(`${controller.identifier}_controller`))
-    }
+    return module
   }
 
-  get #didChangeTriggerAReload() {
-    return this.#stimulusControllerPathsToReload.length > 0
-  }
-
-  #pathForModuleName(moduleName) {
-    return this.#stimulusPathsByModule[moduleName]
+  get #changedControllerIdentifier() {
+    this.changedControllerIdentifier = this.changedControllerIdentifier || this.#extractControllerName(this.changedPath)
+    return this.changedControllerIdentifier
   }
 
   #extractControllerName(path) {
@@ -91,9 +71,16 @@ export class StimulusReloader {
       .replace("_controller", "")
       .replace(/\//g, "--")
       .replace(/_/g, "-")
+      .replace(/\.js$/, "")
+  }
+
+  #deregisterChangedController() {
+    this.#deregisterController(this.#changedControllerIdentifier)
   }
 
   #registerController(name, module) {
+    log("\tReloading controller", name)
+
     this.application.unload(name)
     this.application.register(name, module.default)
   }
@@ -103,3 +90,5 @@ export class StimulusReloader {
     this.application.unload(name)
   }
 }
+
+class SourceFileNotFound extends Error { }

data/config/routes.rb

@@ -1,2 +1,3 @@
 Hotwire::Spark::Engine.routes.draw do
+  get "/source_files", to: "source_files#show"
 end

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

@@ -1,5 +1,5 @@
 class Hotwire::Spark::ActionCable::Server < ActionCable::Server::Base
-  def initialize(config: nil)
+  def initialize
     config = ::ActionCable::Server::Base.config.dup
     config.connection_class = -> { ::ActionCable::Connection::Base }
     super(config: config)

data/lib/hotwire/spark/default_options.rb

@@ -0,0 +1,36 @@
+class Hotwire::Spark::DefaultOptions
+  def initialize
+    @config = base_options
+
+    build
+  end
+
+  def to_h
+    @config
+  end
+
+  private
+    def base_options
+      {
+        enabled: Rails.env.development?,
+        css_paths: File.directory?("app/assets/builds") ? %w[ app/assets/builds ] : %w[ app/assets/stylesheets ],
+        css_extensions: %w[ css ],
+        html_paths: %w[ app/controllers app/helpers app/models app/views ],
+        html_extensions: %w[ rb erb ],
+        stimulus_paths: %w[ app/javascript/controllers ],
+        stimulus_extensions: %w[ js ],
+        html_reload_method: :morph
+      }
+    end
+
+    def build
+      configure_jsbundling if defined?(Jsbundling)
+    end
+
+    def configure_jsbundling
+      @config[:stimulus_paths] = []
+      @config[:html_paths] << "app/assets/builds"
+      @config[:html_extensions] << "js"
+      @config[:html_reload_method] = :replace
+    end
+end

data/lib/hotwire/spark/engine.rb

@@ -1,4 +1,5 @@
 require "action_cable/server/base"
+require "hotwire/spark/default_options"
 
 module Hotwire::Spark
   class Engine < ::Rails::Engine
@@ -6,11 +7,7 @@ module 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: File.directory?("app/assets/builds") ? %w[ app/assets/builds ] : %w[ app/assets/stylesheets ],
-      html_paths: %w[ app/controllers app/helpers app/models app/views ],
-      stimulus_paths: %w[ app/javascript/controllers ]
+    config.hotwire.spark.merge! Hotwire::Spark::DefaultOptions.new.to_h
 
     initializer "hotwire_spark.config" do |application|
       config.hotwire.spark.each do |key, value|
@@ -18,6 +15,10 @@ module Hotwire::Spark
       end
     end
 
+    initializer "hotwire_spark.assets" do |application|
+      application.config.assets.precompile << "hotwire_spark.js"
+    end
+
     initializer "hotwire_spark.install" do |application|
       Hotwire::Spark.install_into application if Hotwire::Spark.enabled?
     end

data/lib/hotwire/spark/file_watcher.rb

@@ -36,9 +36,13 @@ class Hotwire::Spark::FileWatcher
       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) }
+            callbacks.each { |callback| callback.call(as_relative_path(file)) }
           end
         end
       end
     end
+
+    def as_relative_path(path)
+      Pathname.new(path).relative_path_from(Rails.application.root)
+    end
 end

data/lib/hotwire/spark/installer.rb

@@ -1,20 +1,15 @@
 class Hotwire::Spark::Installer
-  attr_reader :file_watcher
-
   def initialize(application)
     @application = application
   end
 
   def install
     configure_cable_server
+    configure_routes
     configure_middleware
     monitor_paths
   end
 
-  def configure_middleware
-    middleware.use Hotwire::Spark::Middleware
-  end
-
   private
     attr_reader :application
     delegate :middleware, to: :application
@@ -25,20 +20,34 @@ class Hotwire::Spark::Installer
       end
     end
 
+    def configure_routes
+      application.routes.prepend do
+        mount Hotwire::Spark::Engine => "/spark", as: "hotwire_spark"
+      end
+    end
+
+    def configure_middleware
+      middleware.use Hotwire::Spark::Middleware
+    end
+
     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
+      monitor :css_paths, action: :reload_css, extensions: Hotwire::Spark.css_extensions
+      monitor :html_paths, action: :reload_html, extensions: Hotwire::Spark.html_extensions
+      monitor :stimulus_paths, action: :reload_stimulus, extensions: Hotwire::Spark.stimulus_extensions
     end
 
-    def monitor(paths_name, action:)
-      file_watcher.monitor Hotwire::Spark.public_send(paths_name) do |file_path|
-        broadcast_reload_action(action, file_path)
+    def monitor(paths_name, action:, extensions:)
+      paths = Hotwire::Spark.public_send(paths_name)
+      if paths.present?
+        file_watcher.monitor paths do |file_path|
+          pattern = /#{extensions.map { |ext| "\\." + ext }.join("|")}$/
+          broadcast_reload_action(action, file_path) if file_path.to_s =~ pattern
+        end
       end
     end
 

data/lib/hotwire/spark/middleware.rb

@@ -7,6 +7,7 @@ class Hotwire::Spark::Middleware
     status, headers, response = @app.call(env)
 
     if html_response?(headers)
+      @request = ActionDispatch::Request.new(env)
       html = html_from(response)
       html = inject_javascript(html)
       html = inject_options(html)
@@ -38,18 +39,22 @@ class Hotwire::Spark::Middleware
     end
 
     def view_helpers
-      ActionController::Base.helpers
+      @request.controller_instance.helpers
     end
 
     def inject_options(html)
-      if Hotwire::Spark.logging
-        html.sub("</head>", "#{logging_option}</head>")
-      else
-        html
-      end
+      html.sub("</head>", "#{options}</head>")
+    end
+
+    def options
+      [ logging_option, html_reload_method_option ].compact.join("\n")
     end
 
     def logging_option
-      view_helpers.tag.meta(name: "hotwire-spark:logging", content: "true")
+      view_helpers.tag.meta(name: "hotwire-spark:logging", content: "true") if Hotwire::Spark.logging
+    end
+
+    def html_reload_method_option
+      view_helpers.tag.meta(name: "hotwire-spark:html-reload-method", content: Hotwire::Spark.html_reload_method)
     end
 end

data/lib/hotwire/spark/version.rb

@@ -1,5 +1,5 @@
 module Hotwire
   module Spark
-    VERSION = "0.1.8"
+    VERSION = "0.1.10"
   end
 end

data/lib/hotwire-spark.rb

@@ -8,10 +8,13 @@ loader.ignore("#{__dir__}/hotwire/spark/version.rb")
 loader.setup
 
 module Hotwire::Spark
-  mattr_accessor :css_paths, default: []
-  mattr_accessor :html_paths, default: []
-  mattr_accessor :stimulus_paths, default: []
+  %i[ css html stimulus ].each do |type|
+    mattr_accessor "#{type}_paths".to_sym, default: []
+    mattr_accessor "#{type}_extensions".to_sym, default: []
+  end
+
   mattr_accessor :logging, default: false
+  mattr_accessor :html_reload_method, default: :morph
 
   mattr_accessor :enabled, default: Rails.env.development?
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hotwire-spark
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Jorge Manrubia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-21 00:00:00.000000000 Z
+date: 2024-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -125,30 +125,33 @@ files:
 - app/assets/javascripts/hotwire_spark.min.js.map
 - app/assets/stylesheets/hotwire_spark/application.css
 - app/channels/hotwire/spark/channel.rb
+- app/controllers/hotwire/spark/source_files_controller.rb
 - app/javascript/hotwire/spark/channels/consumer.js
 - app/javascript/hotwire/spark/channels/monitoring_channel.js
 - app/javascript/hotwire/spark/helpers.js
 - app/javascript/hotwire/spark/index.js
 - app/javascript/hotwire/spark/logger.js
 - app/javascript/hotwire/spark/reloaders/css_reloader.js
-- app/javascript/hotwire/spark/reloaders/html_reloader.js
+- app/javascript/hotwire/spark/reloaders/morph_html_reloader.js
+- app/javascript/hotwire/spark/reloaders/replace_html_reloader.js
 - app/javascript/hotwire/spark/reloaders/stimulus_reloader.js
 - config/routes.rb
 - lib/hotwire-spark.rb
 - lib/hotwire/spark/action_cable/server.rb
+- lib/hotwire/spark/default_options.rb
 - lib/hotwire/spark/engine.rb
 - lib/hotwire/spark/file_watcher.rb
 - lib/hotwire/spark/installer.rb
 - lib/hotwire/spark/middleware.rb
 - lib/hotwire/spark/version.rb
 - lib/tasks/hotwire_spark_tasks.rake
-homepage: https://github.com/basecamp/hotwire_spark
+homepage: https://github.com/hotwired/spark
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/basecamp/hotwire_spark
-  source_code_uri: https://github.com/basecamp/hotwire_spark
-  changelog_uri: https://github.com/basecamp/hotwire_spark
+  homepage_uri: https://github.com/hotwired/spark
+  source_code_uri: https://github.com/hotwired/spark
+  changelog_uri: https://github.com/hotwired/spark
 post_install_message:
 rdoc_options: []
 require_paths: