ruby_ui_admin 0.1.0

data/lib/ruby_ui_admin/fields/belongs_to_field.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class BelongsToField < BaseField
+      register_as :belongs_to
+
+      # belongs_to writes/reads the foreign key column.
+      def database_id
+        :"#{id}_id"
+      end
+
+      def foreign_key_value(record)
+        record.public_send(database_id) if record&.respond_to?(database_id)
+      end
+
+      # The ActiveRecord reflection for this association on the resource model.
+      def reflection
+        resource&.model_class&.reflect_on_association(id)
+      end
+
+      def target_model
+        options[:model] || reflection&.klass
+      end
+
+      # Candidate records to choose from in forms. Capped to avoid huge selects.
+      def options_for_select(limit: 1000)
+        model = target_model
+        return [] if model.nil?
+
+        model.all.limit(limit).map { |record| [display_label(record), record.id] }
+      end
+
+      def display_label(record)
+        return nil if record.nil?
+
+        if record.respond_to?(:to_label)
+          record.to_label
+        elsif record.respond_to?(:name)
+          record.name
+        elsif record.respond_to?(:title)
+          record.title
+        else
+          "#{record.model_name.human} ##{record.id}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/boolean_field.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class BooleanField < BaseField
+      register_as :boolean
+
+      def checked?(record)
+        !!value(record)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/boolean_group_field.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # A group of checkboxes whose value is a Hash of `{ key => boolean }`.
+    #   field :feature_flags, as: :boolean_group, options: { "beta" => "Beta", "pro" => "Pro" }
+    class BooleanGroupField < BaseField
+      register_as :boolean_group
+
+      def default_hidden_views
+        %i[index]
+      end
+
+      # `{ key => label }`. `options:` may be a Hash, an Array of keys, or a lambda.
+      def group_options
+        raw = options[:options] || {}
+        raw = ExecutionContext.new(target: raw, resource: resource).handle if raw.respond_to?(:call)
+
+        raw.is_a?(Hash) ? raw.transform_keys(&:to_s) : Array(raw).to_h { |key| [key.to_s, key.to_s.humanize] }
+      end
+
+      def checked?(record, key)
+        value = value(record)
+        return false unless value.respond_to?(:[])
+
+        truthy?(value[key.to_s].nil? ? value[key.to_sym] : value[key.to_s])
+      end
+
+      def enabled_labels(record)
+        group_options.select { |key, _label| checked?(record, key) }.values
+      end
+
+      # Hash param: permit arbitrary nested keys.
+      def permit_param
+        {permitted_param => {}}
+      end
+
+      # Build the full { key => bool } hash from the submitted (checked-only) params.
+      def fill_value(record, submitted)
+        submitted ||= {}
+        result = group_options.keys.to_h { |key| [key, truthy?(submitted[key])] }
+
+        setter = "#{database_id}="
+        record.public_send(setter, result) if record.respond_to?(setter)
+      end
+
+      private
+
+      def truthy?(value)
+        ["1", "true", true].include?(value)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/code_field.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class CodeField < BaseField
+      register_as :code
+
+      def language
+        options[:language]
+      end
+
+      # Code can be large; keep it off the index by default.
+      def default_hidden_views
+        %i[index]
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/date_field.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class DateField < BaseField
+      register_as :date
+
+      DEFAULT_FORMAT = "%Y-%m-%d"
+
+      def format
+        options[:format] || DEFAULT_FORMAT
+      end
+
+      def formatted_value(record, view_context: nil)
+        raw = value(record, view_context: view_context)
+        return nil if raw.nil?
+        return super if @format_using
+        return raw unless raw.respond_to?(:strftime)
+
+        fmt = options[:format]
+        # A String `format:` is an explicit strftime pattern; otherwise localize via I18n.l
+        # (Symbol = named locale format, nil = gem's locale-aware default) so pt-BR renders
+        # "%d/%m/%Y", en "%Y-%m-%d", etc.
+        return raw.strftime(fmt) if fmt.is_a?(String)
+
+        begin
+          I18n.l(raw, format: fmt || :ruby_ui_admin)
+        rescue
+          raw.strftime(DEFAULT_FORMAT)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/date_time_field.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class DateTimeField < BaseField
+      register_as :date_time
+
+      DEFAULT_FORMAT = "%Y-%m-%d %H:%M"
+
+      def format
+        options[:format] || DEFAULT_FORMAT
+      end
+
+      def formatted_value(record, view_context: nil)
+        raw = value(record, view_context: view_context)
+        return nil if raw.nil?
+        return super if @format_using
+
+        # Display in the admin's configured timezone (set per-request from config.timezone).
+        raw = raw.in_time_zone if raw.respond_to?(:in_time_zone)
+        return raw unless raw.respond_to?(:strftime)
+
+        fmt = options[:format]
+        # A String `format:` is an explicit strftime pattern; otherwise localize via I18n.l
+        # (a Symbol picks a named locale format; nil uses the gem's locale-aware default), so
+        # pt-BR renders "%d/%m/%Y %H:%M", en "%Y-%m-%d %H:%M", etc.
+        return raw.strftime(fmt) if fmt.is_a?(String)
+
+        begin
+          I18n.l(raw, format: fmt || :ruby_ui_admin)
+        rescue
+          raw.strftime(DEFAULT_FORMAT)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/field_manager.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # Registry mapping a DSL symbol (`as: :text`) to a field class.
+    # Each field subclass registers itself via `register_as`.
+    @mapping = {}
+
+    class << self
+      attr_reader :mapping
+
+      def register(key, klass)
+        @mapping[key.to_sym] = klass
+      end
+
+      def field_class_for(key)
+        @mapping.fetch(key.to_sym) do
+          raise ArgumentError, "Unknown field type :#{key}. Registered: #{@mapping.keys.join(", ")}"
+        end
+      end
+
+      def registered?(key)
+        @mapping.key?(key.to_sym)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/file_field.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # Single ActiveStorage attachment.
+    class FileField < BaseField
+      register_as :file
+
+      def default_hidden_views
+        %i[index]
+      end
+
+      def multiple?
+        false
+      end
+
+      def accept
+        options[:accept]
+      end
+
+      # Max display size (W×H, px) for an image thumbnail on the show view. Accepts an Integer
+      # (square, e.g. `preview_size: 100`) or `[width, height]` (e.g. `[120, 80]`). Applied as a
+      # max-width/max-height (the image scales down to fit, preserving aspect). Defaults to 64×64.
+      def preview_size
+        options[:preview_size]
+      end
+
+      def attachment(record)
+        record.public_send(id) if record.respond_to?(id)
+      end
+
+      def attached?(record)
+        att = attachment(record)
+        att.respond_to?(:attached?) && att.attached?
+      end
+
+      # Skip empty uploads so we don't blow away an existing attachment.
+      def fill_value(record, value)
+        return if value.blank?
+
+        setter = "#{id}="
+        record.public_send(setter, value) if record.respond_to?(setter)
+      end
+
+      # Form param for the "remove current file" checkbox.
+      def remove_param
+        :"#{permitted_param}_remove"
+      end
+
+      # Also permit the remove checkbox alongside the upload.
+      def permit_params
+        [permit_param, remove_param]
+      end
+
+      # Purge the current attachment when "remove" is checked; otherwise assign the upload
+      # (skipping blank so an empty input doesn't wipe an existing attachment).
+      def fill(record, attributes)
+        if ActiveModel::Type::Boolean.new.cast(attributes[remove_param.to_s])
+          record.public_send(id).purge if attached?(record)
+          return
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/files_field.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # Multiple ActiveStorage attachments (has_many_attached).
+    class FilesField < FileField
+      register_as :files
+
+      def multiple?
+        true
+      end
+
+      # Submitted as an array (record[avatars][]).
+      def permit_param
+        {permitted_param => []}
+      end
+
+      # Form param holding the ids of attachments marked for removal.
+      def remove_ids_param
+        :"#{permitted_param}_remove_ids"
+      end
+
+      # Permit the upload array plus the array of attachment ids to remove.
+      def permit_params
+        [permit_param, {remove_ids_param => []}]
+      end
+
+      def attachments(record)
+        att = attachment(record)
+        return [] unless att.respond_to?(:attached?) && att.attached?
+
+        att
+      end
+
+      # Purge the attachments the user checked, then APPEND any new uploads (unlike the single
+      # `:file`, new files don't replace the existing set). Both skip blanks/empties.
+      def fill(record, attributes)
+        purge_marked(record, attributes[remove_ids_param.to_s])
+        attach_new(record, attributes[permitted_param.to_s])
+      end
+
+      private
+
+      def purge_marked(record, ids)
+        ids = Array(ids).map(&:to_s).reject(&:blank?)
+        return if ids.empty?
+
+        collection = record.public_send(id)
+        return unless collection.respond_to?(:each)
+
+        collection.each { |att| att.purge if ids.include?(att.id.to_s) }
+      end
+
+      def attach_new(record, files)
+        files = Array(files).reject(&:blank?)
+        return if files.empty?
+
+        record.public_send(id).attach(files)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/has_and_belongs_to_many_field.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class HasAndBelongsToManyField < HasManyField
+      register_as :has_and_belongs_to_many
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/has_many_field.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class HasManyField < AssociationField
+      register_as :has_many
+
+      # Capped collection of associated records for display on the show view.
+      def associated_records(record, limit: 25)
+        collection = scoped(value(record))
+        return [] if collection.nil?
+
+        collection.respond_to?(:limit) ? collection.limit(limit) : Array(collection).first(limit)
+      end
+
+      def count(record)
+        collection = scoped(value(record))
+        return 0 if collection.nil?
+
+        collection.respond_to?(:count) ? collection.count : Array(collection).size
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/has_one_field.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class HasOneField < AssociationField
+      register_as :has_one
+
+      def associated_record(record)
+        value(record)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/hidden_field.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # Renders only as a hidden input on forms; not shown on index/show.
+    class HiddenField < BaseField
+      register_as :hidden
+
+      def default_hidden_views
+        %i[index show]
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/id_field.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class IdField < BaseField
+      register_as :id
+
+      def initialize(id = :id, **options, &block)
+        super
+        @link_to_record = options.fetch(:link_to_record, true)
+      end
+
+      # The id isn't editable, so keep it off the new/edit forms.
+      def default_hidden_views
+        %i[new edit]
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/key_value_field.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyUIAdmin
+  module Fields
+    # Edits a Hash value. Displayed as a key/value table; edited as JSON in a textarea.
+    class KeyValueField < BaseField
+      register_as :key_value
+
+      def default_hidden_views
+        %i[index]
+      end
+
+      def value_as_json(record)
+        raw = value(record)
+        return "{}" if raw.blank?
+
+        JSON.pretty_generate(raw)
+      rescue
+        raw.to_s
+      end
+
+      # Parse the submitted JSON back into a Hash before assigning.
+      def fill_value(record, value)
+        parsed =
+          if value.is_a?(String) && value.present?
+            begin
+              JSON.parse(value)
+            rescue JSON::ParserError
+              value
+            end
+          else
+            value
+          end
+
+        super(record, parsed)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/number_field.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class NumberField < BaseField
+      register_as :number
+
+      def step = options[:step]
+      def min = options[:min]
+      def max = options[:max]
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/password_field.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # Password input on forms; never displays the stored value.
+    class PasswordField < BaseField
+      register_as :password
+
+      def default_hidden_views
+        %i[index show]
+      end
+
+      # Don't write a blank password back onto the record.
+      def fill_value(record, value)
+        return if value.blank?
+
+        super
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/record_link_field.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # Renders a link to another record, resolved through a named resource:
+    #   field :detail, as: :record_link, use_resource: "FormGroup", only_on: :show
+    class RecordLinkField < BaseField
+      register_as :record_link
+
+      def default_hidden_views
+        %i[new edit]
+      end
+
+      def use_resource
+        options[:use_resource]
+      end
+
+      def linked_record(record)
+        value(record)
+      end
+
+      def display_label(record)
+        return nil if record.nil?
+
+        if record.respond_to?(:to_label) then record.to_label
+        elsif record.respond_to?(:name) then record.name
+        elsif record.respond_to?(:title) then record.title
+        else "#{record.model_name.human} ##{record.id}"
+        end
+      end
+
+      # The resource class used to build the link.
+      def target_resource(linked = nil)
+        if use_resource
+          RubyUIAdmin.resource_manager.resources.find { |r| r.name.to_s.demodulize == use_resource.to_s } ||
+            (Object.const_get("RubyUIAdmin::Resources::#{use_resource}") rescue nil)
+        elsif linked
+          RubyUIAdmin.resource_manager.find_for_model(linked.class)
+        end
+      end
+
+      def fill_value(record, value); end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/select_field.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class SelectField < BaseField
+      register_as :select
+
+      # Resolves the configured options into an array of [label, value] pairs.
+      # `options:` accepts an Array, a Hash ({value => label}), or a lambda.
+      # `enum:` derives options from an ActiveRecord enum: pass the enum mapping
+      # (`enum: Post.statuses`) or `enum: true` to read `model_class.<id.pluralize>`.
+      def select_options(record = nil)
+        return enum_options if enum_options
+
+        raw = options[:options]
+        if raw.respond_to?(:call)
+          # The options lambda can use `record`/`resource` plus `params`/`view` (e.g. an
+          # options list that depends on the request, like a nested-create parent id).
+          raw = ExecutionContext.new(
+            target: raw,
+            record: record,
+            resource: resource,
+            params: resource&.params,
+            view: View.wrap(resource&.view)
+          ).handle
+        end
+
+        pairs =
+          case raw
+          when Hash then raw.map { |value, label| [label, value] }
+          when Array then raw.map { |entry| entry.is_a?(Array) ? entry : [entry, entry] }
+          else []
+          end
+
+        # `display_with_value: true` -> option labels become "Label (value)".
+        return pairs.map { |(label, value)| ["#{label} (#{value})", value] } if options[:display_with_value]
+
+        pairs
+      end
+
+      def include_blank?
+        options.fetch(:include_blank, !required?)
+      end
+
+      # `[label, value]` pairs derived from an ActiveRecord enum, or nil when no `enum:`.
+      def enum_options
+        enum = options[:enum]
+        return nil if enum.nil? || enum == false
+
+        mapping =
+          if enum == true
+            resource&.model_class&.public_send(id.to_s.pluralize)
+          else
+            enum
+          end
+        return nil unless mapping.respond_to?(:keys)
+
+        mapping.keys.map { |key| [key.to_s.humanize, key.to_s] }
+      end
+
+      # Display label for the current value.
+      def formatted_value(record, view_context: nil)
+        raw = value(record, view_context: view_context)
+        return super if @format_using
+
+        pair = select_options(record).find { |(_label, val)| val.to_s == raw.to_s }
+        pair ? pair.first : raw
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/status_field.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    # Renders the value as a status badge with a leading dot. Configure with
+    # `options: { success: %w[done], warning: %w[pending], danger: %w[failed] }`.
+    class StatusField < BaseField
+      register_as :status
+
+      VARIANT_FOR_STATE = {success: :success, warning: :warning, danger: :destructive, info: :primary}.freeze
+
+      def variant_for(record)
+        current = value(record).to_s
+        states = options[:options] || {}
+
+        state = states.find { |_key, values| Array(values).map(&:to_s).include?(current) }&.first
+        VARIANT_FOR_STATE.fetch(state&.to_sym, :gray)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/text_field.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class TextField < BaseField
+      register_as :text
+
+      # Render the raw value as HTML (`as_html: true`).
+      def as_html?
+        !!options[:as_html]
+      end
+    end
+  end
+end