ruflet_rails 0.0.11 → 0.0.13

data/lib/ruflet/rails.rb

@@ -14,26 +14,12 @@ module Ruflet
     # Yields the configuration object for block-style setup.
     #
     #   Ruflet::Rails.configure do |c|
-    #     c.app_file = Rails.root.join("app/views/ruflet/main.rb")
-    #     c.ws_path  = "/ws"
+    #     c.backend_url = "https://example.com"
     #   end
     def configure
       yield config
     end
 
-    def view_classes
-      @view_classes ||= []
-    end
-
-    def register_view(view_class)
-      view_classes << view_class unless view_classes.include?(view_class)
-      view_class
-    end
-
-    def render(page, routes: nil, default: nil)
-      ViewRouter.new(page, routes: routes, default: default).start
-    end
-
     # Flet-style routed navigation stack for complex multi-screen apps. Wires
     # up on_route_change / on_view_pop and starts at the current route. See
     # Ruflet::Rails::RouteStack.
@@ -46,17 +32,6 @@ module Ruflet
       RouteStack.new(page, &builder).start
     end
 
-    def load_views(root)
-      return [] if root.to_s.empty?
-
-      files = Dir[File.join(root.to_s, "components", "**", "*.rb")].sort
-      files += Dir[File.join(root.to_s, "**", "*_view.rb")].sort
-
-      files.each do |file|
-        Kernel.load(file)
-      end
-    end
-
     def sessions
       @sessions ||= SessionRegistry.new
     end
@@ -66,8 +41,8 @@ module Ruflet
     end
 
     # WebSocket endpoint for native mobile/desktop clients. The developer
-    # declares the entry the same way they declare a web mount — so the screens
-    # the app shows live in dev code, not in framework auto-discovery:
+    # declares the entry the same way they declare a web mount — the screens
+    # the app shows live in dev code, never in framework auto-discovery:
     #
     #   # a standalone Ruflet app file (Ruflet.run/MyApp.new.run), per session:
     #   match "/ws", to: Ruflet::Rails.endpoint(app_file: Rails.root.join("app/ruflet/main.rb")), via: :all
@@ -78,64 +53,46 @@ module Ruflet
     #   # a custom block:
     #   match "/ws", to: Ruflet::Rails.endpoint { |page| MyHome.render(page) }, via: :all
     #
-    # With nothing declared it falls back to the convenience view router, which
-    # auto-discovers RufletView subclasses and renders a route index. That index
-    # is a framework fallback for the zero-config case — declare an entry above
-    # to own the home screen in your code.
+    # One of view:, app_file:, or a block is required — there is no
+    # auto-discovery fallback.
     def endpoint(view: nil, app_file: nil, &block)
       sources = [view, app_file, block].compact
       raise ArgumentError, "endpoint accepts only one of view:, app_file:, or a block" if sources.length > 1
+      raise ArgumentError, "endpoint requires one of view:, app_file:, or a block" if sources.empty?
 
       return Protocol::Runner.new.build_app_endpoint(file_path: app_file) if app_file
 
-      entry =
-        if block
-          block
-        elsif view
-          web_app_entrypoint(view: view)
-        else
-          ->(page) { render(page) }
-        end
+      entry = block || web_app_entrypoint(view: view)
       Protocol::Runner.new(&entry).build_endpoint
     end
 
-    # Backward-compatible shorthand for a standalone app-file mobile endpoint.
+    # Shorthand for a standalone app-file endpoint.
     #
     #   match "/ws", to: Ruflet::Rails.app(Rails.root.join("app/ruflet/main.rb")), via: :all
     def app(file_path)
       endpoint(app_file: file_path)
     end
 
-    # Backward-compatible alias for older Rails installs.
-    def mobile(file_path)
-      app(file_path)
-    end
-
-    # Serves the pre-built Flutter web build's index.html at the given route.
-    # Static assets (JS, WASM, fonts) are served by ActionDispatch::Static.
-    #
-    # Usage in routes.rb:
-    #   get "/showcase", to: Ruflet::Rails.web(build: Rails.root.join("public/showcase"))
-    def web(build:)
-      Protocol::WebAppEndpoint.new(build_dir: build.to_s)
-    end
-
     # Self-contained web frontend, mountable under any route. Serves the
     # Flutter web build (with <base href> rewritten to the mount point) and
     # answers the Ruflet WebSocket on the same path. Routes stay routing-only;
-    # UI code lives in app/views/ruflet:
-    #
-    #   # all registered RufletView subclasses behind the view router:
-    #   mount Ruflet::Rails.web_app, at: "/app"
+    # UI code lives in dev files:
     #
     #   # a single view class (resolved lazily, so reloading works):
     #   mount Ruflet::Rails.web_app(view: "CounterView"), at: "/myfrontend"
     #
     #   # a standalone Ruflet app file (MyApp.new.run), loaded per session:
     #   mount Ruflet::Rails.web_app(app_file: "app/ruflet/showcase/main.rb"), at: "/showcase"
+    #
+    #   # a custom block:
+    #   mount Ruflet::Rails.web_app { |page| MyHome.render(page) }, at: "/app"
+    #
+    # One of view:, app_file:, or a block is required — there is no
+    # auto-discovery fallback.
     def web_app(view: nil, app_file: nil, build_dir: nil, &app_block)
       sources = [view, app_file, app_block].compact
       raise ArgumentError, "web_app accepts only one of view:, app_file:, or a block" if sources.length > 1
+      raise ArgumentError, "web_app requires one of view:, app_file:, or a block" if sources.empty?
 
       Protocol::WebApp.new(
         build_dir: build_dir,
@@ -166,147 +123,5 @@ module Ruflet
       view.to_s.constantize
     end
 
-    # Reads index.html from the web build dir, injects window.__RUFLET_URL__
-    # from config.backend_url so the Flutter client knows the WS backend
-    # without a rebuild. Falls back to the request base_url if not configured.
-    #
-    # Usage in a Rails controller:
-    #   render html: Ruflet::Rails.web_html(request), layout: false
-    def web_html(request)
-      build_dir = config.web_build_dir.to_s
-      html      = File.read(File.join(build_dir, "index.html"))
-      url       = config.backend_url.to_s.strip
-      url       = request.base_url if url.empty?
-      script    = "<script>window.__RUFLET_URL__=#{url.to_json};</script>"
-      html.include?("</head>") ? html.sub("</head>", "#{script}</head>") : "#{script}#{html}"
-    end
-  end
-
-  module Rails
-    # ViewRouter dispatches incoming page connections to the correct RufletView
-    # subclass based on the current route.  It includes SharedControlForwarders
-    # so that widget helpers (text, column, safe_area, …) can be called directly
-    # inside its own rendering helpers — the same pattern showcase uses.
-    class ViewRouter
-      include Ruflet::UI::SharedControlForwarders
-
-      def initialize(page, routes: nil, default: nil)
-        @page = page
-        @routes = normalize_routes(routes || self.class.discovered_routes)
-        @default = default || @routes["/"]
-      end
-
-      def start
-        @page.on_route_change = ->(_event) { render }
-        render
-      end
-
-      def render
-        if root_route_without_default?
-          render_route_index
-          return
-        end
-
-        target = route_target(@page.route)
-
-        if target.respond_to?(:render)
-          target.render(@page)
-        elsif target.respond_to?(:call)
-          target.call(@page)
-        else
-          render_empty_state
-        end
-      end
-
-      def self.discovered_routes
-        Ruflet::Rails.view_classes.each_with_object({}) do |view_class, routes|
-          next unless view_class.respond_to?(:route)
-
-          routes[view_class.route] = view_class
-        end
-      end
-
-      private
-
-      # Widget builder calls delegate to the global DSL, same as Kernel does,
-      # keeping the showcase pattern consistent across all contexts.
-      def control_delegate
-        Ruflet::DSL
-      end
-
-      def route_target(route)
-        path = route_path(route)
-        return @routes[path] if @routes.key?(path)
-        return @default if path == "/"
-
-        nil
-      end
-
-      def root_route_without_default?
-        route_path(@page.route) == "/" && @default.nil? && @routes["/"].nil? && @routes.any?
-      end
-
-      def normalize_routes(routes)
-        routes.to_h.transform_keys { |path| normalize_route(path) }
-      end
-
-      def route_path(route)
-        normalize_route(route.to_s.split("?", 2).first)
-      end
-
-      def normalize_route(path)
-        value = path.to_s.strip
-        return "/" if value.empty? || value == "/"
-
-        "/#{value.gsub(%r{\A/+|/+\z}, "")}"
-      end
-
-      def render_empty_state
-        @page.title = "Ruflet"
-        @page.add(
-          container(
-            expand: true,
-            alignment: Ruflet::MainAxisAlignment::CENTER,
-            content: text("No Ruflet views found")
-          )
-        )
-        @page.update
-      end
-
-      def render_route_index
-        @page.title = "Ruflet"
-        @page.add(
-          safe_area(
-            container(
-              expand: true,
-              padding: { left: 24, top: 16, right: 24, bottom: 24 },
-              content: column(
-                spacing: 12,
-                controls: [
-                  text("Ruflet", size: 24, weight: "bold"),
-                  *route_index_buttons
-                ]
-              )
-            ),
-            expand: true
-          )
-        )
-        @page.update
-      end
-
-      def route_index_buttons
-        @routes.keys.sort.map do |path|
-          filled_button(
-            content: text(route_label(path)),
-            on_click: ->(_event) { @page.go(path) }
-          )
-        end
-      end
-
-      def route_label(path)
-        label = path.to_s.delete_prefix("/").tr("_-", " ")
-        label.empty? ? "Home" : label.split.map(&:capitalize).join(" ")
-      end
-    end
   end
 end

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.11" unless const_defined?(:VERSION)
+  VERSION = "0.0.13" unless const_defined?(:VERSION)
 end

data/lib/ruflet_rails.rb

@@ -11,7 +11,6 @@ require "ruflet_core"
 require "ruflet_server"
 require_relative "ruflet/rails/session_registry"
 require_relative "ruflet/rails/form_helpers"
-require_relative "ruflet/rails/view"
 require_relative "ruflet/rails/resource_component"
 require_relative "ruflet/rails/route_stack"
 require_relative "ruflet/rails/webview_app"
@@ -20,6 +19,7 @@ require_relative "ruflet/rails/view_helpers"
 require_relative "ruflet/rails/desktop_launcher"
 require_relative "ruflet/rails/protocol"
 require_relative "ruflet/rails/assets"
+require_relative "ruflet/rails/web_installer"
 require_relative "ruflet/rails/configuration"
 require_relative "ruflet/rails/install_support"
 require_relative "ruflet/rails"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_rails
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.13
 platform: ruby
 authors:
 - Adam Moussa Ali
@@ -29,42 +29,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
 - !ruby/object:Gem::Dependency
   name: ruflet_core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
 - !ruby/object:Gem::Dependency
   name: ruflet_server
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.15
+        version: 0.0.16
 description: Build cross-platform mobile and desktop apps with Ruby on Rails using
   Ruflet.
 email:
@@ -82,32 +82,29 @@ files:
 - lib/ruflet/rails/configuration.rb
 - lib/ruflet/rails/desktop_launcher.rb
 - lib/ruflet/rails/form_helpers.rb
+- lib/ruflet/rails/generator_hooks.rb
 - lib/ruflet/rails/install_support.rb
 - lib/ruflet/rails/native_app.rb
 - lib/ruflet/rails/protocol.rb
 - lib/ruflet/rails/protocol/context.rb
 - lib/ruflet/rails/protocol/endpoint.rb
 - lib/ruflet/rails/protocol/local_server.rb
-- lib/ruflet/rails/protocol/middleware.rb
 - lib/ruflet/rails/protocol/mobile_loader.rb
 - lib/ruflet/rails/protocol/runner.rb
-- lib/ruflet/rails/protocol/static_index_guard.rb
 - lib/ruflet/rails/protocol/web_app.rb
-- lib/ruflet/rails/protocol/web_app_endpoint.rb
-- lib/ruflet/rails/protocol/web_socket_connection.rb
 - lib/ruflet/rails/protocol/websocket_detection.rb
-- lib/ruflet/rails/protocol/wire_codec.rb
 - lib/ruflet/rails/railtie.rb
 - lib/ruflet/rails/resource_component.rb
 - lib/ruflet/rails/route_stack.rb
 - lib/ruflet/rails/session_registry.rb
-- lib/ruflet/rails/view.rb
 - lib/ruflet/rails/view_helpers.rb
+- lib/ruflet/rails/web_installer.rb
 - lib/ruflet/rails/webview_app.rb
 - lib/ruflet/version.rb
 - lib/ruflet_rails.rb
 homepage: https://github.com/AdamMusa/ruflet/tree/main/packages/ruflet_rails
-licenses: []
+licenses:
+- MIT
 metadata: {}
 rdoc_options: []
 require_paths:

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

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Ruflet
-  module Rails
-    module Protocol
-      # Rack middleware inserted before ActionDispatch::Static by the Railtie.
-      #
-      # Responsibilities:
-      #   1. WebSocket at ws_path (/ws) — native mobile/desktop clients.
-      #   2. WebSocket at the build dir base path (e.g. /app, /app/) — the
-      #      Flutter web client uses Uri.base from <base href="/app/"> as its
-      #      connection URL, so it naturally connects back to /app/ as WebSocket.
-      #      No URL injection needed — the client finds the server on its own.
-      #   3. Block direct HTTP access to the build dir's index so
-      #      ActionDispatch::Static never leaks it at /app — serves Rails' 404.
-      class Middleware
-        INDEX_SUFFIXES = ["", "/", "/index.html"].freeze
-
-        def initialize(app)
-          @app         = app
-          @ws_endpoint = nil
-        end
-
-        def call(env)
-          cfg  = Ruflet::Rails.config
-          path = env["PATH_INFO"].to_s
-
-          if cfg.app_file
-            # WS at configured ws_path — native/desktop clients
-            if cfg.ws_path && path == normalize(cfg.ws_path) && websocket_upgrade?(env)
-              return Context.with_env(env) { ws_endpoint(cfg).call(env) }
-            end
-
-            # WS at build dir base path — Flutter web client (Uri.base = /app/)
-            if cfg.web_build_dir && build_dir_base?(path, cfg.web_build_dir.to_s) && websocket_upgrade?(env)
-              return Context.with_env(env) { ws_endpoint(cfg).call(env) }
-            end
-          end
-
-          # Block direct HTTP access to the build dir index
-          if cfg.web_build_dir && build_dir_index?(path, cfg.web_build_dir.to_s)
-            return rails_404
-          end
-
-          Context.with_env(env) { @app.call(env) }
-        end
-
-        private
-
-        def ws_endpoint(cfg)
-          @ws_endpoint ||= Runner.new.build_app_endpoint(file_path: cfg.app_file.to_s)
-        end
-
-        def websocket_upgrade?(env)
-          return false unless env["REQUEST_METHOD"] == "GET"
-
-          env["HTTP_UPGRADE"].to_s.downcase == "websocket" &&
-            env["HTTP_CONNECTION"].to_s.downcase.include?("upgrade") &&
-            env["HTTP_SEC_WEBSOCKET_KEY"].to_s != ""
-        end
-
-        # Matches /app and /app/ — the Flutter web client connects here.
-        def build_dir_base?(path, build_dir)
-          base = "/#{File.basename(build_dir)}"
-          path == base || path == "#{base}/"
-        end
-
-        # Matches /app, /app/, /app/index.html — blocks static serving of index.
-        def build_dir_index?(path, build_dir)
-          base = "/#{File.basename(build_dir)}"
-          INDEX_SUFFIXES.any? { |suffix| path == "#{base}#{suffix}" }
-        end
-
-        def rails_404
-          page = rails_404_page
-          [404, { "content-type" => "text/html; charset=utf-8", "content-length" => page.bytesize.to_s }, [page]]
-        end
-
-        def rails_404_page
-          path = defined?(::Rails) ? ::Rails.public_path.join("404.html") : nil
-          path && File.file?(path) ? File.read(path) : "Not Found"
-        end
-
-        def normalize(path)
-          "/#{path.to_s.gsub(%r{\A/+|/+\z}, "")}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-# This file is intentionally empty.
-# StaticIndexGuard was removed — ruflet_rails does not intercept any static
-# paths. The route where the web build is served is defined explicitly in
-# routes.rb, and the backend URL comes from ruflet.yaml at build time.

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Ruflet
-  module Rails
-    module Protocol
-      # Rack endpoint that serves the pre-built Flutter web app's index.html.
-      #
-      # The HTML is read from build_dir and returned as-is — no mutation.
-      # The backend URL is baked into the build at compile time via:
-      #
-      #   rake ruflet:build[web]   # reads backend_url from ruflet.yaml
-      #
-      # which passes --dart-define=RUFLET_URL=<backend_url> to flutter build.
-      # The Flutter client reads it via String.fromEnvironment('RUFLET_URL').
-      #
-      # Static assets (JS, WASM, fonts) in the build dir are served by Rails'
-      # ActionDispatch::Static as normal.
-      #
-      # Usage in routes.rb:
-      #
-      #   match "/ws",       to: Ruflet::Rails.app(Rails.root.join("app/views/mobile/main.rb")), via: :all
-      #   get   "/showcase", to: Ruflet::Rails.web(build: Rails.root.join("public/showcase"))
-      #
-      class WebAppEndpoint
-        def initialize(build_dir:)
-          @index_path = File.join(build_dir.to_s, "index.html")
-        end
-
-        def call(_env)
-          return not_found unless File.file?(@index_path)
-
-          html = File.read(@index_path)
-          [200, { "content-type" => "text/html; charset=utf-8", "content-length" => html.bytesize.to_s }, [html]]
-        end
-
-        private
-
-        def not_found
-          [404, { "content-type" => "text/plain" }, ["Web build not found"]]
-        end
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "ruflet_server"
-
-module Ruflet
-  module Rails
-    module Protocol
-      WebSocketConnection = ::Ruflet::WebSocketConnection unless const_defined?(:WebSocketConnection, false)
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "ruflet_server"
-
-module Ruflet
-  module Rails
-    module Protocol
-      WireCodec = ::Ruflet::WireCodec unless const_defined?(:WireCodec, false)
-    end
-  end
-end

data/lib/ruflet/rails/view.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string/inflections"
-
-# RufletView is the base class for all server-driven Ruflet views in a Rails app.
-# It includes Ruflet::UI::SharedControlForwarders so that all widget builder
-# methods (text, column, row, container, safe_area, filled_button, …) are
-# available directly on the view instance — the same way showcase uses them.
-class RufletView
-  include Ruflet::UI::SharedControlForwarders
-
-  attr_reader :page
-
-  class << self
-    def route(path = nil)
-      @route_path = normalize_route(path) if path
-      @route_path || inferred_route
-    end
-
-    def inherited(child)
-      super
-      Ruflet::Rails.register_view(child) if defined?(Ruflet::Rails) && Ruflet::Rails.respond_to?(:register_view)
-    end
-
-    private
-
-    def inferred_route
-      name_part = name.to_s.split("::").last.to_s.sub(/View\z/, "")
-      path = name_part.underscore.pluralize
-      normalize_route(path.empty? ? "/" : path)
-    end
-
-    def normalize_route(path)
-      value = path.to_s.strip
-      return "/" if value.empty? || value == "/"
-
-      "/#{value.gsub(%r{\A/+|/+\z}, "")}"
-    end
-  end
-
-  def self.render(page, *args, **kwargs, &block)
-    new(page).render(*args, **kwargs, &block)
-  end
-
-  def initialize(page)
-    @page = page
-  end
-
-  private
-
-  # Delegates all widget builder calls (text, column, row, …) to Ruflet::DSL,
-  # matching the same delegate target that Kernel uses. Subclasses can override
-  # this to scope widget building to a local WidgetBuilder instance instead.
-  def control_delegate
-    Ruflet::DSL
-  end
-end