panda-editor 0.4.0 → 0.6.0

data/lib/panda/editor/blocks/image.rb

@@ -5,19 +5,19 @@ module Panda
     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"]
+          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
+          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(" ")}">
+            <figure class="#{css_classes.join(' ')}">
               <img src="#{url}" alt="#{caption}" />
               #{caption_element(caption)}
             </figure>
@@ -27,7 +27,7 @@ module Panda
         private
 
         def caption_element(caption)
-          return "" if caption.blank?
+          return '' if caption.blank?
 
           "<figcaption>#{caption}</figcaption>"
         end

data/lib/panda/editor/blocks/list.rb

@@ -5,10 +5,10 @@ module Panda
     module Blocks
       class List < Base
         def render
-          list_type = (data["style"] == "ordered") ? "ol" : "ul"
+          list_type = data['style'] == 'ordered' ? 'ol' : 'ul'
           html_safe(
             "<#{list_type}>" \
-            "#{render_items(data["items"])}" \
+            "#{render_items(data['items'])}" \
             "</#{list_type}>"
           )
         end
@@ -17,14 +17,14 @@ module Panda
 
         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"]) : ""
+            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
+          self.class.new({ 'items' => items, 'style' => data['style'] }).render
         end
       end
     end

data/lib/panda/editor/blocks/paragraph.rb

@@ -5,10 +5,10 @@ module Panda
     module Blocks
       class Paragraph < Base
         def render
-          content = sanitize(data["text"])
-          return "" if content.blank?
+          content = sanitize(data['text'])
+          return '' if content.blank?
 
-          content = inject_footnotes(content) if data["footnotes"].present?
+          content = inject_footnotes(content) if data['footnotes'].present?
 
           html_safe("<p>#{content}</p>")
         end
@@ -16,15 +16,15 @@ module Panda
         private
 
         def inject_footnotes(text)
-          return text unless data["footnotes"].is_a?(Array)
+          return text unless data['footnotes'].is_a?(Array)
 
           # Sort footnotes by position in descending order to avoid position shifts
-          footnotes = data["footnotes"].sort_by { |fn| -fn["position"].to_i }
+          footnotes = data['footnotes'].sort_by { |fn| -fn['position'].to_i }
 
           footnotes.each do |footnote|
-            position = footnote["position"].to_i
+            position = footnote['position'].to_i
             # Skip if position is beyond text length
-            next if position < 0 || position > text.length
+            next if position.negative? || position > text.length
 
             # Register footnote with renderer's footnote registry
             footnote_number = register_footnote(footnote)
@@ -34,7 +34,7 @@ module Panda
             marker = "<sup id=\"fnref:#{footnote_number}\"><a href=\"#fn:#{footnote_number}\" class=\"footnote\">#{footnote_number}</a></sup>"
 
             # Insert marker at position
-            text = text.insert(position, marker)
+            text.insert(position, marker)
           end
 
           text
@@ -44,8 +44,8 @@ module Panda
           return nil unless options[:footnote_registry]
 
           options[:footnote_registry].add(
-            id: footnote["id"],
-            content: footnote["content"]
+            id: footnote['id'],
+            content: footnote['content']
           )
         end
       end

data/lib/panda/editor/blocks/quote.rb

@@ -5,15 +5,15 @@ module Panda
     module Blocks
       class Quote < Base
         def render
-          text = data["text"]
-          caption = data["caption"]
-          alignment = data["alignment"] || "left"
+          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>"
+            '</figure>'
 
           # Return raw HTML - validation will be handled by the main renderer if enabled
           html_safe(html)
@@ -24,7 +24,7 @@ module Panda
         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>")
+          if text.start_with?('<p>') && text.end_with?('</p>')
             text
           else
             "<p>#{text}</p>"
@@ -32,7 +32,7 @@ module Panda
         end
 
         def caption_element(caption)
-          return "" if caption.blank?
+          return '' if caption.blank?
 
           "<figcaption>#{sanitize(caption)}</figcaption>"
         end

data/lib/panda/editor/blocks/table.rb

@@ -5,8 +5,8 @@ module Panda
     module Blocks
       class Table < Base
         def render
-          content = data["content"]
-          with_headings = data["withHeadings"]
+          content = data['content']
+          with_headings = data['withHeadings']
 
           html_safe(<<~HTML)
             <div class="overflow-x-auto">
@@ -25,10 +25,10 @@ module Panda
 
           while index < content.length
             rows << if index.zero? && with_headings
-              render_header_row(content[index])
-            else
-              render_data_row(content[index])
-            end
+                      render_header_row(content[index])
+                    else
+                      render_data_row(content[index])
+                    end
             index += 1
           end
 

data/lib/panda/editor/content.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+require 'json'
 
 module Panda
   module Editor
@@ -36,21 +36,21 @@ module Panda
       end
 
       def generate_cached_content
-        renderer_options = {autolink_urls: true}
+        renderer_options = { autolink_urls: true }
 
         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::Editor::Renderer.new(parsed_content, renderer_options).render
-            else
-              content
-            end
+            self.cached_content = if parsed_content.is_a?(Hash) && parsed_content['blocks'].present?
+                                    Panda::Editor::Renderer.new(parsed_content, renderer_options).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?
+        elsif content.is_a?(Hash) && content['blocks'].present?
           # Process EditorJS content
           self.cached_content = Panda::Editor::Renderer.new(content, renderer_options).render
         else

data/lib/panda/editor/engine.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "rails"
-require "sanitize"
+require 'rails'
+require 'sanitize'
 
 module Panda
   module Editor
@@ -12,18 +12,22 @@ module Panda
         g.test_framework :rspec
       end
 
-      initializer "panda_editor.assets" do |app|
+      # Eager load converter classes
+      config.to_prepare do
+        require 'panda/editor/markdown_to_editor_js_converter'
+        require 'panda/editor/html_to_editor_js_converter'
+      end
+
+      initializer 'panda_editor.assets' do |app|
         next unless app.config.respond_to?(:assets)
 
-        app.config.assets.paths << root.join("app/javascript")
-        app.config.assets.paths << root.join("public")
+        app.config.assets.paths << root.join('app/javascript')
+        app.config.assets.paths << root.join('public')
         app.config.assets.precompile += %w[panda/editor/*.js panda/editor/*.css]
       end
 
-      initializer "panda_editor.importmap", before: "importmap" do |app|
-        if app.config.respond_to?(:importmap)
-          app.config.importmap.paths << root.join("config/importmap.rb")
-        end
+      initializer 'panda_editor.importmap', before: 'importmap' do |app|
+        app.config.importmap.paths << root.join('config/importmap.rb') if app.config.respond_to?(:importmap)
       end
     end
   end

data/lib/panda/editor/footnote_registry.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "redcarpet"
+require 'redcarpet'
 
 module Panda
   module Editor
@@ -19,7 +19,7 @@ module Panda
         return @footnote_ids[id] if @footnote_ids[id]
 
         # Add new footnote
-        @footnotes << {id: id, content: content}
+        @footnotes << { id: id, content: content }
         number = @footnotes.length
 
         # Cache the number for this ID
@@ -29,7 +29,7 @@ module Panda
       end
 
       def render_sources_section
-        return "" if @footnotes.empty?
+        return '' if @footnotes.empty?
 
         footnote_items = @footnotes.map.with_index do |footnote, index|
           number = index + 1
@@ -88,7 +88,7 @@ module Panda
           no_images: true,
           no_styles: true,
           safe_links_only: true,
-          link_attributes: {target: "_blank", rel: "noopener noreferrer"}
+          link_attributes: { target: '_blank', rel: 'noopener noreferrer' }
         )
 
         markdown = Redcarpet::Markdown.new(
@@ -122,12 +122,12 @@ module Panda
         # Don't replace URLs that are already in <a> tags
         text.gsub(url_pattern) do |url|
           # Skip if this URL is already part of an href attribute
-          before_match = $`
+          before_match = ::Regexp.last_match.pre_match
           if /<a[^>]*href\s*=\s*["']?\z/i.match?(before_match)
             url
           else
             # Add protocol if missing
-            full_url = url.start_with?("www.") ? "https://#{url}" : url
+            full_url = url.start_with?('www.') ? "https://#{url}" : url
             %(<a href="#{full_url}" target="_blank" rel="noopener noreferrer">#{url}</a>)
           end
         end

data/lib/panda/editor/html_to_editor_js_converter.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Panda
+  module Editor
+    # Converts HTML to EditorJS format
+    # Parses HTML and converts it to EditorJS blocks
+    class HtmlToEditorJsConverter
+      def self.convert(html)
+        new(html).convert
+      end
+
+      def initialize(html)
+        @html = html
+        @blocks = []
+      end
+
+      def convert
+        doc = Nokogiri::HTML.fragment(@html)
+
+        doc.children.each do |node|
+          block = node_to_block(node)
+          @blocks << block if block
+        end
+
+        {
+          time: Time.now.to_i * 1000,
+          blocks: @blocks,
+          version: "2.28.0"
+        }
+      end
+
+      private
+
+      def node_to_block(node)
+        return nil if node.text? && node.text.strip.empty?
+
+        case node.name
+        when "h1", "h2", "h3", "h4", "h5", "h6"
+          header_block(node)
+        when "p"
+          paragraph_block(node)
+        when "ul", "ol"
+          list_block(node)
+        when "blockquote"
+          quote_block(node)
+        when "pre"
+          code_block(node)
+        when "table"
+          table_block(node)
+        when "hr"
+          delimiter_block
+        when "text"
+          # Handle text nodes that aren't wrapped in tags
+          text = node.text.strip
+          text.empty? ? nil : paragraph_block_from_text(text)
+        else
+          # For any other node, try to extract text content
+          text = node.text.strip
+          text.empty? ? nil : paragraph_block_from_text(text)
+        end
+      end
+
+      def header_block(node)
+        level = node.name[1].to_i
+        {
+          type: "header",
+          data: {
+            text: node.inner_html.strip,
+            level: level
+          }
+        }
+      end
+
+      def paragraph_block(node)
+        text = node.inner_html.strip
+        return nil if text.empty?
+
+        {
+          type: "paragraph",
+          data: {
+            text: text
+          }
+        }
+      end
+
+      def paragraph_block_from_text(text)
+        {
+          type: "paragraph",
+          data: {
+            text: text
+          }
+        }
+      end
+
+      def list_block(node)
+        style = node.name == "ol" ? "ordered" : "unordered"
+        items = node.css("li").map { |li| li.inner_html.strip }
+
+        {
+          type: "list",
+          data: {
+            style: style,
+            items: items
+          }
+        }
+      end
+
+      def quote_block(node)
+        {
+          type: "quote",
+          data: {
+            text: node.inner_html.strip,
+            caption: "",
+            alignment: "left"
+          }
+        }
+      end
+
+      def code_block(node)
+        code = node.css("code").first
+        text = code ? code.text : node.text
+
+        {
+          type: "code",
+          data: {
+            code: text
+          }
+        }
+      end
+
+      def table_block(node)
+        content = []
+
+        # Process table rows
+        node.css("tr").each do |row|
+          cells = row.css("th, td").map { |cell| cell.inner_html.strip }
+          content << cells
+        end
+
+        {
+          type: "table",
+          data: {
+            withHeadings: node.css("thead").any? || node.css("th").any?,
+            content: content
+          }
+        }
+      end
+
+      def delimiter_block
+        {
+          type: "delimiter",
+          data: {}
+        }
+      end
+    end
+  end
+end

data/lib/panda/editor/markdown_to_editor_js_converter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "redcarpet"
+
+module Panda
+  module Editor
+    # Converts Markdown to EditorJS format
+    # Uses Redcarpet to parse markdown to HTML, then converts HTML to EditorJS blocks
+    class MarkdownToEditorJsConverter
+      def self.convert(markdown)
+        new(markdown).convert
+      end
+
+      def initialize(markdown)
+        @markdown = markdown
+      end
+
+      def convert
+        # Step 1: Convert Markdown to HTML using Redcarpet
+        html = markdown_to_html
+
+        # Step 2: Convert HTML to EditorJS using existing converter
+        Panda::Editor::HtmlToEditorJsConverter.convert(html)
+      end
+
+      private
+
+      def markdown_to_html
+        renderer = Redcarpet::Render::HTML.new(
+          hard_wrap: true,
+          link_attributes: {rel: "noopener noreferrer"}
+        )
+
+        markdown_processor = Redcarpet::Markdown.new(
+          renderer,
+          autolink: true,
+          tables: true,
+          fenced_code_blocks: true,
+          strikethrough: true,
+          superscript: true,
+          footnotes: true,
+          no_intra_emphasis: true,
+          space_after_headers: true
+        )
+
+        markdown_processor.render(@markdown)
+      end
+    end
+  end
+end

data/lib/panda/editor/renderer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "sanitize"
+require 'sanitize'
 
 module Panda
   module Editor
@@ -20,10 +20,10 @@ module Panda
       end
 
       def render
-        return "" if content.nil? || content == {}
-        return content.to_s unless content.is_a?(Hash) && content["blocks"].is_a?(Array)
+        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|
+        rendered = content['blocks'].map do |block|
           render_block(block)
         end.join("\n")
 
@@ -35,36 +35,36 @@ module Panda
           rendered = [rendered, sources_section].join("\n")
         end
 
-        rendered.presence || ""
+        rendered.presence || ''
       end
 
       def section(blocks)
-        return "" if blocks.nil? || blocks.empty?
+        return '' if blocks.nil? || blocks.empty?
 
-        content = {"blocks" => blocks}
+        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?
+        return '' if blocks.nil? || blocks.empty?
 
-        content = {"blocks" => blocks}
+        content = { 'blocks' => blocks }
         rendered = self.class.new(content, options).render
 
         [
-          "<article>",
-          (title ? "<h1>#{title}</h1>" : ""),
+          '<article>',
+          (title ? "<h1>#{title}</h1>" : ''),
           rendered,
-          "</article>"
+          '</article>'
         ].join("\n")
       end
 
       private
 
       def validate_html(html)
-        return "" if html.blank?
+        return '' if html.blank?
 
         begin
           # For quote blocks, only allow specific content
@@ -73,35 +73,35 @@ module Panda
             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 ""
+            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"]
-          })
+                                       'figure' => ['class'],
+                                       'blockquote' => ['class'],
+                                       'p' => ['class'],
+                                       'figcaption' => ['class']
+                                     })
 
           sanitized = Sanitize.fragment(html, config)
-          (sanitized == html) ? html : ""
-        rescue => e
+          sanitized == html ? html : ''
+        rescue StandardError => e
           Rails.logger.error("HTML validation error: #{e.message}")
-          ""
+          ''
         end
       end
 
       def render_block_with_cache(block)
         # Don't cache blocks with footnotes - they need to register with the footnote registry
-        if block["data"]["footnotes"].present?
+        if block['data']['footnotes'].present?
           renderer = renderer_for(block)
           return renderer.render
         end
 
-        cache_key = "editor_js_block/#{block["type"]}/#{Digest::MD5.hexdigest(block["data"].to_json)}"
+        cache_key = "editor_js_block/#{block['type']}/#{Digest::MD5.hexdigest(block['data'].to_json)}"
 
         cache_store.fetch(cache_key) do
           renderer = renderer_for(block)
@@ -110,28 +110,28 @@ module Panda
       end
 
       def renderer_for(block)
-        if custom_renderers[block["type"]]
-          custom_renderers[block["type"]].new(block["data"], options)
+        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::Editor::Blocks::#{block["type"].classify}".constantize
-        renderer_class.new(block["data"], options)
+        renderer_class = "Panda::Editor::Blocks::#{block['type'].classify}".constantize
+        renderer_class.new(block['data'], options)
       rescue NameError
-        Panda::Editor::Blocks::Base.new(block["data"], options)
+        Panda::Editor::Blocks::Base.new(block['data'], options)
       end
 
       def remove_empty_paragraphs(blocks)
         blocks.reject do |block|
-          block["type"] == "paragraph" && block["data"]["text"].blank?
+          block['type'] == 'paragraph' && block['data']['text'].blank?
         end
       end
 
       def empty_paragraph?(block)
-        block["type"] == "paragraph" && block["data"]["text"].blank?
+        block['type'] == 'paragraph' && block['data']['text'].blank?
       end
 
       def render_block(block)