gollum-lib 4.0.3 → 4.1.0

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

@@ -0,0 +1,167 @@
+# ~*~ 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
+
+    def initialize
+      @url = DEFAULT_URL
+      @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 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"
+    response = Net::HTTP.get_response(URI(check_url))
+    return response.is_a?(Net::HTTPSuccess)
+  rescue
+    return false
+  end
+end

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

@@ -14,14 +14,14 @@ require 'open-uri'
 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 = $1
-      uri      = $2
-      protocol = $3
+    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)
+        if (file = @markup.find_file(uri, @markup.wiki.ref))
           contents = file.raw_data
         else
           # How do we communicate a render error?
@@ -35,13 +35,13 @@ class Gollum::Filter::RemoteCode < Gollum::Filter
     end
   end
 
-  def process(d)
-    d
+  def process(data)
+    data
   end
 
   private
 
-  def req uri, cut = 1
+  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

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

@@ -14,7 +14,7 @@ class Gollum::Filter::Render < Gollum::Filter
     data
   end
 
-  def process(d)
-    d
+  def process(data)
+    data
   end
 end

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

@@ -1,8 +1,8 @@
 # ~*~ encoding: utf-8 ~*~
 
 class Gollum::Filter::Sanitize < Gollum::Filter
-  def extract(d)
-    d
+  def extract(data)
+    data
   end
 
   def process(data)

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

@@ -6,23 +6,23 @@ class Gollum::Filter::Tags < Gollum::Filter
   def extract(data)
     return data if @markup.format == :txt || @markup.format == :asciidoc
     data.gsub!(/(.?)\[\[(.+?)\]\]([^\[]?)/m) do
-      if $1 == "'" && $3 != "'"
-        "[[#{$2}]]#{$3}"
-      elsif $2.include?('][')
-        if $2[0..4] == 'file:'
-          pre            = $1
-          post           = $3
-          parts          = $2.split('][')
+      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($2)
-        "#{$1}#{id}#{$3}"
+        id = register_tag(Regexp.last_match[2])
+        "#{Regexp.last_match[1]}#{id}#{Regexp.last_match[3]}"
       end
     end
     data
@@ -42,7 +42,7 @@ class Gollum::Filter::Tags < Gollum::Filter
       if node.text? then
         content = node.content
         content.gsub!(/TAG[a-f0-9]+TAG/) do |id|
-          if tag = @map[id] then
+          if (tag = @map[id]) then
             if is_preformatted?(node) then
               "[[#{tag}]]"
             else
@@ -77,13 +77,13 @@ class Gollum::Filter::Tags < Gollum::Filter
       %{[[#{tag}]]}
     elsif tag =~ /^_$/
       %{<div class="clearfloats"></div>}
-    elsif html = process_include_tag(tag)
+    elsif (html = process_include_tag(tag))
       html
-    elsif html = process_image_tag(tag)
+    elsif (html = process_image_tag(tag))
       html
-    elsif html = process_external_link_tag(tag)
+    elsif (html = process_external_link_tag(tag))
       html
-    elsif html = process_file_link_tag(tag)
+    elsif (html = process_file_link_tag(tag))
       html
     else
       process_page_link_tag(tag)
@@ -125,11 +125,11 @@ class Gollum::Filter::Tags < Gollum::Filter
     return if parts.size.zero?
 
     name = parts[0].strip
-    path = if file = @markup.find_file(name)
-             ::File.join @markup.wiki.base_path, file.path
-           elsif name =~ /^https?:\/\/.+(jpg|png|gif|svg|bmp)$/i
-             name
-           end
+    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
+    end
 
     if path
       opts = parse_image_tag_options(tag)
@@ -155,19 +155,19 @@ class Gollum::Filter::Tags < Gollum::Filter
         end
       end
 
-      if width = opts['width']
+      if (width = opts['width'])
         if width =~ /^\d+(\.\d+)?(em|px)$/
           attrs << %{width="#{width}"}
         end
       end
 
-      if height = opts['height']
+      if (height = opts['height'])
         if height =~ /^\d+(\.\d+)?(em|px)$/
           attrs << %{height="#{height}"}
         end
       end
 
-      if alt = opts['alt']
+      if (alt = opts['alt'])
         attrs << %{alt="#{alt}"}
       end
 
@@ -207,6 +207,7 @@ class Gollum::Filter::Tags < Gollum::Filter
   # 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
@@ -245,11 +246,11 @@ class Gollum::Filter::Tags < Gollum::Filter
 
     name = parts[0].strip
     path = parts[1] && parts[1].strip
-    path = if path && file = @markup.find_file(path)
-             ::File.join @markup.wiki.base_path, file.path
-           else
-             nil
-           end
+    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>}
@@ -269,7 +270,7 @@ class Gollum::Filter::Tags < Gollum::Filter
   #   if it is not.
   def process_page_link_tag(tag)
     parts = tag.split('|')
-    parts.reverse! if @markup.format == :mediawiki
+    parts.reverse! if @markup.reverse_links?
 
     name, page_name = *parts.compact.map(&:strip)
     cname           = @markup.wiki.page_class.cname(page_name || name)
@@ -313,7 +314,7 @@ class Gollum::Filter::Tags < Gollum::Filter
     if page
       return page
     end
-    if pos = cname.index('#')
+    if (pos = cname.index('#'))
       [@markup.wiki.page(cname[0...pos]), cname[pos..-1]]
     end
   end

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

@@ -78,22 +78,22 @@ class Gollum::Filter::TOC < Gollum::Filter
   # Adds an entry to the TOC for the given header.  The generated entry
   # is a link to the given anchor name
   def add_entry_to_toc(header, name)
-    @toc        ||= Nokogiri::XML::DocumentFragment.parse('<div class="toc"><div class="toc-title">Table of Contents</div></div>')
-    tail        ||= @toc.child
-    tail_level  ||= 0
+    @toc ||= Nokogiri::XML::DocumentFragment.parse('<div class="toc"><div class="toc-title">Table of Contents</div></div>')
+    tail ||= @toc.child
+    tail_level ||= 0
 
     level = header.name.gsub(/[hH]/, '').to_i
 
     while tail_level < level
-      node       = Nokogiri::XML::Node.new('ul', @doc)
-      tail       = tail.add_child(node)
+      node = Nokogiri::XML::Node.new('ul', @doc)
+      tail = tail.add_child(node)
       tail_level += 1
     end
     
     while tail_level > level
-      tail       = tail.parent
+      tail = tail.parent
       tail_level -= 1
-     end
+    end
     node = Nokogiri::XML::Node.new('li', @doc)
     # % -> %25 so anchors work on Firefox. See issue #475
     node.add_child(%Q{<a href="##{name}">#{header.content}</a>})

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

@@ -16,8 +16,8 @@ class Gollum::Filter::WSD < Gollum::Filter
   def extract(data)
     return data if @markup.format == :txt
     data.gsub(/^\{\{\{\{\{\{ ?(.+?)\r?\n(.+?)\r?\n\}\}\}\}\}\}\r?$/m) do
-      id       = Digest::SHA1.hexdigest($2)
-      @map[id] = { :style => $1, :code => $2 }
+      id       = Digest::SHA1.hexdigest(Regexp.last_match[2])
+      @map[id] = { :style => Regexp.last_match[1], :code => Regexp.last_match[2] }
       id
     end
   end
@@ -44,7 +44,7 @@ class Gollum::Filter::WSD < Gollum::Filter
   def render_wsd(code, style)
     response = Net::HTTP.post_form(URI.parse(WSD_URL), 'style' => style, 'message' => code)
     if response.body =~ /img: "(.+)"/
-      url = "//www.websequencediagrams.com/#{$1}"
+      url = "//www.websequencediagrams.com/#{Regexp.last_match[1]}"
       "<img src=\"#{url}\" />"
     else
       puts response.body

data/lib/gollum-lib/git_access.rb

@@ -49,7 +49,7 @@ module Gollum
     #
     # Returns an Array of BlobEntry instances.
     def tree(ref)
-      if sha = ref_to_sha(ref)
+      if (sha = ref_to_sha(ref))
         get_cache(:tree, sha) { tree!(sha) }
       else
         []
@@ -74,10 +74,10 @@ module Gollum
       if sha?(ref)
         get_cache(:commit, ref) { commit!(ref) }
       else
-        if sha = get_cache(:ref, ref)
+        if (sha = get_cache(:ref, ref))
           commit(sha)
         else
-          if cm = commit!(ref)
+          if (cm = commit!(ref))
             set_cache(:ref, ref, cm.id)
             set_cache(:commit, cm.id, cm)
           end
@@ -164,7 +164,7 @@ module Gollum
           items << BlobEntry.new(entry[:sha], entry[:path], entry[:size], entry[:mode].to_i(8))
         end
       end
-      if dir = @page_file_dir
+      if (dir = @page_file_dir)
         regex = /^#{dir}\//
         items.select { |i| i.path =~ regex }
       else
@@ -226,7 +226,7 @@ module Gollum
     #
     # Returns an Array of BlobEntry instances.
     def parse_tree_line(line)
-      mode, type, sha, size, *name = line.split(/\s+/)
+      mode, _type, sha, size, *name = line.split(/\s+/)
       BlobEntry.new(sha, name.join(' '), size.to_i, mode.to_i(8))
     end
 
@@ -240,7 +240,7 @@ module Gollum
         path = path[1...-1]
         path.gsub!(/\\\d{3}/) { |m| m[1..-1].to_i(8).chr }
       end
-      path.gsub!(/\\[rn"\\]/) { |m| eval(%("#{m.to_s}")) }
+      path.gsub!(/\\[rn"\\]/) { |m| eval(%("#{m}")) }
       path
     end
   end