gitlab-gollum-lib 1.1.0 → 4.2.7

data/lib/gollum-lib/file.rb

@@ -1,4 +1,5 @@
 # ~*~ encoding: utf-8 ~*~
+
 module Gollum
   class File
     Wiki.file_class = self
@@ -9,9 +10,11 @@ module Gollum
     #
     # Returns a newly initialized Gollum::File.
     def initialize(wiki)
-      @wiki = wiki
-      @blob = nil
-      @path = nil
+      @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.
@@ -27,21 +30,24 @@ module Gollum
     #
     # Returns the String url_path
     def escaped_url_path
-      CGI.escape(self.url_path).gsub('%2F','/')
+      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
@@ -52,7 +58,21 @@ module Gollum
       @blob.data
     end
 
-    # Public: The Grit::Commit version of the file.
+    # Public: Is this an on-disk file reference?
+    #
+    # Returns true if this is a pointer to an on-disk file
+    def on_disk?
+      @on_disk
+    end
+
+    # Public: The path to this file on disk
+    #
+    # Returns nil if on_disk? is false.
+    def on_disk_path
+      @on_disk_path
+    end
+
+    # Public: The Gollum::Git::Commit version of the file.
     attr_accessor :version
 
     # Public: The String path of the file.
@@ -60,18 +80,20 @@ module Gollum
 
     # Public: The String mime type of the file.
     def mime_type
-      @blob.mime_type
+      @blob && @blob.mime_type
     end
 
     # Populate the File with information from the Blob.
     #
-    # blob - The Grit::Blob that contains the info.
+    # 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]
+    def populate(blob, path = nil)
+      @blob         = blob
+      @path         = "#{path}/#{blob.name}"[1..-1]
+      @on_disk      = false
+      @on_disk_path = nil
       self
     end
 
@@ -81,19 +103,53 @@ module Gollum
     #
     #########################################################################
 
+    # 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
+      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.
-    def find(name, version)
+    # 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)
-      if entry = map.detect { |entry| entry.path.downcase == checked }
+      commit  = version.is_a?(Gollum::Git::Commit) ? version : @wiki.commit_for(version)
+
+      if (result = map.detect { |entry| entry.path.downcase == checked })
         @path    = name
-        @blob    = entry.blob(@wiki.repo)
-        @version = version.is_a?(Grit::Commit) ? version : @wiki.commit_for(version)
+        @version = commit
+
+        if try_on_disk && get_disk_reference(name, commit)
+          @on_disk = true
+        else
+          @blob = result.blob(@wiki.repo)
+        end
+
         self
       end
     end

data/lib/gollum-lib/file_view.rb

@@ -1,35 +1,38 @@
 # ~*~ 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
+  # FileView requires that:
+  #  - All files in root dir are processed first
+  #  - Then all the folders are sorted and processed
+
   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
+    def initialize(pages, options = {})
+      @pages    = pages
       @show_all = options[:show_all] || false
-      @checked = options[:collapse_tree] ? '' : "checked"
+      @checked  = options[:collapse_tree] ? '' : "checked"
     end
 
-    def enclose_tree string
+    def enclose_tree(string)
       %Q(<ol class="tree">\n) + string + %Q(</ol>)
     end
 
-    def new_page page
+    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>)
+      url, valid_page  = url_for_page page
+      %Q(  <li class="file"><a href="#{url}"><span class="icon"></span>#{name}</a>#{valid_page ? "" : delete_file(url, valid_page)}</li>)
+    end
+
+    def delete_file(url, valid_page)
+      %Q(<form method="POST" action="/deleteFile/#{url}" onsubmit="return confirm('Do you really want to delete the file #{url}?');"><button type="submit" name="delete" value="true"></button></form>)
     end
 
-    def new_folder folder_path
+    def new_folder(folder_path)
       new_sub_folder folder_path
     end
 
-    def new_sub_folder path
+    def new_sub_folder(path)
       <<-HTML
       <li>
         <label>#{path}</label> <input type="checkbox" #{@checked} />
@@ -41,29 +44,31 @@ module Gollum
       "</ol></li>\n"
     end
 
-    def url_for_page page
+    def url_for_page(page)
       url = ''
+      valid_page_name = false
       if @show_all
         # Remove ext for valid pages.
         filename = page.filename
-        filename = Page::valid_page_name?(filename) ? filename.chomp(::File.extname(filename)) : filename
+        valid_page_name =  Page::valid_page_name?(filename)
+        filename = valid_page_name ? 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
+      url = url[2..-1] if url[0, 2] == './'
+      return url, valid_page_name
     end
 
     def render_files
-      html = ''
-      count = @pages.size
+      html         = ''
+      count        = @pages.size
       folder_start = -1
 
       # Process all pages until folders start
-      count.times do | index |
-        page = @pages[ index ]
+      count.times do |index|
+        page = @pages[index]
         path = page.path
 
         unless path.include? '/'
@@ -81,7 +86,7 @@ module Gollum
 
       # Handle special case of only one folder.
       if (count - folder_start == 1)
-        page = @pages[ folder_start ]
+        page = @pages[folder_start]
         html += <<-HTML
         <li>
           <label>#{::File.dirname(page.path)}</label> <input type="checkbox" #{@checked} />
@@ -95,14 +100,14 @@ module Gollum
       end
 
       sorted_folders = []
-      (folder_start).upto count - 1 do | index |
-        sorted_folders += [[ @pages[ index ].path, index ]]
+      (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]
+      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)
@@ -118,34 +123,34 @@ module Gollum
 
       # keep track of folder depth, 0 = at root.
       cwd_array = []
-      changed = false
+      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
+      (0...sorted_folders.size).each do |i|
+        page   = @pages[sorted_folders[i][1]]
+        path   = page.path
+        folder = ::File.dirname path
 
-          tmp_array = folder.split '/'
+        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
+        (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 ]
+          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
+        html += new_page page
+        cwd_array = tmp_array
+        changed = false
       end
 
       # return the completed html

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(Regexp.last_match[2], Regexp.last_match[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(Regexp.last_match[3], Regexp.last_match[4])
+      end
+    when :markdown
+      data.gsub!(/^([ \t]*)(~~~+) ?([^\r\n]+)?\r?\n(.+?)\r?\n\1(~~~+)[ \t\r]*$/m) do
+        m_indent = Regexp.last_match[1]
+        m_start  = Regexp.last_match[2] # ~~~
+        m_lang   = Regexp.last_match[3]
+        m_code   = Regexp.last_match[4]
+        m_end    = Regexp.last_match[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  
+    end
+    
+
+    data.gsub!(/^([ \t]*)``` ?([^\r\n]+)?\r?\n(.+?)\r?\n\1```[ \t]*\r?$/m) do
+      "#{Regexp.last_match[1]}#{cache_codeblock(Regexp.last_match[2].to_s.strip, Regexp.last_match[3], Regexp.last_match[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
+        # Set the default lexer to 'text' to prevent #153 and #154
+        lang = lang || 'text'
+        lexer = Pygments::Lexer[(lang)] || Pygments::Lexer['text']
+
+        # must set startinline to true for php to be highlighted without <?
+        hl_code = lexer.highlight(code, :options => { :encoding => encoding.to_s, :startinline => true })
+      else # Rouge
+        begin
+          # if `lang` was not defined then assume plaintext
+          lexer = Rouge::Lexer.find_fancy(lang || 'plaintext')
+          formatter = Rouge::Formatters::HTML.new
+          wrap_template = '<pre class="highlight"><code>%s</code></pre>'
+
+          # if `lang` is defined but cannot be found then wrap it with an error
+          if lexer.nil?
+            lexer = Rouge::Lexers::PlainText
+            wrap_template = '<pre class="highlight"><span class="err">%s</span></pre>'
+          end
+
+          formatted = formatter.format(lexer.lex(code))
+
+          hl_code = Kernel.sprintf(wrap_template, formatted)
+        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})/) { body }
+    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) { '' }
+    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