panda-cms 0.7.5 → 0.8.0

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-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

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Panda
-  module CMS
-    module EditorJs
-      module Blocks
-        class Table < Base
-          def render
-            content = data["content"]
-            with_headings = data["withHeadings"]
-
-            html_safe(<<~HTML)
-              <div class="overflow-x-auto">
-                <table class="min-w-full">
-                  #{render_rows(content, with_headings)}
-                </table>
-              </div>
-            HTML
-          end
-
-          private
-
-          def render_rows(content, with_headings)
-            rows = []
-            index = 0
-
-            while index < content.length
-              rows << if index.zero? && with_headings
-                render_header_row(content[index])
-              else
-                render_data_row(content[index])
-              end
-              index += 1
-            end
-
-            rows.join("\n")
-          end
-
-          def render_header_row(row)
-            cells = row.map { |cell| "<th>#{sanitize(cell)}</th>" }
-            "<tr>#{cells.join}</tr>"
-          end
-
-          def render_data_row(row)
-            cells = row.map { |cell| "<td>#{sanitize(cell)}</td>" }
-            "<tr>#{cells.join}</tr>"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require "sanitize"
-
-module Panda
-  module CMS
-    module EditorJs
-      class Renderer
-        attr_reader :content, :options, :custom_renderers, :cache_store
-
-        def initialize(content, options = {})
-          @content = content
-          @options = options
-          @custom_renderers = options.delete(:custom_renderers) || {}
-          @cache_store = options.delete(:cache_store) || Rails.cache
-          @validate_html = options.delete(:validate_html) || false
-        end
-
-        def render
-          return "" if content.nil? || content == {}
-          return content.to_s unless content.is_a?(Hash) && content["blocks"].is_a?(Array)
-
-          rendered = content["blocks"].map do |block|
-            render_block(block)
-          end.join("\n")
-
-          rendered = @validate_html ? validate_html(rendered) : rendered
-          rendered.presence || ""
-        end
-
-        def section(blocks)
-          return "" if blocks.nil? || blocks.empty?
-
-          content = {"blocks" => blocks}
-          rendered = self.class.new(content, options).render
-
-          "<section class=\"content-section\">#{rendered}</section>"
-        end
-
-        def article(blocks, title: nil)
-          return "" if blocks.nil? || blocks.empty?
-
-          content = {"blocks" => blocks}
-          rendered = self.class.new(content, options).render
-
-          [
-            "<article>",
-            (title ? "<h1>#{title}</h1>" : ""),
-            rendered,
-            "</article>"
-          ].join("\n")
-        end
-
-        private
-
-        def validate_html(html)
-          return "" if html.blank?
-
-          begin
-            # For quote blocks, only allow specific content
-            if html.include?('<figure class="text-left">')
-              # 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
-
-            # For other HTML, use sanitize
-            config = Sanitize::Config::RELAXED.dup
-            config[:elements] += %w[figure figcaption blockquote pre code mention math]
-            config[:attributes].merge!({
-              "figure" => ["class"],
-              "blockquote" => ["class"],
-              "p" => ["class"],
-              "figcaption" => ["class"]
-            })
-
-            sanitized = Sanitize.fragment(html, config)
-            (sanitized == html) ? html : ""
-          rescue => e
-            Rails.logger.error("HTML validation error: #{e.message}")
-            ""
-          end
-        end
-
-        def render_block_with_cache(block)
-          cache_key = "editor_js_block/#{block["type"]}/#{Digest::MD5.hexdigest(block["data"].to_json)}"
-
-          cache_store.fetch(cache_key) do
-            renderer = renderer_for(block)
-            renderer.render
-          end
-        end
-
-        def renderer_for(block)
-          if custom_renderers[block["type"]]
-            custom_renderers[block["type"]].new(block["data"], options)
-          else
-            default_renderer_for(block)
-          end
-        end
-
-        def default_renderer_for(block)
-          renderer_class = "Panda::CMS::EditorJs::Blocks::#{block["type"].classify}".constantize
-          renderer_class.new(block["data"], options)
-        rescue NameError
-          Panda::CMS::EditorJs::Blocks::Base.new(block["data"], options)
-        end
-
-        def remove_empty_paragraphs(blocks)
-          blocks.reject do |block|
-            block["type"] == "paragraph" && block["data"]["text"].blank?
-          end
-        end
-
-        def empty_paragraph?(block)
-          block["type"] == "paragraph" && block["data"]["text"].blank?
-        end
-
-        def render_block(block)
-          render_block_with_cache(block)
-        end
-      end
-    end
-  end
-end

data/lib/panda/cms/editor_js.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "editor_js/blocks/base"
-require_relative "editor_js/blocks/alert"
-require_relative "editor_js/blocks/header"
-require_relative "editor_js/blocks/image"
-require_relative "editor_js/blocks/list"
-require_relative "editor_js/blocks/paragraph"
-require_relative "editor_js/blocks/quote"
-require_relative "editor_js/blocks/table"
-require_relative "editor_js/renderer"
-
-module Panda
-  module CMS
-    module EditorJs
-    end
-  end
-end

data/lib/panda/cms/editor_js_content.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Panda
-  module CMS
-    module EditorJsContent
-      extend ActiveSupport::Concern
-
-      included do
-        include ActiveModel::Validations
-        include ActiveModel::Callbacks
-
-        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 = super
-        if value.is_a?(String)
-          begin
-            JSON.parse(value)
-          rescue JSON::ParserError
-            value
-          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
-            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
-          # For any other case, store as is
-          self.cached_content = content.to_s
-        end
-      end
-    end
-  end
-end