gollum-lib 4.0.3-java

data/lib/gollum-lib/helpers.rb

@@ -0,0 +1,13 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+  module Helpers
+
+    def trim_leading_slash url
+      return url if url.nil?
+      url.gsub!('%2F', '/')
+      return '/' + url.gsub(/^\/+/, '') if url[0, 1] == '/'
+      url
+    end
+
+  end
+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

data/lib/gollum-lib/macro.rb

@@ -0,0 +1,43 @@
+module Gollum
+  class Macro
+    # Find the macro named, create an instance of that, and return it
+    def self.instance(macro_name, wiki, page)
+      begin
+        self.const_get(macro_name).new(wiki, page)
+      rescue NameError
+        Unknown_Macro.new(macro_name)
+      end
+    end
+
+    def initialize(wiki, page)
+      @wiki = wiki
+      @page = page
+    end
+
+    def render(*_args)
+      raise ArgumentError,
+            "#{self.class} does not implement #render.  "+
+            "This is a bug in #{self.class}."
+    end
+    
+    protected
+    def html_error(s)
+      "<p class=\"gollum-error\">#{s}</p>"
+    end
+
+    # The special class we reserve for only the finest of screwups.  The
+    # underscore is to make sure nobody can define a real, callable macro
+    # with the same name, because that would be... exciting.
+    class Unknown_Macro < Macro
+      def initialize(macro_name)
+        @macro_name = macro_name
+      end
+
+      def render(*_args)
+        "!!!Unknown macro: #{@macro_name}!!!"
+      end
+    end
+  end
+end
+
+Dir[File.expand_path('../macro/*.rb', __FILE__)].each { |f| require f }

data/lib/gollum-lib/macro/all_pages.rb

@@ -0,0 +1,11 @@
+module Gollum
+  class Macro
+    class AllPages < Gollum::Macro
+      def render
+        if @wiki.pages.size > 0
+          '<ul id="pages">' + @wiki.pages.map { |p| "<li>#{p.name}</li>" }.join + '</ul>'
+        end
+      end
+    end
+  end
+end

data/lib/gollum-lib/markup.rb

@@ -0,0 +1,197 @@
+# ~*~ encoding: utf-8 ~*~
+require 'digest/sha1'
+require 'cgi'
+require 'rouge'
+require 'base64'
+
+require File.expand_path '../helpers', __FILE__
+
+# Use pygments if it's installed
+begin
+  require 'pygments'
+  Pygments.start
+rescue Exception
+end
+
+module Gollum
+
+  class Markup
+    include Helpers
+
+    @formats = {}
+
+    class << self
+
+      # Only use the formats that are specified in config.rb
+      def formats
+        if defined? Gollum::Page::FORMAT_NAMES
+          @formats.select { |_, value| Gollum::Page::FORMAT_NAMES.values.include? value[:name] }
+        else
+          @formats
+        end
+      end
+
+      # Register a file extension and associated markup type
+      #
+      # ext     - The file extension
+      # name    - The name of the markup type
+      # options - Hash of options:
+      #           regexp - Regexp to match against.
+      #                    Defaults to exact match of ext.
+      #
+      # If given a block, that block will be registered with GitHub::Markup to
+      # render any matching pages
+      def register(ext, name, options = {}, &block)
+        regexp        = options[:regexp] || Regexp.new(ext.to_s)
+        @formats[ext] = { :name => name, :regexp => regexp }
+      end
+    end
+
+    attr_accessor :toc
+    attr_accessor :metadata
+    attr_reader :encoding
+    attr_reader :sanitize
+    attr_reader :format
+    attr_reader :wiki
+    attr_reader :page
+    attr_reader :parent_page
+    attr_reader :sub_page
+    attr_reader :name
+    attr_reader :include_levels
+    attr_reader :to_xml_opts
+    attr_reader :dir
+
+    # Initialize a new Markup object.
+    #
+    # page - The Gollum::Page.
+    #
+    # Returns a new Gollum::Markup object, ready for rendering.
+    def initialize(page)
+      if page
+        @wiki        = page.wiki
+        @name        = page.filename
+        @data        = page.text_data
+        @version     = page.version.id if page.version
+        @format      = page.format
+        @sub_page    = page.sub_page
+        @parent_page = page.parent_page
+        @page        = page
+        @dir         = ::File.dirname(page.path)
+      end
+      @metadata    = nil
+      @to_xml_opts = { :save_with => Nokogiri::XML::Node::SaveOptions::DEFAULT_XHTML ^ 1, :indent => 0, :encoding => 'UTF-8' }
+    end
+
+    # Render data using default chain in the target format.
+    #
+    # data - the data to render
+    # format - format to use as a symbol
+    # name - name using the extension of the format
+    #
+    # Returns the processed data
+    def render_default data, format=:markdown, name='render_default.md'
+      # set instance vars so we're able to render data without a wiki or page.
+      @format = format
+      @name   = name
+
+      chain = [:Metadata, :PlainText, :TOC, :RemoteCode, :Code, :Sanitize, :WSD, :Tags, :Render]
+
+      filter_chain = chain.map do |r|
+        Gollum::Filter.const_get(r).new(self)
+      end
+
+      process_chain data, filter_chain
+    end
+
+    # Process the filter chain
+    #
+    # data - the data to send through the chain
+    # filter_chain - the chain to process
+    #
+    # Returns the formatted data
+    def process_chain(data, filter_chain)
+      # First we extract the data through the chain...
+      filter_chain.each do |filter|
+        data = filter.extract(data)
+      end
+
+      # Then we process the data through the chain *backwards*
+      filter_chain.reverse.each do |filter|
+        data = filter.process(data)
+      end
+
+      # Finally, a little bit of cleanup, just because
+      data.gsub!(/<p><\/p>/) do
+        ''
+      end
+
+      data
+    end
+
+    # Render the content with Gollum wiki syntax on top of the file's own
+    # markup language.
+    #
+    # no_follow - Boolean that determines if rel="nofollow" is added to all
+    #             <a> tags.
+    # encoding  - Encoding Constant or String.
+    #
+    # Returns the formatted String content.
+    def render(no_follow = false, encoding = nil, include_levels = 10)
+      @sanitize = no_follow ?
+          @wiki.history_sanitizer :
+          @wiki.sanitizer
+
+      @encoding       = encoding
+      @include_levels = include_levels
+
+      data         = @data.dup
+      filter_chain = @wiki.filter_chain.map do |r|
+        Gollum::Filter.const_get(r).new(self)
+      end
+
+      # Since the last 'extract' action in our chain *should* be the markup
+      # to HTML converter, we now have HTML which we can parse and yield, for
+      # anyone who wants it
+      if block_given?
+        yield Nokogiri::HTML::DocumentFragment.parse(data)
+      end
+
+      process_chain data, filter_chain
+    end
+
+    # Find the given file in the repo.
+    #
+    # name - The String absolute or relative path of the file.
+    #
+    # Returns the Gollum::File or nil if none was found.
+    def find_file(name, version=@version)
+      if name =~ /^\//
+        @wiki.file(name[1..-1], version)
+      else
+        path = @dir == '.' ? name : ::File.join(@dir, name)
+        @wiki.file(path, version)
+      end
+    end
+
+    # Hook for getting the formatted value of extracted tag data.
+    #
+    # type - Symbol value identifying what type of data is being extracted.
+    # id   - String SHA1 hash of original extracted tag data.
+    #
+    # Returns the String cached formatted data, or nil.
+    def check_cache(type, id)
+    end
+
+    # Hook for caching the formatted value of extracted tag data.
+    #
+    # type - Symbol value identifying what type of data is being extracted.
+    # id   - String SHA1 hash of original extracted tag data.
+    # data - The String formatted value to be cached.
+    #
+    # Returns nothing.
+    def update_cache(type, id, data)
+    end
+  end
+
+  MarkupGFM = Markup
+end

data/lib/gollum-lib/markups.rb

@@ -0,0 +1,20 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+  class Markup
+    
+    GitHub::Markup::Markdown::MARKDOWN_GEMS['kramdown'] = proc { |content|
+        Kramdown::Document.new(content, :auto_ids => false, :input => "markdown").to_html
+    }
+
+    register(:markdown,  "Markdown", :regexp => /md|mkdn?|mdown|markdown/)
+    register(:textile,   "Textile")
+    register(:rdoc,      "RDoc")
+    register(:org,       "Org-mode")
+    register(:creole,    "Creole")
+    register(:rest,      "reStructuredText", :regexp => /re?st(\.txt)?/)
+    register(:asciidoc,  "AsciiDoc")
+    register(:mediawiki, "MediaWiki", :regexp => /(media)?wiki/)
+    register(:pod,       "Pod")
+    register(:txt,       "Plain Text")
+  end
+end

data/lib/gollum-lib/page.rb

@@ -0,0 +1,491 @@
+# ~*~ encoding: utf-8 ~*~
+module Gollum
+  class Page
+    include Pagination
+
+    Wiki.page_class = self
+
+    # Sets a Boolean determing whether this page is a historical version.
+    #
+    # Returns nothing.
+    attr_writer :historical
+
+    # Parent page if this is a sub page
+    #
+    # Returns a Page
+    attr_accessor :parent_page
+
+
+    # Checks a filename against the registered markup extensions
+    #
+    # filename - String filename, like "Home.md"
+    #
+    # Returns e.g. ["Home", :markdown], or [] if the extension is unregistered
+    def self.parse_filename(filename)
+      return [] unless filename =~ /^(.+)\.([a-zA-Z]\w*)$/i
+      pref, ext = $1, $2
+
+      Gollum::Markup.formats.each_pair do |name, format|
+        return [pref, name] if ext =~ format[:regexp]
+      end
+      []
+    end
+
+    # Checks if a filename has a valid, registered extension
+    #
+    # filename - String filename, like "Home.md".
+    #
+    # Returns the matching String basename of the file without the extension.
+    def self.valid_filename?(filename)
+      self.parse_filename(filename).first
+    end
+
+    # Checks if a filename has a valid extension understood by GitHub::Markup.
+    # Also, checks if the filename has no "_" in the front (such as
+    # _Footer.md).
+    #
+    # filename - String filename, like "Home.md".
+    #
+    # Returns the matching String basename of the file without the extension.
+    def self.valid_page_name?(filename)
+      match = valid_filename?(filename)
+      filename =~ /^_/ ? false : match
+    end
+
+    # Public: The format of a given filename.
+    #
+    # filename - The String filename.
+    #
+    # Returns the Symbol format of the page; one of the registered format types
+    def self.format_for(filename)
+      self.parse_filename(filename).last
+    end
+
+    # Reusable filter to turn a filename (without path) into a canonical name.
+    # Strips extension, converts dashes to spaces.
+    #
+    # Returns the filtered String.
+    def self.canonicalize_filename(filename)
+      strip_filename(filename).gsub('-', ' ')
+    end
+
+    # Reusable filter to strip extension and path from filename
+    #
+    # filename - The string path or filename to strip
+    #
+    # Returns the stripped String.
+    def self.strip_filename(filename)
+      ::File.basename(filename, ::File.extname(filename))
+    end
+
+    # Public: Initialize a page.
+    #
+    # wiki - The Gollum::Wiki in question.
+    #
+    # Returns a newly initialized Gollum::Page.
+    def initialize(wiki)
+      @wiki           = wiki
+      @blob           = @header = @footer = @sidebar = nil
+      @formatted_data = nil
+      @doc            = nil
+      @parent_page    = nil
+    end
+
+    # Public: The on-disk filename of the page including extension.
+    #
+    # Returns the String name.
+    def filename
+      @blob && @blob.name
+    end
+
+    # Public: The on-disk filename of the page with extension stripped.
+    #
+    # Returns the String name.
+    def filename_stripped
+      self.class.strip_filename(filename)
+    end
+
+    # Public: The canonical page name without extension, and dashes converted
+    # to spaces.
+    #
+    # Returns the String name.
+    def name
+      self.class.canonicalize_filename(filename)
+    end
+
+    # Public: The title will be constructed from the
+    # filename by stripping the extension and replacing any dashes with
+    # spaces.
+    #
+    # Returns the fully sanitized String title.
+    def title
+      Sanitize.clean(name).strip
+    end
+
+    # Public: Determines if this is a sub-page
+    # Sub-pages have filenames beginning with an underscore
+    #
+    # Returns true or false.
+    def sub_page
+      filename =~ /^_/
+    end
+
+    # Public: The path of the page within the repo.
+    #
+    # Returns the String path.
+    attr_reader :path
+
+    # Public: The url path required to reach this page within the repo.
+    #
+    # Returns the String url_path
+    def url_path
+      path = if self.path.include?('/')
+               self.path.sub(/\/[^\/]+$/, '/')
+             else
+               ''
+             end
+
+      path << Page.cname(self.name, '-', '-')
+      path
+    end
+
+    # Public: The display form of the url path required to reach this page within the repo.
+    #
+    # Returns the String url_path
+    def url_path_display
+      url_path.gsub("-", " ")
+    end
+
+    # Public: Defines title for page.rb
+    #
+    # Returns the String title
+    def url_path_title
+      metadata_title || url_path_display
+    end
+
+    # Public: Metadata title
+    #
+    # Set with <!-- --- title: New Title --> in page content
+    #
+    # Returns the String title or nil if not defined
+    def metadata_title
+      if metadata
+        title = metadata['title']
+        return title unless title.nil?
+      end
+
+      nil
+    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 raw contents of the page.
+    #
+    # Returns the String data.
+    def raw_data
+      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: A text data encoded in specified encoding.
+    #
+    # encoding - An Encoding or nil
+    #
+    # Returns a character encoding aware String.
+    def text_data(encoding=nil)
+      if raw_data.respond_to?(:encoding)
+        raw_data.force_encoding(encoding || Encoding::UTF_8)
+      else
+        raw_data
+      end
+    end
+
+    # Public: The formatted contents of the page.
+    #
+    # encoding - Encoding Constant or String.
+    #
+    # Returns the String data.
+    def formatted_data(encoding = nil, include_levels = 10, &block)
+      return nil unless @blob
+
+      if @formatted_data && @doc then
+        yield @doc if block_given?
+      else
+        @formatted_data = markup_class.render(historical?, encoding, include_levels) do |doc|
+          @doc = doc
+          yield doc if block_given?
+        end
+      end
+
+      @formatted_data
+    end
+
+    # Public: The table of contents of the page.
+    #
+    # formatted_data - page already marked up in html.
+    #
+    # Returns the String data.
+    def toc_data()
+      return @parent_page.toc_data if @parent_page and @sub_page
+      formatted_data if markup_class.toc == nil
+      markup_class.toc
+    end
+
+    # Public: Embedded metadata.
+    #
+    # Returns Hash of metadata.
+    def metadata()
+      formatted_data if markup_class.metadata == nil
+      markup_class.metadata
+    end
+
+    # Public: The format of the page.
+    #
+    # Returns the Symbol format of the page; one of the registered format types
+    def format
+      self.class.format_for(@blob.name)
+    end
+
+    # Gets the Gollum::Markup instance that will render this page's content.
+    #
+    # Returns a Gollum::Markup instance.
+    def markup_class
+      @markup_class ||= @wiki.markup_classes[format].new(self)
+    end
+
+    # Public: The current version of the page.
+    #
+    # Returns the Gollum::Git::Commit.
+    attr_reader :version
+
+    # Public: All of the versions that have touched the Page.
+    #
+    # options - The options Hash:
+    #           :page     - The Integer page number (default: 1).
+    #           :per_page - The Integer max count of items to return.
+    #           :follow   - Follow's a file across renames, slower.  (default: false)
+    #
+    # Returns an Array of Gollum::Git::Commit.
+    def versions(options = {})
+      @wiki.repo.git.versions_for_path(@path, @wiki.ref, log_pagination_options(options))
+    end
+
+    # Public: The first 7 characters of the current version.
+    #
+    # Returns the first 7 characters of the current version.
+    def version_short
+      version.to_s[0, 7]
+    end
+
+    # Public: The header Page.
+    #
+    # Returns the header Page or nil if none exists.
+    def header
+      @header ||= find_sub_page(:header)
+    end
+
+    # Public: The footer Page.
+    #
+    # Returns the footer Page or nil if none exists.
+    def footer
+      @footer ||= find_sub_page(:footer)
+    end
+
+    # Public: The sidebar Page.
+    #
+    # Returns the sidebar Page or nil if none exists.
+    def sidebar
+      @sidebar ||= find_sub_page(:sidebar)
+    end
+
+    # Gets a Boolean determining whether this page is a historical version.
+    # Historical pages are pulled using exact SHA hashes and format all links
+    # with rel="nofollow"
+    #
+    # Returns true if the page is pulled from a named branch or tag, or false.
+    def historical?
+      !!@historical
+    end
+
+    #########################################################################
+    #
+    # Class Methods
+    #
+    #########################################################################
+
+    # Convert a human page name into a canonical page name.
+    #
+    # name           - The String human page name.
+    # char_white_sub - Substitution for whitespace
+    # char_other_sub - Substitution for other special chars
+    #
+    # Examples
+    #
+    #   Page.cname("Bilbo Baggins")
+    #   # => 'Bilbo-Baggins'
+    #
+    #   Page.cname("Bilbo Baggins",'_')
+    #   # => 'Bilbo_Baggins'
+    #
+    # Returns the String canonical name.
+    def self.cname(name, char_white_sub = '-', char_other_sub = '-')
+      name.respond_to?(:gsub) ?
+          name.gsub(%r{\s}, char_white_sub).gsub(%r{[<>+]}, char_other_sub) :
+          ''
+    end
+
+    # Convert a format Symbol into an extension String.
+    #
+    # format - The format Symbol.
+    #
+    # Returns the String extension (no leading period).
+    def self.format_to_ext(format)
+      format == :markdown ? "md" : format.to_s
+    end
+
+    #########################################################################
+    #
+    # Internal Methods
+    #
+    #########################################################################
+
+    # The underlying wiki repo.
+    #
+    # Returns the Gollum::Wiki containing the page.
+    attr_reader :wiki
+
+    # Set the Gollum::Git::Commit version of the page.
+    #
+    # Returns nothing.
+    attr_writer :version
+
+    # Find a page in the given Gollum repo.
+    #
+    # name    - The human or canonical String page name to find.
+    # version - The String version ID to find.
+    #
+    # Returns a Gollum::Page or nil if the page could not be found.
+    def find(name, version, dir = nil, exact = false)
+      map = @wiki.tree_map_for(version.to_s)
+      if page = find_page_in_tree(map, name, dir, exact)
+        page.version    = version.is_a?(Gollum::Git::Commit) ?
+            version : @wiki.commit_for(version)
+        page.historical = page.version.to_s == version.to_s
+        page
+      end
+    rescue Gollum::Git::NoSuchShaFound
+    end
+
+    # Find a page in a given tree.
+    #
+    # map         - The Array tree map from Wiki#tree_map.
+    # name        - The canonical String page name.
+    # checked_dir - Optional String of the directory a matching page needs
+    #               to be in.  The string should
+    #
+    # Returns a Gollum::Page or nil if the page could not be found.
+    def find_page_in_tree(map, name, checked_dir = nil, exact = false)
+      return nil if !map || name.to_s.empty?
+
+      checked_dir = BlobEntry.normalize_dir(checked_dir)
+      checked_dir = '' if exact && checked_dir.nil?
+      name        = ::File.join(checked_dir, name) if checked_dir
+
+      map.each do |entry|
+        next if entry.name.to_s.empty?
+        path = checked_dir ? ::File.join(entry.dir, entry.name) : entry.name
+        next unless page_match(name, path)
+        return entry.page(@wiki, @version)
+      end
+
+      return nil # nothing was found
+    end
+
+    # Populate the Page with information from the Blob.
+    #
+    # blob - The Gollum::Git::Blob that contains the info.
+    # path - The String directory path of the page file.
+    #
+    # Returns the populated Gollum::Page.
+    def populate(blob, path=nil)
+      @blob = blob
+      @path = "#{path}/#{blob.name}"[1..-1]
+      self
+    end
+
+    # The full directory path for the given tree.
+    #
+    # treemap - The Hash treemap containing parentage information.
+    # tree    - The Gollum::Git::Tree for which to compute the path.
+    #
+    # Returns the String path.
+    def tree_path(treemap, tree)
+      if ptree = treemap[tree]
+        tree_path(treemap, ptree) + '/' + tree.name
+      else
+        ''
+      end
+    end
+
+    # Compare the canonicalized versions of the two names.
+    #
+    # name     - The human or canonical String page name.
+    # path     - the String path on disk (including file extension).
+    #
+    # Returns a Boolean.
+    def page_match(name, path)
+      if match = self.class.valid_filename?(path)
+        @wiki.ws_subs.each do |sub|
+          return true if Page.cname(name).downcase == Page.cname(match, sub).downcase
+        end
+      end
+      false
+    end
+
+    # Loads a sub page.  Sub page names (footers, headers, sidebars) are prefixed with
+    # an underscore to distinguish them from other Pages. If there is not one within
+    # the current directory, starts walking up the directory tree to try and find one
+    # within parent directories.
+    #
+    # name - String page name.
+    #
+    # Returns the Page or nil if none exists.
+    def find_sub_page(name)
+      return nil unless self.version
+      return nil if self.filename =~ /^_/
+      name = "_#{name.to_s.capitalize}"
+      return nil if page_match(name, self.filename)
+
+      dirs = self.path.split('/')
+      dirs.pop
+      map = @wiki.tree_map_for(@wiki.ref, true)
+      while !dirs.empty?
+        if page = find_page_in_tree(map, name, dirs.join('/'))
+          page.parent_page = self
+          return page
+        end
+        dirs.pop
+      end
+
+      if page = find_page_in_tree(map, name, '')
+        page.parent_page = self
+      end
+      page
+    end
+
+    def inspect
+      %(#<#{self.class.name}:#{object_id} #{name} (#{format}) @wiki=#{@wiki.repo.path.inspect}>)
+    end
+  end
+end