ruflet_rails 0.0.9 → 0.0.11

data/lib/ruflet/rails/install_support.rb

@@ -113,129 +113,25 @@ module Ruflet
         File.join("app", "views", "ruflet", "components", names[:plural], "#{names[:singular]}_form.rb")
       end
 
-      def scaffold_view_path(model_name)
-        names = model_names(model_name)
-
-        File.join("app", "views", "ruflet", "#{names[:plural]}_view.rb")
-      end
-
       def scaffold_component_path(model_name)
         names = model_names(model_name)
 
         File.join("app", "views", "ruflet", "components", names[:plural], "#{names[:singular]}_component.rb")
       end
 
-      def scaffold_view_template(model_name:, attributes: [])
-        names = model_names(model_name)
-        model_class = names[:class_name]
-        view_class = "#{model_class}View"
-        component_class = "#{model_class}Component"
-        title = names[:title]
-        attrs = normalized_form_attributes(attributes)
-        resource_fields = scaffold_resource_fields(attrs)
-        display_fields = scaffold_display_fields(attrs)
-        display_value_cases = scaffold_display_value_cases(attrs)
-
-        template = <<~RUBY
-          # frozen_string_literal: true
-
-          require "ruflet_rails"
-          require_relative "components/#{names[:plural]}/#{names[:singular]}_component"
-
-          class #{view_class} < Ruflet::Rails::ResourceView
-            route #{("/" + names[:plural]).inspect}
-
-            def render
-              page.title = resource_title
-              render_index
-            end
-
-            private
-
-            def model_class
-              #{model_class}
-            end
-
-            def resource_title
-              #{title.inspect}
-            end
-
-            def singular_title
-              model_class.model_name.human.titleize
-            end
-
-            def records
-              scope = model_class.respond_to?(:limit) ? model_class.limit(50) : model_class.all
-              scope.respond_to?(:limit) ? scope.limit(50) : scope.to_a.first(50)
-            end
-
-            def render_index
-              page.views = []
-              page.add(component.render)
-            end
-
-            def render_show(record)
-              page.views = []
-              page.add(component.show(record))
-              page.update
-            end
-
-            def component
-              @component ||= #{component_class}.new(page, controller: self)
-            end
-
-            def show_record(record)
-              render_show(record)
-            end
-
-            def save_record(record, attributes, dialog)
-              if record.update(attributes)
-                close_dialog(dialog)
-                render_index
-                show_snackbar("\#{singular_title} saved")
-              else
-                show_errors(record)
-              end
-            end
-
-            def destroy_record(record, dialog)
-              record.destroy!
-              close_dialog(dialog)
-              render_index
-              show_snackbar("\#{singular_title} deleted")
-            rescue StandardError => e
-              show_snackbar(e.message)
-            end
-
-            def resource_fields
-              #{resource_fields}
-            end
-
-            def display_fields
-              #{display_fields}
-            end
-
-            def display_value(record, field)
-              case field
-              __DISPLAY_VALUE_CASES__
-              else
-                record.public_send(field).to_s
-              end
-            end
-
-            def primary_label(record)
-              field = display_fields.first
-              field ? display_value(record, field) : "##\#{record_id(record)}"
-            end
-
-            def secondary_label(record)
-              field = display_fields[1]
-              field ? display_value(record, field) : nil
-            end
+      # A `case` with no `when` clause is a syntax error, so models without
+      # date/time attributes get the plain fallback body instead.
+      def scaffold_display_value_body(display_value_cases, indent)
+        return "#{indent}record.public_send(field).to_s" if display_value_cases.to_s.strip.empty?
 
+        reindented_cases = display_value_cases.gsub(/^    /, indent)
+        <<~RUBY.chomp.gsub(/^/, indent).gsub(/^#{Regexp.escape(indent)}__CASES__$/, reindented_cases)
+          case field
+          __CASES__
+          else
+            record.public_send(field).to_s
           end
         RUBY
-        template.gsub(/^[ \t]*__DISPLAY_VALUE_CASES__$/, display_value_cases)
       end
 
       def scaffold_component_template(model_name:, attributes: [])
@@ -253,6 +149,15 @@ module Ruflet
           require "date"
           require "ruflet_rails"
 
+          # The model (#{model_class}) is inferred from the class name and the route
+          # ("/#{names[:plural]}") is declared in config/routes.rb. This file is YOURS:
+          # the whole CRUD UI (index table, detail screen, create/edit form) and the
+          # database calls (#{model_class}#update, #destroy!, .new) are explicit below
+          # so you can change the UI or logic however you like. The base class only
+          # provides reusable helpers: record loading, field inference, dialog
+          # open/close, the date/time picker value helpers, and refresh.
+          #
+          # The same component renders on web and on mobile/desktop.
           class #{component_class} < Ruflet::Rails::ResourceComponent
             def render
               safe_area(
@@ -401,6 +306,7 @@ module Ruflet
                   width: dialog_width,
                   content: column(
                     spacing: 8,
+                    horizontal_alignment: "stretch",
                     children: [
                       #{control_list}
                     ]
@@ -409,7 +315,14 @@ module Ruflet
                 actions: [
                   text_button(content: text("Cancel"), on_click: ->(_event) { close_dialog(dialog) }),
                   filled_button(content: text("Save"), on_click: ->(_event) {
-                    save_record(record, attributes.call, dialog)
+                    # Persist with the model (this is your code — change it freely).
+                    if record.update(attributes.call)
+                      close_dialog(dialog)
+                      refresh
+                      show_snackbar("\#{singular_title} saved")
+                    else
+                      show_errors(record)
+                    end
                   })
                 ],
                 actions_alignment: "end"
@@ -426,7 +339,13 @@ module Ruflet
                 content: text("Permanently remove \#{singular_title} #\#{record_id(record)}?", no_wrap: false),
                 actions: [
                   text_button(content: text("Cancel"), on_click: ->(_event) { close_dialog(dialog) }),
-                  filled_button(content: text("Delete"), on_click: ->(_event) { destroy_record(record, dialog) })
+                  filled_button(content: text("Delete"), on_click: ->(_event) {
+                    # Destroy with the model (this is your code — change it freely).
+                    record.destroy!
+                    close_dialog(dialog)
+                    refresh
+                    show_snackbar("\#{singular_title} deleted")
+                  })
                 ],
                 actions_alignment: "end"
               )
@@ -512,7 +431,7 @@ module Ruflet
                   help_text: #{label.inspect},
                   on_change: ->(_event) do
                     close_dialogs(#{control})
-                    page.update(#{display_control}, value: date_display_value(#{control}.props["value"]))
+                    page.update(#{display_control}, value: date_display_value(#{control}.value))
                   end
                 )
                 #{control}_field = column(
@@ -539,7 +458,7 @@ module Ruflet
                   help_text: #{label.inspect},
                   on_change: ->(_event) do
                     close_dialogs(#{control})
-                    page.update(#{display_control}, value: time_display_value(#{control}.props["value"]))
+                    page.update(#{display_control}, value: time_display_value(#{control}.value))
                   end
                 )
                 #{control}_field = column(
@@ -569,7 +488,7 @@ module Ruflet
                     close_dialogs(#{control})
                     page.update(
                       #{display_control},
-                      value: date_range_display_value(#{control}.props["start_value"], #{control}.props["end_value"])
+                      value: date_range_display_value(#{control}.start_value, #{control}.end_value)
                     )
                   end
                 )
@@ -603,13 +522,13 @@ module Ruflet
         value =
           case type
           when "boolean"
-            "!!#{control}.props[\"value\"]"
+            "!!#{control}.value"
           when "date"
-            "#{control}.props[\"value\"].to_s.split(\"T\", 2).first"
+            "#{control}.value.to_s.split(\"T\", 2).first"
           when "date_range", "daterange"
-            "Range.new(Date.parse(#{control}.props[\"start_value\"].to_s), Date.parse(#{control}.props[\"end_value\"].to_s))"
+            "Range.new(Date.parse(#{control}.start_value.to_s), Date.parse(#{control}.end_value.to_s))"
           else
-            "#{control}.props[\"value\"].to_s"
+            "#{control}.value.to_s"
           end
 
         "#{name.inspect} => #{value}"
@@ -648,7 +567,7 @@ module Ruflet
                   spacing: 12,
                   children: [
                     text(title, size: 24, weight: "bold"),
-                    column(spacing: 8, children: ruflet_form_controls(fields)),
+                    column(spacing: 8, horizontal_alignment: "stretch", children: ruflet_form_controls(fields)),
                     row(
                       spacing: 8,
                       children: [
@@ -827,12 +746,12 @@ module Ruflet
         value
       end
 
-      def build_args_for_platform(platform)
+      def build_args_for_platform(platform, ruflet_url: nil)
         normalized = normalize_build_platform(platform)
         return [] if normalized.to_s.empty?
 
         args = [normalized]
-        args += ["--base-href", web_base_href] if normalized == "web"
+        args += ["--dart-define", "RUFLET_URL=#{ruflet_url}"] if normalized == "web" && ruflet_url.to_s.strip != ""
         args
       end
 
@@ -840,132 +759,57 @@ module Ruflet
         File.join("app", "views", "ruflet", "main.rb")
       end
 
-      def route_snippet(entrypoint: default_entrypoint_path, mount_path: "/ws", helper: "app")
-        %(match "#{mount_path}", to: Ruflet::Rails.#{helper}(Rails.root.join("#{entrypoint}")), via: :all)
-      end
-
-      def default_web_public_path
-        "app"
-      end
-
-      def web_base_href(public_path = default_web_public_path)
-        normalized = public_path.to_s.strip.gsub(%r{\A/+|/+\z}, "")
-        normalized.empty? ? "/" : "/#{normalized}/"
-      end
-
-      def publish_web_build(root, public_path: default_web_public_path)
-        publish_web_client(root, source: File.join(root, "build", "web"), public_path: public_path)
-      end
-
-      def publish_prebuilt_web_client(root, platform: host_desktop_platform, public_path: default_web_public_path)
-        source = prebuilt_web_client_path(platform: platform)
-        return false unless source
-
-        publish_web_client(root, source: source, public_path: public_path)
-      end
-
-      def prebuilt_web_client_path(platform: host_desktop_platform)
-        return nil if platform.to_s.empty?
-
-        source = File.join(prebuilt_client_cache_root(platform: platform), "web")
-        return nil unless Dir.exist?(source)
-        return nil unless File.file?(File.join(source, "index.html"))
-
-        source
-      end
+      def initializer_template(entrypoint: default_entrypoint_path, ws_path: "/ws")
+        <<~RUBY
+          # frozen_string_literal: true
 
-      def prebuilt_client_cache_root(platform: host_desktop_platform)
-        require "ruflet/cli"
+          Ruflet::Rails.configure do |config|
+            # Ruflet app entry-point. Auto-mounts a WebSocket endpoint at ws_path —
+            # no explicit route needed in config/routes.rb.
+            config.app_file = Rails.root.join(#{entrypoint.inspect})
+
+            # URL path the WebSocket endpoint listens on (default: "/ws").
+            config.ws_path = #{ws_path.inspect}
+
+            # Base URL the Flutter client uses to reach this Rails app. Always
+            # required: it backs asset URLs (Ruflet::Rails.asset_url), the
+            # build-time RUFLET_URL define, and the desktop launcher. At runtime
+            # it can fall back to the connecting host, but a build has no request,
+            # so set it here. Point it at a LAN IP (not localhost) to test on a
+            # real device.
+            config.backend_url = ENV.fetch("RUFLET_BACKEND_URL") do
+              Rails.env.production? ? "https://example.com" : "http://localhost:3000"
+            end
 
-        if Ruflet::CLI.respond_to?(:client_cache_root_for, true)
-          Ruflet::CLI.send(:client_cache_root_for, platform)
-        else
-          File.join(Dir.home, ".ruflet", "client", Ruflet::VERSION, platform.to_s)
-        end
+            # Directory the Flutter web build is served from. Defaults to
+            # Rails.root/build/web (where `rake ruflet:build[web]` outputs).
+            # Must stay OUTSIDE public/, or Rails would serve it statically and
+            # expose the app at a path no route declares.
+            # config.web_build_dir = Rails.root.join("build", "web")
+          end
+        RUBY
       end
 
-      def publish_web_client(root, source:, public_path: default_web_public_path)
-        return false unless Dir.exist?(source)
-        return false unless File.file?(File.join(source, "index.html"))
-
-        target = File.join(root, "public", public_path.to_s.gsub(%r{\A/+|/+\z}, ""))
-        FileUtils.rm_rf(target)
-        FileUtils.mkdir_p(File.dirname(target))
-        FileUtils.cp_r(source, target)
-        rewrite_web_base_href(target, public_path: public_path)
-        inject_web_client_bootstrap(target)
-        true
+      def initializer_path
+        File.join("config", "initializers", "ruflet.rb")
       end
 
-      def rewrite_web_base_href(target, public_path:)
-        index_path = File.join(target, "index.html")
-        return unless File.file?(index_path)
-
-        content = File.read(index_path)
-        base_href = web_base_href(public_path)
-        updated =
-          if content.match?(%r{<base\s+href=["'][^"']*["']\s*/?>}i)
-            content.sub(%r{<base\s+href=["'][^"']*["']\s*/?>}i, %(<base href="#{base_href}">))
-          else
-            content.sub(%r{<head([^>]*)>}i, %(<head\\1>\n  <base href="#{base_href}">))
-          end
-        File.write(index_path, updated)
-      end
-
-      def inject_web_client_bootstrap(target)
-        index_path = File.join(target, "index.html")
-        return unless File.file?(index_path)
-
-        content = File.read(index_path)
-        return if content.include?('id="ruflet-rails-bootstrap"')
-
-        script = <<~HTML
-          <script id="ruflet-rails-bootstrap">
-            if (window.location.search === "" && window.location.hash === "") {
-              const rufletServerUrl = window.location.origin + "/";
-              window.history.replaceState(
-                null,
-                document.title,
-                window.location.pathname + "?url=" + encodeURIComponent(rufletServerUrl)
-              );
-            }
-          </script>
-        HTML
-
-        updated =
-          if content.include?('<script src="flutter_bootstrap.js"')
-            content.sub(%r{<script src="flutter_bootstrap\.js"[^>]*></script>}i) { |match| "#{script}  #{match}" }
-          else
-            content.sub(%r{</body>}i, "#{script}</body>")
-          end
-        File.write(index_path, updated)
+      # Kept for backward compatibility with apps that use manual mount.
+      def route_snippet(entrypoint: default_entrypoint_path, mount_path: "/ws", helper: "app")
+        %(match "#{mount_path}", to: Ruflet::Rails.#{helper}(Rails.root.join("#{entrypoint}")), via: :all)
       end
 
-      def install_next_steps(target:, entrypoint:, client:, web_published:, mount_path: "/ws")
-        web_path = default_web_public_path
+      def install_next_steps(target:, entrypoint:, client:, mount_path: "/ws")
         lines = [
           "Ruflet Rails installed.",
           "Generated entrypoint: #{entrypoint}",
           "Mounted websocket: #{mount_path}",
           "Next steps:",
           "  1. Start Rails: bin/rails server",
-          "  2. Open the Ruflet web client: /#{web_path}/"
+          "  2. Connect your Ruflet app to ws://localhost:3000#{mount_path}"
         ]
 
-        if web_published
-          lines << "Web client copied to public/#{web_path}."
-        elsif target.to_s == "ruflet" || %w[web all].include?(client.to_s)
-          lines += [
-            "Web client was not copied because no built/prebuilt web index.html was found.",
-            "To download the prebuilt client from GitHub: bin/rails ruflet:update[web]",
-            "To build the WASM web client yourself, install the ruflet CLI globally first:",
-            "  gem install ruflet",
-            "Then build and copy build/web into public/#{web_path}:",
-            "  bin/rails ruflet:build[web]"
-          ]
-        end
-
-        if %w[desktop all].include?(client.to_s)
+        if client.to_s == "desktop"
           lines += [
             "Desktop clients are server-driven and connect to this Rails app.",
             "Plain bin/dev, bin/rails server, and bin/rails s do not launch desktop.",

data/lib/ruflet/rails/native_app.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Ruflet
+  module Rails
+    # Hotwire Native-style driver for ruflet_rails.
+    #
+    # Your existing web app is the body, rendered in a WebView. Navigation works
+    # out of the box: a tiny JS bridge injected into each page intercepts link
+    # clicks and proposes them to native, so every visit becomes a NATIVE screen
+    # pushed onto the stack (with an automatic back button) — no per-link code.
+    # The native AppBar title tracks each page's <title>, and you declare special
+    # paths as data.
+    #
+    #   Ruflet.run do |page|
+    #     Ruflet::Rails.native_app(
+    #       page,
+    #       start_url: "https://myapp.com",
+    #       title: "My App",                              # auto-updates from <title>
+    #       actions: -> { [icon_button("search", on_click: ->(_e) { ... })] },
+    #       navigation_bar: navigation_bar(destinations: [...]),
+    #
+    #       # web content shown in a bottom sheet (auth, quick forms):
+    #       modal: ["/sign_in", "/sign_up", %r{/new\z}],
+    #
+    #       # optional: override a path with a fully native screen:
+    #       native: { %r{\A/products/(\d+)\z} => ->(ctx) { product_screen(ctx.match[1]) } }
+    #     )
+    #   end
+    #
+    # Normal links just push a native webview screen (back returns). Paths listed
+    # in `modal:` open as a bottom sheet. Paths in `native:` render your own UI.
+    #
+    # The bridge talks to native over the webview's console channel
+    # (on_console_message), which works on iOS/Android/macOS. On platforms
+    # without a native webview the body degrades to a plain frame.
+    class NativeApp
+      # Injected into every page: report the title, and turn same-origin link
+      # clicks into native visit proposals (so they don't load in place).
+      BRIDGE_JS = <<~JS
+        (function () {
+          function report(kind, value) { console.log("ruflet:" + kind + ":" + value); }
+          report("title", document.title || "");
+          if (window.__rufletBridgeBound) return;
+          window.__rufletBridgeBound = true;
+          document.addEventListener("click", function (e) {
+            var a = e.target && e.target.closest ? e.target.closest("a[href]") : null;
+            if (!a || a.target === "_blank") return;
+            if (a.origin && a.origin !== location.origin) return; // external: leave it
+            e.preventDefault();
+            report("visit", a.href);
+          }, true);
+        })();
+      JS
+
+      VISIT_PREFIX = "ruflet:visit:"
+      TITLE_PREFIX = "ruflet:title:"
+
+      Screen  = Struct.new(:kind, :url, :view, :webview, :title_text, keyword_init: true)
+      Context = Struct.new(:url, :path, :match, keyword_init: true)
+
+      def initialize(page, start_url:, title: nil, actions: nil, navigation_bar: nil,
+                     bottom_appbar: nil, modal: [], native: {})
+        @page = page
+        @start_url = start_url.to_s
+        @title = title.to_s
+        @actions = actions
+        @navigation_bar = navigation_bar
+        @bottom_appbar = bottom_appbar
+        @modal_patterns = Array(modal).map { |p| compile_pattern(p) }
+        @native_rules = native.map { |pattern, builder| [compile_pattern(pattern), builder] }
+        @screens = []
+        @modal_sheet = nil
+      end
+
+      def self.bridge_js = BRIDGE_JS
+
+      def start
+        @page.on_view_pop = ->(_event) { pop }
+        push_webview(@start_url, root: true)
+        self
+      end
+
+      private
+
+      # --- Stack operations ---------------------------------------------------
+
+      def push_webview(url, root: false)
+        screen = Screen.new(kind: :webview, url: url.to_s)
+        screen.title_text = Ruflet::UI::ControlFactory.build(:text, value: @title)
+        screen.webview = build_webview(screen)
+        screen.view = build_view(screen, root: root)
+        @screens.push(screen)
+        flush
+        screen
+      end
+
+      def push_native(builder, ctx)
+        view = builder.call(ctx)
+        return unless view.is_a?(Ruflet::Control)
+
+        @screens.push(Screen.new(kind: :native, url: ctx.url, view: view))
+        flush
+      end
+
+      def pop
+        return if @screens.size <= 1
+
+        @screens.pop
+        flush
+      end
+
+      def flush
+        @page.views = @screens.map(&:view)
+        @page.update
+      end
+
+      # --- Webview screen + native chrome ------------------------------------
+
+      def build_webview(screen)
+        Ruflet::UI::ControlFactory.build(
+          :webview,
+          url: screen.url,
+          expand: true,
+          on_page_ended: ->(_event) { inject_bridge(screen) },
+          on_console_message: ->(event) { handle_message(screen, message_of(event)) }
+        )
+      end
+
+      def build_view(screen, root:)
+        args = { route: root ? "/" : "/screen", controls: [screen.webview], appbar: build_appbar(screen) }
+        if root
+          args[:navigation_bar] = @navigation_bar unless @navigation_bar.nil?
+          args[:bottom_appbar] = @bottom_appbar unless @bottom_appbar.nil?
+        end
+        Ruflet::UI::ControlFactory.build(:view, **args)
+      end
+
+      def build_appbar(screen)
+        args = { title: screen.title_text }
+        actions = resolve_actions
+        args[:actions] = actions if actions
+        Ruflet::UI::ControlFactory.build(:appbar, **args)
+      end
+
+      def resolve_actions
+        @actions.respond_to?(:call) ? @actions.call : @actions
+      end
+
+      # --- Bridge ------------------------------------------------------------
+
+      def inject_bridge(screen)
+        screen.webview.run_javascript(BRIDGE_JS) if screen.webview.respond_to?(:run_javascript)
+      rescue StandardError
+        nil
+      end
+
+      def handle_message(screen, message)
+        return if message.nil?
+
+        if message.start_with?(TITLE_PREFIX)
+          update_title(screen, message[TITLE_PREFIX.length..])
+        elsif message.start_with?(VISIT_PREFIX)
+          visit(message[VISIT_PREFIX.length..])
+        end
+      end
+
+      def update_title(screen, value)
+        return unless screen.title_text&.wire_id
+
+        @page.update(screen.title_text, value: value.to_s)
+      end
+
+      # A proposed visit: native screen > modal sheet > push a webview screen.
+      def visit(url)
+        path = path_of(url)
+        return if path.nil?
+
+        builder, match = match_native(path)
+        if builder
+          push_native(builder, Context.new(url: url, path: path, match: match))
+        elsif modal?(path)
+          present_modal(url)
+        else
+          push_webview(url)
+        end
+      end
+
+      # --- Modal (bottom sheet of web content) -------------------------------
+
+      def present_modal(url)
+        sheet_webview = Ruflet::UI::ControlFactory.build(:webview, url: url.to_s, expand: true)
+        @modal_sheet = Ruflet::UI::ControlFactory.build(
+          :bottomsheet,
+          open: true,
+          dismissible: true,
+          content: Ruflet::UI::ControlFactory.build(:container, height: 520, content: sheet_webview),
+          on_dismiss: ->(_event) { @modal_sheet = nil }
+        )
+        @page.bottom_sheet = @modal_sheet
+        @page.update
+      end
+
+      # --- Matching ----------------------------------------------------------
+
+      def match_native(path)
+        @native_rules.each do |pattern, builder|
+          if pattern.is_a?(Regexp)
+            m = pattern.match(path)
+            return [builder, m] if m
+          elsif pattern == path
+            return [builder, nil]
+          end
+        end
+        nil
+      end
+
+      def modal?(path)
+        @modal_patterns.any? do |pattern|
+          pattern.is_a?(Regexp) ? pattern.match?(path) : pattern == path
+        end
+      end
+
+      def compile_pattern(pattern)
+        return pattern if pattern.is_a?(Regexp)
+
+        value = pattern.to_s
+        value.start_with?("/") ? value : "/#{value}"
+      end
+
+      def path_of(url)
+        URI.parse(url.to_s).path
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def message_of(event)
+        data = event.respond_to?(:data) ? event.data : event
+        return data["message"] || data[:message] if data.is_a?(Hash)
+
+        data
+      end
+    end
+
+    module_function
+
+    # Start a Hotwire Native-style app. See NativeApp.
+    def native_app(page, **opts)
+      NativeApp.new(page, **opts).start
+    end
+  end
+end