gollum-lib 5.0.a.4-java → 5.0.1-java

data/lib/gollum-lib/file_view.rb

@@ -10,12 +10,13 @@ module Gollum
     # set pages to wiki.pages + wiki.files and show_all to true
     def initialize(pages, options = {})
       @pages    = pages
+      @wiki     = @pages.first ? @pages.first.wiki : nil
       @show_all = options[:show_all] || false
       @checked  = options[:collapse_tree] ? '' : "checked"
     end
 
     def enclose_tree(string)
-      %Q(<ol class="tree">\n) + string + %Q(</ol>)
+      sanitize_html(%Q(<ol class="tree">\n) + string + %Q(</ol>))
     end
 
     def new_page(page)
@@ -96,7 +97,7 @@ module Gollum
         </li>
         HTML
 
-        return enclose_tree html
+        return enclose_tree(html)
       end
 
       sorted_folders = []
@@ -153,8 +154,11 @@ module Gollum
         changed = false
       end
 
-      # return the completed html
-      enclose_tree html
+      enclose_tree(html)
     end # end render_files
+
+    def sanitize_html(data)
+      @wiki ? @wiki.sanitizer.clean(data) : data
+    end
   end # end FileView class
 end # end Gollum module

data/lib/gollum-lib/filter.rb

@@ -47,14 +47,21 @@ module Gollum
   class Filter
     include Gollum::Helpers
 
+    PLACEHOLDER_PATTERN = /%(\S+)%.+=\1=/
+
     # Setup the object.  Sets `@markup` to be the instance of Gollum::Markup that
     # is running this filter chain, and sets `@map` to be an empty hash (for use
     # in your extract/process operations).
+
     def initialize(markup)
       @markup = markup
       @map    = {}
+      @open_pattern = "%#{self.class.to_s.split('::').last}%"
+      @close_pattern = "=#{self.class.to_s.split('::').last}="
     end
 
+    attr_reader :open_pattern, :close_pattern
+
     def extract(data)
       raise RuntimeError,
             "#{self.class} has not implemented ##extract!"
@@ -66,6 +73,11 @@ module Gollum
     end
 
     protected
+
+    def sanitize(data)
+      @markup.wiki.sanitizer.clean(data, @markup.historical)
+    end
+
     # Render a (presumably) non-fatal error as HTML
     #
     def html_error(message)

data/lib/gollum-lib/filter/code.rb

@@ -14,31 +14,27 @@ class Gollum::Filter::Code < Gollum::Filter
       org_headers = %r{([ \t]*#\+HEADER[S]?:[^\r\n]*\n)*}
       org_name = %r{([ \t]*#\+NAME:[^\r\n]*\n)?}
       org_lang = %r{[ ]*([^\n \r]*)[ ]*[^\r\n]*}
-      org_begin = %r{[ \t]*#\+BEGIN_SRC#{org_lang}\n}
-      org_end = %r{\n[ \t]*#\+END_SRC[ \t]*}
+      org_begin = %r{([ \t]*)#\+BEGIN_SRC#{org_lang}\r?\n}
+      org_end = %r{\r?\n[ \t]*#\+END_SRC[ \t\r]*}
       data.gsub!(/^#{org_headers}#{org_name}#{org_begin}(.+?)#{org_end}$/mi) do
-        cache_codeblock(Regexp.last_match[3], Regexp.last_match[4])
+        "#{Regexp.last_match[3]}#{cache_codeblock(Regexp.last_match[4], Regexp.last_match[5])}"
       end
     when :markdown
-      data.gsub!(/^([ \t]*)(~~~+) ?([^\r\n]+)?\r?\n(.+?)\r?\n\1(~~~+)[ \t\r]*$/m) do
+      data.gsub!(/^([ ]{0,3})(~~~+) ?([^\r\n]+)?\r?\n(.+?)\r?\n[ ]{0,3}(~~~+)[ \t\r]*$/m) do
         m_indent = Regexp.last_match[1]
         m_start  = Regexp.last_match[2] # ~~~
         m_lang   = Regexp.last_match[3]
         m_code   = Regexp.last_match[4]
         m_end    = Regexp.last_match[5] # ~~~
-        # start and finish tilde fence must be the same length
-        next '' if m_start.length != m_end.length
-        lang = m_lang ? m_lang.strip : nil
-        if lang
-          lang = lang.match(/\.([^}\s]+)/)
-          lang = lang[1] unless lang.nil?
-        end
+        # The closing code fence must be at least as long as the opening fence
+        next '' if m_end.length < m_start.length
+        lang = m_lang ? m_lang.strip.split.first : nil
         "#{m_indent}#{cache_codeblock(lang, m_code, m_indent)}"
       end  
     end
     
 
-    data.gsub!(/^([ \t]*)``` ?([^\r\n]+)?\r?\n(.+?)\r?\n\1```[ \t]*\r?$/m) do
+    data.gsub!(/^([ ]{0,3})``` ?([^\r\n]+)?\r?\n(.+?)\r?\n[ ]{0,3}```[ \t]*\r?$/m) do
       "#{Regexp.last_match[1]}#{cache_codeblock(Regexp.last_match[2].to_s.strip, Regexp.last_match[3], Regexp.last_match[1])}" # print the SHA1 ID with the proper indentation
     end
     data
@@ -133,7 +129,7 @@ class Gollum::Filter::Code < Gollum::Filter
 
   def cache_codeblock(language, code, indent = "")
     language = language.to_s.empty? ? nil : language
-    id = Digest::SHA1.hexdigest("#{language}.#{code}")
+    id = "#{open_pattern}#{Digest::SHA1.hexdigest("#{language}.#{code}")}#{close_pattern}"
     cached = @markup.check_cache(:code, id)
     @map[id] = cached ?
       { :output => cached } :

data/lib/gollum-lib/filter/critic_markup.rb

@@ -0,0 +1,97 @@
+# ~*~ encoding: utf-8 ~*~
+
+# CriticMarkup
+#
+# Render CriticMarkup
+
+class Gollum::Filter::CriticMarkup < Gollum::Filter
+
+  # Patterns inspired by https://github.com/DivineDominion/criticmarkup.tmbundle/blob/master/Syntaxes/criticmarkup.tmLanguage
+  # All patterns use multiline matching (m flag)
+  # Logic inspired by https://github.com/CriticMarkup/CriticMarkup-toolkit/blob/master/CLI/criticParser_CLI.py
+  
+  ADDITION_PATTERN      = %r|{\+\+(?<content>.*?)\+\+[ \t]*(\[(.*?)\])?[ \t]*\}|m
+  DELETION_PATTERN      = %r|{--(?<content>.*?)--[ \t]*(\[(.*?)\])?[ \t]*\}|m
+  SUBSTITUTION_PATTERN  = %r|{~~(?<oldcontent>.*?)~>(?<newcontent>.*?)~~}|m
+  HIGHLIGHT_PATTERN     = %r|{\=\=(?<content>.*?)[ \t]*(\[(.*?)\])?[ \t]*\=\=\}{>>(?<comment>.*?)<<}|m
+  COMMENT_PATTERN       = %r|{>>(?<content>.*?)<<}|m
+
+  def extract(data)
+    data.gsub! ADDITION_PATTERN do
+      content = $~[:content]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+    	# Is there a new paragraph followed by new text
+      if content.start_with?("\n\n") && content != "\n\n"
+        html = "\n\n<ins class='critic break'>&nbsp;</ins>\n\n<ins>#{content.gsub('\n', ' ')}</ins>"
+    	# Is the addition just a single new paragraph
+      elsif content == "\n\n"
+        html = "\n\n<ins class='critic break'>&nbsp;</ins>\n\n"
+    	# Is it added text followed by a new paragraph?
+      elsif content.end_with?("\n\n") && content != "\n\n"
+  	    html = "<ins>#{content.gsub('\n', ' ')}</ins>\n\n<ins class='critic break'>&nbsp;</ins>\n\n"
+      else
+        html = "<ins>#{content.gsub('\n', ' ')}</ins>"
+      end
+      @map[placeholder] = html
+      placeholder
+    end
+    
+    data.gsub! DELETION_PATTERN do
+      content = $~[:content]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+      if content == "\n\n"
+        html = "<del>&nbsp;</del>"
+      else
+        html = "<del>#{content.gsub('\n\n', ' ')}</del>"
+      end
+      @map[placeholder] = html
+      placeholder
+    end   
+    
+    data.gsub! SUBSTITUTION_PATTERN do
+      oldcontent = $~[:oldcontent]
+      newcontent = $~[:newcontent]
+      placeholder = generate_placeholder("#{oldcontent}#{newcontent}#{@map.size}")
+      html = "<del>#{oldcontent}</del><ins>#{newcontent}</ins>"
+      @map[placeholder] = html
+      placeholder
+    end
+
+    data.gsub! HIGHLIGHT_PATTERN do
+      content = $~[:content]
+      comment = $~[:comment]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+      html = "<mark>#{content}</mark><span class='critic comment'>#{comment}</span>"
+      @map[placeholder] = html
+      placeholder
+    end
+    
+    data.gsub! COMMENT_PATTERN do
+      content = $~[:content]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+      html = "<span class='critic comment'>#{content}</span>"
+      @map[placeholder] = html
+      placeholder
+    end
+    
+    data
+  end
+
+  def process(data)
+    data.gsub! process_pattern do 
+      @map[$~[:placeholder]]
+    end
+    data
+  end
+
+  private
+
+  def process_pattern
+    /(?<placeholder>#{open_pattern}\h{40}#{close_pattern})/
+  end
+
+  def generate_placeholder(content)
+    "#{open_pattern}#{Digest::SHA1.hexdigest(content)}#{close_pattern}"
+  end
+
+end

data/lib/gollum-lib/filter/emoji.rb

@@ -14,17 +14,11 @@ class Gollum::Filter::Emoji < Gollum::Filter
     (?!\]{^2})
   }ix
 
-  PROCESS_PATTERN = %r{
-    =EEMMOOJJII=
-    (?<name>[\w-]+)
-    =IIJJOOMMEE=
-  }ix
-
   def extract(data)
     data.gsub! EXTRACT_PATTERN do
       case
         when $~[:escape] then $&[1..-1]
-        when emoji_exists?($~[:name]) then "=EEMMOOJJII=#{$~[:name]}=IIJJOOMMEE="
+        when emoji_exists?($~[:name]) then "#{open_pattern}#{$~[:name]}#{close_pattern}"
         else $&
       end
     end
@@ -32,12 +26,20 @@ class Gollum::Filter::Emoji < Gollum::Filter
   end
 
   def process(data)
-    data.gsub! PROCESS_PATTERN, %q(<img src="/emoji/\k<name>" alt="\k<name>" class="emoji">)
+    data.gsub! process_pattern, %q(<img src="/gollum/emoji/\k<name>" alt="\k<name>" class="emoji">)
     data
   end
 
   private
 
+  def process_pattern
+    %r{
+    #{open_pattern}
+    (?<name>[\w-]+)
+    #{close_pattern}
+  }ix
+  end
+
   def emoji_exists?(name)
     @index ||= Gemojione::Index.new
     !!@index.find_by_name(name)

data/lib/gollum-lib/filter/macro.rb

@@ -1,4 +1,5 @@
 # ~*~ encoding: utf-8 ~*~
+require 'octicons'
 
 # Replace specified tokens with dynamically generated content.
 class Gollum::Filter::Macro < Gollum::Filter
@@ -12,7 +13,7 @@ class Gollum::Filter::Macro < Gollum::Filter
 
     data.gsub(/('?)\<\<\s*([A-Z][A-Za-z0-9]*)\s*\(#{arg_list}\)\s*\>\>/) do
       next CGI.escape_html($&[1..-1]) unless Regexp.last_match[1].empty?
-      id = Digest::SHA1.hexdigest(Regexp.last_match[2] + Regexp.last_match[3])
+      id = "#{open_pattern}#{Digest::SHA1.hexdigest(Regexp.last_match[2] + Regexp.last_match[3])}#{close_pattern}"
       macro = Regexp.last_match[2]
       argstr = Regexp.last_match[3]
       args = []
@@ -47,7 +48,9 @@ class Gollum::Filter::Macro < Gollum::Filter
         begin
           Gollum::Macro.instance(macro, @markup.wiki, @markup.page).render(*args)
         rescue StandardError => e
-          "!!!Macro Error: #{e.message}!!!"
+          icon = Octicons::Octicon.new('zap', {width: 24, height: 24})
+          icon.options[:class] << ' mr-2'
+          "<div class='flash flash-error'>#{icon.to_svg}Macro Error for #{macro}: #{e.message}</div>"
         end
       end
     end

data/lib/gollum-lib/filter/plantuml.rb

@@ -70,7 +70,7 @@ class Gollum::Filter::PlantUML < Gollum::Filter
   # placeholders.
   def extract(data)
     data.gsub(/(@startuml\r?\n.+?\r?\n@enduml\r?$)/m) do
-      id       = Digest::SHA1.hexdigest($1)
+      id       = "#{open_pattern}#{Digest::SHA1.hexdigest($1)}#{close_pattern}"
       @map[id] = { :code => $1 }
       id
     end

data/lib/gollum-lib/filter/remote_code.rb

@@ -20,7 +20,7 @@ class Gollum::Filter::RemoteCode < Gollum::Filter
 
       # Detect local file
       if protocol.nil?
-        if (file = @markup.find_file(uri, @markup.wiki.ref))
+        if (file = @markup.wiki.file(uri, @markup.wiki.ref))
           contents = file.raw_data
         else
           # How do we communicate a render error?
@@ -45,7 +45,8 @@ class Gollum::Filter::RemoteCode < Gollum::Filter
     return "Too many redirects or retries" if cut >= 10
     http         = Net::HTTP.new uri.host, uri.port
     http.use_ssl = true
-    resp         = http.get uri.path, {
+    path         = uri.path.empty? ? '/' : uri.path
+    resp         = http.get path, {
         'Accept'        => 'text/plain',
         'Cache-Control' => 'no-cache',
         'Connection'    => 'keep-alive',

data/lib/gollum-lib/filter/render.rb

@@ -3,7 +3,11 @@
 class Gollum::Filter::Render < Gollum::Filter
   def extract(data)
     begin
-      data = GitHub::Markup.render(@markup.name, data)
+      working_dir = Pathname.new(@markup.wiki.path).join(@markup.dir)
+      working_dir = working_dir.exist? ? working_dir.to_s : '.'
+      Dir.chdir(working_dir) do
+        data = GitHub::Markup.render_s(@markup.format, data)
+      end
       if data.nil?
         raise "There was an error converting #{@markup.name} to HTML."
       end
@@ -15,6 +19,25 @@ class Gollum::Filter::Render < Gollum::Filter
   end
 
   def process(data)
+    data = add_editable_header_class(data)
     data
   end
-end
+
+  private
+
+  def add_editable_header_class(data)
+    doc = Nokogiri::HTML::DocumentFragment.parse(data)
+    doc.css('h1,h2,h3,h4,h5,h6').each_with_index do |header, i|
+      next if header.content.empty?
+      next if header.inner_html.match(PLACEHOLDER_PATTERN)
+      klass = header['class']
+      if klass
+        header['class'] = klass << ' editable'
+      else
+        header['class'] = 'editable'
+      end
+    end
+    doc.to_xml(@markup.class.to_xml_opts)
+  end
+
+end

data/lib/gollum-lib/filter/sanitize.rb

@@ -6,13 +6,6 @@ class Gollum::Filter::Sanitize < Gollum::Filter
   end
 
   def process(data)
-    if @markup.sanitize
-      doc = Nokogiri::HTML::DocumentFragment.parse(data)
-      doc = @markup.sanitize.clean_node!(doc)
-
-      doc.to_xml(@markup.to_xml_opts).gsub(/<p><\/p>/, '')
-    else
-      data
-    end
+    sanitize(data)
   end
 end

data/lib/gollum-lib/filter/tags.rb

@@ -34,7 +34,7 @@ class Gollum::Filter::Tags < Gollum::Filter
     doc.traverse do |node|
       if node.text? then
         content = node.content
-        content.gsub!(/TAG[a-f0-9]+TAG/) do |id|
+        content.gsub!(%r{#{open_pattern}[a-f0-9]+#{close_pattern}}) do |id|
           if (tag = @map[id]) then
             if is_preformatted?(node) then
               "[[#{tag}]]"
@@ -56,7 +56,7 @@ class Gollum::Filter::Tags < Gollum::Filter
   INCLUDE_TAG = 'include:'
 
   def register_tag(tag)
-    id       = "TAG#{Digest::SHA1.hexdigest(tag)}TAG"
+    id       = "#{open_pattern}#{Digest::SHA1.hexdigest(tag)}#{close_pattern}"
     @map[id] = tag
     id
   end
@@ -77,7 +77,6 @@ class Gollum::Filter::Tags < Gollum::Filter
     return generate_link('', nil, nil, :page_absent) if link_part.nil?
     img_args = extra ? [extra, link_part] : [link_part]
     mime = MIME::Types.type_for(::File.extname(img_args.first.to_s)).first
-
     result = if tag =~ /^_TOC_/
       %{[[#{tag}]]}
     elsif link_part =~ /^_$/
@@ -122,9 +121,9 @@ class Gollum::Filter::Tags < Gollum::Filter
     len = INCLUDE_TAG.length
     return html_error('Cannot process include directive: no page name given') if tag.length <= len
     page_name          = tag[len..-1]
-    resolved_page_name = ::File.expand_path(page_name, "#{::File::SEPARATOR}#{@markup.dir}")
+    resolved_page_name = ::File.join(@markup.dir, page_name)
     if @markup.include_levels > 0
-      page = find_page_from_path(resolved_page_name)
+      page = find_page_or_file_from_path(resolved_page_name)
       if page
         page.formatted_data(@markup.encoding, @markup.include_levels-1)
       else
@@ -146,8 +145,8 @@ class Gollum::Filter::Tags < Gollum::Filter
     opts = parse_image_tag_options(options)
     if path =~ /^https?:\/\/.+$/i
       generate_image(path, opts)
-    elsif file = @markup.find_file(path)
-      generate_image(generate_href_for_path(file.path), opts)
+    elsif file = find_page_or_file_from_path(path, :file)
+      generate_image(generate_href_for_path(file.url_path), opts)
     else
       generate_image('', opts)
     end
@@ -173,14 +172,8 @@ class Gollum::Filter::Tags < Gollum::Filter
   # Return the String HTML if the tag is a valid external link tag or
   # nil if it is not.
   def process_external_link_tag(url, pretty_name = nil)
-    accepted_protocols = @markup.wiki.sanitization.protocols['a']['href'].dup
-    if accepted_protocols.include?(:relative)
-      accepted_protocols.select!{|protocol| protocol != :relative}
-      regexp = %r{^((#{accepted_protocols.join("|")}):)?(//)}
-    else
-      regexp = %r{^((#{accepted_protocols.join("|")}):)}
-    end
-    if url =~ regexp
+    @accepted_protocols_regex ||= %r{^((#{::Gollum::Sanitization.accepted_protocols.join('|')}):)?(//)} 
+    if url =~ @accepted_protocols_regex
       generate_link(url, pretty_name, nil, :external)
     else
       nil
@@ -195,8 +188,9 @@ class Gollum::Filter::Tags < Gollum::Filter
   # Returns the String HTML if the tag is a valid file link tag or nil
   #   if it is not.
   def process_file_link_tag(link_part, pretty_name)
-    if file = @markup.find_file(link_part)
-      generate_link(file.path, pretty_name, nil, :file)
+    return nil if ::Gollum::Page.valid_extension?(link_part)
+    if file = find_page_or_file_from_path(link_part, :file)
+      generate_link(file.url_path, pretty_name, nil, :file)
     else
       nil
     end
@@ -212,18 +206,31 @@ class Gollum::Filter::Tags < Gollum::Filter
   def process_page_link_tag(link_part, pretty_name = nil)
     presence  = :page_absent
     link      = link_part
-    page      = find_page_from_path(link)
+    page      = find_page_or_file_from_path(link)
 
     # If no match yet, try finding page with anchor removed
-    if (page.nil? && pos = link.rindex('#'))
-      extra     = link[pos..-1]
-      link      = link[0...pos]
-      page      = find_page_from_path(link)
-    end
-    presence  = :page_present if page
+    if page.nil?
+      if pos = link.rindex('#')
+        extra = link[pos..-1]
+        link  = link[0...pos]
+      else
+        extra = nil
+      end
+
+      if link.empty? && extra # Internal anchor link, don't search for the page but return immediately
+        return generate_link(nil, pretty_name, extra, :internal_anchor)
+      end
 
-    name = pretty_name ? pretty_name : link
-    link = page ? page.escaped_url_path : CGI.escape(link)
+      page  = find_page_or_file_from_path(link)
+    end
+    presence = :page_present if page
+    
+    if pretty_name
+      name = pretty_name
+    else
+      name = page ? path_to_link_text(link) : link
+    end
+    link = page ? page.escaped_url_path : ERB::Util.url_encode(link).force_encoding('utf-8')
     generate_link(link, name, extra, presence)
   end
 
@@ -232,15 +239,15 @@ class Gollum::Filter::Tags < Gollum::Filter
   # path - The String path to search for.
   #
   # Returns a Gollum::Page instance if a page is found, or nil otherwise
-  def find_page_from_path(path)
-    slash = path.rindex('/')
-
-    unless slash.nil?
-      name = path[slash+1..-1]
-      path = path[0..slash]
-      @markup.wiki.paged(name, path)
+  def find_page_or_file_from_path(path, kind = :page)
+    if Pathname.new(path).relative?
+      result = @markup.wiki.send(kind, ::File.join(@markup.dir, path))
+      if result.nil? && @markup.wiki.global_tag_lookup # 4.x link compatibility option. Slow!
+        result = @markup.wiki.send(kind, path, nil, true)
+      end
+      result
     else
-      @markup.wiki.page(path)
+      @markup.wiki.send(kind, path)
     end
   end
 
@@ -264,7 +271,8 @@ class Gollum::Filter::Tags < Gollum::Filter
   #
   # Returns a String href.
   def generate_href_for_path(path, extra = nil)
-   "#{trim_leading_slash(::File.join(@markup.wiki.base_path, path))}#{extra}"
+    return extra if !path && extra # Internal anchor link
+    "#{trim_leading_slashes(::File.join(@markup.wiki.base_path, path))}#{extra}"
   end
 
   # Construct a CSS class and attribute string for different kinds of links: internal Pages (absent or present) and Files, and External links.
@@ -278,6 +286,8 @@ class Gollum::Filter::Tags < Gollum::Filter
       'class="internal absent"'
     when :page_present
       'class="internal present"'
+    when :internal_anchor
+      'class="internal anchorlink"'
     when :file
       nil
     when :external
@@ -299,10 +309,10 @@ class Gollum::Filter::Tags < Gollum::Filter
     attr_string = attrs.map {|key, value| "#{key}=\"#{value}\""}.join(' ')
 
     if containered
-      %{<span class="#{classes.join(' ')}">} +
-          %{<span>} +
+      %{<span class="d-flex #{classes[:container].join(' ')}">} +
+          %{<span class="#{classes[:nested].join(' ')}">} +
           %{<img src="#{path}" #{attr_string}/>} +
-          (attrs[:alt] ? %{<span>#{attrs[:alt]}</span>} : '') +
+          (options[:frame] && attrs[:alt] ? %{<span class="clearfix">#{attrs[:alt]}</span>} : '') +
           %{</span>} +
           %{</span>}
     else
@@ -314,31 +324,31 @@ class Gollum::Filter::Tags < Gollum::Filter
   #
   # options  - The Hash of parsed image options.
   #
-  # Returns an Array of CSS classes, a Hash of CSS attributes, and a Boolean indicating whether or not the image is containered.
+  # Returns a Hash containing CSS class Arrays, a Hash of CSS attributes, and a Boolean indicating whether or not the image is containered.
   def generate_image_attributes(options)
     containered = false
-    classes = [] # applied to whatever the outermost container is
+    classes = {container: [], nested: []} # applied to the container(s)
     attrs   = {} # applied to the image
 
     align = options[:align]
     if options[:float]
       containered = true
-      align       ||= 'left'
-      if %w{left right}.include?(align)
-        classes << "float-#{align}"
-      end
+      align = 'left' unless align == 'right'
+      classes[:container] << "float-#{align} pb-4"
     elsif %w{top texttop middle absmiddle bottom absbottom baseline}.include?(align)
       attrs[:align] = align
     elsif align
       if %w{left center right}.include?(align)
         containered = true
-        classes << "align-#{align}"
+        text_align = "text-#{align}"
+        align = 'end' if align == 'right'
+        classes[:container] << "flex-justify-#{align} #{text_align}"
       end
     end
 
-    if options[:frame]
+    if options[:frame] 
       containered = true
-      classes << 'frame'
+      classes[:nested] << 'border p-4'
     end
 
     attrs[:alt]    = options[:alt]    if options[:alt]