gollum 1.1.1 → 1.2.0

data/lib/gollum/sanitization.rb

@@ -0,0 +1,115 @@
+module Gollum
+  # Encapsulate sanitization options.
+  #
+  # This class does not yet support all options of Sanitize library.
+  # See http://github.com/rgrove/sanitize/.
+  class Sanitization
+    # Default whitelisted elements.
+    ELEMENTS = [
+      'a', 'abbr', 'acronym', 'address', 'area', 'b', 'big',
+      'blockquote', 'br', 'button', 'caption', 'center', 'cite',
+      'code', 'col', 'colgroup', 'dd', 'del', 'dfn', 'dir',
+      'div', 'dl', 'dt', 'em', 'fieldset', 'font', 'form', 'h1',
+      'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'input',
+      'ins', 'kbd', 'label', 'legend', 'li', 'map', 'menu',
+      'ol', 'optgroup', 'option', 'p', 'pre', 'q', 's', 'samp',
+      'select', 'small', 'span', 'strike', 'strong', 'sub',
+      'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th',
+      'thead', 'tr', 'tt', 'u', 'ul', 'var'
+    ].freeze
+
+    # Default whitelisted attributes.
+    ATTRIBUTES = {
+      'a'   => ['href'],
+      'img' => ['src'],
+      :all  => ['abbr', 'accept', 'accept-charset',
+                'accesskey', 'action', 'align', 'alt', 'axis',
+                'border', 'cellpadding', 'cellspacing', 'char',
+                'charoff', 'class', 'charset', 'checked', 'cite',
+                'clear', 'cols', 'colspan', 'color',
+                'compact', 'coords', 'datetime', 'dir',
+                'disabled', 'enctype', 'for', 'frame',
+                'headers', 'height', 'hreflang',
+                'hspace', 'ismap', 'label', 'lang',
+                'longdesc', 'maxlength', 'media', 'method',
+                'multiple', 'name', 'nohref', 'noshade',
+                'nowrap', 'prompt', 'readonly', 'rel', 'rev',
+                'rows', 'rowspan', 'rules', 'scope',
+                'selected', 'shape', 'size', 'span',
+                'start', 'summary', 'tabindex', 'target',
+                'title', 'type', 'usemap', 'valign', 'value',
+                'vspace', 'width']
+    }.freeze
+
+    # Default whitelisted protocols for URLs.
+    PROTOCOLS = {
+      'a'   => {'href' => ['http', 'https', 'mailto', :relative]},
+      'img' => {'src'  => ['http', 'https', :relative]}
+    }.freeze
+
+    # Gets an Array of whitelisted HTML elements.  Default: ELEMENTS.
+    attr_reader :elements
+
+    # Gets a Hash describing which attributes are allowed in which HTML
+    # elements.  Default: ATTRIBUTES.
+    attr_reader :attributes
+
+    # Gets a Hash describing which URI protocols are allowed in HTML 
+    # attributes.  Default: PROTOCOLS
+    attr_reader :protocols
+
+    # Gets a Hash describing HTML attributes that Sanitize should add.  
+    # Default: {}
+    attr_reader :add_attributes
+
+    # Sets a boolean determining whether Sanitize allows HTML comments in the
+    # output.  Default: false.
+    attr_writer :allow_comments
+
+    def initialize
+      @elements       = ELEMENTS
+      @attributes     = ATTRIBUTES
+      @protocols      = PROTOCOLS
+      @add_attributes = {}
+      @allow_comments = false
+      yield self if block_given?
+    end
+
+    # Determines if Sanitize should allow HTML comments.
+    #
+    # Returns True if comments are allowed, or False.
+    def allow_comments?
+      !!@allow_comments
+    end
+
+    # Modifies the current Sanitization instance to sanitize older revisions
+    # of pages.
+    #
+    # Returns a Sanitization instance.
+    def history_sanitization
+      self.class.new do |sanitize|
+        sanitize.add_attributes['a'] = {'rel' => 'nofollow'}
+      end
+    end
+
+    # Builds a Hash of options suitable for Sanitize.clean.
+    #
+    # Returns a Hash.
+    def to_hash
+      { :elements       => elements,
+        :attributes     => attributes,
+        :protocols      => protocols,
+        :add_attributes => add_attributes,
+        :allow_comments => allow_comments?
+      }
+    end
+
+    # Builds a Sanitize instance from the current options.
+    #
+    # Returns a Sanitize instance.
+    def to_sanitize
+      Sanitize.new(to_hash)
+    end
+  end
+end
+

data/lib/gollum/wiki.rb

@@ -9,12 +9,23 @@ module Gollum
       # Sets the file class used by all instances of this Wiki.
       attr_writer :file_class
 
+      # Sets the markup class used by all instances of this Wiki.
+      attr_writer :markup_class
+
       # Sets the default name for commits.
       attr_accessor :default_committer_name
 
       # Sets the default email for commits.
       attr_accessor :default_committer_email
 
+      # Sets sanitization options. Set to false to deactivate
+      # sanitization altogether.
+      attr_writer :sanitization
+
+      # Sets sanitization options. Set to false to deactivate
+      # sanitization altogether.
+      attr_writer :history_sanitization
+
       # Gets the page class used by all instances of this Wiki.
       # Default: Gollum::Page.
       def page_class
@@ -36,6 +47,37 @@ module Gollum
             ::Gollum::File
           end
       end
+
+      # Gets the markup class used by all instances of this Wiki.
+      # Default: Gollum::Markup
+      def markup_class
+        @markup_class ||
+          if superclass.respond_to?(:markup_class)
+            superclass.markup_class
+          else
+            ::Gollum::Markup
+          end
+      end
+
+      # Gets the default sanitization options for current pages used by
+      # instances of this Wiki.
+      def sanitization
+        if @sanitization.nil?
+          @sanitization = Sanitization.new
+        end
+        @sanitization
+      end
+
+      # Gets the default sanitization options for older page revisions used by
+      # instances of this Wiki.
+      def history_sanitization
+        if @history_sanitization.nil?
+          @history_sanitization = sanitization ?
+            sanitization.history_sanitization  :
+            false
+        end
+        @history_sanitization
+      end
     end
 
     self.default_committer_name  = 'Anonymous'
@@ -46,31 +88,52 @@ module Gollum
     # to "/".
     attr_reader :base_path
 
+    # Gets the sanitization options for current pages used by this Wiki.
+    attr_reader :sanitization
+
+    # Gets the sanitization options for older page revisions used by this Wiki.
+    attr_reader :history_sanitization
+
+    # Gets the String directory in which all page files reside.
+    attr_reader :page_file_dir
+
     # Public: Initialize a new Gollum Repo.
     #
-    # repo    - The String path to the Git repository that holds the Gollum
+    # path    - The String path to the Git repository that holds the Gollum
     #           site.
     # options - Optional Hash:
-    #           :base_path  - String base path for all Wiki links.
-    #                         Default: "/"
-    #           :page_class - The page Class. Default: Gollum::Page
-    #           :file_class - The file Class. Default: Gollum::File
+    #           :base_path     - String base path for all Wiki links.
+    #                            Default: "/"
+    #           :page_class    - The page Class. Default: Gollum::Page
+    #           :file_class    - The file Class. Default: Gollum::File
+    #           :markup_class  - The markup Class. Default: Gollum::Markup
+    #           :sanitization  - An instance of Sanitization.
+    #           :page_file_dir - String the directory in which all page files reside
     #
     # Returns a fresh Gollum::Repo.
     def initialize(path, options = {})
-      @path       = path
-      @repo       = Grit::Repo.new(path)
-      @base_path  = options[:base_path]  || "/"
-      @page_class = options[:page_class] || self.class.page_class
-      @file_class = options[:file_class] || self.class.file_class
-      clear_cache
+      if path.is_a?(GitAccess)
+        options[:access] = path
+        path             = path.path
+      end
+      @path          = path
+      @page_file_dir = options[:page_file_dir]
+      @access        = options[:access]       || GitAccess.new(path, @page_file_dir)
+      @base_path     = options[:base_path]    || "/"
+      @page_class    = options[:page_class]   || self.class.page_class
+      @file_class    = options[:file_class]   || self.class.file_class
+      @markup_class  = options[:markup_class] || self.class.markup_class
+      @repo          = @access.repo
+      @sanitization  = options[:sanitization] || self.class.sanitization
+      @history_sanitization = options[:history_sanitization] ||
+        self.class.history_sanitization
     end
 
     # Public: check whether the wiki's git repo exists on the filesystem.
     #
     # Returns true if the repo exists, and false if it does not.
     def exist?
-      @repo.git.exist?
+      @access.exist?
     end
 
     # Public: Get the formatted page for a given page name.
@@ -105,10 +168,10 @@ module Gollum
     def preview_page(name, data, format)
       page = @page_class.new(self)
       ext  = @page_class.format_to_ext(format.to_sym)
-      path = @page_class.cname(name) + '.' + ext
-      blob = OpenStruct.new(:name => path, :data => data)
-      page.populate(blob, path)
-      page.version = self.repo.commit("HEAD")
+      name = @page_class.cname(name) + '.' + ext
+      blob = OpenStruct.new(:name => name, :data => data)
+      page.populate(blob)
+      page.version = @access.commit('master')
       page
     end
 
@@ -118,29 +181,36 @@ module Gollum
     # format - The Symbol format of the page.
     # data   - The new String contents of the page.
     # commit - The commit Hash details:
-    #          :message - The String commit message.
-    #          :name    - The String author full name.
-    #          :email   - The String email address.
-    #
-    # Returns the String SHA1 of the newly written version.
+    #          :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 String SHA1 of the newly written version, or the 
+    # Gollum::Committer instance if this is part of a batch update.
     def write_page(name, format, data, commit = {})
-      commit = normalize_commit(commit)
-      index  = self.repo.index
+      multi_commit = false
 
-      if pcommit = @repo.commit('master')
-        index.read_tree(pcommit.tree.id)
+      committer = if obj = commit[:committer]
+        multi_commit = true
+        obj
+      else
+        Committer.new(self, commit)
       end
 
-      add_to_index(index, '', name, format, data)
+      committer.add_to_index('', name, format, data)
 
-      parents = pcommit ? [pcommit] : []
-      actor   = Grit::Actor.new(commit[:name], commit[:email])
-      sha1    = index.commit(commit[:message], parents, actor)
-
-      @ref_map.clear
-      update_working_dir(index, '', name, format)
+      committer.after_commit do |index, sha|
+        @access.refresh
+        index.update_working_dir('', name, format)
+      end
 
-      sha1
+      multi_commit ? committer : committer.commit
     end
 
     # Public: Update an existing page with new content. The location of the
@@ -153,66 +223,160 @@ module Gollum
     # format - The Symbol format of the page.
     # data   - The new String contents of the page.
     # commit - The commit Hash details:
-    #          :message - The String commit message.
-    #          :name    - The String author full name.
-    #          :email   - The String email address.
-    #
-    # Returns the String SHA1 of the newly written version.
+    #          :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 String SHA1 of the newly written version, or the 
+    # Gollum::Committer instance if this is part of a batch update.
     def update_page(page, name, format, data, commit = {})
-      commit   = normalize_commit(commit)
-      pcommit  = @repo.commit('master')
       name   ||= page.name
       format ||= page.format
-      index    = self.repo.index
-
-      dir = ::File.dirname(page.path)
-      dir = '' if dir == '.'
+      dir      = ::File.dirname(page.path)
+      dir      = '' if dir == '.'
+      multi_commit = false
 
-      index.read_tree(pcommit.tree.id)
+      committer = if obj = commit[:committer]
+        multi_commit = true
+        obj
+      else
+        Committer.new(self, commit)
+      end
 
       if page.name == name && page.format == format
-        index.add(page.path, normalize(data))
+        committer.add(page.path, normalize(data))
       else
-        index.delete(page.path)
-        add_to_index(index, dir, name, format, data, :allow_same_ext)
+        committer.delete(page.path)
+        committer.add_to_index(dir, name, format, data, :allow_same_ext)
       end
 
-      actor = Grit::Actor.new(commit[:name], commit[:email])
-      sha1  = index.commit(commit[:message], [pcommit], actor)
-
-      @ref_map.clear
-      update_working_dir(index, dir, page.name, page.format)
-      update_working_dir(index, dir, name, format)
+      committer.after_commit do |index, sha|
+        @access.refresh
+        index.update_working_dir(dir, page.name, page.format)
+        index.update_working_dir(dir, name, format)
+      end
 
-      sha1
+      multi_commit ? committer : committer.commit
     end
 
     # Public: Delete a page.
     #
     # page   - The Gollum::Page to delete.
     # commit - 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 String SHA1 of the newly written version, or the 
+    # Gollum::Committer instance if this is part of a batch update.
+    def delete_page(page, commit)
+      multi_commit = false
+
+      committer = if obj = commit[:committer]
+        multi_commit = true
+        obj
+      else
+        Committer.new(self, commit)
+      end
+      
+      committer.delete(page.path)
+
+      committer.after_commit do |index, sha|
+        dir = ::File.dirname(page.path)
+        dir = '' if dir == '.'
+
+        @access.refresh
+        index.update_working_dir(dir, page.name, page.format)
+      end
+
+      multi_commit ? committer : committer.commit
+    end
+
+    # Public: Applies a reverse diff for a given page.  If only 1 SHA is given,
+    # the reverse diff will be taken from its parent (^SHA...SHA).  If two SHAs
+    # are given, the reverse diff is taken from SHA1...SHA2.
+    #
+    # page   - The Gollum::Page to delete.
+    # sha1   - String SHA1 of the earlier parent if two SHAs are given,
+    #          or the child.
+    # sha2   - Optional String SHA1 of the child.
+    # commit - The commit Hash details:
     #          :message - The String commit message.
     #          :name    - The String author full name.
     #          :email   - The String email address.
-    #
-    # Returns the String SHA1 of the newly written version.
-    def delete_page(page, commit)
-      pcommit = @repo.commit('master')
-
-      index = self.repo.index
-      index.read_tree(pcommit.tree.id)
-      index.delete(page.path)
+    #          :parent  - Optional Grit::Commit parent to this update.
+    #
+    # Returns a String SHA1 of the new commit, or nil if the reverse diff does
+    # not apply.
+    def revert_page(page, sha1, sha2 = nil, commit = {})
+      if sha2.is_a?(Hash)
+        commit = sha2
+        sha2   = nil
+      end
 
-      dir = ::File.dirname(page.path)
-      dir = '' if dir == '.'
+      patch     = full_reverse_diff_for(page, sha1, sha2)
+      committer = Committer.new(self, commit)
+      parent    = committer.parents[0]
+      committer.options[:tree] = @repo.git.apply_patch(parent.sha, patch)
+      return false unless committer.options[:tree]
+      committer.after_commit do |index, sha|
+        @access.refresh
+
+        files = []
+        if page
+          files << [page.path, page.name, page.format]
+        else
+          # Grit::Diff can't parse reverse diffs.... yet
+          patch.each_line do |line|
+            if line =~ %r{^diff --git b/.+? a/(.+)$}
+              path = $1
+              ext  = ::File.extname(path)
+              name = ::File.basename(path, ext)
+              if format = ::Gollum::Page.format_for(ext)
+                files << [path, name, format]
+              end
+            end
+          end
+        end
 
-      actor = Grit::Actor.new(commit[:name], commit[:email])
-      sha1  = index.commit(commit[:message], [pcommit], actor)
+        files.each do |(path, name, format)|
+          dir = ::File.dirname(path)
+          dir = '' if dir == '.'
+          index.update_working_dir(dir, name, format)
+        end
+      end
 
-      @ref_map.clear
-      update_working_dir(index, dir, page.name, page.format)
+      committer.commit
+    end
 
-      sha1
+    # Public: Applies a reverse diff to the repo.  If only 1 SHA is given,
+    # the reverse diff will be taken from its parent (^SHA...SHA).  If two SHAs
+    # are given, the reverse diff is taken from SHA1...SHA2.
+    #
+    # sha1   - String SHA1 of the earlier parent if two SHAs are given,
+    #          or the child.
+    # sha2   - Optional String SHA1 of the child.
+    # commit - The commit Hash details:
+    #          :message - The String commit message.
+    #          :name    - The String author full name.
+    #          :email   - The String email address.
+    #
+    # Returns a String SHA1 of the new commit, or nil if the reverse diff does
+    # not apply.
+    def revert_commit(sha1, sha2 = nil, commit = {})
+      revert_page(nil, sha1, sha2, commit)
     end
 
     # Public: Lists all pages for this wiki.
@@ -224,7 +388,7 @@ module Gollum
       tree_list(treeish || 'master')
     end
 
-    # Public: Returns the number of pages accessible from a commit 
+    # Public: Returns the number of pages accessible from a commit
     #
     # ref - A String ref that is either a commit SHA or references one.
     #
@@ -243,10 +407,10 @@ module Gollum
     #
     # Returns an Array with Objects of page name and count of matches
     def search(query)
-      # See: http://github.com/Sirupsen/gollum/commit/f0a6f52bdaf6bee8253ca33bb3fceaeb27bfb87e
-      search_output = @repo.git.grep({:c => query}, 'master')
+      args = [{}, '-i', '-c', query, 'master', '--']
+      args << '--' << @page_file_dir if @page_file_dir
 
-      search_output.split("\n").collect do |line|
+      @repo.git.grep(*args).split("\n").map! do |line|
         result = line.split(':')
         file_name = Gollum::Page.canonicalize_filename(::File.basename(result[1]))
 
@@ -268,6 +432,34 @@ module Gollum
       @repo.log('master', nil, log_pagination_options(options))
     end
 
+    # Public: Refreshes just the cached Git reference data.  This should
+    # be called after every Gollum update.
+    #
+    # Returns nothing.
+    def clear_cache
+      @access.refresh
+    end
+
+    # Public: Creates a Sanitize instance using the Wiki's sanitization
+    # options.
+    #
+    # Returns a Sanitize instance.
+    def sanitizer
+      if options = sanitization
+        @sanitizer ||= options.to_sanitize
+      end
+    end
+
+    # Public: Creates a Sanitize instance using the Wiki's history sanitization
+    # options.
+    #
+    # Returns a Sanitize instance.
+    def history_sanitizer
+      if options = history_sanitization
+        @history_sanitizer ||= options.to_sanitize
+      end
+    end
+
     #########################################################################
     #
     # Internal Methods
@@ -284,26 +476,15 @@ module Gollum
     # Returns the String path.
     attr_reader :path
 
-    # Gets a Hash cache of refs to commit SHAs.
-    #
-    #   {"master" => "abc123", ...}
-    #
-    # Returns the Hash cache.
-    attr_reader :ref_map
-
-    # Gets a Hash cache of commit SHAs to a recursive tree of blobs.
-    #
-    #   {"abc123" => [["lib/foo.rb", "blob-sha"], [file, sha], ...], ...}
-    #
-    # Returns the Hash cache.
-    attr_reader :tree_map
-
     # Gets the page class used by all instances of this Wiki.
     attr_reader :page_class
 
     # Gets the file class used by all instances of this Wiki.
     attr_reader :file_class
 
+    # Gets the markup class used by all instances of this Wiki.
+    attr_reader :markup_class
+
     # Normalize the data.
     #
     # data - The String data to be normalized.
@@ -324,162 +505,74 @@ module Gollum
       @page_class.cname(name) + '.' + ext
     end
 
-    # Update the given file in the repository's working directory if there
-    # is a working directory present.
-    #
-    # index  - The Grit::Index with which to sync.
-    # 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(index, dir, name, format)
-      unless @repo.bare
-        path =
-        if dir == ''
-          page_file_name(name, format)
-        else
-          ::File.join(dir, page_file_name(name, format))
-        end
-
-        Dir.chdir(::File.join(@repo.path, '..')) do
-          if file_path_scheduled_for_deletion?(index.tree, path)
-            @repo.git.rm({'f' => true}, '--', path)
-          else
-            @repo.git.checkout({}, 'HEAD', '--', path)
-          end
-        end
-      end
-    end
-
     # Fill an array with a list of pages.
     #
     # ref - A String ref that is either a commit SHA or references one.
     #
     # Returns a flat Array of Gollum::Page instances.
     def tree_list(ref)
-      tree_map_for(ref).inject([]) do |list, entry|
+      sha    = @access.ref_to_sha(ref)
+      commit = @access.commit(sha)
+      tree_map_for(sha).inject([]) do |list, entry|
         next list unless @page_class.valid_page_name?(entry.name)
-        sha   = ref_map[ref]
-        list << entry.page(self, @repo.commit(sha))
-      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
+        list << entry.page(self, commit)
       end
     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
-
-    # Adds a page to the given Index.
+    # Creates a reverse diff for the given SHAs on the given Gollum::Page.
     #
-    # index  - The Grit::Index to which the page will be added.
-    # 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.
+    # page   - The Gollum::Page to scope the patch to, or a String Path.
+    # sha1   - String SHA1 of the earlier parent if two SHAs are given,
+    #          or the child.
+    # sha2   - Optional String SHA1 of the child.
     #
-    # 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(index, dir, name, format, data, allow_same_ext = false)
-      path = page_file_name(name, format)
-
-      dir = '/' if dir.strip.empty?
-
-      fullpath = ::File.join(dir, path)
-      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
+    # Returns a String of the reverse Diff to apply.
+    def full_reverse_diff_for(page, sha1, sha2 = nil)
+      sha1, sha2 = "#{sha1}^", sha1 if sha2.nil?
+      args = [{:R => true}, sha1, sha2]
+      if page
+        args << '--' << (page.respond_to?(:path) ? page.path : page.to_s)
       end
-
-      index.add(fullpath, normalize(data))
+      repo.git.native(:diff, *args)
     end
 
-    # Ensures a commit hash has all the required fields for a commit.
+    # Creates a reverse diff for the given SHAs.
     #
-    # commit - The commit Hash details:
-    #          :message - The String commit message.
-    #          :name    - The String author full name.
-    #          :email   - The String email address.
+    # sha1   - String SHA1 of the earlier parent if two SHAs are given,
+    #          or the child.
+    # sha2   - Optional String SHA1 of the child.
     #
-    # Returns the commit Hash
-    def normalize_commit(commit = {})
-      commit[:name]  = default_committer_name  if commit[:name].to_s.empty?
-      commit[:email] = default_committer_email if commit[:email].to_s.empty?
-      commit
+    # Returns a String of the reverse Diff to apply.
+    def full_reverse_diff(sha1, sha2 = nil)
+      full_reverse_diff_for(nil, sha1, sha2)
     end
 
     # Gets the default name for commits.
+    #
+    # Returns the String name.
     def default_committer_name
       @default_committer_name ||= \
         @repo.config['user.name'] || self.class.default_committer_name
     end
 
     # Gets the default email for commits.
+    #
+    # Returns the String email address.
     def default_committer_email
       @default_committer_email ||= \
         @repo.config['user.email'] || self.class.default_committer_email
     end
 
+    # Gets the commit object for the given ref or sha.
+    #
+    # ref - A string ref or SHA pointing to a valid commit.
+    #
+    # Returns a Grit::Commit instance.
+    def commit_for(ref)
+      @access.commit(ref)
+    rescue Grit::GitRuby::Repository::NoSuchShaFound
+    end
+
     # Finds a full listing of files and their blob SHA for a given ref.  Each
     # listing is cached based on its actual commit SHA.
     #
@@ -487,62 +580,9 @@ module Gollum
     #
     # Returns an Array of BlobEntry instances.
     def tree_map_for(ref)
-      sha = @ref_map[ref] || ref
-      @tree_map[sha] || begin
-        real_sha              = @repo.git.rev_list({:max_count=>1}, ref)
-        @ref_map[ref]         = real_sha if real_sha != ref
-        @tree_map[real_sha] ||= parse_tree_for(real_sha)
-      end
+      @access.tree(ref)
     rescue Grit::GitRuby::Repository::NoSuchShaFound
       []
     end
-
-    # Finds the full listing of files and their blob SHA for a given commit
-    # SHA.  No caching or ref lookups are performed.
-    #
-    # sha - String commit SHA.
-    #
-    # Returns an Array of BlobEntry instances.
-    def parse_tree_for(sha)
-      tree  = @repo.git.native(:ls_tree, {:r => true, :z => true}, sha)
-      items = []
-      tree.split("\0").each do |line|
-        items << parse_tree_line(line)
-      end
-      items
-    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)
-      data, name = line.split("\t")
-      mode, type, sha = data.split(' ')
-      name = decode_git_path(name)
-      BlobEntry.new sha, name
-    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
-
-    # Resets the ref and tree caches for this wiki.
-    def clear_cache
-      @ref_map  = {}
-      @tree_map = {}
-    end
   end
 end