gollum-lib 4.0.3-java

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

@@ -0,0 +1,109 @@
+# 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               = nil
+    @anchor_names      = {}
+    @current_ancestors = []
+
+    if @markup.sub_page && @markup.parent_page
+      @toc = @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
+
+      @toc  = @toc.to_xml(@markup.to_xml_opts) if @toc != nil
+      data  = @doc.to_xml(@markup.to_xml_opts)
+      
+    end
+ 
+    @markup.toc = @toc
+    data.gsub("[[_TOC_]]") do
+      @toc.nil? ? '' : @toc
+    end
+  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        ||= 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)
+      tail_level += 1
+    end
+    
+    while tail_level > level
+      tail       = tail.parent
+      tail_level -= 1
+     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>})
+    tail.add_child(node)
+  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($2)
+      @map[id] = { :style => $1, :code => $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/#{$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

@@ -0,0 +1,247 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+  # Controls all access to the Git objects from Gollum.  Extend this class to
+  # add custom caching for special cases.
+  class GitAccess
+    # Initializes the GitAccess instance.
+    #
+    # path          - The String path to the Git repository that holds the
+    #                 Gollum site.
+    # page_file_dir - String the directory in which all page files reside
+    #
+    # Returns this instance.
+    def initialize(path, page_file_dir = nil, bare = nil)
+      @page_file_dir = page_file_dir
+      @path          = path
+      @repo = Gollum::Git::Repo.new(path, { :is_bare => bare })
+      clear
+    end
+
+    # Public: Determines whether the Git repository exists on disk.
+    #
+    # Returns true if it exists, or false.
+    def exist?
+      @repo.git.exist?
+    end
+
+    # Public: Converts a given Git reference to a SHA, using the cache if
+    # available.
+    #
+    # ref - a String Git reference (ex: "master")
+    #
+    # Returns a String, or nil if the ref isn't found.
+    def ref_to_sha(ref)
+      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
+      sha.empty? ? nil : sha
+    end
+
+    # Public: Gets a recursive list of Git blobs for the whole tree at the
+    # given commit.
+    #
+    # ref - A String Git reference or Git SHA to a commit.
+    #
+    # Returns an Array of BlobEntry instances.
+    def tree(ref)
+      if sha = ref_to_sha(ref)
+        get_cache(:tree, sha) { tree!(sha) }
+      else
+        []
+      end
+    end
+
+    # Public: Fetches the contents of the Git blob at the given SHA.
+    #
+    # sha - A String Git SHA.
+    #
+    # Returns the String content of the blob.
+    def blob(sha)
+      cat_file!(sha)
+    end
+
+    # Public: Looks up the Git commit using the given Git SHA or ref.
+    #
+    # ref - A String Git SHA or ref.
+    #
+    # Returns a Gollum::Git::Commit.
+    def commit(ref)
+      if sha?(ref)
+        get_cache(:commit, ref) { commit!(ref) }
+      else
+        if sha = get_cache(:ref, ref)
+          commit(sha)
+        else
+          if cm = commit!(ref)
+            set_cache(:ref, ref, cm.id)
+            set_cache(:commit, cm.id, cm)
+          end
+        end
+      end
+    end
+
+    # Public: Clears all of the cached data that this GitAccess is tracking.
+    #
+    # Returns nothing.
+    def clear
+      @ref_map    = {}
+      @tree_map   = {}
+      @commit_map = {}
+    end
+
+    # Public: Refreshes just the cached Git reference data.  This should
+    # be called after every Gollum update.
+    #
+    # Returns nothing.
+    def refresh
+      @ref_map.clear
+    end
+
+    #########################################################################
+    #
+    # Internal Methods
+    #
+    #########################################################################
+
+    # Gets the String path to the Git repository.
+    attr_reader :path
+
+    # Gets the Gollum::Git::Repo instance for the Git repository.
+    attr_reader :repo
+
+    # Gets a Hash cache of refs to commit SHAs.
+    #
+    #   {"master" => "abc123", ...}
+    #
+    attr_reader :ref_map
+
+    # Gets a Hash cache of commit SHAs to a recursive tree of blobs.
+    #
+    #   {"abc123" => [<BlobEntry>, <BlobEntry>]}
+    #
+    attr_reader :tree_map
+
+    # Gets a Hash cache of commit SHAs to the Gollum::Git::Commit instance.
+    #
+    #     {"abcd123" => <Gollum::Git::Commit>}
+    #
+    attr_reader :commit_map
+
+    # Checks to see if the given String is a 40 character hex SHA.
+    #
+    # str - Possible String SHA.
+    #
+    # Returns true if the String is a SHA, or false.
+    def sha?(str)
+      !!(str =~ /^[0-9a-f]{40}$/)
+    end
+
+    # Looks up the Git SHA for the given Git ref.
+    #
+    # ref - String Git ref.
+    #
+    # Returns a String SHA.
+    def ref_to_sha!(ref)
+      commit = @repo.commit(ref)
+      commit ? commit.id : nil
+    end
+
+    # Looks up the Git blobs for a given commit.
+    #
+    # sha - String commit SHA.
+    #
+    # Returns an Array of BlobEntry instances.
+    def tree!(sha)
+      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
+        regex = /^#{dir}\//
+        items.select { |i| i.path =~ regex }
+      else
+        items
+      end
+    end
+
+    # Reads the content from the Git db at the given SHA.
+    #
+    # sha - The String SHA.
+    #
+    # Returns the String content of the Git object.
+    def cat_file!(sha)
+      @repo.git.cat_file({ :p => true }, sha)
+    end
+
+    # Reads a Git commit.
+    #
+    # sha - The string SHA of the Git commit.
+    #
+    # Returns a Gollum::Git::Commit.
+    def commit!(sha)
+      @repo.commit(sha)
+    end
+
+    # Attempts to get the given data from a cache.  If it doesn't exist, it'll
+    # pass the results of the yielded block to the cache for future accesses.
+    #
+    # name - The cache prefix used in building the full cache key.
+    # key  - The unique cache key suffix, usually a String Git SHA.
+    #
+    # Yields a block to pass to the cache.
+    # Returns the cached result.
+    def get_cache(name, key)
+      cache = instance_variable_get("@#{name}_map")
+      value = cache[key]
+      if value.nil? && block_given?
+        set_cache(name, key, value = yield)
+      end
+      value == :_nil ? nil : value
+    end
+
+    # Writes some data to the internal cache.
+    #
+    # name  - The cache prefix used in building the full cache key.
+    # key   - The unique cache key suffix, usually a String Git SHA.
+    # value - The value to write to the cache.
+    #
+    # Returns nothing.
+    def set_cache(name, key, value)
+      cache      = instance_variable_get("@#{name}_map")
+      cache[key] = value || :_nil
+    end
+
+    # Parses a line of output from the `ls-tree` command.
+    #
+    # line - A String line of output:
+    #          "100644 blob 839c2291b30495b9a882c17d08254d3c90d8fb53  Home.md"
+    #
+    # Returns an Array of BlobEntry instances.
+    def parse_tree_line(line)
+      mode, type, sha, size, *name = line.split(/\s+/)
+      BlobEntry.new(sha, name.join(' '), size.to_i, mode.to_i(8))
+    end
+
+    # Decode octal sequences (\NNN) in tree path names.
+    #
+    # path - String path name.
+    #
+    # Returns a decoded String.
+    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 }
+      end
+      path.gsub!(/\\[rn"\\]/) { |m| eval(%("#{m.to_s}")) }
+      path
+    end
+  end
+end

data/lib/gollum-lib/gitcode.rb

@@ -0,0 +1,48 @@
+# ~*~ encoding: utf-8 ~*~
+require 'net/http'
+require 'net/https' # ruby 1.8.7 fix, remove at upgrade
+require 'uri'
+require 'open-uri'
+
+module Gollum
+  class Gitcode
+    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 })
+    end
+
+    def contents
+      @contents ||= self.req @uri
+    end
+
+    def unchomp p
+      return p if p.nil?
+      p[0] == '/' ? p : ('/' + p)
+    end
+
+    def req uri, cut = 1
+      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',
+          '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
+      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 (+)
+      return req uri2, (cut + 1)
+    end
+  end
+end