jugyo-gollum 1.3.1

data/lib/gollum.rb

@@ -0,0 +1,40 @@
+# stdlib
+require 'digest/md5'
+require 'ostruct'
+
+# external
+require 'grit'
+require 'github/markup'
+require 'sanitize'
+
+# internal
+require 'gollum/git_access'
+require 'gollum/committer'
+require 'gollum/pagination'
+require 'gollum/blob_entry'
+require 'gollum/wiki'
+require 'gollum/page'
+require 'gollum/file'
+require 'gollum/markup'
+require 'gollum/albino'
+require 'gollum/sanitization'
+
+module Gollum
+  VERSION = '1.3.1'
+
+  class Error < StandardError; end
+
+  class DuplicatePageError < Error
+    attr_accessor :dir
+    attr_accessor :existing_path
+    attr_accessor :attempted_path
+
+    def initialize(dir, existing, attempted, message = nil)
+      @dir            = dir
+      @existing_path  = existing
+      @attempted_path = attempted
+      super(message || "Cannot write #{@dir}/#{@attempted_path}, found #{@dir}/#{@existing_path}.")
+    end
+  end
+end
+

data/lib/gollum/albino.rb

@@ -0,0 +1,5 @@
+require 'albino/multi'
+
+class Gollum::Albino < Albino::Multi
+  self.bin = ::Albino::Multi.bin
+end

data/lib/gollum/blob_entry.rb

@@ -0,0 +1,78 @@
+module Gollum
+  class BlobEntry
+    # Gets the String SHA for this blob.
+    attr_reader :sha
+
+    # Gets the full path String for this blob.
+    attr_reader :path
+
+    # Gets the Fixnum size of this blob.
+    attr_reader :size
+
+    def initialize(sha, path, size = nil)
+      @sha  = sha
+      @path = path
+      @size = size
+      @dir  = @name = @blob = nil
+    end
+
+    # Gets the normalized directory path String for this blob.
+    def dir
+      @dir ||= self.class.normalize_dir(::File.dirname(@path))
+    end
+
+    # Gets the file base name String for this blob.
+    def name
+      @name ||= ::File.basename(@path)
+    end
+
+    # Gets a Grit::Blob instance for this blob.
+    #
+    # repo - Grit::Repo instance for the Grit::Blob.
+    #
+    # Returns an unbaked Grit::Blob instance.
+    def blob(repo)
+      @blob ||= Grit::Blob.create(repo,
+        :id => @sha, :name => name, :size => @size)
+    end
+
+    # Gets a Page instance for this blob.
+    #
+    # wiki - Gollum::Wiki instance for the Gollum::Page
+    #
+    # Returns a Gollum::Page instance.
+    def page(wiki, commit)
+      blob = self.blob(wiki.repo)
+      page = wiki.page_class.new(wiki).populate(blob, self.dir)
+      page.version = commit
+      page
+    end
+
+    def inspect
+      %(#<Gollum::BlobEntry #{@sha} #{@path}>)
+    end
+
+    # Normalizes a given directory name for searching through tree paths.
+    # Ensures that a directory begins with a slash, or
+    #
+    #   normalize_dir("")      # => ""
+    #   normalize_dir(".")     # => ""
+    #   normalize_dir("foo")   # => "/foo"
+    #   normalize_dir("/foo/") # => "/foo"
+    #   normalize_dir("/")     # => ""
+    #   normalize_dir("c:/")   # => ""
+    #
+    # dir - String directory name.
+    #
+    # Returns a normalized String directory name, or nil if no directory
+    # is given.
+    def self.normalize_dir(dir)
+      return '' if dir =~ /^.:\/$/
+      if dir
+        dir = ::File.expand_path(dir, '/')
+        dir = '' if dir == '/'
+      end
+      dir
+    end
+  end
+end

data/lib/gollum/committer.rb

@@ -0,0 +1,217 @@
+module Gollum
+  # Responsible for handling the commit process for a Wiki.  It sets up the 
+  # Git index, provides methods for modifying the tree, and stores callbacks
+  # to be fired after the commit has been made.  This is specifically 
+  # designed to handle multiple updated pages in a single commit.
+  class Committer
+    # Gets the instance of the Gollum::Wiki that is being updated.
+    attr_reader :wiki
+
+    # Gets a Hash of commit options.
+    attr_reader :options
+
+    # Initializes the Committer.
+    #
+    # wiki    - The Gollum::Wiki instance that is being updated.
+    # options - The commit Hash details:
+    #           :message   - The String commit message.
+    #           :name      - The String author full name.
+    #           :email     - The String email address.
+    #           :parent    - Optional Grit::Commit parent to this update.
+    #           :tree      - Optional String SHA of the tree to create the
+    #                        index from.
+    #           :committer - Optional Gollum::Committer instance.  If provided,
+    #                        assume that this operation is part of batch of 
+    #                        updates and the commit happens later.
+    #
+    # Returns the Committer instance.
+    def initialize(wiki, options = {})
+      @wiki      = wiki
+      @options   = options
+      @callbacks = []
+    end
+
+    # Public: References the Git index for this commit.
+    #
+    # Returns a Grit::Index.
+    def index
+      @index ||= begin
+        idx = @wiki.repo.index
+        if tree   = options[:tree]
+          idx.read_tree(tree)
+        elsif parent = parents.first
+          idx.read_tree(parent.tree.id)
+        end
+        idx
+      end
+    end
+
+    # Public: The committer for this commit.
+    #
+    # Returns a Grit::Actor.
+    def actor
+      @actor ||= begin
+        @options[:name]  = @wiki.default_committer_name  if @options[:name].to_s.empty?
+        @options[:email] = @wiki.default_committer_email if @options[:email].to_s.empty?
+        Grit::Actor.new(@options[:name], @options[:email])
+      end
+    end
+
+    # Public: The parent commits to this pending commit.
+    #
+    # Returns an array of Grit::Commit instances.
+    def parents
+      @parents ||= begin
+        arr = [@options[:parent] || @wiki.repo.commit(@wiki.ref)]
+        arr.flatten!
+        arr.compact!
+        arr
+      end
+    end
+
+    # Adds a page to the given Index.
+    #
+    # dir    - The String subdirectory of the Gollum::Page without any
+    #          prefix or suffix slashes (e.g. "foo/bar").
+    # name   - The String Gollum::Page name.
+    # format - The Symbol Gollum::Page format.
+    # data   - The String wiki data to store in the tree map.
+    # allow_same_ext - A Boolean determining if the tree map allows the same
+    #                  filename with the same extension.
+    #
+    # Raises Gollum::DuplicatePageError if a matching filename already exists.
+    # This way, pages are not inadvertently overwritten.
+    #
+    # Returns nothing (modifies the Index in place).
+    def add_to_index(dir, name, format, data, allow_same_ext = false)
+      path = @wiki.page_file_name(name, format)
+
+      dir = '/' if dir.strip.empty?
+
+      fullpath = ::File.join(*[@wiki.page_file_dir, dir, path].compact)
+      fullpath = fullpath[1..-1] if fullpath =~ /^\//
+
+      if index.current_tree && tree = index.current_tree / dir
+        downpath = path.downcase.sub(/\.\w+$/, '')
+
+        tree.blobs.each do |blob|
+          next if page_path_scheduled_for_deletion?(index.tree, fullpath)
+          file = blob.name.downcase.sub(/\.\w+$/, '')
+          file_ext = ::File.extname(blob.name).sub(/^\./, '')
+          if downpath == file && !(allow_same_ext && file_ext == ext)
+            raise DuplicatePageError.new(dir, blob.name, path)
+          end
+        end
+      end
+
+      index.add(fullpath, @wiki.normalize(data))
+    end
+
+    # Update the given file in the repository's working directory if there
+    # is a working directory present.
+    #
+    # dir    - The String directory in which the file lives.
+    # name   - The String name of the page (may be in human format).
+    # format - The Symbol format of the page.
+    #
+    # Returns nothing.
+    def update_working_dir(dir, name, format)
+      unless @wiki.repo.bare
+        if @wiki.page_file_dir
+          dir = dir.size.zero? ? @wiki.page_file_dir : ::File.join(dir, @wiki.page_file_dir)
+        end
+
+        path =
+          if dir == ''
+            @wiki.page_file_name(name, format)
+          else
+            ::File.join(dir, @wiki.page_file_name(name, format))
+          end
+
+        Dir.chdir(::File.join(@wiki.repo.path, '..')) do
+          if file_path_scheduled_for_deletion?(index.tree, path)
+            @wiki.repo.git.rm({'f' => true}, '--', path)
+          else
+            @wiki.repo.git.checkout({}, 'HEAD', '--', path)
+          end
+        end
+      end
+    end
+
+    # Writes the commit to Git and runs the after_commit callbacks.
+    #
+    # Returns the String SHA1 of the new commit.
+    def commit
+      sha1 = index.commit(@options[:message], parents, actor, nil, @wiki.ref)
+      @callbacks.each do |cb|
+        cb.call(self, sha1)
+      end
+      sha1
+    end
+
+    # Adds a callback to be fired after a commit.
+    #
+    # block - A block that expects this Committer instance and the created 
+    #         commit's SHA1 as the arguments.
+    #
+    # Returns nothing.
+    def after_commit(&block)
+      @callbacks << block
+    end
+
+    # Determine if a given page (regardless of format) is scheduled to be
+    # deleted in the next commit for the given Index.
+    #
+    # map   - The Hash map:
+    #         key - The String directory or filename.
+    #         val - The Hash submap or the String contents of the file.
+    # path - The String path of the page file. This may include the format
+    #         extension in which case it will be ignored.
+    #
+    # Returns the Boolean response.
+    def page_path_scheduled_for_deletion?(map, path)
+      parts = path.split('/')
+      if parts.size == 1
+        deletions = map.keys.select { |k| !map[k] }
+        downfile = parts.first.downcase.sub(/\.\w+$/, '')
+        deletions.any? { |d| d.downcase.sub(/\.\w+$/, '') == downfile }
+      else
+        part = parts.shift
+        if rest = map[part]
+          page_path_scheduled_for_deletion?(rest, parts.join('/'))
+        else
+          false
+        end
+      end
+    end
+
+    # Determine if a given file is scheduled to be deleted in the next commit
+    # for the given Index.
+    #
+    # map   - The Hash map:
+    #         key - The String directory or filename.
+    #         val - The Hash submap or the String contents of the file.
+    # path - The String path of the file including extension.
+    #
+    # Returns the Boolean response.
+    def file_path_scheduled_for_deletion?(map, path)
+      parts = path.split('/')
+      if parts.size == 1
+        deletions = map.keys.select { |k| !map[k] }
+        deletions.any? { |d| d == parts.first }
+      else
+        part = parts.shift
+        if rest = map[part]
+          file_path_scheduled_for_deletion?(rest, parts.join('/'))
+        else
+          false
+        end
+      end
+    end
+
+    # Proxies methods t
+    def method_missing(name, *args)
+      index.send(name, *args)
+    end
+  end
+end

data/lib/gollum/file.rb

@@ -0,0 +1,64 @@
+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 on-disk filename of the file.
+    #
+    # Returns the String name.
+    def name
+      @blob && @blob.name
+    end
+
+    # Public: The raw contents of the page.
+    #
+    # Returns the String data.
+    def raw_data
+      @blob && @blob.data
+    end
+
+    # Public: The Grit::Commit version of the file.
+    attr_reader :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
+
+    #########################################################################
+    #
+    # 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/frontend/app.rb

@@ -0,0 +1,215 @@
+require 'cgi'
+require 'sinatra'
+require 'gollum'
+require 'mustache/sinatra'
+
+require 'gollum/frontend/views/layout'
+require 'gollum/frontend/views/editable'
+
+module Precious
+  class App < Sinatra::Base
+    register Mustache::Sinatra
+
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    # We want to serve public assets for now
+
+    set :public,    "#{dir}/public"
+    set :static,    true
+
+    set :mustache, {
+      # Tell mustache where the Views constant lives
+      :namespace => Precious,
+
+      # Mustache templates live here
+      :templates => "#{dir}/templates",
+
+      # Tell mustache where the views are
+      :views => "#{dir}/views"
+    }
+
+    # Sinatra error handling
+    configure :development, :staging do
+      enable :show_exceptions, :dump_errors
+      disable :raise_errors, :clean_trace
+    end
+
+    configure :test do
+      enable :logging, :raise_errors, :dump_errors
+    end
+
+    get '/' do
+      show_page_or_file('Home')
+    end
+
+    get '/edit/*' do
+      @name = params[:splat].first
+      wiki = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      if page = wiki.page(@name)
+        @page = page
+        @content = page.raw_data
+        mustache :edit
+      else
+        mustache :create
+      end
+    end
+
+    post '/edit/*' do
+      wiki = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      page = wiki.page(params[:splat].first)
+      name = params[:rename] || page.name
+      committer = Gollum::Committer.new(wiki, commit_message)
+      commit    = {:committer => committer}
+
+      update_wiki_page(wiki, page, params[:content], commit, name,
+        params[:format])
+      update_wiki_page(wiki, page.footer,  params[:footer],  commit) if params[:footer]
+      update_wiki_page(wiki, page.sidebar, params[:sidebar], commit) if params[:sidebar]
+      committer.commit
+
+      redirect "/#{CGI.escape(Gollum::Page.cname(name))}"
+    end
+
+    post '/create' do
+      name = params[:page]
+      wiki = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+
+      format = params[:format].intern
+
+      begin
+        wiki.write_page(name, format, params[:content], commit_message)
+        redirect "/#{CGI.escape(name)}"
+      rescue Gollum::DuplicatePageError => e
+        @message = "Duplicate page: #{e.message}"
+        mustache :error
+      end
+    end
+
+    post '/revert/:page/*' do
+      wiki  = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      @name = params[:page]
+      @page = wiki.page(@name)
+      shas  = params[:splat].first.split("/")
+      sha1  = shas.shift
+      sha2  = shas.shift
+
+      if wiki.revert_page(@page, sha1, sha2, commit_message)
+        redirect "/#{CGI.escape(@name)}"
+      else
+        sha2, sha1 = sha1, "#{sha1}^" if !sha2
+        @versions = [sha1, sha2]
+        diffs     = wiki.repo.diff(@versions.first, @versions.last, @page.path)
+        @diff     = diffs.first
+        @message  = "The patch does not apply."
+        mustache :compare
+      end
+    end
+
+    post '/preview' do
+      wiki      = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      @name     = "Preview"
+      @page     = wiki.preview_page(@name, params[:content], params[:format])
+      @content  = @page.formatted_data
+      @editable = false
+      mustache :page
+    end
+
+    get '/history/:name' do
+      @name     = params[:name]
+      wiki      = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      @page     = wiki.page(@name)
+      @page_num = [params[:page].to_i, 1].max
+      @versions = @page.versions :page => @page_num
+      mustache :history
+    end
+
+    post '/compare/:name' do
+      @versions = params[:versions] || []
+      if @versions.size < 2
+        redirect "/history/#{CGI.escape(params[:name])}"
+      else
+        redirect "/compare/%s/%s...%s" % [
+          CGI.escape(params[:name]),
+          @versions.last,
+          @versions.first]
+      end
+    end
+
+    get '/compare/:name/:version_list' do
+      @name     = params[:name]
+      @versions = params[:version_list].split(/\.{2,3}/)
+      wiki      = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      @page     = wiki.page(@name)
+      diffs     = wiki.repo.diff(@versions.first, @versions.last, @page.path)
+      @diff     = diffs.first
+      mustache :compare
+    end
+
+    get %r{^/(javascript|css|images)} do
+      halt 404
+    end
+
+    get %r{/(.+?)/([0-9a-f]{40})} do
+      name = params[:captures][0]
+      wiki = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      if page = wiki.page(name, params[:captures][1])
+        @page = page
+        @name = name
+        @content = page.formatted_data
+        @editable = true
+        mustache :page
+      else
+        halt 404
+      end
+    end
+
+    get '/search' do
+      @query = params[:q]
+      wiki = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      @results = wiki.search @query
+      @name = @query
+      mustache :search
+    end
+
+    get '/pages' do
+      wiki = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      @results = wiki.pages
+      @ref = wiki.ref
+      mustache :pages
+    end
+
+    get '/*' do
+      show_page_or_file(params[:splat].first)
+    end
+
+    def show_page_or_file(name)
+      wiki = Gollum::Wiki.new(settings.gollum_path, settings.wiki_options)
+      if page = wiki.page(name)
+        @page = page
+        @name = name
+        @content = page.formatted_data
+        @editable = true
+        mustache :page
+      elsif file = wiki.file(name)
+        content_type file.mime_type
+        file.raw_data
+      else
+        @name = name
+        mustache :create
+      end
+    end
+
+    def update_wiki_page(wiki, page, content, commit_message, name = nil, format = nil)
+      return if !page ||  
+        ((!content || page.raw_data == content) && page.format == format)
+      name    ||= page.name
+      format    = (format || page.format).to_sym
+      content ||= page.raw_data
+      wiki.update_page(page, name, format, content.to_s, commit_message)
+    end
+
+    def commit_message
+      { :message => params[:message] }
+    end
+  end
+end