gitlab-gollum-lib 1.1.0 → 4.2.7

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

@@ -0,0 +1,39 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Emoji
+#
+# Render emoji such as :smile:
+class Gollum::Filter::Emoji < Gollum::Filter
+
+  EXTRACT_PATTERN = %r{
+    (?<!\[{2})
+    :(?<name>[\w-]+):
+    (?!\]{^2})
+  }ix
+
+  PROCESS_PATTERN = %r{
+    =EEMMOOJJII=
+    (?<name>[\w-]+)
+    =IIJJOOMMEE=
+  }ix
+
+  def extract(data)
+    data.gsub! EXTRACT_PATTERN do
+      emoji_exists?($~[:name]) ? "=EEMMOOJJII=#{$~[:name]}=IIJJOOMMEE=" : $&
+    end
+    data
+  end
+
+  def process(data)
+    data.gsub! PROCESS_PATTERN, %q(<img src="/emoji/\k<name>" alt="\k<name>" class="emoji">)
+    data
+  end
+
+  private
+
+  def emoji_exists?(name)
+    @index ||= Gemojione::Index.new
+    !!@index.find_by_name(name)
+  end
+
+end

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

@@ -0,0 +1,57 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Replace specified tokens with dynamically generated content.
+class Gollum::Filter::Macro < Gollum::Filter
+  def extract(data)
+    quoted_arg   = %r{".*?"}
+    unquoted_arg = %r{[^,)]+}
+    named_arg    = %r{[a-z0-9_]+=".*?"}
+    
+    arg = %r{(?:#{quoted_arg}|#{unquoted_arg}|#{named_arg})}
+    arg_list = %r{(\s*|#{arg}(?:\s*,\s*#{arg})*)}
+
+    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])
+      macro = Regexp.last_match[2]
+      argstr = Regexp.last_match[3]
+      args = []
+      opts = {}
+      
+      argstr.scan(/,?\s*(#{arg})\s*/) do |arguments|
+      	# Stabstabstab
+      	argument = arguments.first
+      	
+        if argument =~ /^([a-z0-9_]+)="(.*?)"/
+      		opts[Regexp.last_match[1]] = Regexp.last_match[2]
+			  elsif argument =~ /^"(.*)"$/
+      		args << Regexp.last_match[1]
+			  else
+				  args << argument
+        end
+      end
+		  
+		  args << opts unless opts.empty?
+      
+      @map[id] = { :macro => macro, :args => args }
+      id
+    end
+  end
+
+  def process(data)
+    @map.each do |id, spec|
+      macro = spec[:macro]
+      args  = spec[:args]
+
+      data.gsub!(id) do
+        begin
+          Gollum::Macro.instance(macro, @markup.wiki, @markup.page).render(*args)
+        rescue StandardError => e
+          "!!!Macro Error: #{e.message}!!!"
+        end
+      end
+    end
+
+    data
+  end
+end

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

@@ -0,0 +1,29 @@
+# Extract metadata for data and build metadata table.  Metadata consists of
+# key/value pairs in "key:value" format found between markers.  Each
+# key/value pair must be on its own line.  Internal whitespace in keys and
+# values is preserved, but external whitespace is ignored.
+#
+# Because ri and ruby 1.8.7 are awesome, the markers can't
+# be included in this documentation without triggering
+# `Unhandled special: Special: type=17`
+# Please read the source code for the exact markers
+class Gollum::Filter::Metadata < Gollum::Filter
+  def extract(data)
+    # The markers are `<!-- ---` and `-->`
+    data.gsub(/\<\!--+\s+---(.*?)--+\>/m) do
+      @markup.metadata ||= {}
+      # Split untrusted input on newlines, then remove bits that look like
+      # HTML elements before parsing each line.
+      Regexp.last_match[1].split("\n").each do |line|
+        line.gsub!(/<[^>]*>/, '')
+        k, v                      = line.split(':', 2)
+        @markup.metadata[k.strip] = (v ? v.strip : '') if k
+      end
+      ''
+    end
+  end
+
+  def process(data)
+    data
+  end
+end

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

@@ -0,0 +1,16 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Plain Text
+#
+# Render plain text documents in a <pre> block without any special markup.
+
+class Gollum::Filter::PlainText < Gollum::Filter
+
+  def extract(data)
+    @markup.format == :txt ? "<pre>#{CGI.escapeHTML(data)}</pre>" : data
+  end
+
+  def process(data)
+    data
+  end
+end

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

@@ -0,0 +1,176 @@
+# ~*~ encoding: utf-8 ~*~
+require 'net/http'
+require 'uri'
+require 'open-uri'
+require 'zlib'
+
+# PlantUML Diagrams
+#
+# This filter replaces PlantUML blocks with HTML img tags. These img tags
+# point to a PlantUML web service that converts the UML text blocks into nice
+# diagrams.
+#
+# For this to work you must have your own PlantUML server running somewhere.
+# Just follow the instructions on the github page to run your own server:
+#
+#   https://github.com/plantuml/plantuml-server
+#
+# Once you start you own plantuml server you need to configure this filter to
+# point to it:
+#
+#   Gollum::Filter::PlantUML.configure do |config|
+#     config.url = "http://localhost:8080/plantuml/png"
+#   end
+#
+# Then in your wiki pages simply add PlantUML blocks anywhere you want a
+# diagram:
+#
+#     @startuml
+#     Alice -> Bob: Authentication Request
+#     Bob --> Alice: Authentication Response
+#     Alice -> Bob: Another authentication Request
+#     Alice <-- Bob: another authentication Response
+#     @enduml
+#
+# To learn more about how to create cool PlantUML diagrams check the examples
+# at: http://plantuml.sourceforge.net/
+#
+class Gollum::Filter::PlantUML < Gollum::Filter
+
+  DEFAULT_URL = "http://localhost:8080/plantuml/png"
+
+  # Configuration class used to change the behaviour of the PlatnUML filter.
+  #
+  #   url: PlantUML server URL (e.g. http://localhost:8080)
+  #   test: Set to true when running tests to skip the server check.
+  #
+  class Configuration
+    attr_accessor :url, :test, :verify_ssl
+
+    def initialize
+      @url = DEFAULT_URL
+      @verify_ssl = true
+      @test = false
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  # Extract all sequence diagram blocks into the map and replace with
+  # placeholders.
+  def extract(data)
+    return data if @markup.format == :txt
+    data.gsub(/(@startuml\r?\n.+?\r?\n@enduml\r?$)/m) do
+      id       = Digest::SHA1.hexdigest($1)
+      @map[id] = { :code => $1 }
+      id
+    end
+  end
+
+  # Process all diagrams from the map and replace the placeholders with
+  # the final HTML.
+  def process(data)
+    @map.each do |id, spec|
+      data.gsub!(id) do
+        render_plantuml(id, spec[:code])
+      end
+    end
+    data
+  end
+
+  private
+
+  def server_url
+    PlantUML::configuration.url
+  end
+
+  def test?
+    PlantUML::configuration.test
+  end
+
+  def verify_ssl?
+    PlantUML::configuration.verify_ssl
+  end
+
+  def render_plantuml(id, code)
+    if check_server
+      plantuml_url = gen_url(code)
+      "<img src=\"#{gen_url(code)}\" />"
+    else
+      html_error("Sorry, unable to render PlantUML diagram at this time")
+    end
+  end
+
+  # Compression code used to generate PlantUML URLs. Taken directly from the
+  # Transcoder class in the PlantUML java code.
+  def gen_url(text)
+    result = ""
+    compressedData = Zlib::Deflate.deflate(text)
+    compressedData.chars.each_slice(3) do |bytes|
+      #print bytes[0], ' ' , bytes[1] , ' ' , bytes[2]
+      b1 = bytes[0].nil? ? 0 : (bytes[0].ord & 0xFF)
+      b2 = bytes[1].nil? ? 0 : (bytes[1].ord & 0xFF)
+      b3 = bytes[2].nil? ? 0 : (bytes[2].ord & 0xFF)
+      result += append3bytes(b1, b2, b3)
+    end
+    "#{server_url}/#{result}"
+  end
+
+  def encode6bit(b)
+    if b < 10
+      return ('0'.ord + b).chr
+    end
+    b = b - 10
+    if b < 26
+      return ('A'.ord + b).chr
+    end
+    b = b - 26
+    if b < 26
+      return ('a'.ord + b).chr
+    end
+    b = b - 26
+    if b == 0
+      return '-'
+    end
+    if b == 1
+      return '_'
+    end
+    return '?'
+  end
+
+  def append3bytes(b1, b2, b3)
+    c1 = b1 >> 2
+    c2 = ((b1 & 0x3) << 4) | (b2 >> 4)
+    c3 = ((b2 & 0xF) << 2) | (b3 >> 6)
+    c4 = b3 & 0x3F
+    return encode6bit(c1 & 0x3F).chr +
+           encode6bit(c2 & 0x3F).chr +
+           encode6bit(c3 & 0x3F).chr +
+           encode6bit(c4 & 0x3F).chr
+  end
+
+  # Make a call to the PlantUML server with the simplest diagram possible to
+  # check if the server is available or not.
+  def check_server
+    return true if test?
+    check_url = "#{server_url}/SyfFKj2rKt3CoKnELR1Io4ZDoSa70000"
+    uri = URI.parse(check_url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true if uri.scheme == 'https'
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless verify_ssl?
+    response = http.request_get(uri.request_uri)
+    return response.is_a?(Net::HTTPSuccess)
+  rescue
+    return false
+  end
+end

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

@@ -0,0 +1,63 @@
+# ~*~ encoding: utf-8 ~*~
+require 'net/http'
+require 'net/https' # ruby 1.8.7 fix, remove at upgrade
+require 'uri'
+require 'open-uri'
+
+# Remote code - fetch code from url and replace the contents to a
+#               code-block that gets run the next parse.
+#           Acceptable formats:
+#              ```language:local-file.ext```
+#              ```language:/abs/other-file.ext```
+#              ```language:https://example.com/somefile.txt```
+#
+class Gollum::Filter::RemoteCode < Gollum::Filter
+  def extract(data)
+    return data if @markup.format == :txt
+    data.gsub(/^[ \t]*``` ?([^:\n\r]+):((http)?[^`\n\r]+)```/) do
+      language = Regexp.last_match[1]
+      uri      = Regexp.last_match[2]
+      protocol = Regexp.last_match[3]
+
+      # Detect local file
+      if protocol.nil?
+        if (file = @markup.find_file(uri, @markup.wiki.ref))
+          contents = file.raw_data
+        else
+          # How do we communicate a render error?
+          next html_error("File not found: #{CGI::escapeHTML(uri)}")
+        end
+      else
+        contents = req(uri)
+      end
+
+      "```#{language}\n#{contents}\n```\n"
+    end
+  end
+
+  def process(data)
+    data
+  end
+
+  private
+
+  def req(uri, cut = 1)
+    uri = URI(uri)
+    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, {
+        'Accept'        => 'text/plain',
+        'Cache-Control' => 'no-cache',
+        'Connection'    => 'keep-alive',
+        'User-Agent'    => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0'
+    }
+    code         = resp.code.to_i
+    return resp.body if code == 200
+    return "Not Found" if code == 404
+    return "Unhandled Response Code #{code}" unless code == 304 or not resp.header['location'].nil?
+    loc  = URI.parse resp.header['location']
+    uri2 = loc.relative? ? (uri + loc) : loc # overloads (+)
+    req uri2, (cut + 1)
+  end
+end

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

@@ -0,0 +1,20 @@
+# ~*~ encoding: utf-8 ~*~
+
+class Gollum::Filter::Render < Gollum::Filter
+  def extract(data)
+    begin
+      data = GitHub::Markup.render(@markup.name, data)
+      if data.nil?
+        raise "There was an error converting #{@markup.name} to HTML."
+      end
+    rescue Object => e
+      data = html_error("Failed to render page: #{e.message}")
+    end
+
+    data
+  end
+
+  def process(data)
+    data
+  end
+end

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

@@ -0,0 +1,18 @@
+# ~*~ encoding: utf-8 ~*~
+
+class Gollum::Filter::Sanitize < Gollum::Filter
+  def extract(data)
+    data
+  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)
+    else
+      data
+    end
+  end
+end

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

@@ -0,0 +1,327 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Render all tags (things in double-square-brackets).  This one's a biggie.
+class Gollum::Filter::Tags < Gollum::Filter
+  # Extract all tags into the tagmap and replace with placeholders.
+  def extract(data)
+    return data if @markup.format == :txt || @markup.format == :asciidoc
+    data.gsub!(/(.?)\[\[(.+?)\]\]([^\[]?)/m) do
+      if Regexp.last_match[1] == "'" && Regexp.last_match[3] != "'"
+        "[[#{Regexp.last_match[2]}]]#{Regexp.last_match[3]}"
+      elsif Regexp.last_match[2].include?('][')
+        if Regexp.last_match[2][0..4] == 'file:'
+          pre            = Regexp.last_match[1]
+          post           = Regexp.last_match[3]
+          parts          = Regexp.last_match[2].split('][')
+          parts[0][0..4] = ""
+          link           = "#{parts[1]}|#{parts[0].sub(/\.org/, '')}"
+          id             = register_tag(link)
+          "#{pre}#{id}#{post}"
+        else
+          Regexp.last_match[0]
+        end
+      else
+        id = register_tag(Regexp.last_match[2])
+        "#{Regexp.last_match[1]}#{id}#{Regexp.last_match[3]}"
+      end
+    end
+    data
+  end
+
+  def register_tag(tag)
+    id       = "TAG#{Digest::SHA1.hexdigest(tag)}TAG"
+    @map[id] = tag
+    id
+  end
+
+  # Process all text nodes from the doc and replace the placeholders with the
+  # final markup.
+  def process(rendered_data)
+    doc  = Nokogiri::HTML::DocumentFragment.parse(rendered_data)
+    doc.traverse do |node|
+      if node.text? then
+        content = node.content
+        content.gsub!(/TAG[a-f0-9]+TAG/) do |id|
+          if (tag = @map[id]) then
+            if is_preformatted?(node) then
+              "[[#{tag}]]"
+            else
+              process_tag(tag).gsub('%2f', '/')
+            end
+          end
+        end
+        node.replace(content) if content != node.content
+      end
+    end
+
+    doc.to_html
+  end
+
+  private
+
+  PREFORMATTED_TAGS = %w(code tt)
+
+  def is_preformatted?(node)
+    node && (PREFORMATTED_TAGS.include?(node.name) ||
+        node.ancestors.any? { |a| PREFORMATTED_TAGS.include?(a.name) })
+  end
+
+  # Process a single tag into its final HTML form.
+  #
+  # tag       - The String tag contents (the stuff inside the double
+  #             brackets).
+  #
+  # Returns the String HTML version of the tag.
+  def process_tag(tag)
+    if tag =~ /^_TOC_/
+      %{[[#{tag}]]}
+    elsif tag =~ /^_$/
+      %{<div class="clearfloats"></div>}
+    elsif (html = process_include_tag(tag))
+      html
+    elsif (html = process_image_tag(tag))
+      html
+    elsif (html = process_external_link_tag(tag))
+      html
+    elsif (html = process_file_link_tag(tag))
+      html
+    else
+      process_page_link_tag(tag)
+    end
+  end
+
+  # Attempt to process the tag as an include tag
+  #
+  # tag - The String tag contents (the  stuff inside the double brackets).
+  #
+  # Returns the String HTML if the tag is a valid image tag or nil
+  #   if it is not.
+  #
+  def process_include_tag(tag)
+    return unless /^include:/.match(tag)
+    page_name          = tag[8..-1]
+    resolved_page_name = ::File.expand_path(page_name, "/"+@markup.dir)
+
+    if @markup.include_levels > 0
+      page = find_page_from_name(resolved_page_name)
+      if page
+        page.formatted_data(@markup.encoding, @markup.include_levels-1)
+      else
+        html_error("Cannot include #{process_page_link_tag(resolved_page_name)} - does not exist yet")
+      end
+    else
+      html_error("Too many levels of included pages, will not include #{process_page_link_tag(resolved_page_name)}")
+    end
+  end
+
+  # Attempt to process the tag as an image tag.
+  #
+  # tag - The String tag contents (the stuff inside the double brackets).
+  #
+  # Returns the String HTML if the tag is a valid image tag or nil
+  #   if it is not.
+  def process_image_tag(tag)
+    parts = tag.split('|')
+    return if parts.size.zero?
+
+    name = parts[0].strip
+    if (file = @markup.find_file(name))
+      path = ::File.join @markup.wiki.base_path, file.path
+    elsif name =~ /^https?:\/\/.+(jpg|png|gif|svg|bmp)$/i
+      path = name
+    elsif name =~ /.+(jpg|png|gif|svg|bmp)$/i
+      # If is image, file not found and no link, then populate with empty String
+      # We can than add an image not found alt attribute for this later
+      path = ""
+    end
+
+    if path
+      opts = parse_image_tag_options(tag)
+
+      containered = false
+
+      classes = [] # applied to whatever the outermost container is
+      attrs   = [] # applied to the image
+
+      align = opts['align']
+      if opts['float']
+        containered = true
+        align       ||= 'left'
+        if %w{left right}.include?(align)
+          classes << "float-#{align}"
+        end
+      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}"
+        end
+      end
+
+      if (width = opts['width'])
+        if width =~ /^\d+(\.\d+)?(em|px)$/
+          attrs << %{width="#{width}"}
+        end
+      end
+
+      if (height = opts['height'])
+        if height =~ /^\d+(\.\d+)?(em|px)$/
+          attrs << %{height="#{height}"}
+        end
+      end
+
+      if path != "" && (alt = opts['alt'])
+        attrs << %{alt="#{alt}"}
+      elsif path == ""
+        attrs << %{alt="Image not found"}
+      end
+
+      attr_string = attrs.size > 0 ? attrs.join(' ') + ' ' : ''
+
+      if opts['frame'] || containered
+        classes << 'frame' if opts['frame']
+        %{<span class="#{classes.join(' ')}">} +
+            %{<span>} +
+            %{<img src="#{path}" #{attr_string}/>} +
+            (alt ? %{<span>#{alt}</span>} : '') +
+            %{</span>} +
+            %{</span>}
+      else
+        %{<img src="#{path}" #{attr_string}/>}
+      end
+    end
+  end
+
+  # Parse any options present on the image tag and extract them into a
+  # Hash of option names and values.
+  #
+  # tag - The String tag contents (the stuff inside the double brackets).
+  #
+  # Returns the options Hash:
+  #   key - The String option name.
+  #   val - The String option value or true if it is a binary option.
+  def parse_image_tag_options(tag)
+    tag.split('|')[1..-1].inject({}) do |memo, attr|
+      parts          = attr.split('=').map { |x| x.strip }
+      memo[parts[0]] = (parts.size == 1 ? true : parts[1])
+      memo
+    end
+  end
+
+  # Return the String HTML if the tag is a valid external link tag or
+  # nil if it is not.
+  def process_external_link_tag(tag)
+    parts = tag.split('|')
+    parts.reverse! if @markup.reverse_links?
+    return if parts.size.zero?
+    if parts.size == 1
+      url = parts[0].strip
+    else
+      name, url = *parts.compact.map(&:strip)
+    end
+    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
+      if name.nil?
+        %{<a href="#{url}">#{url}</a>}
+      else
+        %{<a href="#{url}">#{name}</a>}
+      end
+    else
+      nil
+    end
+
+  end
+
+  # Attempt to process the tag as a file link tag.
+  #
+  # tag       - The String tag contents (the stuff inside the double
+  #             brackets).
+  #
+  # Returns the String HTML if the tag is a valid file link tag or nil
+  #   if it is not.
+  def process_file_link_tag(tag)
+    parts = tag.split('|')
+    return if parts.size.zero?
+
+    name = parts[0].strip
+    path = parts[1] && parts[1].strip
+    if path && file = @markup.find_file(path)
+      path = ::File.join @markup.wiki.base_path, file.path
+    else
+      path = nil
+    end
+
+    if name && path && file
+      %{<a href="#{::File.join @markup.wiki.base_path, file.path}">#{name}</a>}
+    elsif name && path
+      %{<a href="#{path}">#{name}</a>}
+    else
+      nil
+    end
+  end
+
+  # Attempt to process the tag as a page link tag.
+  #
+  # tag       - The String tag contents (the stuff inside the double
+  #             brackets).
+  #
+  # Returns the String HTML if the tag is a valid page link tag or nil
+  #   if it is not.
+  def process_page_link_tag(tag)
+    parts = tag.split('|')
+    parts.reverse! if @markup.reverse_links?
+
+    name, page_name = *parts.compact.map(&:strip)
+    cname           = @markup.wiki.page_class.cname(page_name || name)
+
+    presence    = "absent"
+    link_name   = cname
+    page, extra = find_page_from_name(cname)
+    if page
+      link_name = @markup.wiki.page_class.cname(page.name)
+      presence  = "present"
+    end
+    link = ::File.join(@markup.wiki.base_path, page ? page.escaped_url_path : CGI.escape(link_name))
+
+    # //page is invalid
+    # strip all duplicate forward slashes using helpers.rb trim_leading_slash
+    # //page => /page
+    link = trim_leading_slash link
+
+    %{<a class="internal #{presence}" href="#{link}#{extra}">#{name}</a>}
+  end
+
+  # Find a page from a given cname.  If the page has an anchor (#) and has
+  # no match, strip the anchor and try again.
+  #
+  # cname - The String canonical page name including path.
+  #
+  # Returns a Gollum::Page instance if a page is found, or an Array of
+  # [Gollum::Page, String extra] if a page without the extra anchor data
+  # is found.
+  def find_page_from_name(cname)
+    slash = cname.rindex('/')
+
+    unless slash.nil?
+      name = cname[slash+1..-1]
+      path = cname[0..slash]
+      page = @markup.wiki.paged(name, path)
+    else
+      page = @markup.wiki.paged(cname, '/') || @markup.wiki.page(cname)
+    end
+
+    if page
+      return page
+    end
+    if (pos = cname.index('#'))
+      [@markup.wiki.page(cname[0...pos]), cname[pos..-1]]
+    end
+  end
+end