panda-core 0.2.4 → 0.6.0

data/app/components/panda/core/admin/table_component.rb

@@ -3,32 +3,113 @@
 module Panda
   module Core
     module Admin
-      class TableComponent < ViewComponent::Base
+      class TableComponent < Panda::Core::Base
+        prop :term, String
+        prop :rows, _Nilable(Object), default: -> { [] }
+        prop :icon, String, default: ""
+
         attr_reader :columns
 
-        def initialize(term:, rows:)
-          @term = term
-          @rows = rows
+        def initialize(**props)
+          super
           @columns = []
         end
 
-        def column(label, &)
-          @columns << Column.new(label, &)
+        def view_template(&block)
+          # Capture the block to populate columns
+          instance_eval(&block) if block_given?
+
+          if @rows.any?
+            render_table_with_rows
+          else
+            render_empty_table
+          end
+        end
+
+        def column(label, width: nil, &cell_block)
+          @columns << Column.new(label, width, &cell_block)
         end
 
         private
 
-        # Ensures @columns gets populated [https://dev.to/rolandstuder/supercharged-table-component-built-with-viewcomponent-3j6i]
-        def before_render
-          content
+        def render_table_with_rows
+          div(class: "table overflow-x-auto mb-12 w-full rounded-lg border border-dark", style: "table-layout: fixed;") do
+            render_header
+            render_rows
+          end
+        end
+
+        def render_empty_table
+          div(class: "text-center block border border-dashed py-12 rounded-lg") do
+            i(class: "#{@icon} text-4xl text-gray-400 mb-3") if @icon.present?
+            h3(class: "py-1 text-xl font-semibold text-gray-900") { "No #{@term.pluralize}" }
+            p(class: "py-1 text-base text-gray-500") { "Get started by creating a new #{@term}." }
+          end
+        end
+
+        def render_header
+          div(class: "table-header-group") do
+            div(class: "table-row text-base font-medium text-white bg-dark") do
+              @columns.each_with_index do |column, i|
+                header_classes = "table-cell sticky top-0 z-10 p-4"
+                header_classes += " rounded-tl-md" if i.zero?
+                header_classes += " rounded-tr-md" if i == @columns.size - 1
+
+                header_style = column.width ? "width: #{column.width};" : nil
+                div(class: header_classes, style: header_style) { column.label }
+              end
+            end
+          end
+        end
+
+        def render_rows
+          div(class: "table-row-group") do
+            @rows.each do |row|
+              div(
+                class: "table-row relative bg-gray-500/5 hover:bg-gray-500/20",
+                data: {post_id: row.id}
+              ) do
+                @columns.each do |column|
+                  div(class: "table-cell py-5 px-3 h-20 text-sm align-middle whitespace-nowrap border-b border-dark/20") do
+                    # Capture the cell content by calling the block with the row
+                    render_cell_content(row, column.cell)
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def render_cell_content(row, cell_block)
+          # When called from ERB, we need to capture the block's output buffer
+          # When called from Phlex, evaluate directly
+          if defined?(view_context) && view_context
+            # Use capture to get ERB output buffer content
+            captured_html = view_context.capture(row, &cell_block)
+            # Render the captured HTML (already html_safe from capture)
+            raw(captured_html)
+          else
+            # Pure Phlex context - execute block directly
+            result = cell_block.call(row)
+
+            # Handle different return types
+            if result.is_a?(String)
+              plain(result)
+            elsif result.respond_to?(:render_in)
+              render(result)
+            else
+              plain(result.to_s)
+            end
+          end
         end
       end
 
       class Column
-        attr_reader :label, :cell
+        attr_reader :label, :cell, :width
 
-        def initialize(label, &block)
+        def initialize(label, width = nil, &block)
           @label = label
+          @width = width
           @cell = block
         end
       end

data/app/components/panda/core/admin/tag_component.rb

@@ -3,30 +3,72 @@
 module Panda
   module Core
     module Admin
-      class TagComponent < ViewComponent::Base
-        attr_accessor :status, :text
+      class TagComponent < Panda::Core::Base
+        prop :status, Symbol, default: :active
+        prop :text, _Nilable(String), default: -> {}
+        prop :page_type, _Nilable(Symbol), default: -> {}
 
-        def initialize(status: :active, text: nil)
-          @status = status.to_sym
-          @text = text || status.to_s.humanize
+        def view_template
+          span(class: tag_classes) { computed_text }
         end
 
-        def call
-          classes = "inline-flex items-center py-1 px-2 text-xs font-medium rounded-md ring-1 ring-inset "
+        private
 
-          classes += case @status
+        def computed_text
+          if @page_type
+            @text || type_display_text
+          else
+            @text || @status.to_s.humanize
+          end
+        end
+
+        def type_display_text
+          case @page_type
+          when :standard
+            "Active"
+          when :hidden_type
+            "Hidden"
+          else
+            @page_type.to_s.humanize
+          end
+        end
+
+        def tag_classes
+          base = "inline-flex items-center py-1 px-2 text-xs font-medium rounded-md ring-1 ring-inset "
+          base + (@page_type ? type_classes : status_classes)
+        end
+
+        def type_classes
+          case @page_type
+          when :system
+            "text-red-700 bg-red-100 ring-red-600/20 dark:bg-red-400/10 dark:text-red-400"
+          when :posts
+            "text-purple-700 bg-purple-100 ring-purple-600/20 dark:bg-purple-400/10 dark:text-purple-400"
+          when :code
+            "text-blue-700 bg-blue-100 ring-blue-600/20 dark:bg-blue-400/10 dark:text-blue-400"
+          when :standard
+            "text-green-700 bg-green-100 ring-green-600/20 dark:bg-green-400/10 dark:text-green-400"
+          when :hidden_type
+            "text-gray-700 bg-gray-100 ring-gray-600/20 dark:bg-gray-400/10 dark:text-gray-400"
+          else
+            "text-gray-700 bg-gray-100 ring-gray-600/20 dark:bg-gray-400/10 dark:text-gray-400"
+          end
+        end
+
+        def status_classes
+          case @status
           when :active
-            "text-white ring-black/30 bg-green-600 border-0 "
+            "text-white ring-black/30 bg-green-600 border-0"
           when :draft
-            "text-black ring-black/30 bg-yellow-400 "
+            "text-black ring-black/30 bg-yellow-400"
           when :inactive, :hidden
-            "text-black ring-black/30 bg-black/5 bg-white "
+            "text-black ring-black/30 bg-black/5 bg-white"
+          when :auto
+            "text-blue-700 bg-blue-100 ring-blue-600/20 dark:bg-blue-400/10 dark:text-blue-400"
+          when :static
+            "text-gray-700 bg-gray-100 ring-gray-600/20 dark:bg-gray-400/10 dark:text-gray-400"
           else
-            "text-black bg-white "
-          end
-
-          content_tag :span, class: classes do
-            @text
+            "text-black bg-white"
           end
         end
       end

data/app/components/panda/core/admin/user_activity_component.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      class UserActivityComponent < Panda::Core::Base
+        include ActionView::Helpers::DateHelper
+
+        prop :model, _Nilable(Object), default: -> {}
+        prop :at, _Nilable(Object), default: -> {}
+        prop :user, _Nilable(Object), default: -> {}
+
+        def view_template
+          return unless should_render?
+
+          if @user.is_a?(Panda::Core::User) && time
+            render Panda::Core::Admin::UserDisplayComponent.new(
+              user: @user,
+              metadata: "#{time_ago_in_words(time)} ago"
+            )
+          elsif @user.is_a?(Panda::Core::User)
+            render Panda::Core::Admin::UserDisplayComponent.new(
+              user: @user,
+              metadata: "Not published"
+            )
+          elsif time
+            div(class: "text-black/60") { "#{time_ago_in_words(time)} ago" }
+          end
+        end
+
+        private
+
+        def time
+          @at if @at.is_a?(ActiveSupport::TimeWithZone)
+        end
+
+        def should_render?
+          @user.is_a?(Panda::Core::User) || time
+        end
+      end
+    end
+  end
+end

data/app/components/panda/core/admin/user_display_component.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      class UserDisplayComponent < Panda::Core::Base
+        prop :user_id, _Nilable(String), default: -> {}
+        prop :user, _Nilable(Object), default: -> {}
+        prop :metadata, String, default: ""
+
+        def view_template
+          return unless resolved_user
+
+          div(class: "block flex-shrink-0 group") do
+            div(class: "flex items-center") do
+              render_avatar
+              render_user_info
+            end
+          end
+        end
+
+        private
+
+        def resolved_user
+          @resolved_user ||= if @user.nil? && @user_id.present?
+            Panda::Core::User.find_by(id: @user_id)
+          else
+            @user
+          end
+        end
+
+        def render_avatar
+          has_image = resolved_user.respond_to?(:avatar_url) &&
+            resolved_user.avatar_url.present?
+
+          if has_image
+            div do
+              img(
+                class: "inline-block w-10 h-10 rounded-full object-cover",
+                src: resolved_user.avatar_url,
+                alt: ""
+              )
+            end
+          else
+            div(class: "inline-block w-10 h-10 bg-gray-200 rounded-full flex items-center justify-center") do
+              span(class: "text-sm font-medium text-gray-600") { user_initials }
+            end
+          end
+        end
+
+        def user_initials
+          return "" unless resolved_user.respond_to?(:name)
+
+          name_parts = resolved_user.name.to_s.split
+          if name_parts.length >= 2
+            "#{name_parts.first[0]}#{name_parts.last[0]}".upcase
+          elsif name_parts.length == 1
+            name_parts.first[0..1].upcase
+          else
+            ""
+          end
+        end
+
+        def render_user_info
+          div(class: "ml-3") do
+            p(class: "text-sm text-black") { resolved_user.name }
+            if @metadata.present?
+              p(class: "text-sm text-black/60") { @metadata }
+            elsif resolved_user.respond_to?(:email) && resolved_user.email.present?
+              p(class: "text-sm text-gray-500") { resolved_user.email }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/panda/core/base.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    # Base class for all Phlex components in the Panda ecosystem.
+    #
+    # This base component provides:
+    # - Type-safe properties via Literal
+    # - Tailwind CSS class merging
+    # - Attribute merging with sensible defaults
+    # - Rails helper integration
+    # - Development-mode debugging comments
+    #
+    # @example Basic usage
+    #   class MyComponent < Panda::Core::Base
+    #     prop :title, String
+    #     prop :variant, Symbol, default: :primary
+    #
+    #     def view_template
+    #       div(**@attrs) { title }
+    #     end
+    #
+    #     def default_attrs
+    #       { class: "my-component my-component--#{variant}" }
+    #     end
+    #   end
+    #
+    # @example With attribute merging
+    #   # Component definition
+    #   class Button < Panda::Core::Base
+    #     prop :text, String
+    #
+    #     def view_template
+    #       button(**@attrs) { text }
+    #     end
+    #
+    #     def default_attrs
+    #       { class: "btn btn-primary", type: "button" }
+    #     end
+    #   end
+    #
+    #   # Usage - user attrs merge with defaults
+    #   render Button.new(text: "Click me", class: "mt-4", type: "submit")
+    #   # => <button type="submit" class="btn btn-primary mt-4">Click me</button>
+    #
+    class Base < Phlex::HTML
+      # Frozen instance of TailwindMerge for efficient class merging
+      TAILWIND_MERGER = ::TailwindMerge::Merger.new.freeze unless defined?(TAILWIND_MERGER)
+
+      # Enable type-safe properties via Literal
+      extend Literal::Properties
+
+      # Include Rails helpers for routes, etc.
+      include Phlex::Rails::Helpers::Routes
+
+      # Special handling for the attrs property - merges user attributes with defaults
+      # and intelligently handles Tailwind class merging
+      #
+      # @param value [Hash] User-provided attributes
+      # @return [Hash] Merged attributes with Tailwind classes properly combined
+      prop :attrs, Hash, :**, reader: :private do |value|
+        merge_attrs(value, default_attrs)
+      end
+
+      # Merges user-provided attributes with default attributes.
+      # Special handling for :class to merge Tailwind classes intelligently.
+      #
+      # @param user_attrs [Hash] Attributes provided by the user
+      # @param default_attrs [Hash] Default attributes from the component
+      # @return [Hash] Merged attributes
+      def merge_attrs(user_attrs, default_attrs)
+        attrs = default_attrs.merge(user_attrs)
+        if attrs[:class].is_a?(String)
+          attrs[:class] = TAILWIND_MERGER.merge(attrs[:class])
+        end
+        attrs
+      end
+
+      # Helper alias for merge_attrs with clearer intent
+      #
+      # @param user_attrs [Hash] Attributes provided by the user
+      # @param default_attrs [Hash] Default attributes from the component
+      # @return [Hash] Merged attributes with Tailwind classes combined
+      def tailwind_merge_attrs(user_attrs, default_attrs)
+        merge_attrs(user_attrs, default_attrs)
+      end
+
+      # Override this method in subclasses to provide default attributes
+      # for your component.
+      #
+      # @return [Hash] Default HTML attributes for the component
+      #
+      # @example
+      #   def default_attrs
+      #     {
+      #       class: "btn btn-#{variant}",
+      #       type: "button",
+      #       data: { controller: "button" }
+      #     }
+      #   end
+      def default_attrs
+        {}
+      end
+
+      # In development mode, wrap components with HTML comments
+      # showing their class name for easier debugging
+      if Rails.env.development?
+        def before_template
+          class_name = self.class.name
+          comment { "Begin #{class_name}" }
+          super
+        end
+
+        def after_template
+          class_name = self.class.name
+          super
+          comment { "End #{class_name}" }
+        end
+      end
+    end
+  end
+end

data/app/controllers/panda/core/admin/base_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    module Admin
+      # Base controller for all admin interfaces across Panda gems
+      # Provides authentication, helpers, and hooks for extending functionality
+      class BaseController < ::ActionController::Base
+        layout "panda/core/admin"
+
+        protect_from_forgery with: :exception
+
+        # Add flash types for improved alert support with Tailwind
+        add_flash_types :success, :warning, :error, :info
+
+        # Include helper modules
+        helper Panda::Core::SessionsHelper
+        helper Panda::Core::AssetHelper if defined?(Panda::Core::AssetHelper)
+
+        before_action :set_current_request_details
+        before_action :authenticate_admin_user!
+
+        helper_method :breadcrumbs
+        helper_method :current_user
+        helper_method :user_signed_in?
+
+        def breadcrumbs
+          @breadcrumbs ||= []
+        end
+
+        def add_breadcrumb(name, path = nil)
+          breadcrumbs << Breadcrumb.new(name, path)
+        end
+
+        # Set the current request details
+        # @return [void]
+        def set_current_request_details
+          # Set Core current attributes
+          Panda::Core::Current.request_id = request.uuid
+          Panda::Core::Current.user_agent = request.user_agent
+          Panda::Core::Current.ip_address = request.ip
+          Panda::Core::Current.root = request.base_url
+          Panda::Core::Current.user ||= Panda::Core::User.find_by(id: session[:user_id]) if session[:user_id]
+        end
+
+        def authenticate_user!
+          redirect_to main_app.root_path, flash: {error: "Please login to view this!"} unless user_signed_in?
+        end
+
+        def authenticate_admin_user!
+          return if user_signed_in? && current_user.admin?
+
+          redirect_to panda_core.admin_login_path,
+            flash: {error: "Please login to view this!"}
+        end
+
+        # Required for paper_trail and seems as good as convention these days
+        def current_user
+          Panda::Core::Current.user
+        end
+
+        def user_signed_in?
+          !!Panda::Core::Current.user
+        end
+      end
+    end
+  end
+end

data/app/controllers/panda/core/admin/dashboard_controller.rb

@@ -3,13 +3,15 @@
 module Panda
   module Core
     module Admin
-      class DashboardController < AdminController
+      class DashboardController < BaseController
         # Authentication is automatically enforced by AdminController
 
         def show
           # If a custom dashboard path is configured, redirect there
-          if Panda::Core.configuration.dashboard_redirect_path
-            redirect_to Panda::Core.configuration.dashboard_redirect_path
+          if Panda::Core.config.dashboard_redirect_path
+            redirect_path = Panda::Core.config.dashboard_redirect_path
+            redirect_path = redirect_path.call if redirect_path.respond_to?(:call)
+            redirect_to redirect_path
           else
             # Render the dashboard view
             render :show

data/app/controllers/panda/core/admin/my_profile_controller.rb

@@ -3,7 +3,7 @@
 module Panda
   module Core
     module Admin
-      class MyProfileController < ::Panda::Core::AdminController
+      class MyProfileController < BaseController
         before_action :set_initial_breadcrumb, only: %i[edit update]
 
         # Shows the edit form for the current user's profile
@@ -21,7 +21,7 @@ module Panda
             flash[:success] = "Your profile has been updated successfully."
             redirect_to edit_admin_my_profile_path
           else
-            render :edit, locals: {user: current_user}, status: :unprocessable_entity
+            render :edit, locals: {user: current_user}, status: :unprocessable_content
           end
         end
 
@@ -36,10 +36,10 @@ module Panda
         # @return ActionController::StrongParameters
         def user_params
           # Base parameters that Core always allows
-          base_params = [:firstname, :lastname, :email, :current_theme]
+          base_params = [:name, :email, :current_theme, :avatar]
 
           # Allow additional params from configuration
-          additional_params = Core.configuration.additional_user_params || []
+          additional_params = Core.config.additional_user_params || []
 
           params.require(:user).permit(*(base_params + additional_params))
         end

data/app/controllers/panda/core/admin/sessions_controller.rb

@@ -3,12 +3,14 @@
 module Panda
   module Core
     module Admin
-      class SessionsController < AdminController
+      class SessionsController < BaseController
+        layout "panda/core/admin_simple"
+
         # Skip authentication for login/logout actions
         skip_before_action :authenticate_admin_user!, only: [:new, :create, :destroy, :failure]
 
         def new
-          @providers = Core.configuration.authentication_providers.keys
+          @providers = Core.config.authentication_providers.keys
         end
 
         def create
@@ -18,7 +20,7 @@ module Panda
           # Find the actual provider key (might be using path_name override)
           provider = find_provider_by_path(provider_path)
 
-          unless provider && Core.configuration.authentication_providers.key?(provider)
+          unless provider && Core.config.authentication_providers.key?(provider)
             redirect_to admin_login_path, flash: {error: "Authentication provider not enabled"}
             return
           end
@@ -28,7 +30,9 @@ module Panda
           if user.persisted?
             # Check if user is admin before allowing access
             unless user.admin?
-              redirect_to admin_login_path, flash: {error: "You do not have permission to access the admin area"}
+              flash[:error] = "You do not have permission to access the admin area"
+              flash.keep(:error) if Rails.env.test?
+              redirect_to admin_login_path
               return
             end
 
@@ -40,7 +44,8 @@ module Panda
               provider: provider)
 
             # Use configured dashboard path or default to admin_root_path
-            redirect_path = Panda::Core.configuration.dashboard_redirect_path || admin_root_path
+            redirect_path = Panda::Core.config.dashboard_redirect_path || admin_root_path
+            redirect_path = redirect_path.call if redirect_path.respond_to?(:call)
             redirect_to redirect_path, flash: {success: "Successfully logged in as #{user.name}"}
           else
             redirect_to admin_login_path, flash: {error: "Unable to create account: #{user.errors.full_messages.join(", ")}"}
@@ -55,7 +60,9 @@ module Panda
           strategy = params[:strategy] || "unknown"
 
           Rails.logger.error "OmniAuth failure: strategy=#{strategy}, message=#{message}"
-          redirect_to admin_login_path, flash: {error: "Authentication failed: #{message}"}
+          flash[:error] = "Authentication failed: #{message}"
+          flash.keep(:error) if Rails.env.test?
+          redirect_to admin_login_path
         end
 
         def destroy
@@ -72,10 +79,10 @@ module Panda
         # Find the provider key by path name (handles path_name override)
         def find_provider_by_path(provider_path)
           # First check if it's a direct match
-          return provider_path if Core.configuration.authentication_providers.key?(provider_path)
+          return provider_path if Core.config.authentication_providers.key?(provider_path)
 
           # Then check if any provider has a matching path_name
-          Core.configuration.authentication_providers.each do |key, config|
+          Core.config.authentication_providers.each do |key, config|
             return key if config[:path_name]&.to_sym == provider_path
           end