sparx 0.1.5

data/lib/sparx/constants.rb

@@ -0,0 +1,71 @@
+module Sparx
+  MIME_TYPES = {'webp' => 'image/webp','avif' => 'image/avif','jpg' => 'image/jpeg','jpeg' => 'image/jpeg','png' => 'image/png','gif' => 'image/gif','svg' => 'image/svg+xml'}.freeze
+  CONTAINER_SPECS = {
+     details: {
+        pattern: /\+\[(.*?)\]\{/, placeholder: "DETAILSPLACEHOLDER",
+        build_html: ->(matches, content, citations, numbered_citations) {
+           summary = process_all_inline_elements(matches[:summary], citations, numbered_citations)
+           "<details><summary>#{summary}</summary>#{content}</details>"
+        },extract_params: ->(match) { {summary: match[1]} }
+     },
+      section: {
+        pattern: /\$\[([^\]]+)\]\{/,  # Change this to accept any characters in []
+        placeholder: "SECTIONPLACEHOLDER",
+        build_html: ->(matches, content, citations, numbered_citations) {  
+          id = escape_html_attr(matches[:id])  # Escape the ID
+          "<section id=\"#{id}\">#{content}</section>"  
+        },
+        extract_params: ->(match) { {id: match[1]} }
+      },
+     blockquote: {
+        pattern: />(?:\[([^\]]+)\])?\{/, placeholder: "BLOCKQUOTEPLACEHOLDER",
+        build_html: ->(matches, content, citations, numbered_citations) {  
+           cite_attr = matches[:cite] ? " cite=\"#{escape_html_attr(matches[:cite])}\"" : ""
+           "<blockquote#{cite_attr}>#{content}</blockquote>"  
+        },extract_params: ->(match) { {cite: match[1]} }
+     },
+     div_class: {
+        pattern: /\.([a-zA-Z0-9_-]+)\{/, placeholder: "DIVPLACEHOLDER",
+        build_html: ->(matches, content, citations, numbered_citations) {  
+           "<div class=\"#{matches[:class_name]}\">#{content}</div>"  
+        },extract_params: ->(match) { {class_name: match[1]} }
+     },
+     aside: {
+        pattern: /~\{/, placeholder: "ASIDEPLACEHOLDER",  
+        build_html: ->(matches, content, citations, numbered_citations) {  
+           "<aside>#{content}</aside>"  
+        },extract_params: ->(match) { {} }
+     },
+     figure: {
+        pattern: /f\[(.*?)\]\{/, placeholder: "FIGUREPLACEHOLDER",
+        build_html: ->(matches, content, citations, numbered_citations) {
+           caption = process_all_inline_elements(matches[:caption], citations, numbered_citations)
+           "<figure>#{content}<figcaption>#{caption}</figcaption></figure>"
+        },extract_params: ->(match) { {caption: match[1]} }
+     }
+  }.freeze
+  LIST_SPECS = {
+     ul: {
+        simple_pattern: /^\s*(-+)\s+(.+)$/,complex_pattern: /^\s*(-+)\{$/, placeholder: "ULPLACEHOLDER",
+        build_html: ->(items) {build_nested_list(items, 'ul')},
+        extract_item_params: ->(match, content = nil) {{level: match[1].length, content: content || match[2]}}
+     },
+     ol: {
+        simple_pattern: /^\s*(\++)\s+(.+)$/,complex_pattern: /^\s*(\++)\{$/, placeholder: "OLPLACEHOLDER",
+        build_html: ->(items) {build_nested_list(items, 'ol')},
+        extract_item_params: ->(match, content = nil) {{level: match[1].length, content: content || match[2]}}
+     },
+     dl: {
+        simple_pattern: /^\s*(:+)([^:]+):\s*(.*)$/,complex_pattern: /^\s*(:+)([^:]+):\{$/, placeholder: "DLPLACEHOLDER",
+        build_html: ->(items) {build_nested_definition_list(items)},
+        extract_item_params: ->(match, content = nil) {
+           {level: match[1].length, term: match[2].strip, description: (content ? content : match[3].strip)}
+        }
+     }
+  }.freeze
+
+
+  def self.global_counters
+    @global_counters ||= {}
+  end
+end

data/lib/sparx/container_processor.rb

@@ -0,0 +1,217 @@
+module Sparx
+  def self.process_all_containers(text, citations, numbered_citations)
+    original_text = text.dup
+    all_caches = {}
+    text = process_responsive_images(text, citations, numbered_citations)
+    CONTAINER_SPECS.each do |type, spec|
+      result = process_container_type(text, spec, citations, numbered_citations, type)
+      text = result[:text]
+      all_caches[type] = result[:cache]
+    end
+    LIST_SPECS.each do |type, spec|
+      result = process_list_type(text, spec, citations, numbered_citations, type)
+      text = result[:text]
+      all_caches[type] = result[:cache]
+    end
+    text = parse_styles(text, citations, numbered_citations)
+    text = wrap_paragraphs_if_needed(text, original_text)
+    max_iterations = 10
+    iteration = 0
+    while iteration < max_iterations
+      replacements_made = false
+      (LIST_SPECS.keys + CONTAINER_SPECS.keys).reverse.each do |type|
+        all_caches[type]&.each do |placeholder, html|
+          if text.include?(placeholder)
+            text = text.gsub(placeholder, html)
+            replacements_made = true
+        end
+      end
+    end
+      break unless replacements_made
+      iteration += 1
+    end
+    text
+  end
+  def self.process_container_type(text, spec, citations, numbered_citations, type)
+    container_cache = {}
+    @global_counters[spec[:placeholder]] ||= 0
+    while match = text.match(spec[:pattern])
+      start_pos = match.begin(0)
+      content_start = match.end(0)
+    end_pos = find_matching_brace(text, content_start)
+      content = text[content_start...end_pos].strip
+      params = spec[:extract_params].call(match)
+      processed_content = process_all_containers(content, citations, numbered_citations)
+      html = spec[:build_html].call(params, processed_content, citations, numbered_citations)
+      placeholder = "#{spec[:placeholder]}#{@global_counters[spec[:placeholder]]}END"
+      @global_counters[spec[:placeholder]] += 1
+      container_cache[placeholder] = html
+      text = text[0...start_pos] + placeholder + text[end_pos + 1..-1]
+    end
+    { text: text, cache: container_cache }
+  end
+  def self.process_list_type(text, spec, citations, numbered_citations, type)
+  cache = {}
+  @global_counters[spec[:placeholder]] ||= 0
+  lines = text.split("\n")
+  result_lines = []
+  i = 0
+  complex_just_closed = false
+  while i < lines.length
+    line = lines[i]
+    simple_match = line.match(spec[:simple_pattern])
+    complex_match = line.match(spec[:complex_pattern])
+    if simple_match || complex_match
+      items = []
+      while i < lines.length
+        current_line = lines[i]
+        if type == :dl
+          if !current_line.strip.empty? && !current_line.match(spec[:simple_pattern]) && !current_line.match(spec[:complex_pattern])
+            break
+         end
+          if current_line.strip.empty?
+            if i + 1 < lines.length
+              next_line = lines[i + 1]
+              if next_line.match(spec[:simple_pattern]) || next_line.match(spec[:complex_pattern])
+                i += 1
+                next
+              else
+                break
+             end
+            else
+              break
+           end
+         end
+       end
+        if match = current_line.match(spec[:complex_pattern])
+          i += 1
+          content_lines = []
+          brace_count = 1
+          while i < lines.length && brace_count > 0
+            content_line = lines[i]
+            content_line.each_char do |char|
+              brace_count += 1 if char == '{'
+              brace_count -= 1 if char == '}'
+           end
+            if brace_count > 0
+              content_lines << content_line
+            else
+              close_pos = content_line.rindex('}')
+              content_lines << content_line[0...close_pos] if close_pos && close_pos > 0
+           end
+            i += 1
+         end
+          content = content_lines.join("\n").strip
+          original_content = content.dup
+          processed_content = process_all_containers(content, citations, numbered_citations)
+          if original_content.match?(/\n\s*\n/)
+            processed_content = processed_content
+          else
+            unless processed_content.match(/\A<(ul|ol|table|blockquote|pre|h\d|div|details|section|img|dl|aside|figure)/)
+              processed_content = "<p>#{processed_content}</p>"
+           end
+         end
+          params = spec[:extract_item_params].call(match, processed_content)
+          original_level = params[:level]
+          if type == :dl && complex_just_closed
+            params[:level] = 1
+            if original_level == 1
+              complex_just_closed = false
+           end
+         end
+          params[:closed] = true
+          if type == :dl
+            params[:term] = process_all_inline_elements(params[:term], citations, numbered_citations)
+         end
+          items << params
+          complex_just_closed = true
+        elsif match = current_line.match(spec[:simple_pattern])
+          params = spec[:extract_item_params].call(match)
+          original_level = params[:level]
+          if type == :dl && complex_just_closed
+            params[:level] = 1
+            if original_level == 1
+              complex_just_closed = false
+           end
+         end
+          if type == :dl
+            params[:term] = process_all_inline_elements(params[:term], citations, numbered_citations)
+            params[:description] = process_all_inline_elements(params[:description], citations, numbered_citations)
+          else
+            params[:content] = process_all_inline_elements(params[:content], citations, numbered_citations)
+         end
+          items << params
+          i += 1
+        else
+          break
+       end
+     end
+      if items.any?
+        html = spec[:build_html].call(items)
+        placeholder = "#{spec[:placeholder]}#{@global_counters[spec[:placeholder]]}END"
+        @global_counters[spec[:placeholder]] += 1
+        cache[placeholder] = html
+        result_lines << placeholder
+        i -= 1
+      else
+        result_lines << line
+     end
+    else
+      result_lines << line
+    end
+    i += 1
+  end
+  { text: result_lines.join("\n"), cache: cache }
+  end
+  def self.find_matching_brace(text, start_pos)
+    brace_count = 1
+    pos = start_pos
+    while pos < text.length && brace_count > 0
+      if text[pos] == '{'
+        brace_count += 1
+      elsif text[pos] == '}'
+        brace_count -= 1
+    end
+      pos += 1
+    end
+    pos - 1
+  end
+  def self.build_nested_list(items, list_type);return "" if items.empty?;html, _ = build_list_recursive(items, 0, list_type, 1);html;end
+  def self.build_list_recursive(items, start_index, list_type, expected_level)
+    return ["", start_index] if start_index >= items.length
+    html = "<#{list_type}>"
+    i = start_index
+    while i < items.length
+      item = items[i]
+      if item[:level] == expected_level
+        html += "<li>#{item[:content]}"
+        if i + 1 < items.length && items[i + 1][:level] > expected_level
+          nested_html, new_i = build_list_recursive(items, i + 1, list_type, expected_level + 1)
+          html += nested_html
+          i = new_i - 1
+      end
+        html += "</li>";i += 1;elsif item[:level] < expected_level;break;else;i += 1;end
+    end
+    html += "</#{list_type}>";[html, i]
+  end
+  def self.build_nested_definition_list(items);return "" if items.empty?;html, _ = build_definition_list_recursive(items, 0, 1);html;end
+  def self.build_definition_list_recursive(items, start_index, expected_level)
+    return ["", start_index] if start_index >= items.length
+    html = "<dl>";i = start_index
+    while i < items.length
+      item = items[i]
+      if item[:level] == expected_level
+        html += "<dt>#{item[:term]}</dt>"
+        html += "<dd>#{item[:description]}"
+        if !item[:closed] && i + 1 < items.length && items[i + 1][:level] > expected_level
+          nested_html, new_i = build_definition_list_recursive(items, i + 1, expected_level + 1)
+          html += nested_html
+          i = new_i - 1
+        end
+        html += "</dd>"
+        i += 1
+      elsif item[:level] < expected_level;break;else;i += 1;end
+    end
+    html += "</dl>";[html, i]
+  end
+end

data/lib/sparx/image_processor.rb

@@ -0,0 +1,267 @@
+module Sparx
+  def self.process_srcset_with_expansion(srcset_parts, media_attr, url_prefix, citations)
+    expanded_items = []
+    srcset_parts.each do |part|
+      if part.match(/^(.+\{[^}]+\})(.*)$/)
+        path_with_braces, suffix = $1, $2.strip
+        width_descriptor = suffix.match(/^(\d+w)/) ? $1 : nil
+        if path_with_braces.match(/^(.+)\{([^}]+)\}$/)
+          base_path, extensions = $1, $2.split(',').map(&:strip)
+          extensions.each do |ext|
+            expanded_items << {path: "#{base_path}#{ext}", width: width_descriptor, ext: ext}
+          end
+        end
+      elsif match = part.match(/^([^\s]+)\s*(\d+w)?$/)
+        path, width, ext = match[1], match[2], File.extname(match[1]).sub('.', '')
+        expanded_items << {path: path, width: width, ext: ext}
+      end
+    end
+    grouped = expanded_items.group_by { |item| item[:ext] }
+    sources = []
+    grouped.each do |ext, items|
+      srcset_value = items.map { |item|
+        full_src = resolve_image_src(item[:path], url_prefix, citations)
+        item[:width] ? "#{full_src} #{item[:width]}" : full_src
+      }.join(', ')
+      sources << build_source_tag(srcset_value, infer_type(ext), media_attr)
+    end
+    sources
+  end
+  def self.expand_source(path_str, media_attr, url_prefix, citations)
+    sources = []
+    if path_str.match(/^(.+)\{([^}]+)\}(.*)$/)
+      base_path, extensions, suffix = $1, $2.split(',').map(&:strip), $3
+      extensions.each do |ext|
+        full_path = "#{base_path}#{ext}#{suffix}"
+        actual_path = full_path.split(/\s+/).first
+        width_descriptor = full_path.match(/\s+(\d+w)/) ? $1 : nil
+        full_src = resolve_image_src(actual_path, url_prefix, citations)
+        srcset_value = width_descriptor ? "#{full_src} #{width_descriptor}" : full_src
+        sources << build_source_tag(srcset_value, infer_type(ext), media_attr)
+      end
+    else
+      actual_path = path_str.split(/\s+/).first
+      width_descriptor = path_str.match(/\s+(\d+w)/) ? $1 : nil
+      full_src = resolve_image_src(actual_path, url_prefix, citations)
+      ext = File.extname(actual_path).sub('.', '')
+      srcset_value = width_descriptor ? "#{full_src} #{width_descriptor}" : full_src
+      sources << build_source_tag(srcset_value, infer_type(ext), media_attr)
+    end
+    sources
+  end
+  def self.process_responsive_images(text, citations, numbered_citations)
+    lines = text.split("\n")
+    result_lines = []
+    i = 0
+    @global_counters['PICTUREPLACEHOLDER'] ||= 0
+    picture_cache = {}
+    while i < lines.length
+      line = lines[i]
+      if line.match(/^\s*src\[([^\]]+)\](.+)$/)
+        src_elements = []
+        start_i = i
+        while i < lines.length && lines[i].match(/^\s*src\[([^\]]+)\](.+)$/)
+          src_elements << lines[i]
+          i += 1
+          break if i >= lines.length
+          next_line = lines[i]
+          if next_line.strip.empty?
+            if i + 1 < lines.length
+              following = lines[i + 1]
+              break unless following.match(/^\s*src\[/) || following.match(/^\s*([*\/-]*)i\[/)
+            else
+              break
+            end
+          elsif !next_line.match(/^\s*src\[/) && !next_line.match(/^\s*([*\/-]*)i\[/)
+            break
+          end
+        end
+        img_line_index = i
+        img_line_index = i + 1 if i < lines.length && lines[i].strip.empty?
+        if img_line_index < lines.length && lines[img_line_index].match(/^\s*([*\/-]*)i\[([^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*?)\](@[a-zA-Z0-9_-]+)?([^\s\[\]=^]+)(?:=(\d+x\d+))?/)
+          img_match = lines[img_line_index].match(/^\s*([*\/-]*)i\[([^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*?)\](@[a-zA-Z0-9_-]+)?([^\s\[\]=^]+)(?:=(\d+x\d+))?/)
+          prefix, inner, url_prefix, src, dimensions = img_match[1], img_match[2], img_match[3], img_match[4], img_match[5]
+          sources = []
+          src_elements.each do |src_line|
+            src_match = src_line.match(/^\s*src\[([^\]]+)\](.+)$/)
+            condition, path_and_srcset = src_match[1], src_match[2].strip
+            local_url_prefix = url_prefix
+            if path_and_srcset.match(/^(@[a-zA-Z0-9_-]+)(.+)$/)
+              local_url_prefix = $1
+              path_and_srcset = $2
+            end
+            media_attr = parse_media_condition(condition)
+            if path_and_srcset.include?('|')
+              sources.concat(process_srcset_with_expansion(path_and_srcset.split('|').map(&:strip), media_attr, local_url_prefix, citations))
+            else
+              sources.concat(expand_source(path_and_srcset, media_attr, local_url_prefix, citations))
+            end
+          end
+          parts = inner.split('|', 2)
+          alt, title = parts[0] || "", parts[1]
+          full_src = resolve_image_src(src, url_prefix, citations)
+          img_attrs = "src=\"#{full_src}\" alt=\"#{escape_html_attr(alt)}\""
+          img_attrs += " title=\"#{escape_html_attr(title)}\"" if title && !title.empty?
+          img_attrs += " width=\"#{dimensions.split('x')[0]}\" height=\"#{dimensions.split('x')[1]}\"" if dimensions
+          picture_html = "<picture>\n#{sources.map { |s| "  #{s}" }.join("\n")}\n  <img #{img_attrs}>\n</picture>"
+          picture_html = apply_formatting_prefixes(picture_html, prefix)
+          placeholder = "PICTUREPLACEHOLDER#{@global_counters['PICTUREPLACEHOLDER']}END"
+          @global_counters['PICTUREPLACEHOLDER'] += 1
+          picture_cache[placeholder] = picture_html
+          result_lines << placeholder
+          i = img_line_index + 1
+        else
+          result_lines.concat(src_elements)
+          i = start_i + src_elements.length
+        end
+      else
+        result_lines << line
+        i += 1
+      end
+    end
+    text = result_lines.join("\n")
+    picture_cache.each { |placeholder, html| text = text.gsub(placeholder, html) }
+    text
+  end
+  def self.parse_media_condition(condition)
+    return "(min-width: #{$1}px)" if condition.match(/^>(\d+)px$/)
+    return "(max-width: #{$1}px)" if condition.match(/^<(\d+)px$/)
+    nil
+  end
+
+
+  def self.infer_type(extension)
+    MIME_TYPES[extension.downcase]
+  end
+  def self.build_source_tag(srcset, type_attr, media_attr)
+    attrs = ["srcset=\"#{srcset}\""]
+    attrs << "type=\"#{type_attr}\"" if type_attr
+    attrs << "media=\"#{media_attr}\"" if media_attr
+    "<source #{attrs.join(' ')}>"
+  end
+def self.process_images(content, citations, numbered_citations, recursive_processor = nil)
+  content.gsub(/([*\/-]*)i\[([^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*?)\](@[a-zA-Z0-9_-]+)?([^\n]+)/) do
+    prefix = $1
+    inner = $2
+    url_prefix = $3
+    remainder = $4.strip
+    
+    # Extract dimensions if present
+    dimensions = nil
+    if remainder =~ /(.+)=(\d+x\d+)$/
+      remainder = $1.strip
+      dimensions = $2
+    end
+    
+    # CHECK FOR JAVASCRIPT PROTOCOL IN IMAGE SRC
+    if remainder =~ /^javascript:/i
+      # Block javascript: protocol in images
+      next apply_formatting_prefixes("[IMAGE BLOCKED - UNSAFE PROTOCOL]", prefix)
+    end
+    
+    if remainder.include?('|')
+      srcset_items = remainder.split('|').map(&:strip)
+      first_src = srcset_items[0].gsub(/\s+\d+w$/, '') 
+      src_value = resolve_image_src(first_src, url_prefix, citations)
+      srcset_value = srcset_items.map { |item|
+        if item.match(/^([^\s]+)(?:\s+(\d+w))?$/)
+          path = $1
+          descriptor = $2
+          full_path = resolve_image_src(path, url_prefix, citations)
+          descriptor ? "#{full_path} #{descriptor}" : full_path
+        end
+      }.compact.join(', ')
+      
+      # ESCAPE THE IMAGE ATTRIBUTES (security fix)
+      parts = inner.split('|', 2)
+      alt = escape_html_content(parts[0] || "")
+      title = parts[1] ? escape_html_content(parts[1]) : nil
+      
+      img_attrs = %Q(src="#{src_value}" srcset="#{srcset_value}" alt="#{alt}")
+      img_attrs += %Q( title="#{title}") if title
+      img_attrs += %Q( width="#{dimensions.split('x')[0]}" height="#{dimensions.split('x')[1]}") if dimensions
+      apply_formatting_prefixes("<img #{img_attrs}>", prefix)
+    else
+      src = remainder
+      
+      # ESCAPE THE IMAGE ATTRIBUTES (security fix)
+      parts = inner.split('|', 2)
+      alt = escape_html_content(parts[0] || "")
+      title = parts[1] ? escape_html_content(parts[1]) : nil
+      
+      full_src = resolve_image_src(src, url_prefix, citations)
+      img_attrs = %Q(src="#{full_src}" alt="#{alt}")
+      img_attrs += %Q( title="#{title}") if title
+      img_attrs += %Q( width="#{dimensions.split('x')[0]}" height="#{dimensions.split('x')[1]}") if dimensions
+      apply_formatting_prefixes("<img #{img_attrs}>", prefix)
+    end
+  end
+end
+  def self.resolve_image_src(src, url_prefix, citations)
+    # Block dangerous protocols in images
+    if src =~ /^(javascript|data|vbscript):/i
+      return "[BLOCKED]"
+    end
+    
+    return src.start_with?('/') ? src[1..-1] : src unless url_prefix
+    prefix_id = url_prefix[1..-1]
+    return src.start_with?('/') ? src[1..-1] : src unless citations[prefix_id] && citations[prefix_id][:url]
+    
+    base_url = citations[prefix_id][:url]
+    
+    # Block dangerous protocols in citation URLs too
+    if base_url =~ /^(javascript|data|vbscript):/i
+      return "[BLOCKED]"
+    end
+    if base_url.end_with?('/') && src.start_with?('/')
+      base_url + src[1..-1]
+    elsif !base_url.end_with?('/') && !src.start_with?('/')
+        base_url + '/' + src
+    else
+        base_url + src
+    end
+  end
+  def self.process_images(content, citations, numbered_citations, recursive_processor = nil)
+    content.gsub(/([*\/-]*)i\[([^\[\]]*(?:\[[^\[\]]*\][^\[\]]*)*?)\](@[a-zA-Z0-9_-]+)?([^\n]+)/) do
+      prefix = $1
+      inner = $2
+      url_prefix = $3
+      remainder = $4.strip
+      dimensions = nil
+      if remainder =~ /(.+)=(\d+x\d+)$/
+        remainder = $1.strip
+        dimensions = $2
+      end
+      if remainder.include?('|')
+        srcset_items = remainder.split('|').map(&:strip)
+        first_src = srcset_items[0].gsub(/\s+\d+w$/, '') 
+        src_value = resolve_image_src(first_src, url_prefix, citations)
+        srcset_value = srcset_items.map { |item|
+          if item.match(/^([^\s]+)(?:\s+(\d+w))?$/)
+            path = $1
+            descriptor = $2
+            full_path = resolve_image_src(path, url_prefix, citations)
+            descriptor ? "#{full_path} #{descriptor}" : full_path
+          end
+        }.compact.join(', ')
+        parts = inner.split('|', 2)
+        alt = parts[0] || ""
+        title = parts[1]
+        img_attrs = %Q(src="#{src_value}" srcset="#{srcset_value}" alt="#{escape_html_attr(alt)}")
+        img_attrs += %Q( title="#{escape_html_attr(title)}") if title && !title.empty?
+        img_attrs += %Q( width="#{dimensions.split('x')[0]}" height="#{dimensions.split('x')[1]}") if dimensions
+        apply_formatting_prefixes("<img #{img_attrs}>", prefix)
+      else
+        src = remainder
+        parts = inner.split('|', 2)
+        alt = parts[0] || ""
+        title = parts[1]
+        full_src = resolve_image_src(src, url_prefix, citations)
+        img_attrs = %Q(src="#{full_src}" alt="#{escape_html_attr(alt)}")
+        img_attrs += %Q( title="#{escape_html_attr(title)}") if title && !title.empty?
+        img_attrs += %Q( width="#{dimensions.split('x')[0]}" height="#{dimensions.split('x')[1]}") if dimensions
+        apply_formatting_prefixes("<img #{img_attrs}>", prefix)
+      end
+    end
+  end
+end