hotwire-spark 0.1.9 → 0.1.10

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,15 +1,21 @@
 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
+  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
   }
 
@@ -18,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) {
@@ -90,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)
   }
@@ -102,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/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|

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

@@ -5,6 +5,7 @@ class Hotwire::Spark::Installer
 
   def install
     configure_cable_server
+    configure_routes
     configure_middleware
     monitor_paths
   end
@@ -19,6 +20,12 @@ 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
@@ -29,14 +36,18 @@ class Hotwire::Spark::Installer
     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.9"
+    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.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Jorge Manrubia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-22 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,17 +125,20 @@ 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