ruby_ui_admin 0.1.0

data/app/components/ruby_ui_admin/views/form.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    class Form < Base
+      include StructureRenderer
+
+      def initialize(resource:, record:, view:)
+        @resource = resource
+        @record = record
+        @view = view.to_sym
+      end
+
+      def page_title
+        "#{title_prefix} · #{RubyUIAdmin.configuration.app_name}"
+      end
+
+      def content
+        render_header
+        render_errors_summary
+
+        form(action: form_action, method: "post", enctype: form_enctype, class: "space-y-6") do
+          hidden_method_field
+          csrf_field
+
+          render_structure(@resource.field_structure(view: @view))
+
+          render_actions
+        end
+      end
+
+      private
+
+      # File-upload fields require a multipart form.
+      def form_enctype
+        @resource.get_fields(view: @view).any? { |f| %i[file files].include?(f.type) } ? "multipart/form-data" : nil
+      end
+
+      def new_record?
+        @view == :new
+      end
+
+      def title_prefix
+        new_record? ? "New #{@resource.model_class.model_name.human}" : "Edit #{@resource.record_title(@record)}"
+      end
+
+      def form_action
+        if new_record?
+          resource_index_path(@resource.class)
+        else
+          resource_show_path(@resource.class, @record)
+        end
+      end
+
+      def render_header
+        div(class: "mb-6") do
+          a(href: resource_index_path(@resource.class), class: "text-sm text-muted-foreground hover:underline") { "← #{@resource.navigation_label}" }
+          h1(class: "text-2xl font-semibold tracking-tight mt-1") { title_prefix }
+        end
+      end
+
+      def render_errors_summary
+        return unless @record.errors.any?
+
+        div(class: "mb-4 rounded-md border border-destructive/30 bg-destructive/5 p-4") do
+          p(class: "text-sm font-medium text-destructive mb-1") { rua_t("form.errors") }
+          ul(class: "list-disc list-inside text-sm text-destructive") do
+            @record.errors.full_messages.each { |message| li { message } }
+          end
+        end
+      end
+
+      def render_field(field)
+        # Hidden fields carry a value with no visible label/row.
+        if field.type == :hidden
+          render RubyUIAdmin::Views::FieldInput.new(field: field, record: @record)
+          return
+        end
+
+        # A lone checkbox reads as "[ ] Label" — render it inline beside the label
+        # instead of stacking (which would leave the checkbox glued to the label text).
+        return render_boolean_field(field) if field.type == :boolean && !field.readonly?
+
+        div(class: "space-y-1.5 w-full md:w-8/12") do
+          label(class: "text-sm font-medium leading-none", title: field.description) do
+            plain field.name
+            span(class: "text-destructive ml-0.5") { "*" } if field.required?
+          end
+
+          if field.readonly?
+            div(class: "text-sm text-muted-foreground") do
+              render RubyUIAdmin::Views::FieldValue.new(field: field, record: @record)
+            end
+          else
+            render RubyUIAdmin::Views::FieldInput.new(field: field, record: @record)
+          end
+
+          if (help = field.help)
+            p(class: "text-xs text-muted-foreground") { help }
+          end
+
+          field_errors(field)
+        end
+      end
+
+      def render_boolean_field(field)
+        div(class: "space-y-1.5 w-full md:w-8/12") do
+          label(class: "flex items-center gap-2 text-sm font-medium leading-none", title: field.description) do
+            render RubyUIAdmin::Views::FieldInput.new(field: field, record: @record)
+            plain field.name
+            span(class: "text-destructive ml-0.5") { "*" } if field.required?
+          end
+
+          if (help = field.help)
+            p(class: "text-xs text-muted-foreground") { help }
+          end
+
+          field_errors(field)
+        end
+      end
+
+      def field_errors(field)
+        messages = @record.errors[field.database_id]
+        return if messages.blank?
+
+        p(class: "text-xs text-destructive") { messages.join(", ") }
+      end
+
+      def render_actions
+        div(class: "flex items-center gap-3 pt-2") do
+          button(
+            type: "submit",
+            class: "inline-flex items-center h-9 px-4 rounded-md bg-primary text-primary-foreground text-sm font-medium shadow hover:bg-primary/90"
+          ) { new_record? ? rua_t("actions.create") : rua_t("actions.update") }
+
+          a(href: resource_index_path(@resource.class), class: "text-sm text-muted-foreground hover:underline") { rua_t("actions.cancel") }
+        end
+      end
+
+      def hidden_method_field
+        return if new_record?
+
+        input(type: "hidden", name: "_method", value: "patch")
+      end
+
+      def csrf_field
+        input(type: "hidden", name: "authenticity_token", value: form_authenticity_token)
+      end
+    end
+  end
+end

data/app/components/ruby_ui_admin/views/home.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    class Home < Base
+      def initialize(resources:)
+        @resources = resources
+      end
+
+      def content
+        h1(class: "text-2xl font-semibold tracking-tight mb-6") { RubyUIAdmin.configuration.app_name }
+
+        if @resources.empty?
+          p(class: "text-muted-foreground") { "No resources defined yet. Create one in app/ruby_ui_admin/resources." }
+        else
+          div(class: "grid gap-4 sm:grid-cols-2 lg:grid-cols-3") do
+            @resources.each { |rc| render_card(rc) }
+          end
+        end
+      end
+
+      private
+
+      def render_card(rc)
+        a(href: resource_index_path(rc), class: "block") do
+          render RubyUI::Card.new(class: "hover:shadow-md transition-shadow") do
+            render RubyUI::CardHeader.new do
+              render RubyUI::CardTitle.new { rc.navigation_label }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/ruby_ui_admin/views/index.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    class Index < Base
+      include ActionsMenu
+
+      def initialize(resource:, records:, pagy:, filters: [], filter_values: {}, scopes: [], current_scope_key: nil, scope_param: nil, remove_scope_all: false, query_params: {}, sort_by: nil, sort_direction: nil)
+        @resource = resource
+        @records = records
+        @pagy = pagy
+        @filters = filters
+        @filter_values = filter_values
+        @scopes = scopes
+        @current_scope_key = current_scope_key
+        @scope_param = scope_param
+        @remove_scope_all = remove_scope_all
+        @query_params = query_params
+        @sort_by = sort_by
+        @sort_direction = sort_direction
+      end
+
+      def page_title
+        "#{@resource.navigation_label} · #{RubyUIAdmin.configuration.app_name}"
+      end
+
+      BULK_FORM_ID = "rua-bulk-form"
+
+      def content
+        render_header
+        render_scope_tabs
+        render_filter_bar
+        render_bulk_toolbar
+        # The `rua--bulk-select` controller (select-all + checked-ids) scopes to this table card.
+        card_attrs = {class: "p-4"}
+        card_attrs[:data] = {controller: "rua--bulk-select"} if bulk?
+        render RubyUI::Card.new(**card_attrs) do
+          render_table
+        end
+        render_pagination
+      end
+
+      private
+
+      def policy_class
+        @resource.class.authorization_policy
+      end
+
+      def fields
+        @fields ||= @resource.get_fields(view: :index)
+      end
+
+      # Non-standalone actions become bulk actions (run against selected rows).
+      def bulk_actions
+        return [] unless authorized_to?(:act_on, @resource.model_class, policy_class: policy_class)
+
+        @bulk_actions ||= @resource.actions_for(view: :index).reject(&:standalone?)
+      end
+
+      def bulk?
+        @resource.class.record_selector && bulk_actions.any?
+      end
+
+      def render_header
+        div(class: "flex items-center justify-between mb-6") do
+          div do
+            h1(class: "text-2xl font-semibold tracking-tight") { @resource.navigation_label }
+            if (description = @resource.class.description)
+              p(class: "text-sm text-muted-foreground mt-1") { description }
+            end
+          end
+
+          div(class: "flex items-center gap-2") do
+            render_index_controls
+            render_standalone_actions
+
+            if authorized_to?(:create, @resource.model_class, policy_class: policy_class)
+              render(RubyUI::Link.new(href: resource_new_path(@resource.class), variant: :primary)) do
+                rua_t("actions.new", model: @resource.model_class.model_name.human)
+              end
+            end
+          end
+        end
+      end
+
+      # Renders the resource's `self.index_controls` block (custom header buttons/links).
+      # The block is evaluated in this component, so it can use Phlex (`a`, `button`, …),
+      # the `control_link` helper, route helpers (`ruby_ui_admin.*`) and `@resource`.
+      def render_index_controls
+        controls = @resource.class.index_controls
+        return if controls.nil?
+
+        instance_exec(&controls)
+      end
+
+      # `actions_list` is accepted inside `index_controls` for compatibility, but standalone
+      # actions are already rendered in the header (`render_standalone_actions`), so it is a
+      # no-op here.
+      def actions_list = nil
+
+      # Convenience helper for `index_controls`: a button-styled link (RubyUI Button as `<a>`).
+      def control_link(label, href, variant: :outline)
+        render(RubyUI::Link.new(href: href, variant: (variant == :primary) ? :primary : :outline)) { label }
+      end
+
+      # Link helpers for use inside `index_controls`/`row_controls` blocks.
+      def show_button(record, label: nil)
+        a(href: resource_show_path(@resource.class, record), class: "text-sm text-primary hover:underline") { label || rua_t("actions.show") }
+      end
+
+      def edit_button(record, label: nil)
+        a(href: resource_edit_path(@resource.class, record), class: "text-sm text-primary hover:underline") { label || rua_t("actions.edit") }
+      end
+
+      def create_button(label: nil)
+        control_link(label || rua_t("actions.new", model: @resource.model_class.model_name.human), resource_new_path(@resource.class), variant: :primary)
+      end
+
+      # Standalone actions (no record selection needed) shown on the index header.
+      def render_standalone_actions
+        return unless authorized_to?(:act_on, @resource.model_class, policy_class: policy_class)
+
+        actions = @resource.actions_for(view: :index).select(&:standalone?)
+        return if actions.empty?
+
+        render_actions_menu(actions, bulk: false)
+      end
+
+      # Bulk actions: an empty form (referenced by row checkboxes via the HTML `form`
+      # attribute) plus an "Actions" dropdown of the bulk-action triggers.
+      def render_bulk_toolbar
+        return unless bulk?
+
+        form(id: BULK_FORM_ID, method: "get")
+
+        div(class: "flex items-center justify-end gap-2 mb-4") do
+          span(class: "text-sm text-muted-foreground") { rua_t("index.with_selected") }
+          render_actions_menu(bulk_actions, bulk: true, form_id: BULK_FORM_ID)
+        end
+      end
+
+      def render_table
+        render RubyUI::Table.new do
+          render RubyUI::TableHeader.new do
+            render RubyUI::TableRow.new do
+              render RubyUI::TableHead.new(class: "w-10") { select_all_checkbox } if bulk?
+              fields.each do |field|
+                render RubyUI::TableHead.new { field.name }
+              end
+              render RubyUI::TableHead.new(class: "text-right") { rua_t("index.actions") }
+            end
+          end
+
+          render RubyUI::TableBody.new do
+            if @records.empty?
+              render RubyUI::TableRow.new do
+                render RubyUI::TableCell.new(colspan: column_count, class: "text-center text-muted-foreground py-8") { rua_t("index.empty") }
+              end
+            else
+              @records.each { |record| render_row(record) }
+            end
+          end
+        end
+      end
+
+      def column_count
+        fields.size + 1 + (bulk? ? 1 : 0)
+      end
+
+      # Hidden until the JS reveals it (progressive enhancement).
+      def select_all_checkbox
+        render RubyUI::Checkbox.new(
+          hidden: true,
+          data: {rua__bulk_select_target: "selectAll", action: "change->rua--bulk-select#toggleAll"}
+        )
+      end
+
+      def row_attrs(record)
+        return {} unless RubyUIAdmin.configuration.click_row_to_view_record
+
+        {
+          class: "cursor-pointer",
+          data: {
+            controller: "rua--row-link",
+            action: "click->rua--row-link#navigate",
+            rua__row_link_url_value: resource_show_path(@resource.class, record)
+          }
+        }
+      end
+
+      def render_row(record)
+        render RubyUI::TableRow.new(**row_attrs(record)) do
+          if bulk?
+            render RubyUI::TableCell.new do
+              render RubyUI::Checkbox.new(
+                name: "record_ids[]",
+                value: record.id,
+                form: BULK_FORM_ID,
+                data: {rua_row_select: true}
+              )
+            end
+          end
+
+          fields.each_with_index do |field, index|
+            render RubyUI::TableCell.new(class: ("font-medium" if index.zero?)) do
+              link = field.link_to_record? ? resource_show_path(@resource.class, record) : nil
+              render RubyUIAdmin::Views::FieldValue.new(field: field, record: record, link: link)
+            end
+          end
+
+          render RubyUI::TableCell.new(class: "text-right whitespace-nowrap") do
+            render_row_actions(record)
+          end
+        end
+      end
+
+      def render_row_actions(record)
+        cfg = @resource.class.row_controls_config || {}
+        placement = (cfg[:placement] == :left) ? "justify-start" : "justify-end"
+        modes = [("float" if cfg[:float]), ("hover" if cfg[:show_on_hover])].compact.join(" ")
+        data = modes.empty? ? {} : {rua_row_controls: modes}
+
+        div(class: "inline-flex items-center gap-2 #{placement}", data: data) do
+          render_row_controls(record)
+
+          label = rua_t("actions.show")
+          a(href: resource_show_path(@resource.class, record), title: label, aria_label: label,
+            class: "inline-flex p-1 text-muted-foreground hover:text-foreground transition-colors") do
+            render RubyUIAdmin::UI::Icon.new(:eye)
+          end
+
+          if authorized_to?(:update, record, policy_class: policy_class)
+            label = rua_t("actions.edit")
+            a(href: resource_edit_path(@resource.class, record), title: label, aria_label: label,
+              class: "inline-flex p-1 text-muted-foreground hover:text-foreground transition-colors") do
+              render RubyUIAdmin::UI::Icon.new(:pencil)
+            end
+          end
+
+          if authorized_to?(:destroy, record, policy_class: policy_class)
+            render_delete_button(record)
+          end
+        end
+      end
+
+      # Resource `self.row_controls = ->(record) { ... }` — extra per-row buttons/links.
+      # Evaluated in this component (Phlex methods, `control_link`, route helpers available).
+      def render_row_controls(record)
+        controls = @resource.class.row_controls
+        return if controls.nil?
+
+        instance_exec(record, &controls)
+      end
+
+      def render_delete_button(record)
+        form(action: resource_show_path(@resource.class, record), method: "post", class: "inline") do
+          input(type: "hidden", name: "_method", value: "delete")
+          input(type: "hidden", name: "authenticity_token", value: form_authenticity_token)
+          # `rua--confirm#request` opens the shared AlertDialog before submitting (JS); without
+          # JS the form submits directly. The message names the record being deleted.
+          label = rua_t("actions.destroy")
+          button(
+            type: "submit",
+            title: label,
+            aria_label: label,
+            data: {
+              action: "click->rua--confirm#request",
+              rua__confirm_message_param: rua_t("confirm.destroy", model: @resource.record_title(record)),
+              rua__confirm_heading_param: rua_t("confirm.destroy_title")
+            },
+            class: "inline-flex p-1 text-destructive hover:text-destructive/80 transition-colors"
+          ) { render RubyUIAdmin::UI::Icon.new(:trash) }
+        end
+      end
+
+      def render_scope_tabs
+        scopes = @scopes.select { |scope| scope.visible?(user: RubyUIAdmin::Current.user) }
+        return if scopes.empty?
+
+        base = resource_index_path(@resource.class)
+
+        nav(class: "flex items-center gap-1 mb-4 border-b border-border") do
+          unless @remove_scope_all
+            scope_tab(rua_t("index.all"), "#{base}?scope=all", active: @current_scope_key.nil?)
+          end
+          scopes.each do |scope|
+            scope_tab(scope.name, "#{base}?scope=#{scope.key}", active: @current_scope_key == scope.key, title: scope.description)
+          end
+        end
+      end
+
+      def scope_tab(label, href, active:, title: nil)
+        state = active ? "border-primary text-foreground" : "border-transparent text-muted-foreground hover:text-foreground"
+        a(href: href, title: title, class: "px-3 py-2 -mb-px border-b-2 text-sm font-medium #{state}") { label }
+      end
+
+      def render_filter_bar
+        render RubyUIAdmin::Views::FilterBar.new(
+          filters: @filters,
+          values: @filter_values,
+          action_path: resource_index_path(@resource.class),
+          scope_param: @scope_param
+        )
+      end
+
+      def countless_pagy?
+        defined?(Pagy::Countless) && @pagy.is_a?(Pagy::Countless)
+      end
+
+      def render_pagination
+        return if @pagy.nil?
+        # Countless has no total `pages`; render prev/next only.
+        return if countless_pagy? ? !(@pagy.prev || @pagy.next) : @pagy.pages <= 1
+
+        base = resource_index_path(@resource.class)
+        render RubyUIAdmin::UI::Pagination.new(
+          pagy: @pagy,
+          countless: countless_pagy?,
+          url_for_page: ->(page) { "#{base}?#{(@query_params || {}).merge("page" => page).to_query}" }
+        )
+      end
+    end
+  end
+end

data/app/components/ruby_ui_admin/views/path_helpers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    # Resolves the dynamic per-resource engine routes from inside Phlex views.
+    # `rc` is a resource class. Engine routes are reached through the mounted
+    # `ruby_ui_admin` proxy (provided by RailsHelpers / Routes).
+    module PathHelpers
+      def resource_index_path(rc)
+        ruby_ui_admin.public_send("resources_#{rc.route_key}_path")
+      end
+
+      def resource_new_path(rc)
+        ruby_ui_admin.public_send("new_resources_#{rc.singular_route_key}_path")
+      end
+
+      def resource_show_path(rc, record)
+        ruby_ui_admin.public_send("resources_#{rc.singular_route_key}_path", record)
+      end
+
+      def resource_edit_path(rc, record)
+        ruby_ui_admin.public_send("edit_resources_#{rc.singular_route_key}_path", record)
+      end
+
+      # Path to an ActiveStorage blob. Generated via the application's url helpers (NOT the
+      # request-bound `main_app` proxy): ActiveStorage's blob route is a `direct` route, and inside
+      # a mounted engine the proxy prepends the engine's SCRIPT_NAME (e.g. `/admin/rails/...`),
+      # which 404s — AS lives at the host root. `disposition: "attachment"` forces a download.
+      def attachment_url(blob, disposition: nil)
+        opts = {only_path: true}
+        opts[:disposition] = disposition if disposition
+        Rails.application.routes.url_helpers.rails_blob_path(blob, **opts)
+      end
+    end
+  end
+end

data/app/components/ruby_ui_admin/views/rails_helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    # Bundles the non-deprecated phlex-rails helper adapters used across views.
+    # `Routes` brings the host app url helpers plus mounted-engine proxies, so
+    # engine routes are reached via the `ruby_ui_admin` proxy.
+    module RailsHelpers
+      include Phlex::Rails::Helpers::Routes
+      include Phlex::Rails::Helpers::Flash
+      include Phlex::Rails::Helpers::FormAuthenticityToken
+      include Phlex::Rails::Helpers::Request
+    end
+  end
+end

data/app/components/ruby_ui_admin/views/show.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    class Show < Base
+      include StructureRenderer
+      include ShowFields
+      include ActionsMenu
+
+      def initialize(resource:, record:)
+        @resource = resource
+        @record = record
+      end
+
+      def page_title
+        "#{@resource.record_title(@record)} · #{RubyUIAdmin.configuration.app_name}"
+      end
+
+      def content
+        render_header
+        # `space-y-6` separates the structure's top-level sections (the fields card, panels
+        # and tab groups) so they aren't glued together — mirrors the form's `space-y-6`.
+        div(class: "space-y-6") do
+          render_structure(@resource.field_structure(view: :show))
+        end
+      end
+
+      # Lazy tabs (config): non-active show tabs fetch their content when first opened.
+      def lazy_tabs?
+        RubyUIAdmin.configuration.lazy_tabs
+      end
+
+      # URL a lazy tab fetches — the show path with the tab's flat index and `fragment=1`,
+      # so only that tab's structure is rendered (and its queries run) on demand.
+      def tab_fragment_url(flat_index)
+        "#{resource_show_path(@resource.class, @record)}?tab=#{flat_index}&fragment=1"
+      end
+
+      private
+
+      def policy_class
+        @resource.class.authorization_policy
+      end
+
+      def render_header
+        div(class: "flex items-center justify-between mb-6") do
+          div do
+            a(href: resource_index_path(@resource.class), class: "text-sm text-muted-foreground hover:underline") { "← #{@resource.navigation_label}" }
+            h1(class: "text-2xl font-semibold tracking-tight mt-1") { @resource.record_title(@record).to_s }
+          end
+
+          div(class: "flex items-center gap-2") do
+            render_record_actions
+
+            if authorized_to?(:update, @record, policy_class: policy_class)
+              a(
+                href: resource_edit_path(@resource.class, @record),
+                class: "inline-flex items-center h-9 px-4 rounded-md border border-input bg-background text-sm font-medium shadow-sm hover:bg-accent"
+              ) { rua_t("actions.edit") }
+            end
+          end
+        end
+      end
+
+      # Actions available for this single record, shown on the show view. Collapsed into the
+      # searchable Combobox (same as the index) so many actions don't sprawl across the header.
+      def render_record_actions
+        return unless authorized_to?(:act_on, @record, policy_class: policy_class)
+
+        actions = @resource.actions_for(view: :show, record: @record)
+        return if actions.empty?
+
+        render_actions_menu(actions, record_ids: [@record.id])
+      end
+    end
+  end
+end

data/app/components/ruby_ui_admin/views/show_fields.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    # Renders a show field as a label/value row. Shared by the full Show view and the lazy
+    # tab fragment (ShowTab) so both render fields identically. Expects `@record` to be set.
+    module ShowFields
+      # Called by StructureRenderer for each field.
+      def render_field(field)
+        render_field_row(field)
+      end
+
+      def render_field_row(field)
+        # Collection associations render as a full-width table, so the label goes above it
+        # (a left label column would squeeze the table into a third of the width).
+        return render_association_row(field) if %i[has_many has_and_belongs_to_many].include?(field.type)
+
+        div(class: "grid grid-cols-3 gap-4 py-3 border-b border-border last:border-b-0") do
+          dt(class: "text-sm font-medium text-muted-foreground", title: field.description) { field.name }
+          dd(class: "text-sm col-span-2") do
+            render RubyUIAdmin::Views::FieldValue.new(field: field, record: @record)
+          end
+        end
+      end
+
+      def render_association_row(field)
+        div(class: "py-3 space-y-2 border-b border-border last:border-b-0") do
+          div do
+            span(class: "text-sm font-medium text-muted-foreground") { field.name }
+            p(class: "text-xs text-muted-foreground") { field.description } if field.description
+          end
+          render RubyUIAdmin::Views::FieldValue.new(field: field, record: @record)
+        end
+      end
+    end
+  end
+end