ruby_ui_admin 0.1.0

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    # Renders a form input for a field, dispatching on the field type.
+    class FieldInput < Phlex::HTML
+      include RubyUIAdmin::UI
+      include Translation
+
+      def initialize(field:, record:, name_prefix: "record")
+        @field = field
+        @record = record
+        @name_prefix = name_prefix
+      end
+
+      def view_template
+        case @field.type
+        when :boolean then render_boolean
+        when :number then render_number
+        when :date then render_date
+        when :date_time then render_date_time
+        when :textarea then render_textarea
+        when :code then render_code
+        when :key_value then render_key_value
+        when :select then render_select
+        when :url then render_url
+        when :hidden then render_hidden
+        when :password then render_password
+        when :boolean_group then render_boolean_group
+        when :belongs_to then render_belongs_to
+        when :file then render_file
+        when :files then render_files
+        else render_text
+        end
+      end
+
+      private
+
+      def input_name
+        "#{@name_prefix}[#{@field.permitted_param}]"
+      end
+
+      def render_text
+        render RubyUI::Input.new(type: :text, name: input_name, value: @field.value(@record), placeholder: @field.placeholder)
+      end
+
+      def render_number
+        render RubyUI::Input.new(type: :number, name: input_name, value: @field.value(@record))
+      end
+
+      def render_url
+        render RubyUI::Input.new(type: :url, name: input_name, value: @field.value(@record), placeholder: @field.placeholder)
+      end
+
+      def render_password
+        render RubyUI::Input.new(type: :password, name: input_name, autocomplete: "new-password")
+      end
+
+      def render_hidden
+        input(type: :hidden, name: input_name, value: @field.value(@record))
+      end
+
+      def render_date
+        value = @field.value(@record)
+        formatted = value.respond_to?(:strftime) ? value.strftime("%Y-%m-%d") : value
+        render RubyUI::Input.new(type: :date, name: input_name, value: formatted)
+      end
+
+      def render_date_time
+        value = @field.value(@record)
+        formatted = value.respond_to?(:strftime) ? value.strftime("%Y-%m-%dT%H:%M") : value
+        render RubyUI::Input.new(type: "datetime-local", name: input_name, value: formatted)
+      end
+
+      def render_textarea
+        render RubyUI::Textarea.new(name: input_name, rows: @field.rows) { @field.value(@record).to_s }
+      end
+
+      def render_code
+        render RubyUI::Textarea.new(name: input_name, rows: 8, class: "font-mono") { @field.value(@record).to_s }
+      end
+
+      def render_key_value
+        render RubyUI::Textarea.new(name: input_name, rows: 6, class: "font-mono") { @field.value_as_json(@record) }
+      end
+
+      def render_boolean
+        input(type: :hidden, name: input_name, value: "0")
+        render RubyUI::Checkbox.new(name: input_name, value: "1", checked: !!@field.value(@record))
+      end
+
+      def render_boolean_group
+        div(class: "flex flex-col gap-2") do
+          @field.group_options.each do |key, label_text|
+            option_name = "#{input_name}[#{key}]"
+            label(class: "flex items-center gap-2 text-sm") do
+              # Paired hidden "0" so unchecked boxes are submitted (and persisted as false).
+              input(type: :hidden, name: option_name, value: "0")
+              render RubyUI::Checkbox.new(name: option_name, value: "1", checked: @field.checked?(@record, key))
+              plain label_text
+            end
+          end
+        end
+      end
+
+      def render_select
+        render RubyUIAdmin::UI::Select.new(
+          name: input_name,
+          options: @field.select_options(@record),
+          selected: @field.value(@record),
+          include_blank: @field.include_blank?
+        )
+      end
+
+      def render_belongs_to
+        render RubyUIAdmin::UI::Select.new(
+          name: input_name,
+          options: @field.options_for_select,
+          selected: @field.foreign_key_value(@record),
+          include_blank: true
+        )
+      end
+
+      def render_file
+        div(class: "space-y-2") do
+          if @field.respond_to?(:attached?) && @field.attached?(@record)
+            blob = @field.attachment(@record).blob
+            div(class: "flex items-center gap-2 text-sm text-muted-foreground") do
+              render RubyUIAdmin::UI::Icon.new(:file, class: "size-4 shrink-0")
+              span { blob.filename.to_s }
+            end
+            label(class: "flex items-center gap-2 text-sm text-muted-foreground") do
+              render RubyUI::Checkbox.new(name: "#{@name_prefix}[#{@field.remove_param}]", value: "1")
+              plain rua_t("fields.file.remove")
+            end
+          end
+          render RubyUI::Input.new(type: :file, name: input_name, accept: @field.accept)
+        end
+      end
+
+      def render_files
+        div(class: "space-y-2") do
+          @field.attachments(@record).each do |att|
+            label(class: "flex items-center gap-2 text-sm text-muted-foreground") do
+              render RubyUI::Checkbox.new(name: "#{@name_prefix}[#{@field.remove_ids_param}][]", value: att.id.to_s)
+              render RubyUIAdmin::UI::Icon.new(:file, class: "size-4 shrink-0")
+              span { att.blob.filename.to_s }
+            end
+          end
+          # New uploads are appended (not replacing the existing ones); check a box above to remove.
+          render RubyUI::Input.new(type: :file, name: "#{input_name}[]", accept: @field.accept, multiple: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    # Renders a field's value for index/show views, dispatching on the field type.
+    class FieldValue < Phlex::HTML
+      include RubyUIAdmin::UI
+      include RailsHelpers
+      include PathHelpers
+      include Translation
+
+      def initialize(field:, record:, link: nil)
+        @field = field
+        @record = record
+        @link = link
+      end
+
+      def view_template
+        case @field.type
+        when :boolean then render_boolean
+        when :belongs_to then render_belongs_to
+        when :has_one then render_has_one
+        when :has_many, :has_and_belongs_to_many then render_has_many
+        when :record_link then render_record_link
+        when :url then render_url
+        when :badge then render_badge
+        when :status then render_status
+        when :code then render_code
+        when :key_value then render_key_value
+        when :boolean_group then render_boolean_group
+        when :file then render_file
+        when :files then render_files
+        else render_text
+        end
+      end
+
+      private
+
+      def render_text
+        value = @field.formatted_value(@record, view_context: view_context)
+        return plain("—") if value.nil?
+
+        # Computed blocks may return HTML (e.g. `link_to` -> html_safe); `as_html: true` opts a
+        # plain string into raw rendering. Everything else is escaped.
+        if (value.respond_to?(:html_safe?) && value.html_safe?) || (@field.respond_to?(:as_html?) && @field.as_html?)
+          # User-rendered HTML (e.g. `link_to` in a field block) carries no admin styling.
+          # The `contents` wrapper is layout-neutral and scopes `.rua-rich a` so raw links
+          # underline on hover, matching the framework's own links.
+          span(class: "rua-rich contents") { raw(safe(value.to_s)) }
+        elsif @link && @field.link_to_record?
+          render RubyUI::InlineLink.new(href: @link) { value.to_s }
+        else
+          plain value.to_s
+        end
+      end
+
+      def render_boolean
+        if @field.value(@record)
+          render RubyUI::Badge.new(variant: :success) { rua_t("booleans.true") }
+        else
+          render RubyUI::Badge.new(variant: :gray) { rua_t("booleans.false") }
+        end
+      end
+
+      def render_belongs_to
+        associated = @field.value(@record)
+        return plain("—") if associated.nil?
+
+        render_record_link_to(associated, @field.display_label(associated))
+      end
+
+      def render_has_one
+        associated = @field.associated_record(@record)
+        return plain("—") if associated.nil?
+
+        render_record_link_to(associated, @field.display_label(associated))
+      end
+
+      def render_has_many
+        count = @field.count(@record)
+        return plain("—") if count.zero?
+
+        shown = @field.associated_records(@record, limit: 10).to_a
+        # Columns come from the record's own resource (the fields must match the record's model);
+        # the row link routes through `use_resource:` when given, else the record's own resource.
+        column_resource = record_resource_class(shown.first)
+        link_resource = (@field.respond_to?(:use_resource) && @field.use_resource) || column_resource
+        columns = association_columns(column_resource)
+
+        div(class: "space-y-2") do
+          span(class: "text-xs font-medium text-muted-foreground") { rua_t("associations.count", count: count) }
+          render_association_table(shown, link_resource, columns)
+
+          if count > shown.size
+            p(class: "text-xs text-muted-foreground") { rua_t("associations.more", count: count - shown.size) }
+          end
+        end
+      end
+
+      # Renders associated records as a RubyUI Table. When the associated model has a registered
+      # resource, its index fields become the columns (Avo-style) and each row links to the
+      # record's show page. Otherwise it falls back to a single column of record links.
+      def render_association_table(records, resource_class, columns)
+        render RubyUI::Table.new do
+          if columns
+            render RubyUI::TableHeader.new do
+              render RubyUI::TableRow.new do
+                columns.each { |field| render RubyUI::TableHead.new { field.name } }
+              end
+            end
+          end
+
+          render RubyUI::TableBody.new do
+            records.each do |rec|
+              path = association_show_path(resource_class, rec)
+              attrs = if path
+                {class: "cursor-pointer", data: {controller: "rua--row-link", action: "click->rua--row-link#navigate", rua__row_link_url_value: path}}
+              else
+                {}
+              end
+              render RubyUI::TableRow.new(**attrs) do
+                if columns
+                  columns.each_with_index do |field, index|
+                    render RubyUI::TableCell.new(class: ("font-medium" if index.zero?)) do
+                      link = field.link_to_record? ? path : nil
+                      render RubyUIAdmin::Views::FieldValue.new(field: field, record: rec, link: link)
+                    end
+                  end
+                else
+                  render RubyUI::TableCell.new { render_record_link_to(rec, @field.display_label(rec)) }
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # The resource registered for a record's own model (used to build the table columns), or nil.
+      def record_resource_class(record)
+        return nil if record.nil?
+
+        RubyUIAdmin.resource_manager.find_for_model(record.class)
+      end
+
+      # The columns for the association table. By default the associated resource's index fields;
+      # an explicit `fields:` option on the association field picks a subset (in that order) by
+      # field id — e.g. `field :suppliers, as: :has_many, fields: %i[name identifier state]`.
+      # Returns nil (single-column fallback) when there's no resource or the fields can't be built.
+      def association_columns(resource_class)
+        return nil unless resource_class
+
+        requested = Array(@field.options[:fields]).map(&:to_sym)
+        columns =
+          if requested.any?
+            by_id = resource_class.new.get_fields(view: nil).index_by(&:id)
+            requested.filter_map { |fid| by_id[fid] }
+          else
+            resource_class.new.get_fields(view: :index)
+          end
+        columns.presence
+      rescue StandardError
+        nil
+      end
+
+      def association_show_path(resource_class, record)
+        return nil unless resource_class
+
+        ruby_ui_admin.public_send("resources_#{resource_class.singular_route_key}_path", record)
+      rescue StandardError
+        nil
+      end
+
+      def render_record_link
+        linked = @field.linked_record(@record)
+        return plain("—") if linked.nil?
+
+        target = @field.target_resource(linked)
+        label = @field.display_label(linked)
+        path = target && ruby_ui_admin.public_send("resources_#{target.singular_route_key}_path", linked)
+
+        if path
+          render RubyUI::InlineLink.new(href: path) { label.to_s }
+        else
+          plain label.to_s
+        end
+      end
+
+      def render_url
+        url = @field.value(@record)
+        return plain("—") if url.blank?
+
+        render RubyUI::InlineLink.new(href: url, target: @field.target) { @field.link_text(@record).to_s }
+      end
+
+      def render_badge
+        value = @field.value(@record)
+        return plain("—") if value.blank?
+
+        render RubyUI::Badge.new(variant: @field.variant_for(@record)) { value.to_s }
+      end
+
+      def render_status
+        value = @field.value(@record)
+        return plain("—") if value.blank?
+
+        render RubyUI::Badge.new(variant: @field.variant_for(@record)) { value.to_s }
+      end
+
+      def render_code
+        value = @field.value(@record)
+        lang = @field.respond_to?(:language) ? @field.language : nil
+        pre(class: "rounded-md bg-muted p-3 overflow-x-auto text-xs") do
+          # `language-<lang>` + data-language are the conventions syntax highlighters hook into.
+          code(class: ("language-#{lang}" if lang), data: {language: lang}) { value.to_s }
+        end
+      end
+
+      def render_key_value
+        value = @field.value(@record)
+        return plain("—") if value.blank?
+
+        dl(class: "text-sm") do
+          value.each do |key, val|
+            div(class: "flex gap-2") do
+              dt(class: "font-medium text-muted-foreground") { "#{key}:" }
+              dd { val.to_s }
+            end
+          end
+        end
+      end
+
+      def render_boolean_group
+        div(class: "flex flex-wrap gap-1") do
+          @field.group_options.each do |key, label_text|
+            on = @field.checked?(@record, key)
+            render RubyUI::Badge.new(variant: on ? :success : :gray) { label_text.to_s }
+          end
+        end
+      end
+
+      def render_file
+        return plain("—") unless @field.attached?(@record)
+
+        render_attachment(@field.attachment(@record))
+      end
+
+      def render_files
+        attachments = @field.attachments(@record)
+        return plain("—") if attachments.blank?
+
+        div(class: "flex flex-col gap-2") do
+          attachments.each { |attachment| render_attachment(attachment) }
+        end
+      end
+
+      # An attached file: images render as a thumbnail linking to the file; everything else is a
+      # download link with the filename. Both resolve the URL through the host's ActiveStorage routes.
+      def render_attachment(attachment)
+        blob = attachment.respond_to?(:blob) ? attachment.blob : attachment
+        return plain("—") unless blob
+
+        if blob.content_type.to_s.start_with?("image/")
+          a(href: attachment_url(blob), target: "_blank", rel: "noopener", class: "inline-block") do
+            img(src: attachment_url(blob), alt: blob.filename.to_s, **image_preview_attrs)
+          end
+        else
+          a(href: attachment_url(blob, disposition: "attachment"), class: "inline-flex items-center gap-1.5 text-sm text-primary hover:underline") do
+            render RubyUIAdmin::UI::Icon.new(:download, class: "size-4 shrink-0")
+            plain blob.filename.to_s
+          end
+        end
+      end
+
+      # Thumbnail sizing. With `preview_size:` on the field, the image is capped at that W×H (px)
+      # via an inline max-width/max-height (so large images scale down, preserving aspect). Inline
+      # style — not a Tailwind class — because the size is dynamic and wouldn't be in the CSS build.
+      def image_preview_attrs
+        size = @field.respond_to?(:preview_size) ? @field.preview_size : nil
+        return {class: "h-16 w-16 rounded-md border border-border object-cover"} unless size
+
+        w, h = Array(size).first(2)
+        h ||= w
+        {class: "rounded-md border border-border object-contain", style: "max-width: #{w.to_i}px; max-height: #{h.to_i}px"}
+      end
+
+      # Links to a record's show page through its registered resource, if any.
+      # A field's `use_resource:` overrides the default model→resource lookup.
+      def render_record_link_to(record, label)
+        rc = (@field.respond_to?(:use_resource) && @field.use_resource) ||
+          RubyUIAdmin.resource_manager.find_for_model(record.class)
+
+        if rc
+          path = ruby_ui_admin.public_send("resources_#{rc.singular_route_key}_path", record)
+          render RubyUI::InlineLink.new(href: path) { label.to_s }
+        else
+          plain label.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Views
+    # Renders a GET form with one control per filter, above the index table.
+    class FilterBar < Phlex::HTML
+      include RubyUIAdmin::UI
+      include Translation
+
+      def initialize(filters:, values:, action_path:, scope_param: nil)
+        @filters = filters
+        @values = values || {}
+        @action_path = action_path
+        @scope_param = scope_param
+      end
+
+      def view_template
+        return if @filters.empty?
+
+        render RubyUI::Card.new(class: "mb-4") do
+          render RubyUI::CardContent.new(class: "pt-6") do
+            form(method: "get", action: @action_path, class: "flex flex-wrap items-end gap-4") do
+              # Preserve the active scope when applying filters.
+              input(type: "hidden", name: "scope", value: @scope_param) if @scope_param.present?
+
+              @filters.each { |filter| render_filter(filter) }
+              render_buttons
+            end
+          end
+        end
+      end
+
+      private
+
+      def render_filter(filter)
+        key = filter.param_key
+
+        div(class: "space-y-1 min-w-48") do
+          label(class: "text-xs font-medium text-muted-foreground") { filter.name }
+
+          case filter.type
+          when :select
+            render RubyUIAdmin::UI::Select.new(name: "filters[#{key}]", options: option_pairs(filter), selected: @values[key], include_blank: true)
+          when :multiple_select
+            render_checkboxes(filter, key, multiple: true)
+          when :boolean
+            if filter.options.present?
+              render_checkboxes(filter, key, multiple: false)
+            else
+              render RubyUIAdmin::UI::Select.new(name: "filters[#{key}]", options: [["Yes", "true"], ["No", "false"]], selected: @values[key], include_blank: true)
+            end
+          else
+            render RubyUI::Input.new(type: :text, name: "filters[#{key}]", value: @values[key])
+          end
+        end
+      end
+
+      # Renders the option set with RubyUI's Combobox (searchable popover with checkboxes),
+      # so filters with many options stay compact and match the rest of the RubyUI UI.
+      #
+      # `multiple: true`  -> array value, name `filters[key][]`.
+      # `multiple: false` -> hash value (boolean filter), name `filters[key][optkey]` with a
+      #                      paired hidden "false" so unchecked boxes are still submitted.
+      def render_checkboxes(filter, key, multiple:)
+        selected = @values[key]
+
+        render RubyUI::Combobox.new(term: rua_t("index.selected_suffix")) do
+          render RubyUI::ComboboxTrigger.new(placeholder: rua_t("index.all"))
+          render RubyUI::ComboboxPopover.new do
+            render RubyUI::ComboboxSearchInput.new(placeholder: rua_t("index.search"))
+            render RubyUI::ComboboxList.new do
+              render(RubyUI::ComboboxEmptyState.new) { rua_t("index.no_results") }
+              option_pairs(filter).each do |(label_text, value)|
+                input_name = multiple ? "filters[#{key}][]" : "filters[#{key}][#{value}]"
+                render RubyUI::ComboboxItem.new do
+                  input(type: :hidden, name: input_name, value: "false") unless multiple
+                  render RubyUI::ComboboxCheckbox.new(
+                    name: input_name,
+                    value: multiple ? value.to_s : "true",
+                    checked: checkbox_checked?(selected, value, multiple)
+                  )
+                  span { label_text }
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def checkbox_checked?(selected, value, multiple)
+        if multiple
+          Array(selected).map(&:to_s).include?(value.to_s)
+        else
+          selected.is_a?(Hash) && selected[value.to_s].to_s == "true"
+        end
+      end
+
+      def option_pairs(filter)
+        options = filter.options
+        options.is_a?(Hash) ? options.map { |value, label| [label, value] } : Array(options)
+      end
+
+      def render_buttons
+        div(class: "flex items-center gap-2") do
+          render(RubyUI::Button.new(type: :submit, variant: :primary)) { rua_t("index.filter") }
+          a(href: @action_path, class: "text-sm text-muted-foreground hover:underline") { rua_t("index.clear") }
+        end
+      end
+    end
+  end
+end