panda-cms 0.7.4 → 0.7.5

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/editor_js/blocks/alert.rb

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

data/lib/panda/cms/editor_js/blocks/base.rb

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

data/lib/panda/cms/editor_js/blocks/header.rb

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

data/lib/panda/cms/editor_js/blocks/image.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Panda
   module CMS
     module EditorJs
@@ -27,6 +29,7 @@ module Panda
 
           def caption_element(caption)
             return "" if caption.blank?
+
             "<figcaption>#{caption}</figcaption>"
           end
         end

data/lib/panda/cms/editor_js/blocks/list.rb

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

data/lib/panda/cms/editor_js/blocks/paragraph.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Panda
   module CMS
     module EditorJs
@@ -6,6 +8,7 @@ module Panda
           def render
             content = sanitize(data["text"])
             return "" if content.blank?
+
             html_safe("<p>#{content}</p>")
           end
         end

data/lib/panda/cms/editor_js/blocks/quote.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Panda
   module CMS
     module EditorJs
@@ -32,6 +34,7 @@ module Panda
 
           def caption_element(caption)
             return "" if caption.blank?
+
             "<figcaption>#{sanitize(caption)}</figcaption>"
           end
         end

data/lib/panda/cms/editor_js/blocks/table.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Panda
   module CMS
     module EditorJs
@@ -23,7 +25,7 @@ module Panda
             index = 0
 
             while index < content.length
-              rows << if index == 0 && with_headings
+              rows << if index.zero? && with_headings
                 render_header_row(content[index])
               else
                 render_data_row(content[index])

data/lib/panda/cms/editor_js/renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sanitize"
 
 module Panda
@@ -60,6 +62,7 @@ module Panda
               # Only allow the exact valid content we expect
               valid_content = '<figure class="text-left"><blockquote><p>Valid HTML</p></blockquote><figcaption>Valid caption</figcaption></figure>'
               return html if html.strip == valid_content.strip
+
               return ""
             end
 

data/lib/panda/cms/editor_js.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "editor_js/blocks/base"
 require_relative "editor_js/blocks/alert"
 require_relative "editor_js/blocks/header"

data/lib/panda/cms/editor_js_content.rb

@@ -1,55 +1,61 @@
+# frozen_string_literal: true
+
 require "json"
 
-module Panda::CMS::EditorJsContent
-  extend ActiveSupport::Concern
+module Panda
+  module CMS
+    module EditorJsContent
+      extend ActiveSupport::Concern
 
-  included do
-    include ActiveModel::Validations
-    include ActiveModel::Callbacks
+      included do
+        include ActiveModel::Validations
+        include ActiveModel::Callbacks
 
-    before_save :generate_cached_content
-  end
+        before_save :generate_cached_content
+      end
 
-  def content=(value)
-    if value.is_a?(Hash)
-      super(value.to_json)
-    else
-      super
-    end
-  end
+      def content=(value)
+        if value.is_a?(Hash)
+          super(value.to_json)
+        else
+          super
+        end
+      end
 
-  def content
-    value = super
-    if value.is_a?(String)
-      begin
-        JSON.parse(value)
-      rescue JSON::ParserError
-        value
+      def content
+        value = super
+        if value.is_a?(String)
+          begin
+            JSON.parse(value)
+          rescue JSON::ParserError
+            value
+          end
+        else
+          value
+        end
       end
-    else
-      value
-    end
-  end
 
-  def generate_cached_content
-    if content.is_a?(String)
-      begin
-        parsed_content = JSON.parse(content)
-        self.cached_content = if parsed_content.is_a?(Hash) && parsed_content["blocks"].present?
-          Panda::CMS::EditorJs::Renderer.new(parsed_content).render
+      def generate_cached_content
+        if content.is_a?(String)
+          begin
+            parsed_content = JSON.parse(content)
+            self.cached_content = if parsed_content.is_a?(Hash) && parsed_content["blocks"].present?
+              Panda::CMS::EditorJs::Renderer.new(parsed_content).render
+            else
+              content
+            end
+          rescue JSON::ParserError
+            # If it's not JSON, treat it as plain text
+            self.cached_content = content
+          end
+        elsif content.is_a?(Hash) && content["blocks"].present?
+          # Process EditorJS content
+          self.cached_content = Panda::CMS::EditorJs::Renderer.new(content).render
         else
-          content
+          # For any other case, store as is
+          self.cached_content = content.to_s
         end
-      rescue JSON::ParserError
-        # If it's not JSON, treat it as plain text
-        self.cached_content = content
       end
-    elsif content.is_a?(Hash) && content["blocks"].present?
-      # Process EditorJS content
-      self.cached_content = Panda::CMS::EditorJs::Renderer.new(content).render
-    else
-      # For any other case, store as is
-      self.cached_content = content.to_s
     end
   end
 end