ruby_ui_scaffold 0.1.0

data/lib/ruby_ui_scaffold/attribute_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyUiScaffold
+  # Shared helpers used by both the scaffold_controller and views generators
+  # to identify which attributes participate in sort and search.
+  module AttributeHelpers
+    EXCLUDED_FROM_SORT = %i[text rich_text json jsonb binary attachment attachments].freeze
+
+    # Columns we'll allowlist for sorting. Excludes large/blob types and
+    # password digests, since sorting on them makes no sense.
+    def sortable_columns
+      attributes.reject { |a|
+        EXCLUDED_FROM_SORT.include?(a.type) ||
+          (a.respond_to?(:password_digest?) && a.password_digest?) ||
+          (a.respond_to?(:attachment?) && (a.attachment? || a.attachments?))
+      }.map(&:column_name)
+    end
+
+    # Only string columns are searchable via a LIKE clause. Excludes
+    # password_digest. Boolean/integer/date columns aren't useful with LIKE.
+    def searchable_columns
+      attributes.select { |a|
+        a.type == :string &&
+          !(a.respond_to?(:password_digest?) && a.password_digest?)
+      }.map(&:column_name)
+    end
+
+    # Non-polymorphic belongs_to attributes — used to:
+    #   1. Eager-load via `scope.includes(*reference_associations)` in the controller
+    #   2. Display friendly labels (assoc.name vs assoc_id) in index/show
+    def reference_associations
+      attributes.select do |a|
+        a.respond_to?(:reference?) && a.reference? &&
+          !(a.respond_to?(:polymorphic?) && a.polymorphic?)
+      end.map { |a| a.name.to_sym }
+    end
+  end
+end

data/lib/ruby_ui_scaffold/component_installer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyUiScaffold
+  # Shared helpers for generators that install ruby_ui components. Mixed into
+  # both the install generator (base set) and the scaffold generator
+  # (column/flag-specific set). Relies on the including class exposing
+  # `destination_root` (every Rails generator does).
+  module ComponentInstaller
+    # A ruby_ui component is considered installed once its package directory
+    # (or single-file component) exists under app/components/ruby_ui/. Guarding
+    # on this is essential: `ruby_ui:component` copies files WITHOUT --force,
+    # so re-installing a present component prompts interactively — which would
+    # hang a non-interactive subprocess.
+    def component_installed?(name)
+      base = File.join(destination_root, "app/components/ruby_ui", name)
+      Dir.exist?(base) || File.exist?("#{base}.rb")
+    end
+
+    # The subset of `names` not yet installed, preserving order.
+    def uninstalled_components(names)
+      names.reject { |name| component_installed?(name) }
+    end
+  end
+end

data/lib/ruby_ui_scaffold/component_resolver.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RubyUiScaffold
+  # Resolves which ruby_ui components a scaffold references, given its
+  # attributes and options. Only DIRECT references are listed — the
+  # `ruby_ui:component NAME` generator resolves transitive dependencies
+  # itself (e.g. `date_picker` pulls `calendar` + `popover` + `input`;
+  # `data_table` pulls `table`, `checkbox`, `native_select`, `pagination`,
+  # `dropdown_menu`, `input`, `button`). See ruby_ui's `dependencies.yml`.
+  #
+  # @example
+  #   RubyUiScaffold::ComponentResolver.call(attributes: attrs, datatable: false)
+  #   # => ["alert_dialog", "badge", "button", ...]
+  module ComponentResolver
+    # Components every generated scaffold uses, regardless of columns/flags.
+    # The install generator pre-installs these so a bare `:install` leaves the
+    # ground ready; the scaffold then adds the column/flag-specific ones.
+    #
+    #   index  → table, link, button, dropdown_menu, alert_dialog
+    #   show   → card, typography (Text), link, button
+    #   form   → form (FormField*), input, button
+    BASE = %w[
+      table
+      link
+      button
+      card
+      typography
+      dropdown_menu
+      alert_dialog
+      form
+      input
+    ].freeze
+
+    module_function
+
+    # The full set of ruby_ui component generator names a scaffold with these
+    # attributes/options references — BASE plus the column/flag conditionals.
+    # Returns a sorted, de-duplicated array.
+    def call(attributes:, datatable: false)
+      components = BASE.dup
+      components << "data_table" if datatable
+
+      attributes.each do |attribute|
+        components.concat(components_for_attribute(attribute))
+      end
+
+      components.uniq.sort
+    end
+
+    # Conditional components a single attribute pulls in:
+    #   boolean   → Badge (index/show) + Checkbox (form)
+    #   text      → Textarea (form)
+    #   reference → Combobox + Select (form) — polymorphic falls back to a
+    #               plain number Input, so it adds nothing
+    #   date      → DatePicker (form)
+    # Everything else (string/integer/float/decimal/time/datetime/password/
+    # attachment/polymorphic reference) maps to the base `input`.
+    def components_for_attribute(attribute)
+      return %w[combobox select] if reference?(attribute)
+
+      case attribute.type
+      when :boolean then %w[badge checkbox]
+      when :text    then %w[textarea]
+      when :date    then %w[date_picker]
+      else               []
+      end
+    end
+
+    def reference?(attribute)
+      attribute.respond_to?(:reference?) && attribute.reference? &&
+        !(attribute.respond_to?(:polymorphic?) && attribute.polymorphic?)
+    end
+  end
+end

data/lib/ruby_ui_scaffold/field_type_mapper.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RubyUiScaffold
+  # Maps a Rails::Generators::GeneratedAttribute to a ruby_ui input
+  # component, emitted as a Ruby code snippet for interpolation into
+  # a Phlex view template.
+  #
+  # Multi-line snippets are returned with newline separators and NO
+  # leading indentation; the caller is responsible for indenting
+  # subsequent lines to match its context. The generator wraps this
+  # via `ruby_ui_input_for(attribute, indent:)`.
+  #
+  # @example
+  #   RubyUiScaffold::FieldTypeMapper.render(attribute, model_var: "user")
+  #   # => 'Input(type: "text", id: "user_name", name: "user[name]", value: @user.name)'
+  class FieldTypeMapper
+    def self.render(attribute, model_var:)
+      new(attribute, model_var).render
+    end
+
+    def initialize(attribute, model_var)
+      @attr = attribute
+      @model_var = model_var.to_s
+    end
+
+    def render
+      return password_input if @attr.respond_to?(:password_digest?) && @attr.password_digest?
+      return file_input     if @attr.respond_to?(:attachment?) && (@attr.attachment? || @attr.attachments?)
+      return reference_input if @attr.respond_to?(:reference?) && @attr.reference?
+
+      type_input
+    end
+
+    private
+
+    def type_input
+      case @attr.type
+      when :text                    then textarea
+      when :boolean                 then checkbox
+      when :integer                 then input("number", step: 1)
+      when :float, :decimal         then input("number", step: "any")
+      when :date                    then date_picker
+      when :time                    then input("time", value_suffix: %q{&.strftime("%H:%M")})
+      when :datetime, :timestamp    then input("datetime-local", value_suffix: %q{&.strftime("%Y-%m-%dT%H:%M")})
+      else                               input("text")
+      end
+    end
+
+    def id_attr
+      "#{@model_var}_#{@attr.column_name}"
+    end
+
+    def name_attr
+      "#{@model_var}[#{@attr.column_name}]"
+    end
+
+    def value_ref
+      "@#{@model_var}.#{@attr.column_name}"
+    end
+
+    def input(type, step: nil, value_suffix: nil)
+      value_expr = value_suffix ? "#{value_ref}#{value_suffix}" : value_ref
+      step_part = step ? %Q{, step: #{step.is_a?(String) ? %Q{"#{step}"} : step}} : ""
+      %Q{Input(type: "#{type}", id: "#{id_attr}", name: "#{name_attr}", value: #{value_expr}#{step_part})}
+    end
+
+    # ruby_ui DatePicker renders its own submittable <input> internally (name/
+    # value), wrapped in a Popover + Calendar. We pass the Date straight to
+    # `selected_date:` — the component derives the input's string value via
+    # `selected_date.to_s`, which is already ISO (yyyy-MM-dd), matching its
+    # default `date_format`. `label: nil` suppresses the component's built-in
+    # label, since the form template already emits a FormFieldLabel.
+    def date_picker
+      %Q{DatePicker(id: "#{id_attr}", name: "#{name_attr}", selected_date: #{value_ref}, label: nil)}
+    end
+
+    def textarea
+      <<~RUBY.chomp
+        Textarea(rows: 4, id: "#{id_attr}", name: "#{name_attr}") do
+          #{value_ref}.to_s
+        end
+      RUBY
+    end
+
+    def checkbox
+      <<~RUBY.chomp
+        input(type: "hidden", name: "#{name_attr}", value: "0")
+        Checkbox(id: "#{id_attr}", name: "#{name_attr}", value: "1", checked: !!#{value_ref})
+      RUBY
+    end
+
+    def password_input
+      %Q{Input(type: "password", id: "#{id_attr}", name: "#{name_attr}", value: "")}
+    end
+
+    def file_input
+      if @attr.attachments?
+        %Q{Input(type: "file", id: "#{id_attr}", name: "#{@model_var}[#{@attr.column_name}][]", multiple: true)}
+      else
+        %Q{Input(type: "file", id: "#{id_attr}", name: "#{name_attr}")}
+      end
+    end
+
+    def reference_input
+      if @attr.respond_to?(:polymorphic?) && @attr.polymorphic?
+        return polymorphic_reference_input
+      end
+
+      target_class = @attr.name.to_s.classify
+      assoc_name = @attr.name
+      <<~RUBY.chomp
+        if #{target_class}.count > COMBOBOX_THRESHOLD
+          # Searchable Combobox for large parent lists
+          # The Combobox controller auto-syncs trigger text from the checked
+          # radio on connect (`updateTriggerContent`), so we only need to mark
+          # the current selection via `checked:`.
+          Combobox do
+            ComboboxTrigger(placeholder: "Select #{target_class}")
+            ComboboxPopover do
+              ComboboxSearchInput(placeholder: "Search #{target_class}...")
+              ComboboxList do
+                #{target_class}.all.each do |record|
+                  ComboboxItem do
+                    ComboboxRadio(value: record.id.to_s, name: "#{name_attr}", checked: record.id == #{value_ref})
+                    span { (record.try(:name) || record.try(:title) || record.try(:display_name) || "#{target_class} \#{record.id}").to_s }
+                  end
+                end
+              end
+            end
+          end
+        else
+          # Plain Select for small lists. Unlike Combobox, the Select controller
+          # does NOT auto-sync the trigger label from the hidden input on connect,
+          # so we render the current selection's label inline (via block on
+          # SelectValue) and mark the matching SelectItem with aria_selected.
+          current_#{assoc_name}_label = if @#{@model_var}.#{assoc_name}
+            assoc = @#{@model_var}.#{assoc_name}
+            (assoc.try(:name) || assoc.try(:title) || assoc.try(:display_name) || "#{target_class} \#{assoc.id}").to_s
+          end
+          Select do
+            SelectInput(name: "#{name_attr}", value: #{value_ref})
+            SelectTrigger do
+              SelectValue(placeholder: "Select #{target_class}") { current_#{assoc_name}_label }
+            end
+            SelectContent do
+              #{target_class}.all.each do |record|
+                SelectItem(value: record.id.to_s, aria_selected: (record.id == #{value_ref}).to_s) do
+                  (record.try(:name) || record.try(:title) || record.try(:display_name) || "#{target_class} \#{record.id}").to_s
+                end
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    def polymorphic_reference_input
+      <<~RUBY.chomp
+        # TODO: polymorphic association — fill in target type and id manually
+        Input(type: "number", id: "#{id_attr}", name: "#{name_attr}", value: #{value_ref})
+      RUBY
+    end
+  end
+end

data/lib/ruby_ui_scaffold/railtie.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyUiScaffold
+  class Railtie < ::Rails::Railtie
+    # The `generators` block runs only when Rails actually needs generators
+    # (i.e. on `rails g`), not at app boot — important because
+    # Rails::Generators isn't loaded at boot.
+    generators do
+      # IMPORTANT: set option defaults BEFORE requiring the generator
+      # classes. `class_option(...)` (called by `hook_for`) freezes the
+      # default at class-definition time via `default_value_for_option`,
+      # which reads from Rails::Generators.options.
+      #
+      # We only need to override template_engine — the scaffold_controller
+      # default falls back to :scaffold_controller (Rails-wide), which
+      # combined with our base_name routes correctly to ours.
+      ::Rails::Generators.options[:ruby_ui_scaffold] ||= {}
+      ::Rails::Generators.options[:ruby_ui_scaffold][:template_engine] = "ruby_ui_scaffold"
+
+      require "generators/ruby_ui_scaffold/ruby_ui_scaffold_generator"
+      require "generators/ruby_ui_scaffold/scaffold_controller/scaffold_controller_generator"
+      require "generators/ruby_ui_scaffold/scaffold/scaffold_generator"
+    end
+  end
+end

data/lib/ruby_ui_scaffold/seeder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "ruby_ui_scaffold/value_generator"
+
+module RubyUiScaffold
+  class SeederError < StandardError; end
+
+  # Orchestrates seeding N records for a given ActiveRecord model.
+  # Delegates per-attribute value generation to ValueGenerator.
+  #
+  # @example
+  #   seeder = RubyUiScaffold::Seeder.new(Buddy, count: 50)
+  #   seeder.run  # => prints progress, returns count of created records
+  class Seeder
+    MAX_RETRIES = 3
+    PROGRESS_EVERY = 10
+
+    def initialize(model_class, count:, reset: false, dry_run: false, io: $stdout)
+      @model_class = model_class
+      @count = count
+      @reset = reset
+      @dry_run = dry_run
+      @io = io
+      @created = 0
+      @failed = 0
+      @errors = []
+    end
+
+    def run
+      return dry_run! if @dry_run
+
+      preflight!
+      reset_table! if @reset
+
+      started = Time.now
+      @io.puts "Seeding #{@count} #{@model_class} records..."
+
+      @count.times do |i|
+        record = attempt_create
+        if record
+          @created += 1
+          report_progress(i + 1, record)
+        else
+          @failed += 1
+        end
+      end
+
+      report_summary(Time.now - started)
+      @created
+    end
+
+    private
+
+    def attempt_create
+      MAX_RETRIES.times do
+        attrs = ValueGenerator.attributes_for(@model_class)
+        record = @model_class.new(attrs)
+        return record if record.save
+
+        @errors << record.errors.full_messages.join(", ")
+      end
+      nil
+    end
+
+    def preflight!
+      @model_class.reflect_on_all_associations(:belongs_to).each do |assoc|
+        next if assoc.options[:polymorphic]
+        next if assoc.options[:optional]
+        next if assoc.klass.unscoped.exists?
+
+        raise SeederError,
+          "#{@model_class} requires #{assoc.klass} records first. " \
+          "Run `rails ruby_ui_scaffold:seed #{assoc.klass} --count 10` first."
+      end
+    end
+
+    def reset_table!
+      @io.puts "Resetting #{@model_class}.destroy_all..."
+      @model_class.destroy_all
+    end
+
+    def dry_run!
+      sample = ValueGenerator.attributes_for(@model_class)
+      @io.puts "Dry run — would create #{@model_class} with attributes:"
+      sample.each { |k, v| @io.puts "  #{k}: #{v.inspect}" }
+      0
+    end
+
+    def report_progress(idx, record)
+      return unless (idx % PROGRESS_EVERY).zero? || idx == @count
+
+      label = display_label(record)
+      @io.puts "  [#{idx}/#{@count}] last: #{@model_class}(id: #{record.id}, #{label})"
+    end
+
+    def display_label(record)
+      %i[name title display_name email].each do |attr|
+        next unless record.respond_to?(attr)
+
+        value = record.public_send(attr)
+        return "#{attr}: #{value.inspect}" if value.present?
+      end
+      "id: #{record.id}"
+    end
+
+    def report_summary(elapsed)
+      @io.puts
+      @io.puts "Created #{@created} of #{@count} #{@model_class} records in #{elapsed.round(2)}s."
+      return if @failed.zero?
+
+      @io.puts "Skipped: #{@failed}. First validation errors:"
+      @errors.uniq.first(3).each { |e| @io.puts "  - #{e}" }
+    end
+  end
+end

data/lib/ruby_ui_scaffold/value_generator.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "date"
+require "faker"
+
+module RubyUiScaffold
+  # Produces a single attribute value for a given ActiveRecord column,
+  # using an inference chain: belongs_to FK → enum → inclusion validator →
+  # name-based heuristic → type-based fallback.
+  #
+  # Faker is a runtime dependency of this gem, so realistic fake data
+  # (names, emails, addresses, etc.) is always available.
+  #
+  # @example Build a full attribute hash for a model
+  #   attrs = RubyUiScaffold::ValueGenerator.attributes_for(User)
+  #   User.new(attrs)
+  class ValueGenerator
+    SKIPPED_COLUMN_SUFFIXES = %w[_count].freeze
+    SKIPPED_COLUMN_NAMES = %w[id created_at updated_at].freeze
+
+    class << self
+      # @param model_class [Class] an ActiveRecord::Base subclass
+      # @return [Hash{String => Object}] attributes safe to assign via Model.new
+      def attributes_for(model_class)
+        seedable_columns(model_class).each_with_object({}) do |column, hash|
+          hash[column.name] = new(column, model_class).call
+        end
+      end
+
+      def seedable_columns(model_class)
+        inheritance_column = model_class.inheritance_column
+        polymorphic_types = polymorphic_type_columns(model_class)
+
+        model_class.columns.reject do |c|
+          SKIPPED_COLUMN_NAMES.include?(c.name) ||
+            SKIPPED_COLUMN_SUFFIXES.any? { |s| c.name.end_with?(s) } ||
+            c.name == inheritance_column ||
+            polymorphic_types.include?(c.name)
+        end
+      end
+
+      private
+
+      def polymorphic_type_columns(model_class)
+        model_class.reflect_on_all_associations(:belongs_to).filter_map do |a|
+          "#{a.name}_type" if a.options[:polymorphic]
+        end
+      end
+    end
+
+    def initialize(column, model_class)
+      @column = column
+      @model_class = model_class
+    end
+
+    def call
+      belongs_to_value ||
+        enum_value ||
+        inclusion_value ||
+        numericality_value ||
+        name_based_value ||
+        type_based_value
+    end
+
+    private
+
+    # --- inference layers ---
+
+    def belongs_to_value
+      assoc = @model_class.reflect_on_all_associations(:belongs_to)
+                          .find { |a| !a.options[:polymorphic] && a.foreign_key == @column.name }
+      return nil unless assoc
+
+      ids = assoc.klass.unscoped.ids
+      return ids.sample if ids.any?
+
+      raise SeederError,
+        "#{@model_class} belongs_to :#{assoc.name} but no #{assoc.klass} records exist. " \
+        "Run `rails ruby_ui_scaffold:seed #{assoc.klass} --count 10` first."
+    end
+
+    def enum_value
+      enum = (@model_class.defined_enums || {})[@column.name]
+      enum&.keys&.sample
+    end
+
+    def inclusion_value
+      v = @model_class.validators_on(@column.name).find do |x|
+        x.is_a?(ActiveModel::Validations::InclusionValidator)
+      end
+      return nil unless v
+
+      list = v.options[:in] || v.options[:within]
+      return nil unless list.respond_to?(:to_a)
+
+      list.to_a.sample
+    end
+
+    def numericality_value
+      return nil unless %i[integer bigint float decimal].include?(@column.type)
+
+      v = @model_class.validators_on(@column.name).find do |x|
+        x.is_a?(ActiveModel::Validations::NumericalityValidator)
+      end
+      return nil unless v
+
+      opts = v.options
+      min = opts[:greater_than_or_equal_to] || (opts[:greater_than] && opts[:greater_than] + 1) || 1
+      max = opts[:less_than_or_equal_to] || (opts[:less_than] && opts[:less_than] - 1) || (min + 1000)
+
+      if @column.type == :integer || @column.type == :bigint
+        rand(min.to_i..max.to_i)
+      else
+        rand(min.to_f..max.to_f).round(2)
+      end
+    end
+
+    def name_based_value
+      case @column.name
+      when "email", /_email\z/                          then ::Faker::Internet.unique.email
+      when "first_name"                                  then ::Faker::Name.first_name
+      when "last_name"                                   then ::Faker::Name.last_name
+      when "name", "full_name"                           then ::Faker::Name.name
+      when "username", "login", "handle"                 then ::Faker::Internet.unique.username
+      when "phone", "phone_number", /_phone\z/           then ::Faker::PhoneNumber.cell_phone
+      when "address", "street", "street_address"         then ::Faker::Address.street_address
+      when "city"                                        then ::Faker::Address.city
+      when "state", "province"                           then ::Faker::Address.state
+      when "country"                                     then ::Faker::Address.country
+      when "zip", "zipcode", "postal_code"               then ::Faker::Address.zip
+      when "url", "website", "homepage"                  then ::Faker::Internet.url
+      when "title"                                       then ::Faker::Lorem.sentence(word_count: 4)
+      when "body", "content", "description", "bio",
+           "summary", "notes"                            then ::Faker::Lorem.paragraph(sentence_count: 3)
+      when "company", "company_name"                     then ::Faker::Company.name
+      when "slug"                                        then ::Faker::Internet.unique.slug
+      when "uuid"                                        then SecureRandom.uuid
+      when "birthdate", "birthday", "dob", "date_of_birth" then ::Faker::Date.birthday(min_age: 18, max_age: 80)
+      when "age"                                         then rand(18..80)
+      when "color"                                       then ::Faker::Color.color_name
+      when "latitude"                                    then ::Faker::Address.latitude.to_f
+      when "longitude"                                   then ::Faker::Address.longitude.to_f
+      when "price", "amount"                             then (rand * 1000).round(2)
+      when "quantity", "qty"                             then rand(1..100)
+      when /\Apassword(_digest)?\z/
+        # let model's has_secure_password handle this; assign a literal password
+        "password123"
+      end
+    end
+
+    def type_based_value
+      case @column.type
+      when :string                  then ::Faker::Lorem.word.capitalize
+      when :text                    then ::Faker::Lorem.paragraph(sentence_count: 3)
+      when :integer                 then rand(1..1000)
+      when :bigint                  then rand(1..1_000_000)
+      when :float, :decimal         then (rand * 1000).round(2)
+      when :boolean                 then [true, false].sample
+      when :date                    then ::Faker::Date.between(from: Date.today - 365, to: Date.today)
+      when :datetime, :timestamp    then ::Faker::Time.between(from: Time.now - (60 * 60 * 24 * 365), to: Time.now)
+      when :time                    then Time.now
+      when :json, :jsonb            then {}
+      when :uuid                    then SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/ruby_ui_scaffold/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubyUiScaffold
+  VERSION = "0.1.0"
+end

data/lib/ruby_ui_scaffold.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "ruby_ui_scaffold/version"
+require "ruby_ui_scaffold/field_type_mapper"
+require "ruby_ui_scaffold/attribute_helpers"
+require "ruby_ui_scaffold/component_resolver"
+require "ruby_ui_scaffold/component_installer"
+require "ruby_ui_scaffold/value_generator"
+require "ruby_ui_scaffold/seeder"
+
+# Make sure transitive deps' Railties fire when the gem is loaded via
+# Bundler.require. Without these, the helpers (lucide_icon, Faker) aren't
+# registered in the host app, the `phlex:install` / `ruby_ui:component`
+# generators aren't discoverable, and the generated views/seed command crash.
+require "phlex-rails"
+require "literal"
+require "lucide-rails"
+
+require "ruby_ui_scaffold/railtie" if defined?(Rails::Railtie)
+
+module RubyUiScaffold
+end