ruflet_rails 0.0.9 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 314ea2aafb0153d3d6f5d4b0b37d3f24761b9cf1d54e1b0af4f82cfd54034c3b
-  data.tar.gz: 593cbbfbf58d8cdd12fa0c01e2d5033b6f66a26f28298a0682a241a4bc407645
+  metadata.gz: ebf6ba0607ab65bf23420e9d03d39283aac94ad1ffd92bcd6e96c21fa7d79c9a
+  data.tar.gz: 74bba5b6bbf7976457a49556f5ee3c81c42f7afe30ede8979e5cf6f3f4e77354
 SHA512:
-  metadata.gz: 8757f1cbd09bee0c205f638714777e2a96626a9836af535d6ff9a9b4734e0968b0943ee24109016058ff3801635c56801db2dbd5fd7a348c00cdddbadd0b12c3
-  data.tar.gz: f5c74694f0073a7e69e1608767ccbbf6920795bead5c43549fe99d5ecf349d9c9eb53615fc026f73ea7fde5384c516e4cb51df758550911ed2a17279160a0a93
+  metadata.gz: d1027674f71e87d89e24e2ca90bb9906fe60a67b7f23d93b30e90e053e7a710439fe8d22774976f9c83cdbf83ca82b28aa6610eeec6178d413430fa105ced16c
+  data.tar.gz: e55b5f9c8a3549fb37833f5cc88d9950cf35428a2bd688884205b6c83a1ff7d68c627a25469a5893d0b81dd445d5c697fe66b80dcac91c57ae129748da9f1e6b

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

@@ -6,10 +6,8 @@ require "ruflet/rails/install_support"
 module Ruflet
   module Generators
     class InstallGenerator < ::Rails::Generators::Base
-      class_option :frontend, type: :boolean, default: false, desc: "Install the Rails-hosted Ruflet web client"
-      class_option :web, type: :boolean, default: false, desc: "Install the Rails-hosted Ruflet web client"
       class_option :desktop, type: :boolean, default: false, desc: "Download the server-driven desktop Ruflet client"
-      class_option :client, type: :string, default: nil, desc: "Download prebuilt client from GitHub releases: web, desktop, all, or none"
+      class_option :client, type: :string, default: nil, desc: "Download prebuilt client from GitHub releases: desktop or none"
 
       desc "Install Ruflet into a Rails app."
 
@@ -27,14 +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)
-        return if File.read(target).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
@@ -46,17 +41,8 @@ module Ruflet
 
       def download_prebuilt_client
         client = requested_client
-        @web_client_published = false
         return if client == "none"
 
-        if %w[web all].include?(client)
-          @web_client_published = Ruflet::Rails::InstallSupport.publish_web_build(destination_root)
-          if @web_client_published
-            say "Ruflet web build copied from build/web to public/#{Ruflet::Rails::InstallSupport.default_web_public_path}"
-            return if client == "web"
-          end
-        end
-
         require "ruflet/cli"
         exit_code = Dir.chdir(destination_root) do
           Ruflet::CLI.command_update([client])
@@ -64,17 +50,6 @@ module Ruflet
         unless exit_code.to_i.zero?
           @client_download_failed = true
           say_status(:warn, "Ruflet client download failed; install files were generated and build/update steps are printed below", :yellow)
-          return
-        end
-
-        return unless %w[web all].include?(client)
-
-        published = Ruflet::Rails::InstallSupport.publish_prebuilt_web_client(destination_root)
-        @web_client_published = published
-        if published
-          say "Ruflet web client published at /#{Ruflet::Rails::InstallSupport.default_web_public_path}/"
-        else
-          say_status(:warn, "Ruflet web client downloaded, but no prebuilt web index.html was found to publish", :yellow)
         end
       rescue StandardError => e
         @client_download_failed = true
@@ -85,8 +60,7 @@ module Ruflet
         Ruflet::Rails::InstallSupport.install_next_steps(
           target: install_target,
           entrypoint: entrypoint_path,
-          client: requested_client,
-          web_published: !!@web_client_published
+          client: requested_client
         ).each { |line| say line }
       end
 
@@ -103,22 +77,18 @@ module Ruflet
       def requested_client
         explicit = options[:client].to_s.strip.downcase
         unless explicit.empty?
-          raise Thor::Error, "--client must be web, desktop, all, or none" unless %w[web desktop all none].include?(explicit)
+          raise Thor::Error, "--client must be desktop or none" unless %w[desktop none].include?(explicit)
 
           return explicit
         end
 
-        wants_web = options[:frontend] || options[:web]
-        wants_desktop = options[:desktop]
-        return "all" if wants_web && wants_desktop
-        return "web" if wants_web
-        return "desktop" if wants_desktop
+        return "desktop" if options[:desktop]
 
         "none"
       end
 
       def desktop_requested?
-        %w[desktop all].include?(requested_client)
+        requested_client == "desktop"
       end
 
       def install_target

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