ruby_ui_admin 0.1.0

data/lib/ruby_ui_admin/fields/textarea_field.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class TextareaField < BaseField
+      register_as :textarea
+
+      def rows
+        options[:rows] || 4
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/fields/url_field.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Fields
+    class UrlField < BaseField
+      register_as :url
+
+      # Optional display text; defaults to the URL itself.
+      def link_text(record)
+        text = options[:text]
+        return ExecutionContext.new(target: text, record: record, resource: resource).handle if text.respond_to?(:call)
+
+        text || value(record)
+      end
+
+      def target
+        options[:target] || "_blank"
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/filters/base_filter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Filters
+    # Base class for filters. Subclasses implement `apply(request, query, value)`
+    # and (for select-style filters) `options`.
+    class BaseFilter
+      class << self
+        # Class-level `self.name =` while still falling back to the real class
+        # name (so Zeitwerk/Rails keep working when no display name is set).
+        def name=(value)
+          @display_name = value
+        end
+
+        def name
+          @display_name || super
+        end
+
+        def empty_message=(value)
+          @empty_message = value
+        end
+
+        def empty_message
+          defined?(@empty_message) ? @empty_message : nil
+        end
+
+        # Inherited down the chain (subclasses of SelectFilter are :select, etc.).
+        def filter_type
+          return @filter_type if defined?(@filter_type) && @filter_type
+          return superclass.filter_type if superclass.respond_to?(:filter_type)
+
+          nil
+        end
+
+        def register_type(type)
+          @filter_type = type.to_sym
+        end
+      end
+
+      attr_reader :arguments
+
+      def initialize(arguments: {})
+        @arguments = arguments || {}
+      end
+
+      def name
+        self.class.name
+      end
+
+      def type
+        self.class.filter_type
+      end
+
+      def empty_message
+        self.class.empty_message
+      end
+
+      # Unique key used in the query string, e.g.
+      # RubyUIAdmin::Filters::PublishedFilter -> "published_filter".
+      # Uses `to_s` (not the overridable `name`) to get the real class name.
+      def param_key
+        self.class.to_s.sub(/^RubyUIAdmin::Filters::/, "").gsub("::", "_").underscore
+      end
+
+      # Override in subclasses.
+      def apply(request, query, value)
+        query
+      end
+
+      # Override in select/multiple-select filters.
+      def options
+        {}
+      end
+
+      # Override to provide a default selected value.
+      def default
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/filters/boolean_filter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Filters
+    class BooleanFilter < BaseFilter
+      register_type :boolean
+    end
+  end
+end

data/lib/ruby_ui_admin/filters/multiple_select_filter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Filters
+    # A filter offering several checkboxes; the submitted value is an Array of the
+    # checked option keys. Subclasses define `options` and `apply(request, query, value)`.
+    class MultipleSelectFilter < BaseFilter
+      register_type :multiple_select
+    end
+  end
+end

data/lib/ruby_ui_admin/filters/select_filter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Filters
+    class SelectFilter < BaseFilter
+      register_type :select
+    end
+  end
+end

data/lib/ruby_ui_admin/filters/text_filter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Filters
+    class TextFilter < BaseFilter
+      register_type :text
+    end
+  end
+end

data/lib/ruby_ui_admin/menu/builder.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Menu
+    # A leaf linking to a resource's index. Carries the resolved resource so the view
+    # can build the path through the dynamic routes.
+    ResourceItem = Struct.new(:resource, :label, keyword_init: true) do
+      def type = :resource
+    end
+
+    # A leaf linking to an arbitrary path.
+    LinkItem = Struct.new(:label, :path, keyword_init: true) do
+      def type = :link
+    end
+
+    # A leaf linking to a dashboard.
+    DashboardItem = Struct.new(:dashboard, :label, keyword_init: true) do
+      def type = :dashboard
+    end
+
+    # A titled group of items.
+    SectionItem = Struct.new(:label, :icon, :items, keyword_init: true) do
+      def type = :section
+    end
+
+    # Evaluates a `config.main_menu` block into a tree of menu items. The block is
+    # instance_exec'd against a Builder, so `section`/`resource`/`link`/... are DSL calls.
+    #
+    #   config.main_menu = -> do
+    #     section "Tables", icon: "table" do
+    #       resource :user
+    #       resource :buyer, label: "Buyers"
+    #       link "Docs", "https://example.com"
+    #     end
+    #   end
+    class Builder
+      def self.build(&block)
+        builder = new
+        builder.instance_exec(&block)
+        builder.items
+      end
+
+      attr_reader :items
+
+      def initialize
+        @items = []
+      end
+
+      def section(label = nil, icon: nil, &block)
+        children = self.class.build(&block)
+        @items << SectionItem.new(label: label, icon: icon, items: children)
+      end
+      alias_method :group, :section
+
+      def resource(name, label: nil, **)
+        resource = RubyUIAdmin.resource_manager.find_by_route_key(name.to_s)
+        @items << ResourceItem.new(resource: resource, label: label) if resource
+      end
+      alias_method :resources, :resource
+
+      def link(label, path = nil, **args)
+        @items << LinkItem.new(label: label, path: path || args[:path])
+      end
+      alias_method :link_to, :link
+
+      def dashboard(id, label: nil)
+        dash = RubyUIAdmin.dashboard_manager.dashboards.find { |d| d.id.to_s == id.to_s }
+        @items << DashboardItem.new(dashboard: dash, label: label) if dash
+      end
+
+      def all_resources(except: [])
+        excluded = Array(except).map(&:to_s)
+        RubyUIAdmin.resource_manager.navigation_resources.each do |rc|
+          next if excluded.include?(rc.route_key)
+
+          @items << ResourceItem.new(resource: rc, label: nil)
+        end
+      end
+
+      def all_dashboards(except: [])
+        excluded = Array(except).map(&:to_s)
+        RubyUIAdmin.dashboard_manager.dashboards.each do |dash|
+          next if excluded.include?(dash.id.to_s)
+
+          @items << DashboardItem.new(dashboard: dash, label: nil)
+        end
+      end
+
+      # Available inside the menu block.
+      def current_user = RubyUIAdmin::Current.user
+      def params = RubyUIAdmin::Current.params
+    end
+  end
+end

data/lib/ruby_ui_admin/resource_manager.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/subclasses"
+
+module RubyUIAdmin
+  # Discovers and indexes the host app's resources (defined under
+  # `RubyUIAdmin::Resources` in `app/ruby_ui_admin/resources`).
+  class ResourceManager
+    def boot
+      @resources = nil
+      self
+    end
+
+    def resources
+      @resources ||= fetch_resources
+    end
+
+    # All resources visible in the sidebar navigation.
+    def navigation_resources
+      resources.select { |resource| resource.visible_on_sidebar }
+    end
+
+    # Find a resource class by its route key, e.g. "buyers".
+    def find_by_route_key(key)
+      key = key.to_s
+      resources.find { |resource| resource.route_key == key } ||
+        resources.find { |resource| resource.resource_name == key.singularize }
+    end
+
+    # Find the resource class for a given model class.
+    def find_for_model(model_class)
+      mapped = RubyUIAdmin.configuration.model_resource_mapping[model_class.to_s]
+      return mapped.to_s.constantize if mapped
+
+      resources.find { |resource| resource.model_class == model_class }
+    end
+
+    private
+
+    def fetch_resources
+      eager_load_resources!
+
+      selected = RubyUIAdmin::BaseResource.descendants.select do |resource|
+        next false if resource.abstract?
+
+        # Only real, named resources count — excludes anonymous subclasses (e.g.
+        # those built in tests) that would otherwise pollute the registry.
+        name = resource.name
+        name && (RubyUIAdmin.configuration.resources.present? || name.start_with?("RubyUIAdmin::Resources::"))
+      end
+
+      # Dedupe by name and re-resolve the constant: in development, `descendants` retains
+      # stale class versions from previous Zeitwerk reloads (same name) — keep the current one.
+      selected.map(&:name).uniq.filter_map { |name| name.safe_constantize }
+    end
+
+    def eager_load_resources!
+      configured = RubyUIAdmin.configuration.resources
+
+      if configured.present?
+        Array(configured).each { |name| name.to_s.constantize }
+      elsif defined?(::Rails)
+        eager_load_resources_dir
+      end
+    rescue NameError
+      nil
+    end
+
+    def eager_load_resources_dir
+      dir = Rails.root.join("app", "ruby_ui_admin", "resources")
+      return unless Dir.exist?(dir)
+
+      loader = Rails.autoloaders.main
+      if loader.respond_to?(:eager_load_dir)
+        loader.eager_load_dir(dir)
+      else
+        # Fallback for older Zeitwerk: reference the namespace to trigger loading.
+        loader.eager_load_namespace(RubyUIAdmin::Resources) if defined?(RubyUIAdmin::Resources)
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/scopes/base_scope.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Scopes
+    # Base class for named index scopes. A scope narrows the index query
+    # via a `scope` lambda and shows up as a tab above the table.
+    #
+    #   class Published < RubyUIAdmin::Scopes::BaseScope
+    #     self.name = "Published"
+    #     self.scope = -> { query.where(published: true) }
+    #     self.default = true
+    #   end
+    class BaseScope
+      class << self
+        # Class-level `self.name =` with fallback to the real class name.
+        def name=(value)
+          @display_name = value
+        end
+
+        def name
+          @display_name || super
+        end
+
+        def scope=(value)
+          @scope = value
+        end
+
+        def scope
+          @scope if defined?(@scope)
+        end
+
+        def description=(value)
+          @description = value
+        end
+
+        def description
+          @description if defined?(@description)
+        end
+
+        def default=(value)
+          @default = value
+        end
+
+        def default?
+          !!(@default if defined?(@default))
+        end
+
+        def visible=(value)
+          @visible = value
+        end
+
+        def visible_setting
+          defined?(@visible) ? @visible : true
+        end
+
+        # URL key, e.g. RubyUIAdmin::Scopes::PublishedPosts -> "published_posts".
+        def scope_key
+          to_s.sub(/^RubyUIAdmin::Scopes::/, "").gsub("::", "_").underscore
+        end
+      end
+
+      attr_reader :params
+
+      # `default_override` (set via `scope Klass, default: true` on the resource) wins over
+      # the scope class's own `self.default`.
+      def initialize(params: {}, default_override: nil)
+        @params = params || {}
+        @default_override = default_override
+      end
+
+      def name
+        self.class.name
+      end
+
+      def key
+        self.class.scope_key
+      end
+
+      def description
+        self.class.description
+      end
+
+      def default?
+        return !!@default_override unless @default_override.nil?
+
+        self.class.default?
+      end
+
+      # Applies the scope to the query. A Symbol calls the model's named scope/class method;
+      # a lambda is run with `query` and `params` available.
+      def apply(query)
+        scope = self.class.scope
+        return query if scope.nil?
+        return query.public_send(scope) if scope.is_a?(Symbol)
+
+        ExecutionContext.new(target: scope, query: query, params: params).handle
+      end
+
+      def visible?(user: nil)
+        setting = self.class.visible_setting
+        return setting unless setting.respond_to?(:call)
+
+        ExecutionContext.new(target: setting, user: user, params: params).handle
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/services/authorization_service.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  module Services
+    # Facade over the configured authorization adapter (`config.authorization_client`, default
+    # action_policy). Resolves the adapter and delegates, so controllers/views/resources stay
+    # backend-agnostic. The backend logic lives in `RubyUIAdmin::Authorization::*Adapter`.
+    class AuthorizationService
+      def initialize(user, record = nil, policy_class: nil, true_user: nil)
+        @adapter = RubyUIAdmin::Authorization.build(user, record, policy_class: policy_class, true_user: true_user)
+      end
+
+      def authorize_action(rule, record: nil, raise_exception: true)
+        @adapter.authorize_action(rule, record: record, raise_exception: raise_exception)
+      end
+
+      def allowed?(rule, record: nil) = @adapter.allowed?(rule, record: record)
+
+      def apply_policy(scope) = @adapter.apply_policy(scope)
+
+      def has_rule?(rule, record: nil) = @adapter.has_rule?(rule, record: record)
+
+      def defines_rule?(rule) = @adapter.defines_rule?(rule)
+
+      def true_user = @adapter.true_user
+
+      def set_record(record)
+        @adapter.set_record(record)
+        self
+      end
+
+      # Context readers (kept for backward compatibility with any caller reading them).
+      def user = @adapter.user
+      def record = @adapter.record
+      def policy_class = @adapter.policy_class
+    end
+  end
+end

data/lib/ruby_ui_admin/structure.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  # Layout containers produced by the resource DSL (`panel`, `tabs`, `tab`).
+  # They hold child items (fields or nested containers) for structured rendering
+  # on the show/form views.
+  module Structure
+    class Panel
+      attr_reader :name, :items
+
+      def initialize(name = nil)
+        @name = name
+        @items = []
+      end
+    end
+
+    class TabGroup
+      attr_reader :tabs
+
+      def initialize
+        @tabs = []
+      end
+
+      # Containers expose their children through `items` for uniform traversal.
+      def items
+        @tabs
+      end
+    end
+
+    class Tab
+      attr_reader :name, :description, :items
+
+      def initialize(name, description: nil)
+        @name = name
+        @description = description
+        @items = []
+      end
+    end
+  end
+end

data/lib/ruby_ui_admin/tailwind_source.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module RubyUIAdmin
+  # Extracts the Tailwind class candidates used by the admin's Phlex views into a single file the
+  # host app can `@source` from its Tailwind build. This solves the "gem path changes per
+  # environment" problem: instead of pointing `@source` at the gem's `.rb` files (whose absolute
+  # path differs between dev/CI/deploy), the host writes the class inventory into its OWN tree (a
+  # stable, relative path) and re-runs on upgrade. It scans the same literals Tailwind would, so the
+  # generated utilities match the previous `@source "<gem>/**/*.rb"` approach.
+  #
+  # Driven by `rake ruby_ui_admin:tailwind_source`.
+  module TailwindSource
+    VIEWS_GLOB = "app/components/ruby_ui_admin/**/*.rb"
+
+    module_function
+
+    # All class candidates across the engine's view files, deduped and sorted.
+    def class_candidates
+      Dir[RubyUIAdmin::Engine.root.join(VIEWS_GLOB)].sort
+        .flat_map { |file| extract(File.read(file)) }
+        .uniq.sort
+    end
+
+    # Pulls Tailwind-ish class tokens out of a chunk of Ruby source: every double-quoted string
+    # literal (and heredoc `CLASSES` body) is split into tokens, with `#{…}` interpolations dropped
+    # so the literal fragments around them survive. Non-class words are filtered out by
+    # `class_token?`. Only double quotes are scanned — the views write every `class:` with them, and
+    # scanning single quotes would let stray apostrophes in comments span across real code.
+    def extract(ruby_source)
+      strings = ruby_source.scan(/"([^"]*)"/).flatten
+      strings += ruby_source.scan(/<<~?CLASSES\n(.*?)\n\s*CLASSES/m).flatten
+
+      strings
+        .map { |string| string.gsub(/#\{[^}]*\}/, " ") }
+        .flat_map { |string| string.split(/\s+/) }
+        .select { |token| class_token?(token) }
+        .uniq
+    end
+
+    # Heuristic: a Tailwind utility candidate. Must start with a letter (optionally `!`/`-` for
+    # important/negative) and may carry variants/values (`hover:`, `/10`, `[356px]`). Requiring a
+    # letter start drops embedded SVG path coordinates (e.g. `0-7.07l-1.72`), which start with a
+    # digit and would otherwise be scanned as junk — no real Tailwind utility starts with a digit.
+    def class_token?(token)
+      token.match?(%r{\A!?-?[a-z][a-z0-9:_/\[\]().,%#-]*\z})
+    end
+
+    # The scannable file body (valid HTML so any Tailwind extractor picks it up).
+    def html
+      <<~HTML
+        <!-- Generated by `rake ruby_ui_admin:tailwind_source`. Do not edit — re-run after upgrading ruby_ui_admin. -->
+        <div class="#{class_candidates.join(" ")}"></div>
+      HTML
+    end
+
+    # Writes the inventory to `dest` and returns the path.
+    def write(dest)
+      FileUtils.mkdir_p(File.dirname(dest))
+      File.write(dest, html)
+      dest
+    end
+  end
+end

data/lib/ruby_ui_admin/version.rb

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

data/lib/ruby_ui_admin/view.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyUIAdmin
+  # A small value object for the current view, so user lambdas (`visible:`, action
+  # `self.visible`/`self.message`) can write either `view == :show` or `view.show?`.
+  # It behaves like its underlying Symbol for comparison.
+  class View
+    def self.wrap(value)
+      value.is_a?(View) ? value : new(value)
+    end
+
+    def initialize(name)
+      @name = name&.to_sym
+    end
+
+    def to_sym = @name
+    def to_s = @name.to_s
+    def inspect = "#<RubyUIAdmin::View #{@name.inspect}>"
+
+    def index? = @name == :index
+    def show? = @name == :show
+    def new? = @name == :new
+    def edit? = @name == :edit
+    def form? = @name == :new || @name == :edit       # new + edit
+    def display? = @name == :index || @name == :show   # index + show
+
+    def ==(other)
+      other.respond_to?(:to_sym) ? @name == other.to_sym : false
+    end
+    alias_method :eql?, :==
+
+    def hash = @name.hash
+  end
+end