panda-core 0.7.5 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5b6a96a40435b148afebf0b96b694e6e22f42519e6a8354bfb3553bdecb492a
-  data.tar.gz: 88bdb192bd9796b261cc71030fea9a0fb355d3e36f2e71ef7b8f7f962c37757d
+  metadata.gz: d71882619f044e6c12c628c91dd32e1f3f8d35ed6c06c2d56a952df67b2d185d
+  data.tar.gz: 98ffdb33880b310143ba47d13f40edda3fe5568a9474d089fc56fa6f43b45cba
 SHA512:
-  metadata.gz: 1c3415fba271ab61118cb85c53805b97609196a67db98a0f50a7364902a137b25162e788822c57f5c06232aa9e36e54ef26114dd118012fcfbb3dbcef96d6304
-  data.tar.gz: 6cb4bf5de81695ffc7fa6ce0e452fd049f90284213cfcf6842653a944590b91942c9ba0175818c544dbec4f9566404b4eea87431d397b969e7c5bf15e1ab5c00
+  metadata.gz: e76cc361df60d271c1ce4489eb892731e5ae03bdbe7de1eaddd9ae60c3bb9a0c31319aa309f6a8be020a9fae34cd1cbdcf3bfcce3ebc7bc8379609412b870167
+  data.tar.gz: a16db81da2dd0248dc6e0dd9d306dcc2d134ddcb372b707c65c99a9a6c31a24c79e175ee01412abe46fe6f6148afe2bd648351fa876cca3bfd6ec6d39c646a04

data/Rakefile

@@ -2,7 +2,6 @@ require "bundler/setup"
 
 APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
 load "rails/tasks/engine.rake"
-load "rails/tasks/statistics.rake"
 
 require "bundler/gem_tasks"
 

data/lib/panda/core/asset_loader.rb

@@ -157,14 +157,28 @@ module Panda
         end
 
         def development_css_url
-          # Try versioned file first
-          version = asset_version
-          versioned_file = "/panda-core-assets/panda-core-#{version}.css"
-          return versioned_file if File.exist?(Rails.public_path.join("panda-core-assets", "panda-core-#{version}.css"))
+          assets_dir = Panda::Core::Engine.root.join("public", "panda-core-assets")
+
+          # In dev/test, look for timestamp-based files (latest one)
+          if Rails.env.test? || Rails.env.development?
+            # Find all timestamp-based CSS files (exclude symlinks)
+            css_files = Dir[assets_dir.join("panda-core-*.css")].reject { |f| File.symlink?(f) }
+
+            if css_files.any?
+              # Return the most recently created file
+              latest = css_files.max_by { |f| File.basename(f)[/\d+/].to_i }
+              return "/panda-core-assets/#{File.basename(latest)}"
+            end
+          else
+            # In production, try versioned file first
+            version = asset_version
+            versioned_file = "/panda-core-assets/panda-core-#{version}.css"
+            return versioned_file if File.exist?(Rails.public_path.join("panda-core-assets", "panda-core-#{version}.css"))
+          end
 
           # Fall back to unversioned file (always available from engine's public directory)
           unversioned_file = "/panda-core-assets/panda-core.css"
-          return unversioned_file if File.exist?(Panda::Core::Engine.root.join("public", "panda-core-assets", "panda-core.css"))
+          return unversioned_file if File.exist?(assets_dir.join("panda-core.css"))
 
           nil
         end

data/lib/panda/core/engine.rb

@@ -19,6 +19,10 @@ ensure
   $stderr = original_stderr
 end
 
+# Load shared configuration modules
+require_relative "shared/inflections_config"
+require_relative "shared/generator_config"
+
 # Load engine configuration modules
 require_relative "engine/test_config"
 require_relative "engine/autoload_config"
@@ -28,6 +32,9 @@ require_relative "engine/omniauth_config"
 require_relative "engine/phlex_config"
 require_relative "engine/admin_controller_config"
 
+# Load module registry
+require_relative "module_registry"
+
 module Panda
   module Core
     class Engine < ::Rails::Engine
@@ -49,6 +56,51 @@ module Panda
       initializer "panda_core.config" do |app|
         # Configuration is already initialized with defaults in Configuration class
       end
+
+      # Auto-compile CSS for test/development environments
+      initializer "panda_core.auto_compile_assets", after: :load_config_initializers do |app|
+        # Only auto-compile in test or when explicitly requested
+        next unless Rails.env.test? || ENV["PANDA_CORE_AUTO_COMPILE"] == "true"
+
+        # Use timestamp for cache busting in dev/test
+        timestamp = Time.now.to_i
+        assets_dir = Panda::Core::Engine.root.join("public", "panda-core-assets")
+        timestamped_css = assets_dir.join("panda-core-#{timestamp}.css")
+
+        # Check if any compiled CSS exists (timestamp-based)
+        existing_css = Dir[assets_dir.join("panda-core-*.css")].reject { |f| File.symlink?(f) }
+
+        if existing_css.empty?
+          warn "🐼 [Panda Core] Auto-compiling CSS for test environment..."
+
+          # Compile CSS with timestamp
+          require "open3"
+          require "fileutils"
+
+          FileUtils.mkdir_p(assets_dir)
+
+          # Get content paths from ModuleRegistry
+          content_paths = Panda::Core::ModuleRegistry.tailwind_content_paths
+          content_flags = content_paths.map { |path| "--content '#{path}'" }.join(" ")
+
+          # Compile directly to timestamped file with all registered module content
+          input_file = Panda::Core::Engine.root.join("app/assets/tailwind/application.css")
+          cmd = "bundle exec tailwindcss -i #{input_file} -o #{timestamped_css} #{content_flags} --minify"
+
+          _, stderr, status = Open3.capture3(cmd)
+
+          if status.success?
+            # Create unversioned symlink for fallback
+            symlink = assets_dir.join("panda-core.css")
+            FileUtils.rm_f(symlink) if File.exist?(symlink)
+            FileUtils.ln_sf(File.basename(timestamped_css), symlink)
+
+            warn "🐼 [Panda Core] CSS compilation successful (#{timestamped_css.size} bytes)"
+          else
+            warn "🐼 [Panda Core] CSS compilation failed: #{stderr}"
+          end
+        end
+      end
     end
   end
 end

data/lib/panda/core/module_registry.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Panda
+  module Core
+    # Module registry for Panda ecosystem components
+    #
+    # This class maintains a registry of all Panda modules (CMS, CMS Pro, Community, etc.)
+    # and their asset paths. Each module self-registers during engine initialization.
+    #
+    # Benefits:
+    # - Core doesn't need hardcoded knowledge of other modules
+    # - Supports private modules (e.g., panda-community in development)
+    # - Single source of truth for asset compilation
+    # - Scales automatically to future modules
+    #
+    # Usage:
+    #   # In module's engine.rb (after class definition):
+    #   Panda::Core::ModuleRegistry.register(
+    #     gem_name: 'panda-cms',
+    #     engine: 'Panda::CMS::Engine',
+    #     paths: {
+    #       views: 'app/views/panda/cms/**/*.erb',
+    #       components: 'app/components/panda/cms/**/*.rb',
+    #       stylesheets: 'app/assets/stylesheets/panda/cms/**/*.css'
+    #     }
+    #   )
+    #
+    class ModuleRegistry
+      @modules = {}
+
+      class << self
+        # Register a Panda module with its asset paths
+        #
+        # @param gem_name [String] Gem name (e.g., 'panda-cms')
+        # @param engine [String] Engine constant name (e.g., 'Panda::CMS::Engine')
+        # @param paths [Hash] Asset path patterns relative to engine root
+        # @option paths [String] :views View template paths
+        # @option paths [String] :components ViewComponent paths
+        # @option paths [String] :stylesheets Stylesheet paths (optional)
+        def register(gem_name:, engine:, paths:)
+          @modules[gem_name] = {
+            engine: engine,
+            paths: paths
+          }
+        end
+
+        # Returns all registered modules
+        #
+        # @return [Hash] Module registry
+        attr_reader :modules
+
+        # Returns content paths for Tailwind CSS scanning
+        #
+        # Tailwind needs to scan all files that might contain utility classes:
+        # - Views (ERB templates)
+        # - Components (ViewComponent classes)
+        # - JavaScript (Stimulus controllers, etc.)
+        #
+        # @return [Array<String>] Full paths for Tailwind --content flags
+        def tailwind_content_paths
+          paths = []
+
+          # Core's own content (always included)
+          core_root = Panda::Core::Engine.root
+          paths << "#{core_root}/app/views/panda/core/**/*.erb"
+          paths << "#{core_root}/app/components/panda/core/**/*.rb"
+
+          # Registered modules (only if engine is loaded)
+          @modules.each do |gem_name, info|
+            next unless engine_available?(info[:engine])
+
+            root = engine_root(info[:engine])
+            next unless root
+
+            # Add configured path types
+            paths << "#{root}/#{info[:paths][:views]}" if info[:paths][:views]
+            paths << "#{root}/#{info[:paths][:components]}" if info[:paths][:components]
+
+            # For Tailwind scanning, we also need to scan JavaScript for utility classes
+            # Check if module has JavaScript (via importmap or direct paths)
+            js_root = root.join("app/javascript")
+            if js_root.directory?
+              paths << "#{js_root}/**/*.js"
+            end
+          end
+
+          # Host application Panda overrides
+          # Applications can override any Panda views/components
+          if defined?(Rails.root)
+            paths << "#{Rails.root}/app/views/panda/**/*.erb"
+            paths << "#{Rails.root}/app/components/panda/**/*.rb"
+            paths << "#{Rails.root}/app/javascript/panda/**/*.js"
+          end
+
+          paths.compact
+        end
+
+        # Returns JavaScript source files by introspecting importmaps
+        #
+        # Instead of duplicating file lists, we read the importmap configuration
+        # that each engine already maintains. This provides a single source of truth.
+        #
+        # @return [Array<String>] Full paths to JavaScript source files
+        def javascript_sources
+          return [] unless defined?(Rails.application&.importmap)
+
+          sources = []
+
+          # Detect importmap-rails version and use appropriate API
+          importmap = Rails.application.importmap
+          entries = if importmap.respond_to?(:packages)
+            # importmap-rails 2.x - packages is a hash
+            importmap.packages
+          elsif importmap.respond_to?(:entries)
+            # importmap-rails 1.x - entries is an array
+            importmap.entries.map { |e| [e.name, e] }.to_h
+          else
+            {}
+          end
+
+          # Find all Panda-namespaced imports and resolve to file paths
+          entries.each do |name, config|
+            next unless name.to_s.match?(/^panda-/)
+
+            path = resolve_importmap_to_path(name, config)
+            sources << path if path
+          end
+
+          sources.compact.uniq
+        end
+
+        # Returns registered module names
+        #
+        # @return [Array<String>] List of registered gem names
+        def registered_modules
+          @modules.keys
+        end
+
+        # Check if a specific module is registered
+        #
+        # @param gem_name [String] Gem name to check
+        # @return [Boolean] True if module is registered
+        def registered?(gem_name)
+          @modules.key?(gem_name)
+        end
+
+        private
+
+        # Check if an engine constant is defined and available
+        #
+        # @param engine_name [String] Engine constant name
+        # @return [Boolean] True if engine is available
+        def engine_available?(engine_name)
+          Object.const_defined?(engine_name)
+        rescue NameError
+          false
+        end
+
+        # Get the root path of an engine
+        #
+        # @param engine_name [String] Engine constant name
+        # @return [Pathname, nil] Engine root path or nil if unavailable
+        def engine_root(engine_name)
+          return nil unless engine_available?(engine_name)
+
+          engine_class = Object.const_get(engine_name)
+          engine_class.root
+        rescue NoMethodError
+          nil
+        end
+
+        # Resolve an importmap entry to an actual file path
+        #
+        # Importmap entries can be:
+        # - Direct paths: "panda/cms/controllers/dashboard_controller.js"
+        # - Module names: "panda-cms/controllers/dashboard_controller"
+        #
+        # We need to find where these files actually live in the filesystem.
+        #
+        # @param name [String, Symbol] Import name
+        # @param config [Object] Importmap entry (structure varies by version)
+        # @return [String, nil] Full file path or nil if not found
+        def resolve_importmap_to_path(name, config)
+          # Extract path from config (API differs between importmap-rails versions)
+          relative_path = if config.respond_to?(:path)
+            config.path
+          elsif config.respond_to?(:[])
+            config[:path] || config["path"]
+          elsif config.is_a?(String)
+            config
+          end
+
+          return nil unless relative_path
+
+          # Try to find the file in registered engines
+          @modules.each do |gem_name, info|
+            next unless engine_available?(info[:engine])
+
+            root = engine_root(info[:engine])
+            next unless root
+
+            # Check common JavaScript locations
+            [
+              root.join("app/javascript", relative_path),
+              root.join("app/javascript", "#{relative_path}.js"),
+              root.join("app/assets/javascripts", relative_path),
+              root.join("app/assets/javascripts", "#{relative_path}.js")
+            ].each do |candidate|
+              return candidate.to_s if candidate.exist?
+            end
+          end
+
+          # Check Rails app if available
+          if defined?(Rails.root)
+            [
+              Rails.root.join("app/javascript", relative_path),
+              Rails.root.join("app/javascript", "#{relative_path}.js")
+            ].each do |candidate|
+              return candidate.to_s if candidate.exist?
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/panda/core/testing/rails_helper.rb

@@ -31,7 +31,14 @@ end
 # Load all support files from panda-core
 # Files are now in lib/panda/core/testing/support/ to be included in the published gem
 support_path = File.expand_path("../support", __FILE__)
-Dir[File.join(support_path, "**/*.rb")].sort.each { |f| require f }
+
+# Load system test infrastructure first (Capybara, Cuprite, helpers)
+system_test_files = Dir[File.join(support_path, "system/**/*.rb")].sort
+system_test_files.each { |f| require f }
+
+# Load other support files
+other_support_files = Dir[File.join(support_path, "**/*.rb")].sort.reject { |f| f.include?("/system/") }
+other_support_files.each { |f| require f }
 
 RSpec.configure do |config|
   # Include panda-core route helpers by default

data/lib/panda/core/testing/support/system/capybara_setup.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Shared Capybara configuration for all Panda gems
+# This provides standard Capybara setup with sensible defaults
+
+# Increase wait time for CI environments where asset loading is slower
+Capybara.default_max_wait_time = ENV["CI"].present? ? 10 : 5
+
+# Normalize whitespaces when using `has_text?` and similar matchers,
+# i.e., ignore newlines, trailing spaces, etc.
+# That makes tests less dependent on slight UI changes.
+Capybara.default_normalize_ws = true
+
+# Where to store system tests artifacts (e.g. screenshots, downloaded files, etc.).
+# It could be useful to be able to configure this path from the outside (e.g., on CI).
+Capybara.save_path = ENV.fetch("CAPYBARA_ARTIFACTS", "./tmp/capybara")
+
+# Disable animation so we're not waiting for it
+Capybara.disable_animation = true
+
+# See SystemTestHelpers#take_screenshot
+# This allows us to track which session was last used for proper screenshot naming
+Capybara.singleton_class.prepend(Module.new do
+  attr_accessor :last_used_session
+
+  def using_session(name, &block)
+    self.last_used_session = name
+    super
+  ensure
+    self.last_used_session = nil
+  end
+end)
+
+# Configure server host and port
+Capybara.server_host = "127.0.0.1"
+Capybara.server_port = ENV["CAPYBARA_PORT"]&.to_i # Let Capybara choose if not specified
+
+# Configure Puma server with explicit options
+# Use single-threaded mode to share database connection with tests
+Capybara.register_server :puma do |app, port, host|
+  require "rack/handler/puma"
+  Rack::Handler::Puma.run(app, Port: port, Host: host, Silent: true, Threads: "1:1")
+end
+Capybara.server = :puma
+
+# Do not set app_host here - let Capybara determine it from the server
+# This avoids conflicts between what's configured and what's actually running
+
+# RSpec configuration for Capybara
+RSpec.configure do |config|
+  # Save screenshots on system test failures
+  config.after(:each, type: :system) do |example|
+    if example.exception
+      timestamp = Time.now.strftime("%Y-%m-%d-%H%M%S")
+      "tmp/capybara/failures/#{example.full_description.parameterize}_#{timestamp}"
+
+      # Screenshots are saved automatically by Capybara, but we could save additional artifacts here
+      # save_page("#{filename_base}.html")
+      # save_screenshot("#{filename_base}.png", full: true)
+    end
+  end
+end

data/lib/panda/core/testing/support/system/cuprite_setup.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "ferrum"
+require "capybara/cuprite"
+
+# Shared Cuprite driver configuration for all Panda gems
+# This provides standard Cuprite setup with sensible defaults that work across gems
+#
+# Features:
+# - :cuprite driver for standard desktop testing
+# - :cuprite_mobile driver for mobile viewport testing
+# - JavaScript error reporting enabled by default (js_errors: true)
+# - CI-optimized browser options
+# - Environment-based configuration (HEADLESS, INSPECTOR, SLOWMO)
+
+module Panda
+  module Core
+    module Testing
+      module CupriteSetup
+        # Base Cuprite options shared across all drivers
+        def self.base_options
+          {
+            window_size: [1440, 1000],
+            inspector: ENV["INSPECTOR"].in?(%w[y 1 yes true]),
+            headless: !ENV["HEADLESS"].in?(%w[n 0 no false]),
+            slowmo: ENV["SLOWMO"]&.to_f || 0,
+            timeout: 30,
+            js_errors: true,  # IMPORTANT: Report JavaScript errors as test failures
+            ignore_default_browser_options: false,
+            process_timeout: 10,
+            wait_for_network_idle: false,  # Don't wait for all network requests
+            pending_connection_errors: false,  # Don't fail on pending external connections
+            browser_options: {
+              "no-sandbox": nil,
+              "disable-gpu": nil,
+              "disable-dev-shm-usage": nil,
+              "disable-background-networking": nil,
+              "disable-default-apps": nil,
+              "disable-extensions": nil,
+              "disable-sync": nil,
+              "disable-translate": nil,
+              "no-first-run": nil,
+              "ignore-certificate-errors": nil,
+              "allow-insecure-localhost": nil,
+              "enable-features": "NetworkService,NetworkServiceInProcess",
+              "disable-blink-features": "AutomationControlled"
+            }
+          }
+        end
+
+        # Additional options for CI environments
+        def self.ci_browser_options
+          {
+            "disable-web-security": nil,
+            "allow-file-access-from-files": nil,
+            "allow-file-access": nil
+          }
+        end
+
+        # Configure standard desktop driver
+        def self.register_desktop_driver
+          options = base_options.dup
+
+          # Add CI-specific options
+          if ENV["GITHUB_ACTIONS"] == "true"
+            options[:browser_options].merge!(ci_browser_options)
+
+            puts "\n🔍 Cuprite Configuration (Desktop):"
+            puts "   Debug mode: #{ENV["DEBUG"]}"
+            puts "   Headless: #{options[:headless]}"
+            puts "   JS Errors: #{options[:js_errors]}"
+            puts "   Browser options: #{options[:browser_options].keys.join(", ")}"
+            puts ""
+          end
+
+          Capybara.register_driver :cuprite do |app|
+            Capybara::Cuprite::Driver.new(app, **options)
+          end
+        end
+
+        # Configure mobile viewport driver
+        def self.register_mobile_driver
+          options = base_options.dup
+          options[:window_size] = [375, 667]  # iPhone SE size
+
+          if ENV["GITHUB_ACTIONS"] == "true"
+            options[:browser_options].merge!(ci_browser_options)
+
+            puts "\n🔍 Cuprite Configuration (Mobile):"
+            puts "   Window size: #{options[:window_size]}"
+            puts "   JS Errors: #{options[:js_errors]}"
+            puts ""
+          end
+
+          Capybara.register_driver :cuprite_mobile do |app|
+            Capybara::Cuprite::Driver.new(app, **options)
+          end
+        end
+
+        # Register all drivers
+        def self.setup!
+          register_desktop_driver
+          register_mobile_driver
+
+          # Set default drivers
+          Capybara.default_driver = :cuprite
+          Capybara.javascript_driver = :cuprite
+        end
+      end
+    end
+  end
+end
+
+# Auto-setup when required
+Panda::Core::Testing::CupriteSetup.setup!

data/lib/panda/core/testing/support/system/database_connection_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Share database connection between test thread and server thread
+# This allows the Puma server to see uncommitted transaction data from fixtures
+class ActiveRecord::Base
+  mattr_accessor :shared_connection
+  @@shared_connection = nil
+
+  def self.connection
+    @@shared_connection || retrieve_connection
+  end
+end
+
+# Set up shared connection before system tests
+RSpec.configure do |config|
+  config.before(:each, type: :system) do
+    ActiveRecord::Base.shared_connection = ActiveRecord::Base.connection
+  end
+
+  config.after(:each, type: :system) do
+    ActiveRecord::Base.shared_connection = nil
+  end
+end