gollum-lib 4.0.3-java

data/lib/gollum-lib/file.rb

@@ -0,0 +1,158 @@
+# ~*~ encoding: utf-8 ~*~
+require 'pathname'
+
+module Gollum
+  class File
+    Wiki.file_class = self
+
+    # Public: Initialize a file.
+    #
+    # wiki - The Gollum::Wiki in question.
+    #
+    # Returns a newly initialized Gollum::File.
+    def initialize(wiki)
+      @wiki         = wiki
+      @blob         = nil
+      @path         = nil
+      @on_disk      = false
+      @on_disk_path = nil
+    end
+
+    # Public: The url path required to reach this page within the repo.
+    #
+    # Returns the String url_path
+    def url_path
+      path = self.path
+      path = path.sub(/\/[^\/]+$/, '/') if path.include?('/')
+      path
+    end
+
+    # Public: The url_path, but CGI escaped.
+    #
+    # Returns the String url_path
+    def escaped_url_path
+      CGI.escape(self.url_path).gsub('%2F', '/')
+    end
+
+    # Public: The on-disk filename of the file.
+    #
+    # Returns the String name.
+    def name
+      return @path if on_disk?
+      @blob && @blob.name
+    end
+
+    alias filename name
+
+    # Public: The raw contents of the page.
+    #
+    # Returns the String data.
+    def raw_data
+      return IO.read(@on_disk_path) if on_disk?
+      return nil unless @blob
+
+      if !@wiki.repo.bare && @blob.is_symlink
+        new_path = @blob.symlink_target(::File.join(@wiki.repo.path, '..', self.path))
+        return IO.read(new_path) if new_path
+      end
+
+      @blob.data
+    end
+
+    # Public: Is this an on-disk file reference?
+    #
+    # Returns true if this is a pointer to an on-disk file
+    def on_disk?
+      return @on_disk
+    end
+
+    # Public: The path to this file on disk
+    #
+    # Returns nil if on_disk? is false.
+    def on_disk_path
+      return @on_disk_path
+    end
+
+    # Public: The Gollum::Git::Commit version of the file.
+    attr_accessor :version
+
+    # Public: The String path of the file.
+    attr_reader :path
+
+    # Public: The String mime type of the file.
+    def mime_type
+      @blob && @blob.mime_type
+    end
+
+    # Populate the File with information from the Blob.
+    #
+    # blob - The Gollum::Git::Blob that contains the info.
+    # path - The String directory path of the file.
+    #
+    # Returns the populated Gollum::File.
+    def populate(blob, path=nil)
+      @blob         = blob
+      @path         = "#{path}/#{blob.name}"[1..-1]
+      @on_disk      = false
+      @on_disk_path = nil
+      self
+    end
+
+    #########################################################################
+    #
+    # Internal Methods
+    #
+    #########################################################################
+
+    # Return the file path to this file on disk, if available.
+    #
+    # Returns nil if the file isn't available on disk. This can occur if the
+    # repo is bare, if the commit isn't the HEAD, or if there are problems
+    # resolving symbolic links.
+    def get_disk_reference(name, commit)
+      return false if @wiki.repo.bare
+      return false if commit.sha != @wiki.repo.head.commit.sha
+
+      # This will try to resolve symbolic links, as well
+      pathname = Pathname.new(::File.expand_path(::File.join(@wiki.repo.path, '..', name)))
+      if pathname.symlink?
+        source   = ::File.readlink(pathname.to_path)
+        realpath = ::File.join(::File.dirname(pathname.to_path), source)
+        return false unless realpath && ::File.exist?(realpath)
+        @on_disk_path = realpath.to_s
+      else
+        @on_disk_path = pathname.to_path
+      end
+      return true
+    end
+
+    # Find a file in the given Gollum repo.
+    #
+    # name    - The full String path.
+    # version - The String version ID to find.
+    # try_on_disk - If true, try to return just a reference to a file
+    #               that exists on the disk.
+    #
+    # Returns a Gollum::File or nil if the file could not be found. Note
+    # that if you specify try_on_disk=true, you may or may not get a file
+    # for which on_disk? is actually true.
+    def find(name, version, try_on_disk=false)
+      checked = name.downcase
+      map     = @wiki.tree_map_for(version)
+      commit  = version.is_a?(Gollum::Git::Commit) ? version : @wiki.commit_for(version)
+
+      if entry = map.detect { |entry| entry.path.downcase == checked }
+        @path    = name
+        @version = commit
+
+        if try_on_disk && get_disk_reference(name, commit)
+          @on_disk = true
+        else
+          @blob = entry.blob(@wiki.repo)
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/gollum-lib/file_view.rb

@@ -0,0 +1,155 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+=begin
+  FileView requires that:
+    - All files in root dir are processed first
+    - Then all the folders are sorted and processed
+=end
+  class FileView
+    # common use cases:
+    # set pages to wiki.pages and show_all to false
+    # set pages to wiki.pages + wiki.files and show_all to true
+    def initialize pages, options = {}
+      @pages    = pages
+      @show_all = options[:show_all] || false
+      @checked  = options[:collapse_tree] ? '' : "checked"
+    end
+
+    def enclose_tree string
+      %Q(<ol class="tree">\n) + string + %Q(</ol>)
+    end
+
+    def new_page page
+      name = page.name
+      url  = url_for_page page
+      %Q(  <li class="file"><a href="#{url}"><span class="icon"></span>#{name}</a></li>)
+    end
+
+    def new_folder folder_path
+      new_sub_folder folder_path
+    end
+
+    def new_sub_folder path
+      <<-HTML
+      <li>
+        <label>#{path}</label> <input type="checkbox" #{@checked} />
+        <ol>
+      HTML
+    end
+
+    def end_folder
+      "</ol></li>\n"
+    end
+
+    def url_for_page page
+      url = ''
+      if @show_all
+        # Remove ext for valid pages.
+        filename = page.filename
+        filename = Page::valid_page_name?(filename) ? filename.chomp(::File.extname(filename)) : filename
+
+        url = ::File.join(::File.dirname(page.path), filename)
+      else
+        url = ::File.join(::File.dirname(page.path), page.filename_stripped)
+      end
+      url = url[2..-1] if url[0, 2] == './'
+      url
+    end
+
+    def render_files
+      html         = ''
+      count        = @pages.size
+      folder_start = -1
+
+      # Process all pages until folders start
+      count.times do |index|
+        page = @pages[index]
+        path = page.path
+
+        unless path.include? '/'
+          # Page processed (not contained in a folder)
+          html += new_page page
+        else
+          # Folders start at the next index
+          folder_start = index
+          break # Pages finished, move on to folders
+        end
+      end
+
+      # If there are no folders, then we're done.
+      return enclose_tree(html) if folder_start <= -1
+
+      # Handle special case of only one folder.
+      if (count - folder_start == 1)
+        page = @pages[folder_start]
+        html += <<-HTML
+        <li>
+          <label>#{::File.dirname(page.path)}</label> <input type="checkbox" #{@checked} />
+          <ol>
+          #{new_page page}
+         </ol>
+        </li>
+        HTML
+
+        return enclose_tree html
+      end
+
+      sorted_folders = []
+      (folder_start).upto count - 1 do |index|
+        sorted_folders += [[@pages[index].path, index]]
+      end
+
+      # http://stackoverflow.com/questions/3482814/sorting-list-of-string-paths-in-vb-net
+      sorted_folders.sort! do |first, second|
+        a           = first[0]
+        b           = second[0]
+
+        # use :: operator because gollum defines its own conflicting File class
+        dir_compare = ::File.dirname(a) <=> ::File.dirname(b)
+
+        # Sort based on directory name unless they're equal (0) in
+        # which case sort based on file name.
+        if dir_compare == 0
+          ::File.basename(a) <=> ::File.basename(b)
+        else
+          dir_compare
+        end
+      end
+
+      # keep track of folder depth, 0 = at root.
+      cwd_array = []
+      changed   = false
+
+      # process rest of folders
+      (0...sorted_folders.size).each do |index|
+        page   = @pages[sorted_folders[index][1]]
+        path   = page.path
+        folder = ::File.dirname path
+
+        tmp_array = folder.split '/'
+
+        (0...tmp_array.size).each do |index|
+          if cwd_array[index].nil? || changed
+            html += new_sub_folder tmp_array[index]
+            next
+          end
+
+          if cwd_array[index] != tmp_array[index]
+            changed = true
+            (cwd_array.size - index).times do
+              html += end_folder
+            end
+            html += new_sub_folder tmp_array[index]
+          end
+        end
+
+        html      += new_page page
+        cwd_array = tmp_array
+        changed   = false
+      end
+
+      # return the completed html
+      enclose_tree html
+    end # end render_files
+  end # end FileView class
+end # end Gollum module

data/lib/gollum-lib/filter.rb

@@ -0,0 +1,78 @@
+# A "filter", in Gollum-speak, is an object which extracts tokens from an
+# input stream of an arbitrary markup language, then replaces them with a
+# final form in a rendered form of the same document.  Filters are composed
+# into a "filter chain", which forms the order in which filters are applied
+# in both the extraction and processing phases (processing happens in the
+# reverse order to extraction).  A single instance of a filter class is used
+# for both the extraction and processing, so you can store internal state
+# from the extraction phase for use in the processing phase.
+#
+# Any class which is to be used as a filter must have an `initialize` method
+# which takes a single mandatory argument (the instance of the `Markup`
+# class we're being called from), and must implement two methods: `extract`
+# and `process`, both of which must take a string as input and return a
+# (possibly modified) form of that string as output.
+#
+# An example rendering session: consider a filter chain with three filters
+# in it, :A, :B, and :C (filter chains are specified as symbols, which are
+# taken to be class names within the Gollum::Filter namespace).  An
+# equivalent of the following will take place:
+#
+#     a = Gollum::Filter.const_get(:A).new
+#     b = Gollum::Filter.const_get(:B).new
+#     c = Gollum::Filter.const_get(:C).new
+#
+#     data = "<some markup>"
+#
+#     data = a.extract(data)
+#     data = b.extract(data)
+#     data = c.extract(data)
+#
+#     data = c.process(data)
+#     data = b.process(data)
+#     data = a.process(data)
+#
+#     # `data` now contains the rendered document, ready for processing
+#
+# Note how the extraction steps go in the order of the filter chain, while
+# the processing steps go in the reverse order.  There hasn't (yet) been a
+# case where that is a huge problem.
+#
+# If your particular filter doesn't need to do something with either the
+# original markup or rendered forms, you can simply define the relevant
+# method to be a pass-through (`def extract(d) d; end`), but you *must*
+# define both methods yourself.
+#     
+module Gollum
+  class Filter
+    include Gollum::Helpers
+
+    # 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    = {}
+    end
+
+    def extract(_d)
+      raise RuntimeError,
+            "#{self.class} has not implemented ##extract!"
+    end
+
+    def process(_d)
+      raise RuntimeError,
+            "#{self.class} has not implemented ##process!"
+    end
+
+    protected
+    # Render a (presumably) non-fatal error as HTML
+    #
+    def html_error(message)
+      "<p class=\"gollum-error\">#{message}</p>"
+    end
+  end
+end
+
+# Load all standard filters
+Dir[File.expand_path('../filter/*.rb', __FILE__)].each { |f| require f }

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

@@ -0,0 +1,145 @@
+# ~*~ encoding: utf-8 ~*~
+
+# Code
+#
+# Render a block of code using the Rouge syntax-highlighter.
+class Gollum::Filter::Code < Gollum::Filter
+  def extract(data)
+    case @markup.format
+      when :txt
+        return data
+      when :asciidoc
+        data.gsub!(/^(\[source,([^\r\n]*)\]\n)?----\n(.+?)\n----$/m) do
+          cache_codeblock($2, $3)
+        end
+      when :org
+        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]*}
+        data.gsub!(/^#{org_headers}#{org_name}#{org_begin}(.+?)#{org_end}$/mi) do
+          cache_codeblock($3, $4)
+        end
+    end
+    data.gsub!(/^([ \t]*)(~~~+) ?([^\r\n]+)?\r?\n(.+?)\r?\n\1(~~~+)[ \t\r]*$/m) do
+      m_indent = $1
+      m_start  = $2 # ~~~
+      m_lang   = $3
+      m_code   = $4
+      m_end    = $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
+      "#{m_indent}#{cache_codeblock(lang, m_code, m_indent)}"
+    end
+
+    data.gsub!(/^([ \t]*)``` ?([^\r\n]+)?\r?\n(.+?)\r?\n\1```[ \t]*\r?$/m) do
+      "#{$1}#{cache_codeblock($2.to_s.strip, $3, $1)}" # print the SHA1 ID with the proper indentation
+    end
+    data
+  end
+
+  # Process all code from the codemap and replace the placeholders with the
+  # final HTML.
+  #
+  # data     - The String data (with placeholders).
+  # encoding - Encoding Constant or String.
+  #
+  # Returns the marked up String data.
+  def process(data)
+    return data if data.nil? || data.size.zero? || @map.size.zero?
+
+    blocks = []
+
+    @map.each do |id, spec|
+      next if spec[:output] # cached
+
+      code = spec[:code]
+
+      remove_leading_space(code, /^#{spec[:indent]}/m)
+      remove_leading_space(code, /^(  |\t)/m)
+
+      blocks << [spec[:lang], code]
+    end
+
+    highlighted = []
+    blocks.each do |lang, code|
+      encoding = @markup.encoding || 'utf-8'
+
+      if defined? Pygments
+        # treat unknown and bash as standard pre tags
+        if !lang || lang.downcase == 'bash'
+          hl_code = "<pre>#{code}</pre>"
+        else
+          # must set startinline to true for php to be highlighted without <?
+          hl_code = Pygments.highlight(code, :lexer => lang, :options => { :encoding => encoding.to_s, :startinline => true })
+        end
+      else # Rouge
+        begin
+          # if `lang` was not defined then assume plaintext
+          # if `lang` is defined but cannot be found then wrap it and escape it
+          lang ||= 'plaintext'
+          if Rouge::Lexer.find(lang).nil?
+            lexer     = Rouge::Lexers::PlainText.new
+            formatter = Rouge::Formatters::HTML.new(:wrap => false)
+            hl_code   = formatter.format(lexer.lex(code))
+            hl_code   = "<pre class='highlight'><span class='err'>#{CGI.escapeHTML(hl_code)}</span></pre>"
+          else
+            hl_code = Rouge.highlight(code, lang, 'html')
+          end
+        rescue
+          hl_code = code
+        end
+      end
+
+      highlighted << hl_code
+    end
+
+    @map.each do |id, spec|
+      body = spec[:output] || begin
+        if (body = highlighted.shift.to_s).size > 0
+          @markup.update_cache(:code, id, body)
+          body
+        else
+          "<pre><code>#{CGI.escapeHTML(spec[:code])}</code></pre>"
+        end
+      end
+      # Removes paragraph tags surrounding <pre> blocks, see issue https://github.com/gollum/gollum-lib/issues/97
+      data.gsub!(/(<p>#{id}<\/p>|#{id})/) do
+        body
+      end
+    end
+
+    data
+  end
+
+  private
+  # Remove the leading space from a code block. Leading space
+  # is only removed if every single line in the block has leading
+  # whitespace.
+  #
+  # code      - The code block to remove spaces from
+  # regex     - A regex to match whitespace
+  def remove_leading_space(code, regex)
+    if code.lines.all? { |line| line =~ /\A\r?\n\Z/ || line =~ regex }
+      code.gsub!(regex) do
+        ''
+      end
+    end
+  end
+
+  def cache_codeblock(language, code, indent = "")
+    language = language.to_s.empty? ? nil : language
+    id = Digest::SHA1.hexdigest("#{language}.#{code}")
+    cached = @markup.check_cache(:code, id)
+    @map[id] = cached ?
+      { :output => cached } :
+      { :lang => language, :code => code, :indent => indent }
+    id
+  end
+end