panda-editor 0.3.0 → 0.5.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,16 @@ module Panda
         g.test_framework :rspec
       end
 
-      initializer "panda_editor.assets" do |app|
+      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,14 +1,17 @@
 # frozen_string_literal: true
 
+require 'redcarpet'
+
 module Panda
   module Editor
     class FootnoteRegistry
       attr_reader :footnotes
 
-      def initialize(autolink_urls: false)
+      def initialize(autolink_urls: false, markdown: false)
         @footnotes = []
         @footnote_ids = {}
         @autolink_urls = autolink_urls
+        @markdown = markdown
       end
 
       def add(id:, content:)
@@ -16,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
@@ -26,11 +29,11 @@ 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
-          content = @autolink_urls ? autolink_urls(footnote[:content]) : footnote[:content]
+          content = process_content(footnote[:content])
           <<~HTML.strip
             <li id="fn:#{number}">
               <p>
@@ -66,6 +69,45 @@ module Panda
 
       private
 
+      def process_content(content)
+        # Apply markdown processing if enabled
+        content = render_markdown(content) if @markdown
+
+        # Apply URL autolinking if enabled
+        # Note: Markdown already includes autolink, but custom autolink_urls can still be used
+        # if needed for additional URL patterns. The autolink_urls method skips already-linked URLs.
+        content = autolink_urls(content) if @autolink_urls
+
+        content
+      end
+
+      def render_markdown(text)
+        # Configure Redcarpet with safe options for footnotes
+        renderer = Redcarpet::Render::HTML.new(
+          filter_html: false,
+          no_images: true,
+          no_styles: true,
+          safe_links_only: true,
+          link_attributes: { target: '_blank', rel: 'noopener noreferrer' }
+        )
+
+        markdown = Redcarpet::Markdown.new(
+          renderer,
+          autolink: true,
+          space_after_headers: true,
+          fenced_code_blocks: false,
+          no_intra_emphasis: true,
+          strikethrough: true,
+          superscript: false,
+          underline: false
+        )
+
+        # Render markdown and strip the wrapping <p> tags if present
+        # since we're already wrapping in <p> tags in the template
+        html = markdown.render(text).strip
+        html.gsub(%r{^<p>(.*)</p>$}m, '\1')
+      end
+
       def autolink_urls(text)
         # Regex to match URLs that aren't already in <a> tags
         # Matches http://, https://, and other common protocols
@@ -80,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/renderer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "sanitize"
+require 'sanitize'
 
 module Panda
   module Editor
@@ -14,15 +14,16 @@ module Panda
         @cache_store = options.delete(:cache_store) || Rails.cache
         @validate_html = options.delete(:validate_html) || false
         autolink_urls = options.delete(:autolink_urls) || false
-        @footnote_registry = FootnoteRegistry.new(autolink_urls: autolink_urls)
+        markdown = options.delete(:markdown) || false
+        @footnote_registry = FootnoteRegistry.new(autolink_urls: autolink_urls, markdown: markdown)
         @options[:footnote_registry] = @footnote_registry
       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")
 
@@ -34,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
@@ -72,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)
@@ -109,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)

data/lib/panda/editor/version.rb

@@ -2,6 +2,6 @@
 
 module Panda
   module Editor
-    VERSION = "0.3.0"
+    VERSION = '0.5.0'
   end
 end

data/lib/panda/editor.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "dry-configurable"
-require_relative "editor/version"
-require_relative "editor/engine"
+require 'dry-configurable'
+require_relative 'editor/version'
+require_relative 'editor/engine'
 
 module Panda
   module Editor
@@ -18,19 +18,19 @@ module Panda
     class Error < StandardError; end
 
     # Autoload components
-    autoload :Renderer, "panda/editor/renderer"
-    autoload :Content, "panda/editor/content"
-    autoload :FootnoteRegistry, "panda/editor/footnote_registry"
+    autoload :Renderer, 'panda/editor/renderer'
+    autoload :Content, 'panda/editor/content'
+    autoload :FootnoteRegistry, 'panda/editor/footnote_registry'
 
     module Blocks
-      autoload :Base, "panda/editor/blocks/base"
-      autoload :Alert, "panda/editor/blocks/alert"
-      autoload :Header, "panda/editor/blocks/header"
-      autoload :Image, "panda/editor/blocks/image"
-      autoload :List, "panda/editor/blocks/list"
-      autoload :Paragraph, "panda/editor/blocks/paragraph"
-      autoload :Quote, "panda/editor/blocks/quote"
-      autoload :Table, "panda/editor/blocks/table"
+      autoload :Base, 'panda/editor/blocks/base'
+      autoload :Alert, 'panda/editor/blocks/alert'
+      autoload :Header, 'panda/editor/blocks/header'
+      autoload :Image, 'panda/editor/blocks/image'
+      autoload :List, 'panda/editor/blocks/list'
+      autoload :Paragraph, 'panda/editor/blocks/paragraph'
+      autoload :Quote, 'panda/editor/blocks/quote'
+      autoload :Table, 'panda/editor/blocks/table'
     end
   end
 end