panda-cms 0.7.4 → 0.8.0

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

@@ -1,50 +0,0 @@
-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 == 0 && 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,124 +0,0 @@
-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,16 +0,0 @@
-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,55 +0,0 @@
-require "json"
-
-module Panda::CMS::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