panda-cms 0.7.4 → 0.8.0

data/app/javascript/panda/cms/editor/rich_text_editor.js

@@ -1,162 +0,0 @@
-import EditorJS from "@editorjs/editorjs"
-import Paragraph from "@editorjs/paragraph"
-import Header from "@editorjs/header"
-import List from "@editorjs/list"
-import Quote from "@editorjs/quote"
-import Table from "@editorjs/table"
-import NestedList from "@editorjs/nested-list"
-
-export default class RichTextEditor {
-  constructor(element, iframe) {
-    this.element = element
-    this.iframe = iframe
-    this.editor = null
-    this.initialized = false
-    this.initialize()
-  }
-
-  async initialize() {
-    if (this.initialized) return
-    console.debug("[Panda CMS] Initializing EditorJS")
-
-    try {
-      let content = this.element.dataset.editableContent || ""
-      let previousData = this.element.dataset.editablePreviousData || ""
-      console.debug("[Panda CMS] Initial content:", content)
-      console.debug("[Panda CMS] Previous data:", previousData)
-
-      let parsedContent
-      if (previousData) {
-        try {
-          // Try to decode base64 first
-          const decodedData = atob(previousData)
-          console.debug("[Panda CMS] Decoded base64 data:", decodedData)
-          parsedContent = JSON.parse(decodedData)
-          console.debug("[Panda CMS] Successfully parsed base64 data:", parsedContent)
-        } catch (e) {
-          console.debug("[Panda CMS] Not base64 encoded or invalid, trying direct JSON parse:", e)
-          try {
-            parsedContent = JSON.parse(previousData)
-            console.debug("[Panda CMS] Successfully parsed JSON data:", parsedContent)
-          } catch (e2) {
-            console.error("[Panda CMS] Failed to parse previous data:", e2)
-            parsedContent = this.getDefaultContent()
-          }
-        }
-      } else if (content) {
-        try {
-          parsedContent = JSON.parse(content)
-          console.debug("[Panda CMS] Successfully parsed content:", parsedContent)
-        } catch (e) {
-          console.error("[Panda CMS] Failed to parse content:", e)
-          parsedContent = this.getDefaultContent()
-        }
-      } else {
-        parsedContent = this.getDefaultContent()
-      }
-
-      // Create holder element before initialization
-      const holderId = `editor-${Math.random().toString(36).substr(2, 9)}`
-      const holderElement = document.createElement("div")
-      holderElement.id = holderId
-      holderElement.className = "editor-js-holder codex-editor"
-
-      // Clear any existing content and append holder
-      this.element.textContent = ""
-      this.element.appendChild(holderElement)
-
-      // Initialize EditorJS
-      this.editor = new EditorJS({
-        holder: holderId,
-        data: parsedContent,
-        placeholder: "Click to start writing...",
-        tools: {
-          paragraph: {
-            class: Paragraph,
-            inlineToolbar: true
-          },
-          header: {
-            class: Header,
-            inlineToolbar: true
-          },
-          list: {
-            class: NestedList,
-            inlineToolbar: true,
-            config: {
-              defaultStyle: 'unordered',
-              enableLineBreaks: true
-            }
-          },
-          quote: {
-            class: Quote,
-            inlineToolbar: true
-          },
-          table: {
-            class: Table,
-            inlineToolbar: true
-          }
-        },
-        onChange: () => {
-          this.save()
-        }
-      })
-
-      await this.editor.isReady
-      this.initialized = true
-      console.debug("[Panda CMS] EditorJS initialized successfully")
-    } catch (error) {
-      console.error("[Panda CMS] Error initializing EditorJS:", error)
-    }
-  }
-
-  getDefaultContent() {
-    return {
-      time: Date.now(),
-      blocks: [
-        {
-          type: "paragraph",
-          data: {
-            text: ""
-          }
-        }
-      ],
-      version: "2.28.2"
-    }
-  }
-
-  async save() {
-    if (!this.editor) return null
-
-    try {
-      const savedData = await this.editor.save()
-      const jsonString = JSON.stringify(savedData)
-      // Store both base64 and regular JSON
-      this.element.dataset.editablePreviousData = btoa(jsonString)
-      this.element.dataset.editableContent = jsonString
-      return jsonString
-    } catch (error) {
-      console.error("[Panda CMS] Error saving EditorJS content:", error)
-      return null
-    }
-  }
-
-  async clear() {
-    if (!this.editor) return
-
-    try {
-      await this.editor.clear()
-      this.element.dataset.editablePreviousData = ""
-      this.element.dataset.editableContent = ""
-    } catch (error) {
-      console.error("[Panda CMS] Error clearing EditorJS content:", error)
-    }
-  }
-
-  destroy() {
-    if (this.editor) {
-      this.editor.destroy()
-      this.editor = null
-      this.initialized = false
-    }
-  }
-}

data/app/models/panda/cms/breadcrumb.rb

@@ -1,12 +0,0 @@
-module Panda
-  module CMS
-    class Breadcrumb
-      attr_reader :name, :path
-
-      def initialize(name, path)
-        @name = name
-        @path = path
-      end
-    end
-  end
-end

data/app/models/panda/cms/user.rb

@@ -1,31 +0,0 @@
-module Panda
-  module CMS
-    class User < ApplicationRecord
-      validates :firstname, presence: true
-      validates :lastname, presence: true
-      validates :email, presence: true, uniqueness: true
-
-      before_save :downcase_email
-
-      scope :admin, -> { where(admin: true) }
-
-      def is_admin?
-        admin
-      end
-
-      def name
-        "#{firstname} #{lastname}"
-      end
-
-      def self.for_select_list(scope = :all, order = {firstname: :asc, lastname: :asc})
-        Panda::CMS::User.send(scope).order(order).map { |u| [u.name, u.id] }
-      end
-
-      private
-
-      def downcase_email
-        self.email = email.to_s.downcase
-      end
-    end
-  end
-end

data/app/services/panda/cms/html_to_editor_js_converter.rb

@@ -1,193 +0,0 @@
-module Panda
-  module CMS
-    class HtmlToEditorJsConverter
-      class ConversionError < StandardError; end
-
-      def self.convert(html)
-        return {} if html.blank?
-
-        # If it's already in EditorJS format, return as is
-        return html if html.is_a?(Hash) && (html["blocks"].present? || html[:blocks].present?)
-
-        begin
-          # Parse the HTML content
-          doc = Nokogiri::HTML.fragment(html.to_s)
-          raise ConversionError, "Failed to parse HTML content" unless doc
-
-          blocks = []
-          current_text = ""
-
-          doc.children.each do |node|
-            case node.name
-            when "h1", "h2", "h3", "h4", "h5", "h6"
-              # Add any accumulated text as a paragraph before the header
-              if current_text.present?
-                blocks << create_paragraph_block(current_text)
-                current_text = ""
-              end
-
-              blocks << {
-                "type" => "header",
-                "data" => {
-                  "text" => node.text.strip,
-                  "level" => node.name[1].to_i
-                }
-              }
-            when "p", "div"
-              # Add any accumulated text first
-              if current_text.present?
-                blocks << create_paragraph_block(current_text)
-                current_text = ""
-              end
-
-              if node.name == "div"
-                # Process div children separately
-                node.children.each do |child|
-                  case child.name
-                  when "h1", "h2", "h3", "h4", "h5", "h6"
-                    blocks << {
-                      "type" => "header",
-                      "data" => {
-                        "text" => child.text.strip,
-                        "level" => child.name[1].to_i
-                      }
-                    }
-                  when "p"
-                    text = process_inline_elements(child)
-                    paragraphs = text.split(/<br\s*\/?>\s*<br\s*\/?>/).map(&:strip)
-                    paragraphs.each do |paragraph|
-                      blocks << create_paragraph_block(paragraph) if paragraph.present?
-                    end
-                  when "ul", "ol"
-                    items = child.css("li").map { |li| process_inline_elements(li) }
-                    next if items.empty?
-
-                    blocks << {
-                      "type" => "list",
-                      "data" => {
-                        "style" => (child.name == "ul") ? "unordered" : "ordered",
-                        "items" => items
-                      }
-                    }
-                  when "blockquote"
-                    blocks << {
-                      "type" => "quote",
-                      "data" => {
-                        "text" => process_inline_elements(child),
-                        "caption" => "",
-                        "alignment" => "left"
-                      }
-                    }
-                  when "text"
-                    text = child.text.strip
-                    current_text += text if text.present?
-                  end
-                end
-              else
-                # Handle p with nested content
-                text = process_inline_elements(node)
-                paragraphs = text.split(/<br\s*\/?>\s*<br\s*\/?>/).map(&:strip)
-                paragraphs.each do |paragraph|
-                  blocks << create_paragraph_block(paragraph) if paragraph.present?
-                end
-              end
-            when "br"
-              current_text += "\n\n"
-            when "text"
-              text = node.text.strip
-              current_text += text if text.present?
-            when "ul", "ol"
-              # Add any accumulated text first
-              if current_text.present?
-                blocks << create_paragraph_block(current_text)
-                current_text = ""
-              end
-
-              items = node.css("li").map { |li| process_inline_elements(li) }
-              next if items.empty?
-
-              blocks << {
-                "type" => "list",
-                "data" => {
-                  "style" => (node.name == "ul") ? "unordered" : "ordered",
-                  "items" => items
-                }
-              }
-            when "blockquote"
-              # Add any accumulated text first
-              if current_text.present?
-                blocks << create_paragraph_block(current_text)
-                current_text = ""
-              end
-
-              blocks << {
-                "type" => "quote",
-                "data" => {
-                  "text" => process_inline_elements(node),
-                  "caption" => "",
-                  "alignment" => "left"
-                }
-              }
-            end
-          end
-
-          # Add any remaining text
-          blocks << create_paragraph_block(current_text) if current_text.present?
-
-          # Return the complete EditorJS structure
-          {
-            "time" => Time.current.to_i * 1000,
-            "blocks" => blocks,
-            "version" => "2.28.2"
-          }
-        rescue => e
-          Rails.logger.error "HTML to EditorJS conversion failed: #{e.message}"
-          Rails.logger.error e.backtrace.join("\n")
-          raise ConversionError, "Failed to convert HTML to EditorJS format: #{e.message}"
-        end
-      end
-
-      def self.create_paragraph_block(text)
-        {
-          "type" => "paragraph",
-          "data" => {
-            "text" => text.strip
-          }
-        }
-      end
-
-      def self.process_inline_elements(node)
-        result = ""
-        node.children.each do |child|
-          case child.name
-          when "br"
-            result += "<br>"
-          when "text"
-            result += child.text
-          when "strong", "b"
-            result += "<b>#{child.text}</b>"
-          when "em", "i"
-            result += "<i>#{child.text}</i>"
-          when "a"
-            href = child["href"]
-            text = child.text.strip
-            # Handle email links specially
-            if href&.start_with?("mailto:")
-              email = href.sub("mailto:", "")
-              result += "<a href=\"mailto:#{email}\">#{text}</a>"
-            else
-              result += "<a href=\"#{href}\">#{text}</a>"
-            end
-          else
-            result += if child.text?
-              child.text
-            else
-              child.to_html
-            end
-          end
-        end
-        result.strip
-      end
-    end
-  end
-end

data/app/views/panda/cms/admin/my_profile/edit.html.erb

@@ -1,35 +0,0 @@
-<%= render Panda::CMS::Admin::ContainerComponent.new do |component| %>
-  <% component.with_heading(text: "My Profile", level: 1) %>
-
-  <%= panda_cms_form_with model: user,
-                         url: admin_my_profile_path,
-                         method: :patch,
-                         data: { controller: "theme-form" } do |f| %>
-    <% if user.errors.any? %>
-      <div class="mb-4 p-4 bg-red-50 border border-red-200 rounded-md">
-        <div class="text-sm text-red-600">
-          <% user.errors.full_messages.each do |message| %>
-            <p><%= message %></p>
-          <% end %>
-        </div>
-      </div>
-    <% end %>
-
-    <div class="space-y-4">
-      <%= f.text_field :firstname %>
-
-      <%= f.text_field :lastname %>
-
-      <%= f.email_field :email %>
-
-      <%= f.select :current_theme,
-                   [["Default", "default"], ["Sky", "sky"]],
-                   { label: "Theme" },
-                   data: { action: "change->theme-form#updateTheme" } %>
-    </div>
-
-    <%= f.submit "Update Profile",
-        class: "btn btn-primary mt-6",
-        data: { disable_with: "Saving..." } %>
-  <% end %>
-<% end %>

data/app/views/panda/cms/admin/sessions/new.html.erb

@@ -1,17 +0,0 @@
-<div class="flex flex-col justify-center py-12 px-6 min-h-full text-center lg:px-8">
-  <div class="text-center sm:mx-auto sm:w-full sm:max-w-sm">
-    <img src="/panda-cms-assets/panda-nav.png" class="py-2 mx-auto w-auto h-32">
-    <h2 class="mt-10 mb-6 text-2xl font-bold text-center text-white"><%= t("panda.cms.admin.sessions.new.title") %></h2>
-  </div>
-  <% @providers.each do |provider| %>
-    <div class="mt-4 text-center sm:mx-auto sm:w-full sm:max-w-sm">
-      <%= form_tag "#{Panda::CMS.root_path}/auth/#{provider}", method: "post", data: {turbo: false} do %>
-        <input type="hidden" name="redirect_uri" value="<%= admin_login_callback_url(provider: provider) %>">
-        <button type="submit" id="button-sign-in-<%= provider %>" class="inline-flex gap-x-2 items-center py-2.5 px-3.5 mx-auto mb-4 bg-white rounded-md border min-w-56 border-neutral-400">
-          <i class="fa-brands fa-<%= provider %> text-xl mr-1"></i>
-          <%= t("panda.cms.authentication.sign_in_with", provider: t("panda.cms.authentication.providers.#{provider}")) %>
-        </button>
-      <% end %>
-    </div>
-  <% end %>
-</div>

data/db/migrate/20250504221812_add_current_theme_to_panda_cms_users.rb

@@ -1,5 +0,0 @@
-class AddCurrentThemeToPandaCMSUsers < ActiveRecord::Migration[8.0]
-  def change
-    add_column :panda_cms_users, :current_theme, :string, default: "default"
-  end
-end

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

@@ -1,34 +0,0 @@
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class Alert < Base
-          def render
-            message = sanitize(data["message"])
-            type = data["type"] || "primary"
-
-            html_safe(
-              "<div class=\"#{alert_classes(type)} p-4 mb-4 rounded-lg\">" \
-                "#{message}" \
-              "</div>"
-            )
-          end
-
-          private
-
-          def alert_classes(type)
-            case type
-            when "primary" then "bg-blue-100 text-blue-800"
-            when "secondary" then "bg-gray-100 text-gray-800"
-            when "success" then "bg-green-100 text-green-800"
-            when "danger" then "bg-red-100 text-red-800"
-            when "warning" then "bg-yellow-100 text-yellow-800"
-            when "info" then "bg-indigo-100 text-indigo-800"
-            else "bg-blue-100 text-blue-800"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class Base
-          include ActionView::Helpers::SanitizeHelper
-          include ActionView::Helpers::TagHelper
-
-          attr_reader :data, :options
-
-          def initialize(data, options = {})
-            @data = data
-            @options = options
-          end
-
-          def render
-            ""
-          end
-
-          protected
-
-          def html_safe(content)
-            content.html_safe
-          end
-
-          def sanitize(text)
-            Rails::Html::SafeListSanitizer.new.sanitize(text, tags: %w[b i u a code])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class Header < Base
-          def render
-            content = sanitize(data["text"])
-            level = data["level"] || 2
-            html_safe("<h#{level}>#{content}</h#{level}>")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class Image < Base
-          def render
-            url = data["url"]
-            caption = sanitize(data["caption"])
-            with_border = data["withBorder"]
-            with_background = data["withBackground"]
-            stretched = data["stretched"]
-
-            css_classes = ["prose"]
-            css_classes << "border" if with_border
-            css_classes << "bg-gray-100" if with_background
-            css_classes << "w-full" if stretched
-
-            html_safe(<<~HTML)
-              <figure class="#{css_classes.join(" ")}">
-                <img src="#{url}" alt="#{caption}" />
-                #{caption_element(caption)}
-              </figure>
-            HTML
-          end
-
-          private
-
-          def caption_element(caption)
-            return "" if caption.blank?
-            "<figcaption>#{caption}</figcaption>"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class List < Base
-          def render
-            list_type = (data["style"] == "ordered") ? "ol" : "ul"
-            html_safe(
-              "<#{list_type}>" \
-              "#{render_items(data["items"])}" \
-              "</#{list_type}>"
-            )
-          end
-
-          private
-
-          def render_items(items)
-            items.map do |item|
-              content = item.is_a?(Hash) ? item["content"] : item
-              nested = (item.is_a?(Hash) && item["items"].present?) ? render_nested(item["items"]) : ""
-              "<li>#{sanitize(content)}#{nested}</li>"
-            end.join
-          end
-
-          def render_nested(items)
-            self.class.new({"items" => items, "style" => data["style"]}).render
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class Paragraph < Base
-          def render
-            content = sanitize(data["text"])
-            return "" if content.blank?
-            html_safe("<p>#{content}</p>")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class Quote < Base
-          def render
-            text = data["text"]
-            caption = data["caption"]
-            alignment = data["alignment"] || "left"
-
-            # Build the HTML structure
-            html = "<figure class=\"text-#{alignment}\">" \
-              "<blockquote>#{wrap_text_in_p(text)}</blockquote>" \
-              "#{caption_element(caption)}" \
-              "</figure>"
-
-            # Return raw HTML - validation will be handled by the main renderer if enabled
-            html_safe(html)
-          end
-
-          private
-
-          def wrap_text_in_p(text)
-            # Only wrap in <p> if it's not already wrapped
-            text = sanitize(text)
-            if text.start_with?("<p>") && text.end_with?("</p>")
-              text
-            else
-              "<p>#{text}</p>"
-            end
-          end
-
-          def caption_element(caption)
-            return "" if caption.blank?
-            "<figcaption>#{sanitize(caption)}</figcaption>"
-          end
-        end
-      end
-    end
-  end
-end