gitlab-gollum-lib 1.0.0

data/lib/gollum-lib/file.rb

@@ -0,0 +1,101 @@
+# ~*~ encoding: utf-8 ~*~
+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
+    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
+      @blob && @blob.name
+    end
+    alias filename name
+
+    # 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: The Grit::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.mime_type
+    end
+
+    # Populate the File with information from the Blob.
+    #
+    # blob - The Grit::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]
+      self
+    end
+
+    #########################################################################
+    #
+    # Internal Methods
+    #
+    #########################################################################
+
+    # Find a file in the given Gollum repo.
+    #
+    # name    - The full String path.
+    # version - The String version ID to find.
+    #
+    # Returns a Gollum::File or nil if the file could not be found.
+    def find(name, version)
+      checked = name.downcase
+      map     = @wiki.tree_map_for(version)
+      if entry = 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)
+        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/git_access.rb

@@ -0,0 +1,249 @@
+# ~*~ 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 = false)
+      @page_file_dir = page_file_dir
+      @path = path
+      @repo = Grit::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 Grit::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 Grit::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 Grit::Commit instance.
+    #
+    #     {"abcd123" => <Grit::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)
+      @repo.git.rev_list({:max_count=>1}, ref)
+    rescue Grit::GitRuby::Repository::NoSuchShaFound
+    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.git.native(:ls_tree,
+        {:r => true, :l => true, :z => true}, sha)
+      if tree.respond_to?(:force_encoding)
+        tree.force_encoding("UTF-8")
+      end
+      items = tree.split("\0").inject([]) do |memo, line|
+        memo << parse_tree_line(line)
+      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 Grit::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