ruflet_rails 0.0.11 → 0.0.13

data/lib/ruflet/rails/protocol/web_app.rb

@@ -8,10 +8,10 @@ module Ruflet
       # the same mount point, so it mounts like any Rack app:
       #
       #   # config/routes.rb
-      #   mount Ruflet::Rails.web_app, at: "/myfrontend"
+      #   mount Ruflet::Rails.web_app(app_file: Rails.root.join("app/views/ruflet/main.rb")), at: "/myfrontend"
       #
       #   # or with an explicit entrypoint and build directory:
-      #   mount Ruflet::Rails.web_app(build_dir: Rails.root.join("public/app")) { |page|
+      #   mount Ruflet::Rails.web_app(build_dir: Rails.root.join("frontend")) { |page|
       #     CounterView.render(page)
       #   }, at: "/myfrontend"
       #
@@ -73,15 +73,16 @@ module Ruflet
         end
 
         def entrypoint
-          @entrypoint_option || @app_block || lambda { |page| Ruflet::Rails.render(page) }
+          @entrypoint_option || @app_block ||
+            raise(ArgumentError, "web_app requires one of view:, app_file:, or a block")
         end
 
         # The web build must NOT live under public/, or Rails' static
         # middleware would serve it directly (e.g. /app/index.html) and bypass
         # the mount — making it reachable at a path no route declares. The
-        # default is Rails.root/build/web, exactly where `rake ruflet:build[web]`
-        # exports, which Rails never serves statically. A configured
-        # web_build_dir or explicit build_dir: under public/ is rejected.
+        # default is Rails.root/frontend, exactly where `rake ruflet:web`
+        # installs the prebuilt web client, which Rails never serves statically.
+        # An explicit build_dir: under public/ is rejected.
         def build_dir
           dir = resolve_build_dir
           reject_public_build_dir!(dir)
@@ -92,10 +93,7 @@ module Ruflet
           explicit = @explicit_build_dir.to_s
           return explicit unless explicit.empty?
 
-          configured = Ruflet::Rails.config.web_build_dir.to_s
-          return configured unless configured.empty?
-
-          return ::Rails.root.join("build", "web").to_s if defined?(::Rails.root) && ::Rails.root
+          return ::Rails.root.join("frontend").to_s if defined?(::Rails.root) && ::Rails.root
 
           ""
         end
@@ -110,19 +108,20 @@ module Ruflet
 
           raise ArgumentError,
                 "Ruflet web build dir (#{dir}) is under public/, which Rails serves " \
-                "statically and would expose the app outside its mount. Build to a " \
-                "non-public directory such as #{::Rails.root.join('build', 'web')}."
+                "statically and would expose the app outside its mount. Use a " \
+                "non-public directory such as #{::Rails.root.join('frontend')}."
         end
 
         def serve_index(env)
           index_path = File.join(build_dir, "index.html")
           unless File.file?(index_path)
             return [404, { "content-type" => "text/plain" },
-                    ["Ruflet web build not found at #{index_path}. Run `rake ruflet:build[web]`."]]
+                    ["Ruflet web client not found at #{index_path}. Run `rake ruflet:web`."]]
           end
 
           html = rewrite_base_href(File.read(index_path), mount_base(env))
-          html = inject_mount_url_param(html)
+          html = inject_mount_websocket(html)
+          html = inject_service_worker_cleanup(html)
           [200,
            { "content-type" => "text/html; charset=utf-8",
              "cache-control" => "no-cache",
@@ -130,28 +129,47 @@ module Ruflet
            [html]]
         end
 
-        # The Flet web client builds its WebSocket URL as
-        # ws(s)://<page authority>/<window.flet.webSocketEndpoint || "ws">.
-        # Without help, every build connects to the origin's /ws and escapes
-        # the mount. Deriving the endpoint from document.baseURI (which
-        # follows the rewritten <base href>) pins any build to <mount>/ws —
-        # answered by this same Rack app.
-        MOUNT_URL_BOOTSTRAP = <<~HTML
-          <script>
-            (function () {
-              window.flet = window.flet || {};
-              if (!window.flet.webSocketEndpoint) {
-                var basePath = new URL(document.baseURI).pathname;
-                window.flet.webSocketEndpoint = (basePath + "ws").replace(/^\\/+/, "");
-              }
-            })();
-          </script>
-        HTML
-
-        def inject_mount_url_param(html)
+        def inject_mount_websocket(html)
           return html if html.include?("window.flet.webSocketEndpoint")
 
-          html.sub(%r{(<base\s+href="[^"]*"\s*/?>)}) { "#{::Regexp.last_match(1)}\n#{MOUNT_URL_BOOTSTRAP}" }
+          html.sub(%r{(<base\s+href="[^"]*"\s*/?>)}) { "#{::Regexp.last_match(1)}\n#{mount_websocket_bootstrap}" }
+        end
+
+        # Mounted Rails apps are server-driven and must always load the client
+        # shipped by the Rails app. Remove service workers previously installed
+        # for this mount so they cannot keep serving a stale connection client.
+        def inject_service_worker_cleanup(html)
+          return html if html.include?("ruflet-rails-service-worker-cleanup")
+
+          script = <<~HTML
+            <script id="ruflet-rails-service-worker-cleanup">
+              if ("serviceWorker" in navigator) {
+                navigator.serviceWorker.getRegistrations().then(function (registrations) {
+                  registrations.forEach(function (registration) {
+                    if (registration.scope.indexOf(document.baseURI) === 0) registration.unregister();
+                  });
+                });
+              }
+            </script>
+          HTML
+          html.include?("</head>") ? html.sub("</head>", "#{script}</head>") : "#{script}#{html}"
+        end
+
+        # Pins Flet-style clients to <mount>/ws (derived from the rewritten
+        # <base href>) instead of the origin's /ws. The Ruflet client itself
+        # uses the mounted page URL, so Rails needs no separate backend URL.
+        def mount_websocket_bootstrap
+          <<~HTML
+            <script>
+              (function () {
+                window.flet = window.flet || {};
+                if (!window.flet.webSocketEndpoint) {
+                  var basePath = new URL(document.baseURI).pathname;
+                  window.flet.webSocketEndpoint = (basePath + "ws").replace(/^\\/+/, "");
+                }
+              })();
+            </script>
+          HTML
         end
 
         # <base href> drives the Flutter client's asset and WebSocket URLs;
@@ -172,6 +190,8 @@ module Ruflet
         end
 
         def serve_static(path)
+          return retire_service_worker if path == "/flutter_service_worker.js"
+
           root = File.expand_path(build_dir)
           full = File.expand_path(File.join(root, path))
           unless full.start_with?(root + File::SEPARATOR) && File.file?(full)
@@ -179,8 +199,37 @@ module Ruflet
           end
 
           body = File.binread(full)
+          body = disable_service_worker(body) if path == "/flutter_bootstrap.js"
           [200,
            { "content-type" => content_type_for(full),
+             "cache-control" => "no-cache",
+             "content-length" => body.bytesize.to_s },
+           [body]]
+        end
+
+        def disable_service_worker(body)
+          body.sub(
+            /serviceWorkerSettings:\s*\{\s*serviceWorkerVersion:\s*[^}]+\}\s*,?/m,
+            ""
+          )
+        end
+
+        def retire_service_worker
+          body = <<~JS
+            self.addEventListener("install", function () { self.skipWaiting(); });
+            self.addEventListener("activate", function (event) {
+              event.waitUntil((async function () {
+                await self.registration.unregister();
+                for (const key of await caches.keys()) await caches.delete(key);
+                for (const client of await self.clients.matchAll({ type: "window" })) {
+                  client.navigate(client.url);
+                }
+              })());
+            });
+          JS
+          [200,
+           { "content-type" => "application/javascript",
+             "cache-control" => "no-store",
              "content-length" => body.bytesize.to_s },
            [body]]
         end

data/lib/ruflet/rails/protocol.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "protocol/context"
-require_relative "protocol/middleware"
-require_relative "protocol/wire_codec"
-require_relative "protocol/web_socket_connection"
 require_relative "protocol/local_server"
 require_relative "protocol/websocket_detection"
 require_relative "protocol/endpoint"
 require_relative "protocol/mobile_loader"
 require_relative "protocol/runner"
-require_relative "protocol/web_app_endpoint"
 require_relative "protocol/web_app"

data/lib/ruflet/rails/railtie.rb

@@ -3,10 +3,9 @@
 module Ruflet
   module Rails
     class Railtie < ::Rails::Railtie
-      # Must run before ActionDispatch::Static so the Middleware can serve
-      # web_path and block the build dir's index before Static can touch it.
-      initializer "ruflet_rails.middleware", before: "ActionDispatch::Static" do |app|
-        app.middleware.insert_before(ActionDispatch::Static, Ruflet::Rails::Protocol::Middleware)
+      generators do
+        require "ruflet/rails/generator_hooks"
+        Ruflet::Rails::GeneratorHooks.install!
       end
 
       # Make ruflet_frame and friends available in every .erb template.
@@ -16,6 +15,18 @@ module Ruflet
         end
       end
 
+      # Ruflet components live under app/views so Rails will not discover them
+      # by default. Add that directory as a Zeitwerk root and collapse its
+      # organizational subdirectories, matching generated top-level constants
+      # such as components/products/product_component.rb -> ProductComponent.
+      initializer "ruflet_rails.components", before: :bootstrap_hook do |app|
+        components = app.root.join("app/views/ruflet/components")
+        next unless components.directory?
+
+        app.autoloaders.main.push_dir(components)
+        app.autoloaders.main.collapse(components.join("**"))
+      end
+
       initializer "ruflet_rails.desktop_launcher", after: :load_config_initializers do |_app|
         next unless defined?(::Rails.root)
 
@@ -27,22 +38,21 @@ module Ruflet
 
       rake_tasks do
         namespace :ruflet do
-          desc "Build Ruflet client for this Rails app. Usage: rake ruflet:build[platform]"
+          desc "Build Ruflet native client for this Rails app. Usage: rake ruflet:build[platform]"
           task :build, [:platform] do |_task, args|
             platform = args[:platform].to_s.strip.downcase
 
+            if platform == "web"
+              warn "ruflet_rails does not build the web client. Install the prebuilt web client with: rake ruflet:web"
+              next
+            end
+
             cfg        = Ruflet::Rails.config
             ruflet_url = cfg.backend_url.to_s.strip
             build_args = Ruflet::Rails::InstallSupport.build_args_for_platform(platform, ruflet_url: ruflet_url)
 
-            # Derive --base-href from config.web_build_dir so the built index.html
-            # uses the correct path for assets and Uri.base in the Dart client.
-            if platform == "web" && (dir = cfg.web_build_dir)
-              build_args += ["--base-href", "/#{File.basename(dir.to_s)}/"]
-            end
-
             if build_args.empty?
-              warn "Usage: rake ruflet:build[apk|android|ios|aab|web|desktop|macos|windows|linux]"
+              warn "Usage: rake ruflet:build[apk|android|ios|aab|desktop|macos|windows|linux]"
               next
             end
 
@@ -72,6 +82,12 @@ module Ruflet
             raise SystemExit, exit_code unless exit_code.to_i.zero?
           end
 
+          desc "Install the prebuilt Ruflet web client into frontend/. Usage: rake ruflet:web"
+          task :web do
+            ok = Ruflet::Rails::WebInstaller.install!(root: ::Rails.root)
+            raise SystemExit, 1 unless ok
+          end
+
           desc "Download/update prebuilt Ruflet clients from GitHub releases. Usage: rake ruflet:update[target]"
           task :update, [:target] do |_task, args|
             target = args[:target].to_s.strip

data/lib/ruflet/rails/resource_component.rb

@@ -12,7 +12,7 @@ module Ruflet
     # The generated subclass owns the explicit CRUD UI (render, show, the
     # create/edit form) AND the database calls (record.update, record.destroy!,
     # model_class.new) — so a developer can read and change anything. This base
-    # provides only reusable, non-DB helpers: model resolution, record loading,
+    # provides reusable helpers: model resolution, record loading,
     # field inference (resource_fields/display_fields/display_value), navigation
     # (render_index/render_show/refresh), dialog management, snackbars, and the
     # date/time picker value helpers.
@@ -88,9 +88,8 @@ module Ruflet
         model_class.respond_to?(:model_name) ? model_class.model_name.human.titleize : self.class.singular_title
       end
 
-      # Fields rendered on the detail (show) screen. The generated subclass
-      # overrides this with the scaffolded attributes; the default falls back to
-      # the model's own attribute names.
+      # Fields rendered on the detail (show) screen. The default uses the
+      # model's own attribute names; subclasses can override it.
       def resource_fields
         default_resource_fields
       end
@@ -105,7 +104,7 @@ module Ruflet
         record.public_send(field).to_s
       end
 
-      # --- Record loading & persistence --------------------------------------
+      # --- Record loading & navigation ---------------------------------------
 
       def records
         scope = model_class.respond_to?(:limit) ? model_class.limit(50) : model_class.all

data/lib/ruflet/rails/web_installer.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "tmpdir"
+require "open3"
+
+module Ruflet
+  module Rails
+    # Installs the prebuilt Ruflet web client into a Rails app's frontend/
+    # directory. The web client is the `ruflet_client-web.tar.gz` release asset
+    # (the same prebuilt Flutter web build shipped on GitHub releases) — so the
+    # Rails app serves a web frontend without ever running a Flutter build.
+    #
+    #   rake ruflet:web
+    #
+    # The extracted build is what Ruflet::Rails.web_app serves (its default
+    # build dir is <Rails.root>/frontend).
+    module WebInstaller
+      module_function
+
+      REPO       = "AdamMusa/Ruflet"
+      ASSET_NAME = "ruflet_client-web.tar.gz"
+      TARGET_DIR = "frontend"
+
+      # Downloads and extracts the web client into <root>/<dir>. Returns true on
+      # success. The asset name and release tag are overridable via ENV so a
+      # project can pin a specific build.
+      def install!(root:, dir: TARGET_DIR, asset_name: env_asset_name, tag: env_tag, force: true)
+        target = File.join(root.to_s, dir)
+
+        url = release_asset_url(asset_name, tag: tag)
+        unless url
+          warn "Ruflet web client asset #{asset_name.inspect} not found in the #{REPO} release#{tag ? " #{tag}" : " (latest)"}."
+          return false
+        end
+
+        Dir.mktmpdir("ruflet-web-") do |tmp|
+          archive = File.join(tmp, asset_name)
+          return false unless download(url, archive)
+
+          staging = File.join(tmp, "frontend")
+          FileUtils.mkdir_p(staging)
+          unless safe_archive?(archive) && extract(archive, staging)
+            warn "Failed to safely extract #{asset_name}."
+            return false
+          end
+
+          unless File.file?(File.join(staging, "index.html"))
+            warn "Extracted web client but no index.html was found."
+            return false
+          end
+
+          return false if Dir.exist?(target) && !force
+
+          replace_target(staging, target)
+        end
+
+        puts "Installed Ruflet web client into #{target} (#{asset_name})."
+        true
+      rescue SystemCallError => e
+        warn "Failed to install Ruflet web client into #{target}: #{e.message}"
+        false
+      end
+
+      def release_asset_url(asset_name, tag: nil)
+        api = tag ? "releases/tags/#{tag}" : "releases/latest"
+        release = github_json("https://api.github.com/repos/#{REPO}/#{api}")
+        return nil unless release
+
+        asset = Array(release["assets"]).find { |a| a["name"] == asset_name }
+        unless asset
+          names = Array(release["assets"]).map { |a| a["name"] }
+          warn "Available release assets: #{names.join(', ')}" unless names.empty?
+        end
+        asset && asset["browser_download_url"]
+      end
+
+      def github_json(url)
+        out, status = Open3.capture2(
+          "curl", "-sSL", "--fail",
+          "-H", "Accept: application/vnd.github+json",
+          "-H", "User-Agent: ruflet_rails",
+          url
+        )
+        return nil unless status.success?
+
+        JSON.parse(out)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def download(url, path)
+        ok = system("curl", "-sSL", "--fail", "-o", path, url)
+        warn "Download failed: #{url}" unless ok
+        ok
+      end
+
+      def extract(archive, target)
+        system("tar", "-xzf", archive, "-C", target)
+      end
+
+      def safe_archive?(archive)
+        out, status = Open3.capture2("tar", "-tzf", archive)
+        return false unless status.success?
+
+        out.lines.all? do |line|
+          path = line.strip
+          !path.start_with?("/") && path.split("/").none?("..")
+        end
+      end
+
+      def replace_target(staging, target)
+        FileUtils.mkdir_p(File.dirname(target))
+        backup = "#{target}.ruflet-backup"
+        FileUtils.rm_rf(backup)
+        FileUtils.mv(target, backup) if File.exist?(target)
+        FileUtils.mv(staging, target)
+        FileUtils.rm_rf(backup)
+      rescue StandardError
+        FileUtils.rm_rf(target)
+        FileUtils.mv(backup, target) if File.exist?(backup)
+        raise
+      end
+
+      def env_asset_name
+        value = ENV["RUFLET_RAILS_WEB_ARTIFACT"].to_s.strip
+        value.empty? ? ASSET_NAME : value
+      end
+
+      def env_tag
+        value = ENV["RUFLET_RAILS_WEB_TAG"].to_s.strip
+        value.empty? ? nil : value
+      end
+    end
+  end
+end

data/lib/ruflet/rails/webview_app.rb

@@ -33,7 +33,7 @@ module Ruflet
     def webview_app(url:, appbar: nil, navigation_bar: nil, bottom_appbar: nil,
                     route: "/", prevent_links: nil, on_navigate: nil,
                     on_page_started: nil, on_page_ended: nil, **webview_props)
-      webview_args = { url: url, expand: true }
+      webview_args = { url: url, method: "get", expand: true }
       webview_args[:prevent_links] = prevent_links unless prevent_links.nil?
       webview_args[:on_url_change] = ->(event) { on_navigate.call(event.data) } if on_navigate
       webview_args[:on_page_started] = on_page_started if on_page_started