ruflet_rails 0.0.7 → 0.0.8

data/lib/ruflet/rails/resource_component.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module Ruflet
+  module Rails
+    class ResourceComponent
+      include Ruflet::UI::SharedControlForwarders
+
+      attr_reader :page, :controller
+
+      def initialize(page, controller:)
+        @page = page
+        @controller = controller
+      end
+
+      private
+
+      def control_delegate
+        Ruflet::DSL
+      end
+
+      def open_dialog(dialog)
+        prune_closed_dialogs
+        return open_primary_dialog(dialog) if primary_dialog?(dialog) && !latest_stack_dialog
+
+        preserve_rendered_open_dialog_state
+        page.show_dialog(dialog)
+        dialog
+      end
+
+      def close_dialog(dialog)
+        close_tracked_dialog(dialog)
+      end
+
+      def close_dialogs(*dialogs)
+        dialogs.flatten.compact.each do |dialog|
+          remove_tracked_dialog(dialog)
+        end
+      end
+
+      def date_picker_value(value, fallback: Date.today)
+        return value.to_date.iso8601 if value.respond_to?(:to_date)
+        return fallback.iso8601 if value.to_s.empty?
+
+        Date.parse(value.to_s).iso8601
+      rescue ArgumentError
+        fallback.iso8601
+      end
+
+      def datetime_picker_value(value, fallback: Time.now)
+        return value.iso8601 if value.respond_to?(:iso8601)
+        return fallback.iso8601 if value.to_s.empty?
+
+        Time.parse(value.to_s).iso8601
+      rescue ArgumentError
+        fallback.iso8601
+      end
+
+      def time_picker_value(value)
+        return value.strftime("%H:%M") if value.respond_to?(:strftime)
+
+        value.to_s
+      end
+
+      def date_range_picker_values(value)
+        if value.respond_to?(:begin) && value.respond_to?(:end)
+          return [date_picker_value(value.begin), date_picker_value(value.end)]
+        end
+        if value.respond_to?(:to_a) && value.to_a.length >= 2
+          first, last = value.to_a.first(2)
+          return [date_picker_value(first), date_picker_value(last)]
+        end
+
+        raw = value.to_s.strip.gsub(/\A[\[(]|[\])]\z/, "")
+        start_value, end_value =
+          if raw.include?("...")
+            raw.split("...", 2)
+          elsif raw.include?("..")
+            raw.split("..", 2)
+          else
+            raw.split(",", 2)
+          end
+        [date_picker_value(start_value), date_picker_value(end_value || start_value)]
+      end
+
+      def date_display_value(value)
+        visible = value.to_s.split("T", 2).first
+        visible.empty? ? "Not selected" : visible
+      end
+
+      def date_range_display_value(start_value, end_value)
+        "#{date_display_value(start_value)} - #{date_display_value(end_value)}"
+      end
+
+      def time_display_value(value)
+        visible = value.to_s
+        visible.empty? ? "Not selected" : visible
+      end
+
+      def close_tracked_dialog(dialog)
+        return unless dialog
+
+        close_dialog_stack_entry(dialog)
+      end
+
+      def remove_tracked_dialog(dialog)
+        return unless dialog
+
+        close_dialog_stack_entry(dialog)
+      end
+
+      def close_dialog_stack_entry(dialog)
+        return close_primary_dialog(dialog) if primary_dialog_slot?(dialog)
+
+        unless page.respond_to?(:remove_dialog_tracking, true)
+          page.close_dialog(dialog)
+          return
+        end
+
+        page.update(dialog, open: false) if dialog.wire_id
+        page.__send__(:remove_dialog_tracking, dialog)
+        sync_dialogs_container
+      end
+
+      def sync_dialogs_container
+        dialogs_container = page.instance_variable_get(:@dialogs_container) if page.instance_variable_defined?(:@dialogs_container)
+        return page.update unless dialogs_container&.wire_id
+
+        page.update(dialogs_container, controls: dialogs_container.props["controls"])
+      end
+
+      def open_primary_dialog(dialog)
+        dialog.props["open"] = true
+        page.dialog = dialog
+        dialog
+      end
+
+      def close_primary_dialog(dialog)
+        page.update(dialog, open: false) if dialog.wire_id
+      end
+
+      def primary_dialog_slot?(dialog)
+        page.instance_variable_defined?(:@dialog) && page.instance_variable_get(:@dialog).equal?(dialog)
+      end
+
+      def latest_stack_dialog
+        page.__send__(:latest_open_dialog) if page.respond_to?(:latest_open_dialog, true)
+      end
+
+      def primary_dialog?(dialog)
+        dialog.type.to_s.tr("_", "").casecmp("alertdialog").zero?
+      end
+
+      def preserve_rendered_open_dialog_state
+        tracked_dialogs.each do |dialog|
+          next if dialog.props["open"] == false
+
+          dialog.props["_open"] = true
+        end
+      end
+
+      def tracked_dialogs
+        dialogs = []
+        dialogs << page.instance_variable_get(:@dialog) if page.instance_variable_defined?(:@dialog)
+        dialogs.concat(Array(page.instance_variable_get(:@dialogs))) if page.instance_variable_defined?(:@dialogs)
+        dialogs.compact.uniq
+      end
+
+      def prune_closed_dialogs
+        return unless page.respond_to?(:remove_dialog_tracking, true)
+
+        dialogs = page.instance_variable_get(:@dialogs) if page.instance_variable_defined?(:@dialogs)
+        Array(dialogs).select { |dialog| dialog.props["open"] == false }.each do |dialog|
+          page.__send__(:remove_dialog_tracking, dialog)
+        end
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        return controller.__send__(name, *args, **kwargs, &block) if controller.respond_to?(name, true)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        controller.respond_to?(name, true) || super
+      end
+    end
+  end
+end

data/lib/ruflet/rails/resource_view.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "active_model"
+require "active_support/core_ext/string/inflections"
+require_relative "view"
+
+module Ruflet
+  module Rails
+    class ResourceView < ::RufletView
+      class << self
+        def model(value = nil)
+          @model_class = value if value
+          @model_class || inferred_model_class
+        end
+
+        def title(value = nil)
+          @resource_title = value if value
+          @resource_title || model_name.plural.humanize.titleize
+        end
+
+        def component(value = nil)
+          @component_class = value if value
+          @component_class || inferred_component_class
+        end
+
+        private
+
+        def inferred_model_class
+          model_name.name.safe_constantize
+        end
+
+        def inferred_component_class
+          "#{model_name.name}Component".safe_constantize
+        end
+
+        def model_name
+          ActiveModel::Name.new(name.to_s.sub(/View\z/, "").singularize.constantize)
+        rescue NameError
+          ActiveModel::Name.new(Object, nil, name.to_s.sub(/View\z/, "").singularize)
+        end
+      end
+
+      private
+
+      def close_dialog(dialog)
+        close_open_dialogs_above(dialog)
+        close_tracked_dialog(dialog)
+      end
+
+      def show_errors(record)
+        show_snackbar(error_message(record))
+      end
+
+      def show_snackbar(message)
+        page.snackbar = snackbar(text(message), open: true)
+      end
+
+      def error_message(record)
+        messages = record.errors.full_messages
+        messages.respond_to?(:to_sentence) ? messages.to_sentence : messages.join(", ")
+      end
+
+      def compact?
+        width = page.client_details["width"].to_f
+        width > 0 && width < 600
+      end
+
+      def dialog_width
+        width = page.client_details["width"].to_f
+        return 520 if width <= 0
+
+        [[width - 64, 280].max, 520].min
+      end
+
+      def record_id(record)
+        record.respond_to?(:id) ? record.id : nil
+      end
+
+      def close_open_dialogs_above(dialog)
+        return false unless page.respond_to?(:latest_open_dialog, true)
+
+        while (latest = page.__send__(:latest_open_dialog)) && !latest.equal?(dialog)
+          close_tracked_dialog(latest)
+        end
+      rescue StandardError
+        false
+      end
+
+      def close_tracked_dialog(dialog)
+        return unless dialog
+
+        close_dialog_stack_entry(dialog)
+      end
+
+      def close_dialog_stack_entry(dialog)
+        return close_primary_dialog(dialog) if primary_dialog_slot?(dialog)
+
+        unless page.respond_to?(:remove_dialog_tracking, true)
+          page.close_dialog(dialog)
+          return
+        end
+
+        page.update(dialog, open: false) if dialog.wire_id
+        page.__send__(:remove_dialog_tracking, dialog)
+        sync_dialogs_container
+      end
+
+      def sync_dialogs_container
+        dialogs_container = page.instance_variable_get(:@dialogs_container) if page.instance_variable_defined?(:@dialogs_container)
+        return page.update unless dialogs_container&.wire_id
+
+        page.update(dialogs_container, controls: dialogs_container.props["controls"])
+      end
+
+      def close_primary_dialog(dialog)
+        page.update(dialog, open: false) if dialog.wire_id
+      end
+
+      def primary_dialog_slot?(dialog)
+        page.instance_variable_defined?(:@dialog) && page.instance_variable_get(:@dialog).equal?(dialog)
+      end
+    end
+  end
+end

data/lib/ruflet/rails/session_registry.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Ruflet
+  module Rails
+    class Session
+      attr_reader :key, :page, :env, :connected_at, :connection_key
+
+      def initialize(key:, page:, env: nil, connected_at: Time.now, connection_key: nil)
+        @key = key
+        @page = page
+        @env = env
+        @connected_at = connected_at
+        @connection_key = connection_key
+      end
+
+      def session_id
+        page.session_id
+      end
+
+      def client_details
+        page.client_details
+      end
+    end
+
+    class SessionRegistry
+      include Enumerable
+
+      def initialize
+        @sessions = {}
+        @mutex = Mutex.new
+      end
+
+      def add(key:, page:, env: nil, connection_key: nil)
+        session = Session.new(key: key, page: page, env: env, connection_key: connection_key)
+        @mutex.synchronize { @sessions[key] = session }
+        session
+      end
+
+      def remove(key, connection_key: nil)
+        @mutex.synchronize do
+          session = @sessions[key]
+          return nil if connection_key && session&.connection_key && session.connection_key != connection_key
+
+          @sessions.delete(key)
+        end
+      end
+
+      def [](key)
+        @mutex.synchronize { @sessions[key] }
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+
+        snapshot.each(&block)
+      end
+
+      def size
+        @mutex.synchronize { @sessions.size }
+      end
+
+      def empty?
+        size.zero?
+      end
+
+      def clear
+        @mutex.synchronize { @sessions.clear }
+      end
+
+      def pages
+        map(&:page)
+      end
+
+      def broadcast(&block)
+        raise ArgumentError, "Ruflet::Rails.broadcast requires a block" unless block
+
+        count = 0
+        each do |session|
+          block.arity == 1 ? block.call(session.page) : block.call(session.page, session)
+          count += 1
+        end
+        count
+      end
+
+      private
+
+      def snapshot
+        @mutex.synchronize { @sessions.values.dup }
+      end
+    end
+  end
+end

data/lib/ruflet/rails/view.rb

@@ -0,0 +1,57 @@
+# 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

data/lib/ruflet/rails.rb

@@ -4,14 +4,179 @@ module Ruflet
   module Rails
     module_function
 
+    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
+
+    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
+
+    def broadcast(&block)
+      sessions.broadcast(&block)
+    end
+
     # Mount inside Rails routes; route "at:" controls URL path.
     def endpoint(&block)
       Protocol::Runner.new(&block).build_endpoint
     end
 
-    # Load app/mobile/main.rb (MyApp.new.run) and mount it in Rails routes.
+    # Load a Ruflet app file (MyApp.new.run) and mount it in Rails routes.
+    def app(file_path)
+      Protocol::Runner.new.build_app_endpoint(file_path: file_path)
+    end
+
+    # Backward-compatible alias for older Rails installs.
     def mobile(file_path)
-      Protocol::Runner.new.build_mobile_endpoint(file_path: file_path)
+      app(file_path)
+    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.7" unless const_defined?(:VERSION)
+  VERSION = "0.0.8" unless const_defined?(:VERSION)
 end

data/lib/ruflet_rails.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-%w[ruflet_core ruflet].reverse_each do |package|
+%w[ruflet_core ruflet_server ruflet].reverse_each do |package|
   local_package_lib = File.expand_path("../../#{package}/lib", __dir__)
   if File.directory?(local_package_lib) && !$LOAD_PATH.include?(local_package_lib)
     $LOAD_PATH.unshift(local_package_lib)
@@ -8,6 +8,13 @@
 end
 
 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/resource_view"
+require_relative "ruflet/rails/desktop_launcher"
 require_relative "ruflet/rails/protocol"
 require_relative "ruflet/rails/install_support"
 require_relative "ruflet/rails"