flexi_admin 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7899a2bba48f2ff003b6b90de70a6df1b61a05fc37e07dc47e07f4d3a3a9cc7
-  data.tar.gz: c22ed4d803e860e4b250ac55670737c5df158705d3b5c3dd0d425646b4155adf
+  metadata.gz: 59b4913fe340c0507725c10bfdea39f47dcc271315c2d95e1c39469e6b44d56b
+  data.tar.gz: d45f9fdb404663bbe74a4e6afa103cf0d6c2018b6a346ee58b3f28ab55e19cd1
 SHA512:
-  metadata.gz: 2d80c1451c28a1d842e2eb24660f5489184bb403a1eec4eb740eeda5f7eb11d3592ddd9a4cc9f80866664af28552aaaf2f70f07ddab18ca635fa551106f56f0e
-  data.tar.gz: 7677d9ab7f7fdc1980066ec248e52725db1f4b017a1baaf0ae700cdb69f9cd06d81bdeee9271f51ab86617459aa278e433077f4cb56a65bea23f509e7bfb5f38
+  metadata.gz: d04fac65d08116d344bf99247c1c5b61c5bf5ba3fced0fd792516b87c7c37d5c1fc9b8570f0b0bcc4274f05489b414051246d184237b52369cf3aef9bc31efaa
+  data.tar.gz: 5a4d7d818963fabbe4554960b4d2e75c9880013f5fbe3dd5fdddd059f8b987c68e5de33572cd1dc494cb183ec16d049e24bc2ea1d5aceced9b7c49cca22e9ba8

data/README.md

@@ -1,42 +1,278 @@
 # FlexiAdmin Rails
 
-Steps required to get FlexiAdmin working with a Rails app:
+FlexiAdmin is a Rails engine that provides a flexible admin interface with modern JavaScript integration using Stimulus controllers and Turbo.
 
-**Gemfile**
+## Installation
 
-1. add `gem 'flexi_admin', git: 'https://github.com/landovsky/flexi_admin.git', branch: 'main'` to the `Gemfile`
+**Gemfile**
 
-**Stylesheets**
+1. Add to your `Gemfile`:
 
-2. add `@import "flexi_admin.scss";` to the `app/assets/stylesheets/application.scss` file
+```ruby
+gem 'flexi_admin', git: 'https://github.com/landovsky/flexi_admin.git', branch: 'main'
+```
 
-**JavaScript**
+2. Run `bundle install`
 
-3. add `import "flexi_admin";` to the `app/javascript/application.js` file
+## Setup
 
-# Temporary (workaround) requirements
+### Stylesheets
 
-- can't get stylesheets to load from gem, so adding to host app:
+Add to `app/assets/stylesheets/application.scss`:
 
 ```scss
-// Production
-// @import "flexi_admin.scss";
-// Local dev
-// @import "../../flexi_admin/app/assets/stylesheets/flexi_admin";
+@import "flexi_admin.scss";
+```
+
+### JavaScript Integration
+
+FlexiAdmin works with modern JavaScript bundlers. Choose your bundler below:
+
+#### With esbuild (Recommended)
+
+Add to `app/javascript/application.js`:
+
+```javascript
+import "flexi_admin"
 ```
 
-- add modals controller:
+**esbuild Configuration:**
+
+The gem's Railtie automatically sets up NODE_PATH to include the FlexiAdmin JavaScript directory. If you're using a custom esbuild configuration, ensure it can resolve the gem's JavaScript:
+
+```javascript
+// esbuild.config.mjs
+import * as esbuild from 'esbuild'
+import path from 'path'
+
+await esbuild.build({
+  entryPoints: ['app/javascript/application.js'],
+  bundle: true,
+  sourcemap: true,
+  format: 'esm',
+  outdir: 'app/assets/builds',
+  publicPath: '/assets',
+  nodePaths: [
+    './node_modules',
+    // Path to gem JavaScript (adjust if needed)
+    path.resolve('../flexi_admin/lib/flexi_admin/javascript')
+  ]
+})
+```
+
+Or set NODE_PATH in your package.json build script:
+
+```json
+{
+  "scripts": {
+    "build": "NODE_PATH=./node_modules:$(bundle show flexi_admin)/lib/flexi_admin/javascript esbuild app/javascript/*.* --bundle --sourcemap --format=esm --outdir=app/assets/builds"
+  }
+}
+```
+
+#### With webpack
+
+Add to `app/javascript/application.js`:
 
+```javascript
+import "flexi_admin"
 ```
-# frozen_string_literal: true
 
+**Webpack Configuration:**
+
+Update your webpack configuration to resolve the gem's JavaScript directory:
+
+```javascript
+// webpack.config.js
+const path = require('path')
+
+module.exports = {
+  resolve: {
+    modules: [
+      path.resolve(__dirname, 'node_modules'),
+      // Add gem JavaScript directory
+      path.resolve(__dirname, '../flexi_admin/lib/flexi_admin/javascript')
+    ]
+  }
+}
+```
+
+Or find the gem path dynamically:
+
+```javascript
+const { execSync } = require('child_process')
+const gemPath = execSync('bundle show flexi_admin').toString().trim()
+
+module.exports = {
+  resolve: {
+    modules: [
+      'node_modules',
+      path.join(gemPath, 'lib/flexi_admin/javascript')
+    ]
+  }
+}
+```
+
+### Stimulus Controllers
+
+FlexiAdmin includes 19 Stimulus controllers that automatically register when you import the gem's JavaScript:
+
+#### Available Controllers
+
+- `add-row` - Dynamically add rows to forms
+- `autocomplete` - Autocomplete search fields
+- `bulk-action` - Bulk selection with persistence across pagination
+- `button-select` - Custom button selection controls
+- `datalist` - Enhanced datalist inputs
+- `delete` - Confirmation dialogs for delete actions
+- `filter-auto-submit` - Auto-submit filters on change
+- `floating-toc` - Floating table of contents navigation
+- `form` - Enhanced form behavior
+- `form-validation` - Client-side form validation
+- `pagination` - Page navigation controls
+- `sorting` - Column sorting
+- `switch-view` - Toggle between list/grid views
+- `tabs` - Keeps the open `TabsComponent` tab in the URL hash
+- `toast` - Toast notification system
+- `trix` - Rich text editor integration
+- `uploads` - File upload handling
+
+#### Usage in Views
+
+Use controllers in your ERB templates with the `data-controller` attribute:
+
+```erb
+<div data-controller="flexi-admin--bulk-action"
+     data-flexi-admin--bulk-action-scope-value="users">
+  <!-- Your bulk action content -->
+</div>
+```
+
+Controller naming convention: `flexi-admin--[controller-name]`
+
+#### Example: Pagination
+
+```erb
+<nav data-controller="flexi-admin--pagination">
+  <%= link_to "Previous",
+      admin_users_path(page: @page - 1),
+      data: {
+        turbo_frame: "users_list",
+        action: "flexi-admin--pagination#navigate"
+      } %>
+</nav>
+```
+
+#### Example: Bulk Actions with Selection
+
+```erb
+<div data-controller="flexi-admin--bulk-action"
+     data-flexi-admin--bulk-action-scope-value="users">
+
+  <%= check_box_tag "select_all", nil, false,
+      data: { action: "flexi-admin--bulk-action#toggleAll" } %>
+
+  <% @users.each do |user| %>
+    <%= check_box_tag "user_ids[]", user.id, false,
+        data: {
+          action: "flexi-admin--bulk-action#toggle",
+          flexi_admin__bulk_action_target: "checkbox"
+        } %>
+  <% end %>
+
+  <%= button_to "Delete Selected",
+      bulk_action_admin_users_path,
+      data: {
+        flexi_admin__bulk_action_target: "actionButton",
+        confirm: "Are you sure?"
+      } %>
+</div>
+```
+
+#### Example: Autocomplete Search
+
+```erb
+<%= text_field_tag :search, params[:search],
+    data: {
+      controller: "flexi-admin--autocomplete",
+      flexi_admin__autocomplete_url_value: autocomplete_admin_users_path,
+      action: "input->flexi-admin--autocomplete#search"
+    } %>
+```
+
+#### Example: Tabs on a show page
+
+`FlexiAdmin::Components::Shared::TabsComponent` splits a long page into Bootstrap tabs. Every
+pane is rendered up front (no lazy loading), so content behaves exactly as it did on one page.
+The open tab is kept in the URL hash (`/orders/1#kalkulace`), so a reload or a shared link
+reopens it.
+
+```slim
+= render FlexiAdmin::Components::Shared::TabsComponent.new(id: 'order') do |tabs|
+  - tabs.with_tab(key: 'prehled', label: 'Přehled')
+    = render Admin::Order::Show::EditFormComponent.new(resource)
+  - tabs.with_tab(key: 'kalkulace', label: 'Kalkulace', count: calculations.size)
+    = render Admin::OrderCalculation::ResourcesComponent.new(calculations, context_params:, parent: resource)
+```
+
+- `id:` prefixes the DOM ids (`order-tab-<key>`, `order-pane-<key>`). It must be unique on the page.
+- `with_tab(key:, label:, count: nil, active: false)`: `count` renders a badge, and `active: true` opens that tab
+  (the first tab otherwise).
+- `remember: false` turns off the URL-hash memory, for example for a second tab set on the same page.
+- `nav_class:` sets the classes on the `ul.nav-tabs` (default `mb-4`).
+
+Requires Bootstrap 5's JavaScript (`data-bs-toggle="tab"`).
+
+### Verification
+
+To verify the JavaScript is loading correctly:
+
+1. Start your Rails server
+2. Open browser console
+3. Check for Stimulus registration:
+
+```javascript
+// Should list all FlexiAdmin controllers
+window.Stimulus.controllers
+```
+
+## Temporary Workarounds
+
+Currently, the following manual steps are required:
+
+### Modals Controller
+
+Create a modals controller in your app:
+
+```ruby
+# app/controllers/modals_controller.rb
 class ModalsController < AdminController
   include FlexiAdmin::Controllers::ModalsController
 end
 ```
 
+Add to routes:
+
 ```ruby
-  resources :modals, only: [] do
-    get :show, on: :collection
-  end
+resources :modals, only: [] do
+  get :show, on: :collection
+end
 ```
+
+## Development
+
+See [TESTING.md](TESTING.md) for information on:
+- Running the test suite
+- Setting up the dummy app for development
+- JavaScript build process
+- Test coverage
+
+## Documentation
+
+- [TESTING.md](TESTING.md) - Testing guide and infrastructure
+- [CI_REQUIREMENTS.md](CI_REQUIREMENTS.md) - CI/CD setup for esbuild
+- [spec/dummy/README.md](spec/dummy/README.md) - Dummy app documentation
+
+## License
+
+This project is licensed under the MIT License.

data/lib/flexi_admin/components/helpers/action_helper.rb

@@ -9,4 +9,25 @@ module FlexiAdmin::Components::Helpers::ActionHelper
                                                                               disabled:,
                                                                               selection_dependent:)
   end
+
+  def action_button(item, action_component, hide_icon: false, **options)
+    render FlexiAdmin::Components::Resources::BulkAction::RowActionButtonComponent.new(item,
+                                                                                       context,
+                                                                                       action_component,
+                                                                                       hide_icon: hide_icon,
+                                                                                       **options)
+  end
+
+  # Renders a dropdown with multiple action buttons for a single row/item
+  # Use this in column blocks when you have multiple actions for an item
+  # Example:
+  #   = actions_dropdown(item) do |dropdown|
+  #     - dropdown.with_action_button(item, context, ChangeStatus)
+  #     - dropdown.with_action_button(item, context, AssignUser)
+  def actions_dropdown(item, &block)
+    render FlexiAdmin::Components::Resources::BulkAction::RowActionsDropdownComponent.new(item, context) do |component|
+      block.call(component) if block
+      component
+    end
+  end
 end

data/lib/flexi_admin/components/helpers/frontend_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "action_view"
+
+module FlexiAdmin::Components::Helpers::FrontendHelper
+  def active(path, predicate = :ends_with)
+    css_match "active", request.path, match: path, use: predicate
+  end
+
+  # Example: css_match 'active', request.path, match: 'alternativy', use: :starts_with
+  def css_match(klasses, subject, match:, use: :includes)
+    case use
+    when :starts_with
+      klasses if subject.to_s.starts_with?(match)
+    when :ends_with
+      klasses if subject.to_s.ends_with?(match)
+    when :includes
+      klasses if subject.to_s.include?(match)
+    else
+      raise "Unknown predicate: #{predicate}"
+    end
+  end
+end

data/lib/flexi_admin/components/helpers/link_helper.rb

@@ -2,7 +2,40 @@
 
 module FlexiAdmin::Components::Helpers::LinkHelper
   def navigate_to(title, resource)
-    helpers.link_to title, [:admin, resource], "data-turbo-frame": "_top"
-    # content_tag(:a, title, href: resource, "data-turbo-frame": "_top")
+    parent = context&.options&.dig(:parent) || parent_from_params
+    namespace = FlexiAdmin::Config.configuration.namespace
+    if resource.is_a?(String)
+      helpers.link_to title, resource, "data-turbo-frame": "_top"
+    else
+      path_segments = if parent.present? && parent.class != resource.class
+                        namespace.present? ? [namespace.to_sym, parent, resource] : [parent, resource]
+                      elsif namespace.present?
+                        [namespace.to_sym, resource]
+                      else
+                        resource
+                      end
+
+      result_path = begin
+        helpers.polymorphic_path(path_segments)
+      rescue NoMethodError
+        without_parent = path_segments.without(parent)
+        raise if without_parent.empty?
+
+        helpers.polymorphic_path(without_parent)
+      end
+
+      helpers.link_to title, result_path, "data-turbo-frame": "_top"
+    end
+  end
+
+  private
+
+  def parent_from_params
+    return nil if context&.params&.parent.blank?
+
+    gid = URI.decode_www_form_component(context.params.parent)
+    GlobalID::Locator.locate(gid)
+  rescue StandardError
+    nil
   end
 end

data/lib/flexi_admin/components/helpers/resource_helper.rb

@@ -3,14 +3,20 @@
 module FlexiAdmin::Components::Helpers::ResourceHelper
   include FlexiAdmin::Components::Helpers::UrlHelper
 
-  def autocomplete_path(action:, fields:, parent: nil)
+  def autocomplete_path(action:, fields:, parent: nil, custom_scope: nil)
     payload = {
       ac_action: action,
       ac_path: resource__path,
       fa_parent: parent&.gid_param,
       ac_fields: fields
     }
-    main_app.send("autocomplete_admin_#{scope_plural}_path", params: payload)
+
+    payload[:fa_custom_scope] = custom_scope if custom_scope.present?
+
+    path = namespaced_path("autocomplete", "namespace", scope_plural)
+    route_exists_in_main_app?(path) ? main_app.send(path, params: payload) : helpers.send(path, params: payload)
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def datalist_path(action:, fields:, parent: nil)
@@ -19,41 +25,99 @@ module FlexiAdmin::Components::Helpers::ResourceHelper
       ac_fields: fields
     }
 
-    main_app.send("datalist_admin_#{scope_plural}_path", params: payload)
+    path = namespaced_path("datalist", "namespace", scope_plural)
+    route_exists_in_main_app?(path) ? main_app.send(path, params: payload) : helpers.send(path, params: payload)
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def edit_resource_path(resource, **params)
-    main_app.send("edit_admin_#{scope_singular}_path", resource, params:)
+    path = namespaced_path("edit", "namespace", scope_singular)
+    if route_exists_in_main_app?(path)
+      main_app.send(path, resource,
+                    params: params)
+    else
+      helpers.send(path, resource, params: params)
+    end
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def bulk_action_path(scope, **params)
-    raise 'Scope is not defined' if scope.blank?
+    raise "Scope is not defined" if scope.blank?
 
-    main_app.send("bulk_action_admin_#{scope}_path", params:)
+    path = namespaced_path("bulk_action", "namespace", scope)
+    route_exists_in_main_app?(path) ? main_app.send(path, params: params) : helpers.send(path, params: params)
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def resource_path(resource, **params)
-    main_app.send("admin_#{scope_singular}_path", resource, params:)
+    path = namespaced_path("namespace", scope_singular)
+    if route_exists_in_main_app?(path)
+      main_app.send(path, resource,
+                    params: params)
+    else
+      helpers.send(path, resource, params: params)
+    end
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def resource__path
-    "admin_#{scope_singular}_path"
+    namespaced_path("namespace", scope_singular)
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def resources_path(**params)
-    main_app.send("admin_#{scope_plural}_path", params:)
+    path = namespaced_path("namespace", scope_plural)
+    route_exists_in_main_app?(path) ? main_app.send(path, params: params) : helpers.send(path, params: params)
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def resource_input_name
     "#{scope_singular}_id"
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def scope_plural
-    scope.gsub('/', '_')
+    if instance_variable_defined?(:@target_controller) && @target_controller.present?
+      @target_controller.to_s.underscore.gsub("/", "_")
+    elsif instance_variable_defined?(:@name) && @name.present?
+      field_name = @name.to_s.gsub(/_id$/, "")
+
+      base_name = field_name.gsub(/^(primary_|secondary_|main_|default_)/, "")
+
+      base_name.pluralize
+    else
+      unless defined?(scope) && !scope.is_a?(Proc)
+        raise "Cannot infer controller from scope without target_controller or field name"
+      end
+
+      scope.to_s.underscore.gsub("/", "_")
+
+    end
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def scope_singular
-    scope.singularize
+    if scope.is_a?(Proc)
+      if instance_variable_defined?(:@target_controller) && @target_controller.present?
+        @target_controller.to_s.underscore.gsub("/", "_").singularize
+      elsif instance_variable_defined?(:@name) && @name.present?
+        @name.to_s.gsub(/_id$/, "").singularize
+      else
+        raise "Cannot infer singular scope from Proc without target_controller or field name"
+      end
+    else
+      scope.to_s.underscore.singularize
+    end
+    # rescue => e
+    #   binding.pry if Rails.env.development?
   end
 
   def scope
@@ -61,11 +125,12 @@ module FlexiAdmin::Components::Helpers::ResourceHelper
       return context.scope if defined?(context)
       return resource.model_name.try(:plural) if defined?(resource)
 
-      raise 'Scope is not defined'
+      raise "Scope is not defined"
     end
   end
 
-  def paginate(resource, per_page: 10)
-    resource.paginate(page: params[:page], per_page:)
+  def paginate(resource, per_page: WillPaginate.per_page)
+    resource.paginate(page: params[:page], per_page: per_page)
   end
+
 end

data/lib/flexi_admin/components/helpers/url_helper.rb

@@ -5,4 +5,19 @@ require "action_view"
 module FlexiAdmin::Components::Helpers::UrlHelper
   include ::ActionView::Helpers::UrlHelper
   include ::ActionView::RoutingUrlFor
+
+  def namespaced_path(*segments)
+    namespace = FlexiAdmin::Config.configuration.namespace
+
+    segments.map! do |segment|
+      segment = segment.to_s.gsub("/", "_")
+      segment == "namespace" ? (namespace.presence || nil) : segment
+    end
+    segments.compact!
+    "#{segments.join("_")}_path"
+  end
+
+  def route_exists_in_main_app?(path)
+    main_app.respond_to?(path)
+  end
 end

data/lib/flexi_admin/components/nav/breadcrumbs_component.html.slim

@@ -0,0 +1,13 @@
+nav.breadcrumbs aria-label="breadcrumb"
+  ol.breadcrumb
+    - breadcrumbs.each_with_index do |crumb, idx|
+      - if idx < breadcrumbs.size - 1
+        li.breadcrumb-item
+          - if (main_app.routes.recognize_path("#{request.base_url}#{crumb[:url]}", method: :get) rescue false)
+            = helpers.link_to crumb[:label], crumb[:url], "data-turbo-frame": "_top"
+          - else
+            - puts "here"
+            = crumb[:label]
+      - else
+        li.breadcrumb-item.active aria-current="page"
+          = crumb[:label]

data/lib/flexi_admin/components/nav/breadcrumbs_component.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module FlexiAdmin::Components::Nav
+  class BreadcrumbsComponent < FlexiAdmin::Components::BaseComponent
+    include FlexiAdmin::Components::Helpers::UrlHelper
+
+    attr_reader :path
+
+    def initialize(path:)
+      super()
+      @path = path
+    end
+
+    def breadcrumbs
+      segments = path.split("/").reject(&:blank?)
+      return [] if segments.size <= 1
+
+      crumbs = []
+      url = ""
+      segments.each_with_index do |segment, idx|
+        if idx.positive? && is_id?(segment)
+          # For instance, use singularized model name for lookup, but display uses instance title
+          model_class = infer_model_class(segments[idx - 1], segments[0..idx-2])
+          record = model_class&.find_by(id: segment)
+          label = record&.title if record.respond_to?(:title)
+          label ||= record&.try(:name)
+          label ||= "#{segments[idx - 1].singularize.camelize} ##{segment}"
+          url += "/#{segment}"
+        elsif !is_id?(segment)
+          # For collection, use plural segment for display and I18n lookup
+          plural_segment = segment
+          model_class = infer_model_class(segment, segments[0..idx-1])
+          label = breadcrumb_label(model_class, plural_segment)
+          url += "/#{segment}"
+        end
+
+        crumbs << { label: label, url: url.dup }
+      end
+      crumbs
+    end
+
+    private
+
+    def is_id?(segment)
+      segment.match?(/\A\d+\z/) || segment.match?(/\A[\da-fA-F-]{36}\z/)
+    end
+
+    def breadcrumb_label(model_class, plural_segment)
+      if model_class.is_a?(Class) && model_class.respond_to?(:breadcrumb_title)
+        model_class.breadcrumb_title
+      elsif model_class.is_a?(Class) && model_class.respond_to?(:model_name)
+        I18n.t("activerecord.models.#{model_class.model_name.i18n_key}.few",
+               default: model_class.model_name.human)
+      elsif model_class.is_a?(Module)
+        # For namespaces/modules, try to translate
+        module_name = model_class.name.underscore
+        I18n.t("activerecord.models.#{module_name}.few", default: module_name.humanize)
+      else
+        I18n.t("breadcrumbs.#{plural_segment}", default: plural_segment.titleize)
+      end
+    end
+
+    def infer_model_class(segment, previous_segments = [])
+      singular = segment.singularize
+      candidates = [singular.camelize]
+      if singular.include?('_')
+        parts = singular.split('_')
+        namespace = parts[0].camelize
+        model = parts[1..-1].join('_').camelize
+        candidates << "#{namespace}::#{model}"
+      end
+      # Try with previous segments as potential namespaces
+      previous_segments.reverse.each do |prev|
+        next if is_id?(prev)
+
+        namespace = prev.singularize.camelize
+        candidates << "#{namespace}::#{singular.camelize}"
+      end
+      candidates.each do |name|
+        cls = name.safe_constantize
+        return cls if cls.is_a?(Class) && cls < ActiveRecord::Base
+      end
+      nil
+    end
+  end
+end