gitlab-gollum-lib 1.1.0 → 4.2.7

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

@@ -0,0 +1,134 @@
+# Inserts header anchors and creates TOC
+class Gollum::Filter::TOC < Gollum::Filter
+  def extract(data)
+    data
+  end
+
+  def process(data)
+
+    @doc               = Nokogiri::HTML::DocumentFragment.parse(data)
+    @toc_doc           = nil
+    @anchor_names      = {}
+    @current_ancestors = []
+
+    toc_str            = ''
+    if @markup.sub_page && @markup.parent_page
+      toc_str = @markup.parent_page.toc_data
+    else
+      @doc.css('h1,h2,h3,h4,h5,h6').each_with_index do |header, i|
+        next if header.content.empty?
+        # omit the first H1 (the page title) from the TOC if so configured
+        next if (i == 0 && header.name =~ /[Hh]1/) && @markup.wiki && @markup.wiki.h1_title
+
+        anchor_name = generate_anchor_name(header)
+        
+        add_anchor_to_header header, anchor_name
+        add_entry_to_toc     header, anchor_name
+      end
+      if not @toc_doc.nil?
+        toc_str = @toc_doc.to_xml(@markup.to_xml_opts)
+      end
+
+      data  = @doc.to_xml(@markup.to_xml_opts)
+    end
+
+    @markup.toc = toc_str
+
+    data.gsub!(/\[\[_TOC_(.*?)\]\]/) do
+      levels = nil
+      levels_match = Regexp.last_match[1].match /\|\s*levels\s*=\s*(\d+)/
+      if levels_match
+        levels = levels_match[1].to_i
+      end
+
+      if levels.nil? || toc_str.empty?
+        toc_str
+      else
+        @toc_doc ||= Nokogiri::HTML::DocumentFragment.parse(toc_str)
+        toc_clone = @toc_doc.clone
+        toc_clone.traverse do |e|
+          if e.name == 'ul' and e.ancestors('ul').length > levels - 1
+            e.remove
+          end
+        end
+        toc_clone.to_xml(@markup.to_xml_opts)
+      end
+    end
+
+    data
+  end
+
+  private
+
+  # Generates the anchor name from the given header element 
+  # removing all non alphanumeric characters, replacing them
+  # with single dashes.  
+  #
+  # Generates heading ancestry prefixing the headings
+  # ancestor names to the generated name.
+  #
+  # Prefixes duplicate anchors with an index
+  def generate_anchor_name(header)
+    name = header.content
+    level = header.name.gsub(/[hH]/, '').to_i
+
+    # normalize the header name
+    name.gsub!(/[^\d\w\u00C0-\u1FFF\u2C00-\uD7FF]/, "-")
+    name.gsub!(/-+/, "-")
+    name.gsub!(/^-/, "")
+    name.gsub!(/-$/, "")
+    name.downcase!
+
+    @current_ancestors[level - 1] = name
+    @current_ancestors = @current_ancestors.take(level)
+    anchor_name = @current_ancestors.compact.join("_")
+
+    # Ensure duplicate anchors have a unique prefix or the toc will break
+    index = increment_anchor_index(anchor_name)
+    anchor_name = "#{index}-#{anchor_name}" unless index.zero? # if the index is zero this name is unique
+
+    anchor_name
+  end
+
+  # Creates an anchor element with the given name and adds it before
+  # the given header element.
+  def add_anchor_to_header(header, name)
+    anchor_element = %Q(<a class="anchor" id="#{name}" href="##{name}"><i class="fa fa-link"></i></a>)
+    header.children.before anchor_element # Add anchor element before the header
+  end
+
+  # 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_doc ||= Nokogiri::XML::DocumentFragment.parse('<div class="toc"><div class="toc-title">Table of Contents</div></div>')
+    @tail ||= @toc_doc.child
+    @tail_level ||= 0
+
+    level = header.name.gsub(/[hH]/, '').to_i
+
+    if @tail_level < level
+      while @tail_level < level
+        list = Nokogiri::XML::Node.new('ul', @doc)
+        @tail.add_child(list)
+        @tail = list.add_child(Nokogiri::XML::Node.new('li', @doc))
+        @tail_level += 1
+      end
+    else
+      while @tail_level > level
+        @tail = @tail.parent.parent
+        @tail_level -= 1
+      end
+      @tail = @tail.parent.add_child(Nokogiri::XML::Node.new('li', @doc))
+    end
+
+    # % -> %25 so anchors work on Firefox. See issue #475
+    @tail.add_child(%Q{<a href="##{name}">#{header.content}</a>})
+  end
+
+  # Increments the number of anchors with the given name
+  # and returns the current index
+  def increment_anchor_index(name)
+    @anchor_names = {} if @anchor_names.nil?
+    @anchor_names[name].nil? ? @anchor_names[name] = 0 : @anchor_names[name] += 1
+  end
+end

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

@@ -0,0 +1,54 @@
+# ~*~ encoding: utf-8 ~*~
+require 'net/http'
+require 'uri'
+require 'open-uri'
+
+# Web Sequence Diagrams
+#
+# Render an inline web sequence diagram by sending the WSD code through the
+# online renderer available from www.websequencediagrams.com.
+#
+class Gollum::Filter::WSD < Gollum::Filter
+  WSD_URL = "http://www.websequencediagrams.com/index.php"
+
+  # Extract all sequence diagram blocks into the map and replace with
+  # placeholders.
+  def extract(data)
+    return data if @markup.format == :txt
+    data.gsub(/^\{\{\{\{\{\{ ?(.+?)\r?\n(.+?)\r?\n\}\}\}\}\}\}\r?$/m) do
+      id       = Digest::SHA1.hexdigest(Regexp.last_match[2])
+      @map[id] = { :style => Regexp.last_match[1], :code => Regexp.last_match[2] }
+      id
+    end
+  end
+
+  # Process all diagrams from the map and replace the placeholders with
+  # the final HTML.
+  #
+  # data - The String data (with placeholders).
+  #
+  # Returns the marked up String data.
+  def process(data)
+    @map.each do |id, spec|
+      data.gsub!(id) do
+        render_wsd(spec[:code], spec[:style])
+      end
+    end
+    data
+  end
+
+  private
+  # Render the sequence diagram on the remote server.
+  #
+  # Returns an <img> tag to the rendered image, or an HTML error.
+  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/#{Regexp.last_match[1]}"
+      "<img src=\"#{url}\" />"
+    else
+      puts response.body
+      html_error("Sorry, unable to render sequence diagram at this time.")
+    end
+  end
+end

data/lib/gollum-lib/git_access.rb

@@ -10,10 +10,10 @@ module Gollum
     # page_file_dir - String the directory in which all page files reside
     #
     # Returns this instance.
-    def initialize(path, page_file_dir = nil, bare = false)
+    def initialize(path, page_file_dir = nil, bare = nil)
       @page_file_dir = page_file_dir
-      @path = path
-      @repo = Grit::Repo.new(path, { :is_bare => bare })
+      @path          = path
+      @repo = Gollum::Git::Repo.new(path, { :is_bare => bare })
       clear
     end
 
@@ -34,11 +34,11 @@ module Gollum
       ref = ref.to_s
       return if ref.empty?
       sha =
-        if sha?(ref)
-          ref
-        else
-          get_cache(:ref, ref) { ref_to_sha!(ref) }
-        end.to_s
+          if sha?(ref)
+            ref
+          else
+            get_cache(:ref, ref) { ref_to_sha!(ref) }
+          end.to_s
       sha.empty? ? nil : sha
     end
 
@@ -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
         []
@@ -69,16 +69,16 @@ module Gollum
     #
     # ref - A String Git SHA or ref.
     #
-    # Returns a Grit::Commit.
+    # Returns a Gollum::Git::Commit.
     def commit(ref)
       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)
-            set_cache(:ref,    ref,   cm.id)
+          if (cm = commit!(ref))
+            set_cache(:ref, ref, cm.id)
             set_cache(:commit, cm.id, cm)
           end
         end
@@ -111,7 +111,7 @@ module Gollum
     # Gets the String path to the Git repository.
     attr_reader :path
 
-    # Gets the Grit::Repo instance for the Git repository.
+    # Gets the Gollum::Git::Repo instance for the Git repository.
     attr_reader :repo
 
     # Gets a Hash cache of refs to commit SHAs.
@@ -126,9 +126,9 @@ module Gollum
     #
     attr_reader :tree_map
 
-    # Gets a Hash cache of commit SHAs to the Grit::Commit instance.
+    # Gets a Hash cache of commit SHAs to the Gollum::Git::Commit instance.
     #
-    #     {"abcd123" => <Grit::Commit>}
+    #     {"abcd123" => <Gollum::Git::Commit>}
     #
     attr_reader :commit_map
 
@@ -147,8 +147,8 @@ module Gollum
     #
     # Returns a String SHA.
     def ref_to_sha!(ref)
-      @repo.git.rev_list({:max_count=>1}, ref)
-    rescue Grit::GitRuby::Repository::NoSuchShaFound
+      commit = @repo.commit(ref)
+      commit ? commit.id : nil
     end
 
     # Looks up the Git blobs for a given commit.
@@ -157,16 +157,14 @@ module Gollum
     #
     # Returns an Array of BlobEntry instances.
     def tree!(sha)
-      tree  = @repo.git.native(:ls_tree,
-        {:r => true, :l => true, :z => true}, sha)
-      if tree.respond_to?(:force_encoding)
-        tree.force_encoding("UTF-8")
-      end
-      items = tree.split("\0").inject([]) do |memo, line|
-        memo << parse_tree_line(line)
+      tree  = @repo.lstree(sha, { :recursive => true })
+      items = []
+      tree.each do |entry|
+        if entry[:type] == 'blob'
+          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
@@ -180,14 +178,14 @@ module Gollum
     #
     # Returns the String content of the Git object.
     def cat_file!(sha)
-      @repo.git.cat_file({:p => true}, sha)
+      @repo.git.cat_file({ :p => true }, sha)
     end
 
     # Reads a Git commit.
     #
     # sha - The string SHA of the Git commit.
     #
-    # Returns a Grit::Commit.
+    # Returns a Gollum::Git::Commit.
     def commit!(sha)
       @repo.commit(sha)
     end
@@ -228,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,9 +238,9 @@ module Gollum
     def decode_git_path(path)
       if path[0] == ?" && path[-1] == ?"
         path = path[1...-1]
-        path.gsub!(/\\\d{3}/)   { |m| m[1..-1].to_i(8).chr }
+        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

data/lib/gollum-lib/gitcode.rb

@@ -6,41 +6,41 @@ require 'open-uri'
 
 module Gollum
   class Gitcode
-    def initialize path
+    def initialize(path)
       raise(ArgumentError, 'path is nil or empty') if path.nil? or path.empty?
 
       @uri = URI::HTTP.build({
-        :path   => self.unchomp(path),
-        :host   => 'raw.github.com',
-        :scheme => 'https',
-        :port   => 443 })
+                                 :path   => self.unchomp(path),
+                                 :host   => 'raw.github.com',
+                                 :scheme => 'https',
+                                 :port   => 443 })
     end
 
     def contents
       @contents ||= self.req @uri
     end
 
-    def unchomp p
+    def unchomp(p)
       return p if p.nil?
       p[0] == '/' ? p : ('/' + p)
     end
 
-    def req uri, cut = 1
+    def req(uri, cut = 1)
       return "Too many redirects or retries" if cut >= 10
-      http = Net::HTTP.new uri.host, uri.port
+      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',
-        'Host'          => uri.host,
-        'User-Agent'    => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0'
+      resp         = http.get uri.path, {
+          'Accept'        => 'text/plain',
+          'Cache-Control' => 'no-cache',
+          'Connection'    => 'keep-alive',
+          'Host'          => uri.host,
+          'User-Agent'    => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0'
       }
-      code = resp.code.to_i
+      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']
+      loc  = URI.parse resp.header['location']
       uri2 = loc.relative?() ? (uri + loc) : loc # overloads (+)
       return req uri2, (cut + 1)
     end

data/lib/gollum-lib/helpers.rb

@@ -2,10 +2,10 @@
 module Gollum
   module Helpers
 
-    def trim_leading_slash url
+    def trim_leading_slash(url)
       return url if url.nil?
-      url.gsub!('%2F','/')
-      return '/' + url.gsub(/^\/+/,'') if url[0,1] == '/'
+      url.gsub!('%2F', '/')
+      return '/' + url.gsub(/^\/+/, '') if url[0, 1] == '/'
       url
     end
 

data/lib/gollum-lib/hook.rb

@@ -0,0 +1,35 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+  class Hook
+    @hooks = {}
+
+    class << self
+      def register(type, id, &block)
+        type_hooks     = @hooks[type] ||= {}
+        type_hooks[id] = block
+      end
+
+      def unregister(type, id)
+        type_hooks = @hooks[type]
+        if type_hooks
+          type_hooks.delete(id)
+          @hooks.delete(type) if type_hooks.empty?
+        end
+      end
+
+      def get(type, id)
+        @hooks.fetch(type, {})[id]
+      end
+
+      def execute(type, *args)
+        type_hooks = @hooks[type]
+        if type_hooks
+          type_hooks.each_value do |block|
+            block.call(*args)
+          end
+        end
+      end
+    end
+
+  end
+end