gollum-lib 5.0.a.4-java → 5.0.5-java

data/lib/gollum-lib/file.rb

@@ -2,55 +2,125 @@
 
 module Gollum
   class File
-    Wiki.file_class = self
+
+    # Does the filesystem support reading symlinks?
+    FS_SUPPORT_SYMLINKS = !Gem.win_platform?
+
+    class << self
+
+      # For use with self.find: returns true if the given query corresponds to the in-repo path of the BlobEntry.
+      #
+      # query     - The String path to match.
+      # entry     - The BlobEntry to check against.
+      # global_match - (Not implemented for File, see Page.path_match)
+      # hyphened_tags  - If true, replace spaces in match_path with hyphens.
+      # case_insensitive - If true, compare query and match_path case-insensitively
+      def path_match(query, entry, global_match = false, hyphened_tags = false, case_insensitive = false)
+        path_compare(query, ::File.join('/', entry.path), hyphened_tags, case_insensitive)
+      end
+      
+      # For use with self.path_match: returns true if 'query' and 'match_path' match, strictly or taking account of the following parameters:
+      # hyphened_tags  - If true, replace spaces in match_path with hyphens.
+      # case_insensitive - If true, compare query and match_path case-insensitively
+      def path_compare(query, match_path, hyphened_tags, case_insensitive)
+        if hyphened_tags
+          final_query = query.gsub(' ', '-')
+          final_match = match_path.gsub(' ', '-')
+        else
+          final_query = query
+          final_match = match_path
+        end
+        final_match.send(case_insensitive ? :casecmp? : :==, final_query)
+      end
+    end
+
+    # Find a file in the given Gollum wiki.
+    #
+    # wiki    - The wiki.
+    # path    - 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.
+    # global_match - If true, find a File matching path's filename, but not it's directory (so anywhere in the repo)
+    #
+    # 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 self.find(wiki, path, version, try_on_disk = false, global_match = false)
+      map = wiki.tree_map_for(version.to_s)
+
+      query_path = Pathname.new(::File.join(['/', wiki.page_file_dir, path].compact)).cleanpath.to_s
+      query_path.sub!(/^\/\//, '/') if Gem.win_platform? # On Windows, Pathname#cleanpath will leave double slashes at the start of a path intact, so sub them out.
+
+      begin
+        entry = map.detect do |entry|
+          path_match(query_path, entry, global_match, wiki.hyphened_tag_lookup, wiki.case_insensitive_tag_lookup)
+        end
+        entry ? self.new(wiki, entry.blob(wiki.repo), entry.dir, version, try_on_disk) : nil
+      rescue Gollum::Git::NoSuchShaFound
+        nil
+      end
+    end
 
     # Public: Initialize a file.
     #
-    # wiki - The Gollum::Wiki in question.
+    # wiki - The Gollum::Wiki
+    # blob - The Gollum::Git::Blob
+    # path - The String path
+    # version - The String SHA or Gollum::Git::Commit version
+    # try_on_disk - If true, try to get an on disk reference for this file.
     #
     # Returns a newly initialized Gollum::File.
-    def initialize(wiki)
+    def initialize(wiki, blob, path, version, try_on_disk = false)
       @wiki         = wiki
-      @blob         = nil
-      @path         = nil
-      @on_disk      = false
-      @on_disk_path = nil
+      @blob         = blob
+      @path         = "#{path}/#{blob.name}"[1..-1]
+      @version      = version.is_a?(Gollum::Git::Commit) ? version : @wiki.commit_for(version)
+      get_disk_reference if try_on_disk
     end
 
-    # Public: The url path required to reach this page within the repo.
+    # Public: The path of the page within the repo.
     #
-    # Returns the String url_path
-    def url_path
-      path = self.path
-      path = path.sub(/\/[^\/]+$/, '/') if path.include?('/')
-      path
-    end
+    # Returns the String path.
+    attr_reader :path
+
+    # Public: The Gollum::Git::Commit version of the file.
+    attr_accessor :version
 
-    # Public: The SHA hash identifying this file
+    # Public: Whether the file can be read from disk.
+    attr_accessor :on_disk
+
+    # Public: The SHA hash identifying this page
     #
     # Returns the String SHA.
     def sha
       @blob && @blob.id
     end
 
-    # Public: The url_path, but CGI escaped.
+    # Public: The on-disk filename of the page including extension.
     #
-    # Returns the String url_path
-    def escaped_url_path
-      CGI.escape(self.url_path).gsub('%2F', '/')
+    # Returns the String name.
+    def filename
+      @blob && @blob.name
     end
+    alias :name :filename
 
-    # Public: The on-disk filename of the file.
+    # Public: The url path required to reach this file within the repo.
     #
-    # Returns the String name.
-    def name
-      return @path if on_disk?
-      @blob && @blob.name
+    # Returns the String url_path
+    def url_path
+      # Chop off the page_file_dir and first slash if necessary
+      @wiki.page_file_dir ? self.path[@wiki.page_file_dir.length+1..-1] : self.path
     end
 
-    alias filename name
+    # Public: The url_path, but URL encoded.
+    #
+    # Returns the String url_path
+    def escaped_url_path
+      ERB::Util.url_encode(self.url_path).gsub('%2F', '/').force_encoding('utf-8')
+    end
 
-    # Public: The raw contents of the page.
+    # Public: The raw contents of the file.
     #
     # Returns the String data.
     def raw_data
@@ -69,7 +139,7 @@ module Gollum
     #
     # Returns true if this is a pointer to an on-disk file
     def on_disk?
-      @on_disk
+      !!@on_disk
     end
 
     # Public: The path to this file on disk
@@ -79,48 +149,29 @@ module Gollum
       @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
+    def self.protected_files
+      ['custom.css', 'custom.js', '.redirects.gollum']
     end
 
-    #########################################################################
-    #
-    # Internal Methods
-    #
-    #########################################################################
+    private
 
     # 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)
+    def get_disk_reference
       return false if @wiki.repo.bare
-      return false if commit.sha != @wiki.repo.head.commit.sha
+      return false if @version.sha != @wiki.repo.head.commit.sha
+      return false if @blob.is_symlink && !FS_SUPPORT_SYMLINKS
 
       # This will try to resolve symbolic links, as well
-      pathname = Pathname.new(::File.expand_path(::File.join(@wiki.repo.path, '..', name)))
+      pathname = Pathname.new(::File.expand_path(::File.join(@wiki.repo.path, '..', @path)))
       if pathname.symlink?
         source   = ::File.readlink(pathname.to_path)
         realpath = ::File.join(::File.dirname(pathname.to_path), source)
@@ -129,36 +180,8 @@ module Gollum
       else
         @on_disk_path = pathname.to_path
       end
-      true
+      @on_disk = 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 (result = 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 = result.blob(@wiki.repo)
-        end
-
-        self
-      end
-    end
   end
 end

data/lib/gollum-lib/file_view.rb

@@ -10,12 +10,13 @@ module Gollum
     # set pages to wiki.pages + wiki.files and show_all to true
     def initialize(pages, options = {})
       @pages    = pages
+      @wiki     = @pages.first ? @pages.first.wiki : nil
       @show_all = options[:show_all] || false
       @checked  = options[:collapse_tree] ? '' : "checked"
     end
 
     def enclose_tree(string)
-      %Q(<ol class="tree">\n) + string + %Q(</ol>)
+      sanitize_html(%Q(<ol class="tree">\n) + string + %Q(</ol>))
     end
 
     def new_page(page)
@@ -96,7 +97,7 @@ module Gollum
         </li>
         HTML
 
-        return enclose_tree html
+        return enclose_tree(html)
       end
 
       sorted_folders = []
@@ -153,8 +154,11 @@ module Gollum
         changed = false
       end
 
-      # return the completed html
-      enclose_tree html
+      enclose_tree(html)
     end # end render_files
+
+    def sanitize_html(data)
+      @wiki ? @wiki.sanitizer.clean(data) : data
+    end
   end # end FileView class
 end # end Gollum module

data/lib/gollum-lib/filter.rb

@@ -47,14 +47,21 @@ module Gollum
   class Filter
     include Gollum::Helpers
 
+    PLACEHOLDER_PATTERN = /%(\S+)%.+=\1=/
+
     # 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    = {}
+      @open_pattern = "%#{self.class.to_s.split('::').last}%"
+      @close_pattern = "=#{self.class.to_s.split('::').last}="
     end
 
+    attr_reader :open_pattern, :close_pattern
+
     def extract(data)
       raise RuntimeError,
             "#{self.class} has not implemented ##extract!"
@@ -66,6 +73,11 @@ module Gollum
     end
 
     protected
+
+    def sanitize(data)
+      @markup.wiki.sanitizer.clean(data, @markup.historical)
+    end
+
     # Render a (presumably) non-fatal error as HTML
     #
     def html_error(message)

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

@@ -14,31 +14,27 @@ class Gollum::Filter::Code < Gollum::Filter
       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]*}
+      org_begin = %r{([ \t]*)#\+BEGIN_SRC#{org_lang}\r?\n}
+      org_end = %r{\r?\n[ \t]*#\+END_SRC[ \t\r]*}
       data.gsub!(/^#{org_headers}#{org_name}#{org_begin}(.+?)#{org_end}$/mi) do
-        cache_codeblock(Regexp.last_match[3], Regexp.last_match[4])
+        "#{Regexp.last_match[3]}#{cache_codeblock(Regexp.last_match[4], Regexp.last_match[5])}"
       end
     when :markdown
-      data.gsub!(/^([ \t]*)(~~~+) ?([^\r\n]+)?\r?\n(.+?)\r?\n\1(~~~+)[ \t\r]*$/m) do
+      data.gsub!(/^([ ]{0,3})(~~~+) ?([^\r\n]+)?\r?\n(.+?)\r?\n[ ]{0,3}(~~~+)[ \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
+        # The closing code fence must be at least as long as the opening fence
+        next '' if m_end.length < m_start.length
+        lang = m_lang ? m_lang.strip.split.first : nil
         "#{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
+    data.gsub!(/^([ ]{0,3})``` ?([^\r\n]+)?\r?\n(.+?)\r?\n[ ]{0,3}```[ \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
@@ -133,7 +129,7 @@ class Gollum::Filter::Code < Gollum::Filter
 
   def cache_codeblock(language, code, indent = "")
     language = language.to_s.empty? ? nil : language
-    id = Digest::SHA1.hexdigest("#{language}.#{code}")
+    id = "#{open_pattern}#{Digest::SHA1.hexdigest("#{language}.#{code}")}#{close_pattern}"
     cached = @markup.check_cache(:code, id)
     @map[id] = cached ?
       { :output => cached } :

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

@@ -0,0 +1,97 @@
+# ~*~ encoding: utf-8 ~*~
+
+# CriticMarkup
+#
+# Render CriticMarkup
+
+class Gollum::Filter::CriticMarkup < Gollum::Filter
+
+  # Patterns inspired by https://github.com/DivineDominion/criticmarkup.tmbundle/blob/master/Syntaxes/criticmarkup.tmLanguage
+  # All patterns use multiline matching (m flag)
+  # Logic inspired by https://github.com/CriticMarkup/CriticMarkup-toolkit/blob/master/CLI/criticParser_CLI.py
+  
+  ADDITION_PATTERN      = %r|{\+\+(?<content>.*?)\+\+[ \t]*(\[(.*?)\])?[ \t]*\}|m
+  DELETION_PATTERN      = %r|{--(?<content>.*?)--[ \t]*(\[(.*?)\])?[ \t]*\}|m
+  SUBSTITUTION_PATTERN  = %r|{~~(?<oldcontent>.*?)~>(?<newcontent>.*?)~~}|m
+  HIGHLIGHT_PATTERN     = %r|{\=\=(?<content>.*?)[ \t]*(\[(.*?)\])?[ \t]*\=\=\}{>>(?<comment>.*?)<<}|m
+  COMMENT_PATTERN       = %r|{>>(?<content>.*?)<<}|m
+
+  def extract(data)
+    data.gsub! ADDITION_PATTERN do
+      content = $~[:content]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+    	# Is there a new paragraph followed by new text
+      if content.start_with?("\n\n") && content != "\n\n"
+        html = "\n\n<ins class='critic break'>&nbsp;</ins>\n\n<ins>#{content.gsub('\n', ' ')}</ins>"
+    	# Is the addition just a single new paragraph
+      elsif content == "\n\n"
+        html = "\n\n<ins class='critic break'>&nbsp;</ins>\n\n"
+    	# Is it added text followed by a new paragraph?
+      elsif content.end_with?("\n\n") && content != "\n\n"
+  	    html = "<ins>#{content.gsub('\n', ' ')}</ins>\n\n<ins class='critic break'>&nbsp;</ins>\n\n"
+      else
+        html = "<ins>#{content.gsub('\n', ' ')}</ins>"
+      end
+      @map[placeholder] = html
+      placeholder
+    end
+    
+    data.gsub! DELETION_PATTERN do
+      content = $~[:content]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+      if content == "\n\n"
+        html = "<del>&nbsp;</del>"
+      else
+        html = "<del>#{content.gsub('\n\n', ' ')}</del>"
+      end
+      @map[placeholder] = html
+      placeholder
+    end   
+    
+    data.gsub! SUBSTITUTION_PATTERN do
+      oldcontent = $~[:oldcontent]
+      newcontent = $~[:newcontent]
+      placeholder = generate_placeholder("#{oldcontent}#{newcontent}#{@map.size}")
+      html = "<del>#{oldcontent}</del><ins>#{newcontent}</ins>"
+      @map[placeholder] = html
+      placeholder
+    end
+
+    data.gsub! HIGHLIGHT_PATTERN do
+      content = $~[:content]
+      comment = $~[:comment]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+      html = "<mark>#{content}</mark><span class='critic comment'>#{comment}</span>"
+      @map[placeholder] = html
+      placeholder
+    end
+    
+    data.gsub! COMMENT_PATTERN do
+      content = $~[:content]
+      placeholder = generate_placeholder("#{content}#{@map.size}")
+      html = "<span class='critic comment'>#{content}</span>"
+      @map[placeholder] = html
+      placeholder
+    end
+    
+    data
+  end
+
+  def process(data)
+    data.gsub! process_pattern do 
+      @map[$~[:placeholder]]
+    end
+    data
+  end
+
+  private
+
+  def process_pattern
+    /(?<placeholder>#{open_pattern}\h{40}#{close_pattern})/
+  end
+
+  def generate_placeholder(content)
+    "#{open_pattern}#{Digest::SHA1.hexdigest(content)}#{close_pattern}"
+  end
+
+end