panda-cms 0.7.4 → 0.8.0

data/lib/panda/cms/asset_loader.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+module Panda
+  module CMS
+    # AssetLoader handles loading compiled assets from GitHub releases
+    # Falls back to local development assets when GitHub assets unavailable
+    class AssetLoader
+      class << self
+        # Generate HTML tags for loading Panda CMS assets
+        def asset_tags(options = {})
+          if use_github_assets?
+            github_asset_tags(options)
+          else
+            development_asset_tags(options)
+          end
+        end
+
+        # Get the JavaScript asset URL
+        def javascript_url
+          if use_github_assets?
+            github_javascript_url
+          else
+            development_javascript_url
+          end
+        end
+
+        # Get the CSS asset URL (if exists)
+        def css_url
+          if use_github_assets?
+            github_css_url
+          else
+            development_css_url
+          end
+        end
+
+        # Check if GitHub-hosted assets should be used
+        def use_github_assets?
+          # Use GitHub assets in production or when explicitly enabled
+          Rails.env.production? ||
+            ENV["PANDA_CMS_USE_GITHUB_ASSETS"] == "true" ||
+            !development_assets_available? ||
+            ((Rails.env.test? || in_test_environment?) && compiled_assets_available?)
+        end
+
+        # Download assets from GitHub to local cache
+        def ensure_assets_available!
+          return if development_assets_available? && !use_github_assets?
+
+          cache_dir = local_cache_directory
+          version = `git rev-parse --short HEAD`.strip
+
+          # Check if we already have cached assets for this version
+          if cached_assets_exist?(version)
+            Rails.logger.info "[Panda CMS] Using cached assets #{version}"
+            return
+          end
+
+          Rails.logger.info "[Panda CMS] Downloading assets #{version} from GitHub..."
+          download_github_assets(version, cache_dir)
+        end
+
+        private
+
+        def github_asset_tags(options = {})
+          version = asset_version
+          base_url = github_base_url(version)
+
+          tags = []
+
+          # JavaScript tag with integrity check
+          js_url = "#{base_url}panda-cms-#{version}.js"
+          integrity = asset_integrity(version, "panda-cms-#{version}.js")
+
+          js_attrs = {
+            src: js_url
+          }
+          # In CI environment, don't use defer to ensure immediate execution
+          js_attrs[:defer] = true unless ENV["GITHUB_ACTIONS"] == "true"
+          # Standalone bundles should NOT use type="module" - they're regular scripts
+          # Only use type="module" for importmap/ES module assets
+          if !js_url.include?("panda-cms-assets")
+            js_attrs[:type] = "module"
+          end
+          js_attrs[:integrity] = integrity if integrity
+          js_attrs[:crossorigin] = "anonymous" if integrity
+
+          tags << content_tag(:script, "", js_attrs)
+
+          # CSS tag if CSS bundle exists
+          css_url = "#{base_url}panda-cms-#{version}.css"
+          if github_asset_exists?(version, "panda-cms-#{version}.css")
+            css_integrity = asset_integrity(version, "panda-cms-#{version}.css")
+
+            css_attrs = {
+              rel: "stylesheet",
+              href: css_url
+            }
+            css_attrs[:integrity] = css_integrity if css_integrity
+            css_attrs[:crossorigin] = "anonymous" if css_integrity
+
+            tags << tag(:link, css_attrs)
+          end
+
+          tags.join("\n").html_safe
+        end
+
+        def development_asset_tags(options = {})
+          # In test environment with CI, always use compiled assets
+          if (Rails.env.test? || ENV["CI"].present?) && compiled_assets_available?
+            # Use the same logic as GitHub assets but with local paths
+            version = asset_version
+            js_url = "/panda-cms-assets/panda-cms-#{version}.js"
+            css_url = "/panda-cms-assets/panda-cms-#{version}.css"
+
+            tags = []
+
+            # JavaScript tag
+            tags << content_tag(:script, "", {
+              src: js_url,
+              defer: true
+            })
+
+            # CSS tag if exists
+            if cached_asset_exists?(css_url)
+              tags << tag(:link, {
+                rel: "stylesheet",
+                href: css_url
+              })
+            end
+
+            tags.join("\n").html_safe
+          else
+            # In development, just use a simple script tag
+            # The view will handle importmap tags separately
+            content_tag(:script, "", {
+              src: development_javascript_url,
+              type: "module",
+              defer: true
+            })
+          end
+        end
+
+        def github_javascript_url
+          version = asset_version
+          # In test environment with local compiled assets, use local URL
+          if Rails.env.test? && compiled_assets_available?
+            "/panda-cms-assets/panda-cms-#{version}.js"
+          else
+            "#{github_base_url(version)}panda-cms-#{version}.js"
+          end
+        end
+
+        def github_css_url
+          version = asset_version
+          # In test environment with local compiled assets, use local URL
+          if Rails.env.test? && compiled_assets_available?
+            "/panda-cms-assets/panda-cms-#{version}.css"
+          else
+            "#{github_base_url(version)}panda-cms-#{version}.css"
+          end
+        end
+
+        def development_javascript_url
+          # Try cached assets first, then importmap
+          version = asset_version
+          # Try root level first (standalone bundle), then versioned directory
+          root_path = "/panda-cms-assets/panda-cms-#{version}.js"
+          versioned_path = "/panda-cms-assets/#{version}/panda-cms-#{version}.js"
+
+          if cached_asset_exists?(root_path)
+            root_path
+          elsif cached_asset_exists?(versioned_path)
+            versioned_path
+          else
+            # Fallback to importmap or engine asset
+            "/assets/panda/cms/controllers/index.js"
+          end
+        end
+
+        def development_css_url
+          version = asset_version
+          # Try versioned directory first, then root level
+          versioned_path = "/panda-cms-assets/#{version}/panda-cms-#{version}.css"
+          root_path = "/panda-cms-assets/panda-cms-#{version}.css"
+
+          if cached_asset_exists?(versioned_path)
+            versioned_path
+          elsif cached_asset_exists?(root_path)
+            root_path
+          else
+            nil # No CSS in development mode typically
+          end
+        end
+
+        def github_base_url(version)
+          # In test environment with compiled assets, use local URLs
+          if (Rails.env.test? || in_test_environment?) && compiled_assets_available?
+            "/panda-cms-assets/"
+          else
+            "https://github.com/tastybamboo/panda-cms/releases/download/#{version}/"
+          end
+        end
+
+        def asset_version
+          # In test environment, use VERSION constant for consistency with compiled assets
+          # In other environments, use git SHA for dynamic versioning
+          # Also check for test environment indicators since Rails.env might be development in specs
+          if Rails.env.test? || ENV["CI"].present? || in_test_environment?
+            Panda::CMS::VERSION
+          else
+            `git rev-parse --short HEAD`.strip
+          end
+        end
+
+        def in_test_environment?
+          # Check if we're running specs even if Rails.env is development
+          defined?(RSpec) && RSpec.respond_to?(:configuration)
+        end
+
+        def compiled_assets_available?
+          # Check if compiled assets exist in test location
+          version = asset_version
+          js_file = Rails.public_path.join("panda-cms-assets", "panda-cms-#{version}.js")
+          css_file = Rails.public_path.join("panda-cms-assets", "panda-cms-#{version}.css")
+          js_file.exist? && css_file.exist?
+        end
+
+        def development_assets_available?
+          # Check if local development assets exist (importmap, etc.)
+          importmap_available? || engine_assets_available?
+        end
+
+        def importmap_available?
+          return false unless defined?(Rails.application.importmap)
+
+          begin
+            # Rails 8+ uses a different API for accessing importmap entries
+            if Rails.application.importmap.respond_to?(:to_json)
+              importmap_json = JSON.parse(Rails.application.importmap.to_json)
+              importmap_json.any? { |name, _| name.include?("panda") }
+            elsif Rails.application.importmap.respond_to?(:entries)
+              Rails.application.importmap.entries.any? { |entry| entry.name.include?("panda") }
+            else
+              false
+            end
+          rescue => e
+            Rails.logger.debug "[Panda CMS] Could not check importmap: #{e.message}"
+            false
+          end
+        end
+
+        def engine_assets_available?
+          # Check if engine's JavaScript files are available
+          engine_js_path = Rails.root.join("..", "..", "app", "javascript", "panda", "cms", "controllers", "index.js")
+          File.exist?(engine_js_path)
+        end
+
+        def cached_assets_exist?(version)
+          cache_dir = local_cache_directory.join(version)
+          cache_dir.exist? && cache_dir.join("panda-cms-#{version}.js").exist?
+        end
+
+        def cached_asset_exists?(path)
+          Rails.public_path.join(path.delete_prefix("/")).exist?
+        end
+
+        def local_cache_directory
+          Rails.public_path.join("panda-cms-assets")
+        end
+
+        def download_github_assets(version, cache_dir)
+          require "net/http"
+          require "uri"
+          require "json"
+
+          version_dir = cache_dir.join(version)
+          FileUtils.mkdir_p(version_dir)
+
+          # Download manifest first
+          manifest_url = "#{github_base_url(version)}manifest.json"
+
+          begin
+            manifest_response = fetch_url(manifest_url)
+            if manifest_response.success?
+              manifest = JSON.parse(manifest_response.body)
+
+              # Download each file
+              manifest["files"].each do |file_info|
+                filename = file_info["filename"]
+                file_url = "#{github_base_url(version)}#{filename}"
+
+                Rails.logger.debug "[Panda CMS] Downloading #{filename}..."
+
+                file_response = fetch_url(file_url)
+                if file_response.success?
+                  File.write(version_dir.join(filename), file_response.body)
+                  Rails.logger.debug "[Panda CMS] Downloaded #{filename}"
+                else
+                  Rails.logger.warn "[Panda CMS] Failed to download #{filename}: #{file_response.code}"
+                end
+              end
+
+              # Save manifest
+              File.write(version_dir.join("manifest.json"), manifest_response.body)
+              Rails.logger.info "[Panda CMS] Assets cached locally"
+            else
+              Rails.logger.warn "[Panda CMS] Failed to download manifest: #{manifest_response.code}"
+            end
+          rescue => e
+            Rails.logger.error "[Panda CMS] Error downloading assets: #{e.message}"
+            # Fall back to development mode
+          end
+        end
+
+        def fetch_url(url)
+          uri = URI(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+          http.open_timeout = 10
+          http.read_timeout = 30
+
+          request = Net::HTTP::Get.new(uri)
+          request["User-Agent"] = "Panda-CMS/#{`git rev-parse --short HEAD`}"
+
+          response = http.request(request)
+
+          OpenStruct.new(
+            success?: response.code.to_i == 200,
+            code: response.code,
+            body: response.body
+          )
+        rescue => e
+          Rails.logger.error "[Panda CMS] Network error: #{e.message}"
+          OpenStruct.new(success?: false, code: "error", body: nil)
+        end
+
+        def asset_integrity(version, filename)
+          # Try to get integrity from cached manifest
+          manifest_path = local_cache_directory.join(version, "manifest.json")
+          return nil unless manifest_path.exist?
+
+          begin
+            manifest = JSON.parse(File.read(manifest_path))
+            file_info = manifest["files"].find { |f| f["filename"] == filename }
+            return nil unless file_info
+
+            "sha256-#{Base64.strict_encode64([file_info["sha256"]].pack("H*"))}"
+          rescue => e
+            Rails.logger.warn "[Panda CMS] Error reading asset integrity: #{e.message}"
+            nil
+          end
+        end
+
+        def github_asset_exists?(version, filename)
+          # Quick check - assume it exists for now
+          # Could be enhanced to do HEAD request
+          true
+        end
+
+        def content_tag(name, content, options = {})
+          if defined?(ActionView::Helpers::TagHelper)
+            # Create a view context to render the tag
+            view_context = ActionView::Base.new(ActionView::LookupContext.new([]), {}, nil)
+            view_context.content_tag(name, content, options)
+          else
+            # Fallback implementation
+            attrs = options.map { |k, v| %(#{k}="#{v}") }.join(" ")
+            if content.present?
+              "<#{name} #{attrs}>#{content}</#{name}>"
+            else
+              "<#{name} #{attrs}></#{name}>"
+            end
+          end
+        end
+
+        def tag(name, options = {})
+          if defined?(ActionView::Helpers::TagHelper)
+            # Create a view context to render the tag
+            view_context = ActionView::Base.new(ActionView::LookupContext.new([]), {}, nil)
+            view_context.tag(name, options)
+          else
+            # Fallback implementation
+            attrs = options.map { |k, v| %(#{k}="#{v}") }.join(" ")
+            "<#{name} #{attrs}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/panda/cms/bulk_editor.rb

@@ -1,4 +1,5 @@
-require "htmlentities"
+# frozen_string_literal: true
+
 require "json"
 
 module Panda
@@ -77,11 +78,12 @@ module Panda
 
             if current_data.dig("pages", path, "contents", key).nil?
               raise "Unknown page 1" if page.nil?
+
               block = Panda::CMS::Block.find_or_create_by(key: key, template: page.template) do |block_meta|
                 block_meta.name = key.titleize
               end
 
-              if !block
+              unless block
                 debug[:error] << "Error creating block '#{key.titleize}' on page '#{page.title}'"
                 next
               end
@@ -104,6 +106,7 @@ module Panda
             elsif content != current_data["pages"][path]["contents"][key]["content"]
               # Content has changed
               raise "Unknown page 2" if page.nil?
+
               block = Panda::CMS::Block.find_by(key: key, template: page.template)
               if Panda::CMS::BlockContent.find_by(page: page, block: block)&.update(content: content)
                 debug[:success] << "Updated '#{key.titleize}' content on page '#{page.title}'"
@@ -143,7 +146,8 @@ module Panda
         end
 
         # TODO: Eventually set the position of the block in the template, and then order from there rather than the name?
-        Panda::CMS::BlockContent.includes(:block, page: [:template]).order("panda_cms_pages.lft ASC, panda_cms_blocks.key ASC").each do |block_content|
+        Panda::CMS::BlockContent.includes(:block,
+          page: [:template]).order("panda_cms_pages.lft ASC, panda_cms_blocks.key ASC").each do |block_content|
           item = data["pages"][block_content.page.path] ||= {}
           item["title"] = block_content.page.title
           item["template"] = block_content.page.template.name

data/lib/panda/cms/demo_site_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Panda
   module CMS
     class DemoSiteGenerator

data/lib/panda/cms/engine.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "rubygems"
 require "panda/core"
 require "panda/core/engine"
+require "panda/editor"
+require "panda/editor/engine"
 require "panda/cms/railtie"
 
 require "invisible_captcha"
@@ -16,10 +20,8 @@ module Panda
       ]
 
       # Basic session setup only
-      initializer "panda_cms.session", before: :load_config_initializers do |app|
-        if app.config.middleware.frozen?
-          app.config.middleware = app.config.middleware.dup
-        end
+      initializer "panda.cms.session", before: :load_config_initializers do |app|
+        app.config.middleware = app.config.middleware.dup if app.config.middleware.frozen?
 
         app.config.session_store :cookie_store, key: "_panda_cms_session"
         app.config.middleware.use ActionDispatch::Cookies
@@ -28,15 +30,16 @@ module Panda
 
       config.to_prepare do
         ApplicationController.helper(::ApplicationHelper)
+        ApplicationController.helper(Panda::CMS::AssetHelper)
       end
 
       # Set our generators
       config.generators do |g|
         g.orm :active_record, primary_key_type: :uuid
         g.test_framework :rspec, fixture: true
-        g.fixture_replacement :factory_bot, dir: "spec/factories"
+        g.fixture_replacement nil
         g.view_specs false
-        g.templates.unshift File.expand_path("../../templates", __FILE__)
+        g.templates.unshift File.expand_path("../templates", __dir__)
       end
 
       # Make files in public available to the main app (e.g. /panda_cms-assets/favicon.ico)
@@ -49,7 +52,7 @@ module Panda
       # Custom error handling
       # config.exceptions_app = Panda::CMS::ExceptionsApp.new(exceptions_app: routes)
 
-      initializer "panda_cms.assets" do |app|
+      initializer "panda.cms.assets" do |app|
         if Rails.configuration.respond_to?(:assets)
           # Add JavaScript paths
           app.config.assets.paths << root.join("app/javascript")
@@ -67,12 +70,10 @@ module Panda
       end
 
       # Add importmap paths from the engine
-      initializer "panda_cms.importmap", before: "importmap" do |app|
+      initializer "panda.cms.importmap", before: "importmap" do |app|
         if app.config.respond_to?(:importmap)
           # Create a new array if frozen
-          if app.config.importmap.paths.frozen?
-            app.config.importmap.paths = app.config.importmap.paths.dup
-          end
+          app.config.importmap.paths = app.config.importmap.paths.dup if app.config.importmap.paths.frozen?
 
           # Add our paths
           app.config.importmap.paths << root.join("config/importmap.rb")
@@ -96,13 +97,13 @@ module Panda
         end
       end
 
-      initializer "#{engine_name}.backtrace_cleaner" do |app|
+      initializer "#{engine_name}.backtrace_cleaner" do |_app|
         engine_root_regex = Regexp.escape(root.to_s + File::SEPARATOR)
 
         # Clean those ERB lines, we don't need the internal autogenerated
         # ERB method, what we do need (line number in ERB file) is already there
         Rails.backtrace_cleaner.add_filter do |line|
-          line.sub(/(\.erb:\d+):in `__.*$/, "\\1")
+          line.sub(/(\.erb:\d+):in `__.*$/, '\\1')
         end
 
         # Remove our own engine's path prefix, even if it's
@@ -124,118 +125,58 @@ module Panda
         end
       end
 
-      # Set up ViewComponent and Lookbook
-      # config.view_component.component_parent_class = "Panda::CMS::BaseComponent"
-      # config.view_component.view_component_path = Panda::CMS::Engine.root.join("lib/components").to_s
-      # config.eager_load_paths << Panda::CMS::Engine.root.join("lib/components").to_s
-      # config.view_component.generate.sidecar = true
-      # config.view_component.generate.preview = truexw
-      # config.view_component.preview_paths ||= []
-      # config.view_component.preview_paths << Panda::CMS::Engine.root.join("lib/component_previews").to_s
-      # config.view_component.generate.preview_path = "lib/component_previews"
-
-      # Set up authentication
-      initializer "panda_cms.omniauth", before: "omniauth" do |app|
-        app.config.session_store :cookie_store, key: "_panda_cms_session"
-        app.config.middleware.use ActionDispatch::Cookies
-        app.config.middleware.use ActionDispatch::Session::CookieStore, app.config.session_options
+      # Set up ViewComponent
+      initializer "panda.cms.view_component" do |app|
+        app.config.view_component.preview_paths ||= []
+        app.config.view_component.preview_paths << root.join("spec/components/previews")
+        app.config.view_component.generate.sidecar = true
+        app.config.view_component.generate.preview = true
+      end
 
-        OmniAuth.config.logger = Rails.logger
-
-        # TODO: Move this to somewhere more sensible?
-        # Define the mapping of our provider "names" to the OmniAuth strategies and configuration
-        auth_path = "#{Panda::CMS.route_namespace}/auth"
-        callback_path = "/callback"
-        available_providers = {
-          microsoft: {
-            strategy: :microsoft_graph,
-            defaults: {
-              name: "microsoft",
-              # Setup at the following URL:
-              # https://portal.azure.com/#view/Microsoft_AAD_RegisteredApps/ApplicationsListBlade
-              client_id: Rails.application.credentials.dig(:microsoft, :client_id),
-              client_secret: Rails.application.credentials.dig(:microsoft, :client_secret),
-              # Don't change this or the sky will fall on your head
-              # https://github.com/synth/omniauth-microsoft_graph/tree/main?tab=readme-ov-file#domain-verification
-              skip_domain_verification: false,
-              # If your application is single-tenanted, replace "common" with your tenant (directory) ID
-              # from https://portal.azure.com/#settings/directory, otherwise you'll likely want to leave
-              # these settings unchanged
-              client_options: {
-                site: "https://login.microsoftonline.com/",
-                token_url: "common/oauth2/v2.0/token",
-                authorize_url: "common/oauth2/v2.0/authorize"
-              },
-              # If you assign specific users or groups, you will likely want to set this to
-              # true to enable auto-provisioning
-              create_account_on_first_login: false,
-              create_admin_account_on_first_login: false,
-              # Don't hide this provider from the login page
-              hidden: false
-            }
-          },
-          google: {
-            strategy: :google_oauth2,
-            defaults: {
-              name: "google",
-              # Setup at the following URL: https://console.developers.google.com/
-              client_id: Rails.application.credentials.dig(:google, :client_id),
-              client_secret: Rails.application.credentials.dig(:google, :client_secret),
-              # If you assign specific users or groups, you will likely want to set this to
-              # true to enable auto-provisioning
-              create_account_on_first_login: false,
-              create_admin_account_on_first_login: false,
-              # Options we need
-              scope: "email, profile",
-              image_aspect_ratio: "square",
-              image_size: 150,
-              # Worth setting select_account as default, as many people have multiple Google accounts now:
-              prompt: "select_account",
-              # You should probably also set the 'hd' option, huh?,
-              # Don't hide this provider from the login page
-              hidden: false
-            }
-          },
-          github: {
-            strategy: :github,
-            defaults: {
-              name: "github",
-              # Setup at the following URL: https://github.com/settings/applications/new
-              # with a callback of
-              # In the meantime, as long as you're set to /admin as your login path, and on
-              # http://localhost:3000, you can use these for a first login :)
-              client_id: Rails.application.credentials.dig(:github, :client_id),
-              client_secret: Rails.application.credentials.dig(:github, :client_secret),
-              scope: "user:email,read:user",
-              create_account_on_first_login: false,
-              create_admin_account_on_first_login: false,
-              # Don't hide this provider from the login page
-              hidden: false
-            }
-          }
-        }
+      # Authentication is now handled by Panda::Core::Engine
 
-        available_providers.each do |provider, options|
-          if Panda::CMS.config.authentication.dig(provider, :enabled)
-            auth_path = auth_path.starts_with?("/") ? auth_path : "/#{auth_path}"
-            options[:defaults][:path_prefix] = auth_path
+      # Configure Core for CMS
+      initializer "panda.cms.configure_core" do |app|
+        Panda::Core.configure do |config|
+          # Customize login page
+          config.login_logo_path = "/panda-cms-assets/panda-nav.png"
+          config.login_page_title = "Panda CMS Admin"
 
-            options[:defaults][:redirect_uri] = if Rails.env.test?
-              "#{Capybara.app_host}#{auth_path}/#{provider}#{callback_path}"
-            else
-              "#{Panda::CMS.config.url}#{auth_path}/#{provider}#{callback_path}"
-            end
+          # Set dashboard redirect path to CMS dashboard (using Core's admin_path)
+          config.dashboard_redirect_path = "#{Panda::Core.configuration.admin_path}/cms"
 
-            provider_config = options[:defaults].merge(Panda::CMS.config.authentication[provider])
+          # Customize initial breadcrumb
+          config.initial_admin_breadcrumb = ->(controller) {
+            # Use CMS dashboard path - just use the string path
+            ["Admin", "#{Panda::Core.configuration.admin_path}/cms"]
+          }
 
-            app.config.middleware.use OmniAuth::Builder do
-              provider options[:strategy], provider_config
+          # Dashboard widgets
+          config.admin_dashboard_widgets = ->(user) {
+            widgets = []
+
+            # Add CMS statistics widgets if CMS is available
+            if defined?(Panda::CMS)
+              widgets << Panda::CMS::Admin::StatisticsComponent.new(
+                metric: "Views Today",
+                value: Panda::CMS::Visit.group_by_day(:visited_at, last: 1).count.values.first || 0
+              )
+              widgets << Panda::CMS::Admin::StatisticsComponent.new(
+                metric: "Views Last Week",
+                value: Panda::CMS::Visit.group_by_week(:visited_at, last: 1).count.values.first || 0
+              )
+              widgets << Panda::CMS::Admin::StatisticsComponent.new(
+                metric: "Views Last Month",
+                value: Panda::CMS::Visit.group_by_month(:visited_at, last: 1).count.values.first || 0
+              )
             end
-          end
+
+            widgets
+          }
         end
       end
 
-      config.before_initialize do |app|
+      config.before_initialize do |_app|
         # Default configuration
         Panda::CMS.configure do |config|
           # Array of additional EditorJS tools to load

data/lib/panda/cms/exceptions_app.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # https://guides.rubyonrails.org/configuring.html#config-exceptions-app
 module Panda
   module CMS