ruflet_rails 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ffd81f0143fcba01b93a6d0f773d1d0e4aa983a01c4bf282ed383a631273b13
-  data.tar.gz: 8840d1be44c36b8d82789f9a9d8055bd2ab0f8e893bafe1fc2ab6f8f082f90d0
+  metadata.gz: ebf6ba0607ab65bf23420e9d03d39283aac94ad1ffd92bcd6e96c21fa7d79c9a
+  data.tar.gz: 74bba5b6bbf7976457a49556f5ee3c81c42f7afe30ede8979e5cf6f3f4e77354
 SHA512:
-  metadata.gz: 456e8aaf3966f272a7b5b0945163a8f96955c240577fb5a1f4f5023ec635260eb531872505e03d552199f6d52c5a68839cbb3a2a4115d82d25f3e1c0bcf95765
-  data.tar.gz: a63099e903e698ceb130f8b678deaa8a2cb238335266615704fdac47b41f1775fc8e1d677789bab3c6a3961034173d323719325ac159d1b679b4dfd772636a03
+  metadata.gz: d1027674f71e87d89e24e2ca90bb9906fe60a67b7f23d93b30e90e053e7a710439fe8d22774976f9c83cdbf83ca82b28aa6610eeec6178d413430fa105ced16c
+  data.tar.gz: e55b5f9c8a3549fb37833f5cc88d9950cf35428a2bd688884205b6c83a1ff7d68c627a25469a5893d0b81dd445d5c697fe66b80dcac91c57ae129748da9f1e6b

data/lib/generators/ruflet/install/install_generator.rb

@@ -25,15 +25,11 @@ module Ruflet
         create_file target, Ruflet::Rails::InstallSupport.default_ruflet_yaml(app_name: app_name)
       end
 
-      def add_routes
-        target = File.join(destination_root, "config/routes.rb")
-        return unless File.file?(target)
-
-        route = Ruflet::Rails::InstallSupport.route_snippet(entrypoint: entrypoint_path)
-        source = File.read(target)
-        return if source.include?(route)
+      def create_ruflet_initializer
+        target = File.join(destination_root, Ruflet::Rails::InstallSupport.initializer_path)
+        return if File.exist?(target)
 
-        insert_into_file target, "  #{route}\n", after: /Rails\.application\.routes\.draw do\s*\n/
+        create_file target, Ruflet::Rails::InstallSupport.initializer_template(entrypoint: entrypoint_path)
       end
 
       def add_desktop_flag_to_binstubs

data/lib/generators/ruflet/scaffold/scaffold_generator.rb

@@ -10,17 +10,7 @@ module Ruflet
       argument :model_name, type: :string
       argument :attributes, type: :array, default: [], banner: "field:type field:type"
 
-      desc "Generate a Rails-first Ruflet resource view for an existing model."
-
-      def create_ruflet_resource_view
-        create_file(
-          File.join(destination_root, scaffold_view_path),
-          Ruflet::Rails::InstallSupport.scaffold_view_template(
-            model_name: model_name,
-            attributes: scaffold_attributes
-          )
-        )
-      end
+      desc "Generate a Rails-first Ruflet resource component for an existing model."
 
       def create_ruflet_resource_component
         create_file(
@@ -33,15 +23,19 @@ module Ruflet
       end
 
       def print_scaffold_status
-        say "Ruflet scaffold generated at #{scaffold_view_path}"
-        say "Ruflet UI component generated at #{scaffold_component_path}"
-        say "The generated view owns the resource logic; the generated component owns the UI."
+        say "Ruflet resource component generated at #{scaffold_component_path}"
+        say "Mount it in config/routes.rb:"
+        say "  mount Ruflet::Rails.web_app(view: #{scaffold_component_class.inspect}), at: \"/#{scaffold_route_segment}\""
       end
 
       private
 
-      def scaffold_view_path
-        Ruflet::Rails::InstallSupport.scaffold_view_path(model_name)
+      def scaffold_component_class
+        "#{model_name.to_s.camelize}Component"
+      end
+
+      def scaffold_route_segment
+        model_name.to_s.underscore.pluralize
       end
 
       def scaffold_component_path

data/lib/ruflet/rails/assets.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    # Resolve Rails assets to absolute URLs the Flutter client can load over
+    # HTTP, so server-driven UI can show app images:
+    #
+    #   image(src: Ruflet::Rails.asset_url("logo.png"))
+    #   image(src: Ruflet::Rails.image_url("brand/header.png"), fit: "cover")
+    #
+    # The *path* comes from the Rails asset pipeline — digested in production
+    # (/assets/logo-<digest>.png), plain otherwise — so it survives
+    # fingerprinting and CDNs. The *host* is resolved, in order, from:
+    #
+    #   1. an explicit `host:` argument
+    #   2. Ruflet::Rails.config.backend_url
+    #   3. the host the client connected on (the live WebSocket request)
+    #
+    # The client is a separate device (simulator, phone, browser), so a bare
+    # "/assets/..." path would not resolve — the URL must be absolute. If Rails
+    # already has an asset_host/CDN configured, the pipeline returns an absolute
+    # URL and it is used unchanged. A value that is already a full URL passes
+    # through untouched.
+    module_function
+
+    # The base URL the Flutter client uses to reach this Rails app — the single
+    # source of truth for asset URLs, the build-time RUFLET_URL define and the
+    # desktop launcher. A Rails Ruflet app always needs one, so this always
+    # resolves to a usable value:
+    #
+    #   1. an explicit host: argument
+    #   2. Ruflet::Rails.config.backend_url (set it in config/initializers/ruflet.rb)
+    #   3. the host the client connected on (the live WebSocket request)
+    #
+    # Returns "" only when none of those are available (e.g. a build with no
+    # configured backend_url) — set config.backend_url to cover that case.
+    def backend_url(host: nil)
+      candidate = host || config.backend_url
+      candidate = request_base_url if candidate.to_s.strip.empty?
+      candidate.to_s.strip.sub(%r{/+\z}, "")
+    end
+
+    def asset_url(source, host: nil)
+      raw = source.to_s
+      return raw if absolute_url?(raw)
+
+      path = asset_pipeline_path(raw)
+      return path if absolute_url?(path)
+
+      base = backend_url(host: host)
+      base.empty? ? path : "#{base}#{path}"
+    end
+
+    # Readability alias for image sources — identical resolution.
+    def image_url(source, host: nil)
+      asset_url(source, host: host)
+    end
+
+    def asset_pipeline_path(source)
+      ::ActionController::Base.helpers.asset_path(source)
+    rescue StandardError
+      source.start_with?("/") ? source : "/#{source}"
+    end
+    private_class_method :asset_pipeline_path
+
+    # Derive scheme://host from the live WebSocket request env so the URL points
+    # back at the exact host the client reached — the one address guaranteed to
+    # be reachable from that device.
+    def request_base_url
+      env = Protocol::Context.current_env
+      return nil unless env
+
+      host = env["HTTP_X_FORWARDED_HOST"] || env["HTTP_HOST"]
+      return nil if host.to_s.strip.empty?
+
+      scheme = (env["HTTP_X_FORWARDED_PROTO"] || env["rack.url_scheme"] || "http").to_s.split(",").first.to_s.strip
+      scheme = "http" if scheme.empty?
+      "#{scheme}://#{host}"
+    end
+    private_class_method :request_base_url
+
+    def absolute_url?(value)
+      !(value.to_s =~ %r{\A[a-z][a-z0-9+.-]*://}i).nil?
+    end
+    private_class_method :absolute_url?
+  end
+end

data/lib/ruflet/rails/configuration.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    # Central configuration for ruflet_rails.
+    #
+    # Mirrors the full ruflet.yaml schema so a Rails app needs only
+    # config/initializers/ruflet.rb — no ruflet.yaml on disk.
+    #
+    # Set in config/initializers/ruflet.rb:
+    #
+    #   Ruflet::Rails.configure do |config|
+    #     # Runtime / server
+    #     config.app_file    = Rails.root.join("app/views/ruflet/main.rb")
+    #     config.ws_path     = "/ws"
+    #     config.backend_url = Rails.env.production? ? "https://example.com" : "http://localhost:3000"
+    #
+    #     # Flutter web build output directory
+    #     config.web_build_dir = Rails.root.join("public/app")
+    #
+    #     # App metadata (ruflet.yaml → app:)
+    #     config.app_name = "My App"
+    #
+    #     # Services (ruflet.yaml → services:)
+    #     config.services = []
+    #
+    #     # Assets (ruflet.yaml → assets:)
+    #     config.splash_screen = Rails.root.join("app/assets/images/splash.png")
+    #     config.splash_dark   = Rails.root.join("app/assets/images/splash_dark.png")
+    #     config.icon_launcher = Rails.root.join("app/assets/images/icon.png")
+    #     config.icon_android  = Rails.root.join("app/assets/images/icon_android.png")
+    #     config.icon_ios      = Rails.root.join("app/assets/images/icon_ios.png")
+    #     config.icon_web      = Rails.root.join("app/assets/images/icon_web.png")
+    #     config.icon_windows  = Rails.root.join("app/assets/images/icon_windows.png")
+    #     config.icon_macos    = Rails.root.join("app/assets/images/icon_macos.png")
+    #
+    #     # Build options (ruflet.yaml → build:)
+    #     config.splash_color      = "#FFFFFF"
+    #     config.splash_dark_color = "#000000"
+    #     config.icon_background   = "#FFFFFF"
+    #     config.theme_color       = "#FFFFFF"
+    #   end
+    class Configuration
+      # --- Runtime / server ---
+
+      # Absolute path to the Ruflet app entry-point.
+      attr_accessor :app_file
+
+      # URL path the WebSocket endpoint listens on. Defaults to "/ws".
+      attr_accessor :ws_path
+
+      # Backend base URL. Used as --dart-define=RUFLET_URL at build time
+      # and by the desktop launcher. Replaces ruflet.yaml → app.backend_url.
+      attr_accessor :backend_url
+
+      # Absolute directory containing the Flutter web build (index.html + assets).
+      attr_accessor :web_build_dir
+
+      # --- App metadata (ruflet.yaml → app:) ---
+
+      attr_accessor :app_name
+
+      # --- Services (ruflet.yaml → services:) ---
+
+      attr_accessor :services
+
+      # --- Assets (ruflet.yaml → assets:) ---
+
+      attr_accessor :splash_screen
+      attr_accessor :splash_dark
+      attr_accessor :icon_launcher
+      attr_accessor :icon_android
+      attr_accessor :icon_ios
+      attr_accessor :icon_web
+      attr_accessor :icon_windows
+      attr_accessor :icon_macos
+
+      # --- Build options (ruflet.yaml → build:) ---
+
+      attr_accessor :splash_color
+      attr_accessor :splash_dark_color
+      attr_accessor :icon_background
+      attr_accessor :theme_color
+
+      def initialize
+        @ws_path      = "/ws"
+        @app_file     = nil
+        @backend_url  = nil
+        @web_build_dir = nil
+        @app_name     = nil
+        @services     = []
+      end
+
+      # Serialises config to the ruflet.yaml hash structure so the CLI can
+      # consume it without a yaml file on disk (written to a temp file by
+      # the Railtie's build task).
+      def to_ruflet_yaml_hash
+        hash = {}
+
+        app = {}
+        app["name"]        = @app_name    if @app_name
+        app["backend_url"] = @backend_url if @backend_url
+        hash["app"] = app unless app.empty?
+
+        hash["services"] = Array(@services)
+
+        assets = {}
+        assets["splash_screen"] = @splash_screen.to_s if @splash_screen
+        assets["splash_dark"]   = @splash_dark.to_s   if @splash_dark
+        assets["icon_launcher"] = @icon_launcher.to_s  if @icon_launcher
+        assets["icon_android"]  = @icon_android.to_s   if @icon_android
+        assets["icon_ios"]      = @icon_ios.to_s        if @icon_ios
+        assets["icon_web"]      = @icon_web.to_s        if @icon_web
+        assets["icon_windows"]  = @icon_windows.to_s    if @icon_windows
+        assets["icon_macos"]    = @icon_macos.to_s      if @icon_macos
+        hash["assets"] = assets unless assets.empty?
+
+        build = {}
+        build["splash_color"]      = @splash_color      if @splash_color
+        build["splash_dark_color"] = @splash_dark_color if @splash_dark_color
+        build["icon_background"]   = @icon_background   if @icon_background
+        build["theme_color"]       = @theme_color       if @theme_color
+        hash["build"] = build unless build.empty?
+
+        hash
+      end
+    end
+  end
+end

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,17 +746,55 @@ 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?
 
-        [normalized]
+        args = [normalized]
+        args += ["--dart-define", "RUFLET_URL=#{ruflet_url}"] if normalized == "web" && ruflet_url.to_s.strip != ""
+        args
       end
 
       def default_entrypoint_path
         File.join("app", "views", "ruflet", "main.rb")
       end
 
+      def initializer_template(entrypoint: default_entrypoint_path, ws_path: "/ws")
+        <<~RUBY
+          # frozen_string_literal: true
+
+          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
+
+            # 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 initializer_path
+        File.join("config", "initializers", "ruflet.rb")
+      end
+
+      # 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