gitlab_git 6.3.0 → 7.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f512e6aa7aeac3ab0fd43175bc3d53e50f510776
-  data.tar.gz: 4949e60987b1dbe296a97d0a041a09091cd1cf44
+  metadata.gz: badf0b7ecbe40208622e3e555055ab825f98ad6e
+  data.tar.gz: f85a1a6a30411397118fe910b8f0479799ddfcf2
 SHA512:
-  metadata.gz: 9b4d0e7beb1942463241b37cee1e02c719a0a8cbfca5f5d5a1920d91b47ab4f2be781dd0f33e33ff312b31154162cc3219e465375ee6c56fa0242b5b32980eaf
-  data.tar.gz: a370d903817cfc3f8893741ddd042cee6d74482cfcfaed36d35e257223bf7efa846104c2fd5da75a84da2a737140b482debed0b79a4f76a34eb44f1339d44a08
+  metadata.gz: 4f12a58cdb7e060e72096836c8cff6ab7ca1f56870c69b09cb9af578198e27c1a39234e3c21cff566a84569dd8d02e93a89e3bb6b475443f83ab6c007bc77e49
+  data.tar.gz: 5cc43362edf2f18cb84f6090a46e380153d5ac5b44c94e440b556c9b55ac0a0c39d8c84f11f734840d0a6559ccbab22ccdf88e17d315f627201014ad9a7489a8

data/VERSION

@@ -1 +1 @@
-6.3.0
+7.0.0.rc1

data/lib/gitlab_git.rb

@@ -1,18 +1,12 @@
 # Libraries
 require 'ostruct'
 require 'fileutils'
-require 'grit'
 require 'linguist'
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/object/try'
-require 'grit'
-require 'grit_ext'
 require 'rugged'
 require "charlock_holmes"
-
-Grit::Blob.class_eval do
-  include Linguist::BlobHelper
-end
+require "zip"
 
 # Gitlab::Git
 require_relative "gitlab_git/popen"
@@ -20,6 +14,7 @@ require_relative 'gitlab_git/encoding_helper'
 require_relative "gitlab_git/blame"
 require_relative "gitlab_git/blob"
 require_relative "gitlab_git/commit"
+require_relative "gitlab_git/commit_stats"
 require_relative "gitlab_git/compare"
 require_relative "gitlab_git/diff"
 require_relative "gitlab_git/repository"

data/lib/gitlab_git/blob_snippet.rb

@@ -13,7 +13,7 @@ module Gitlab
       end
 
       def data
-        lines.join("\n")
+        lines.join("\n") if lines
       end
 
       def name

data/lib/gitlab_git/commit.rb

@@ -1,6 +1,4 @@
-# Gitlab::Git::Commit is a wrapper around native Grit::Commit object
-# We dont want to use grit objects inside app/
-# It helps us easily migrate to rugged in future
+# Gitlab::Git::Commit is a wrapper around native Rugged::Commit object
 module Gitlab
   module Git
     class Commit
@@ -13,6 +11,18 @@ module Gitlab
       ]
       attr_accessor *SERIALIZE_KEYS
 
+      def ==(other)
+        return false unless other.is_a?(Gitlab::Git::Commit)
+
+        methods = [:message, :parent_ids, :authored_date, :author_name,
+                   :author_email, :committed_date, :committer_name,
+                   :committer_email]
+
+        methods.all? do |method|
+          send(method) == other.send(method)
+        end
+      end
+
       class << self
         # Get commits collection
         #
@@ -39,9 +49,17 @@ module Gitlab
         #
         #   Commit.find(repo, 'master')
         #
-        def find(repo, commit_id = nil)
-          commit = repo.log(ref: commit_id, limit: 1).first
+        def find(repo, commit_id = "HEAD")
+          return decorate(commit_id) if commit_id.is_a?(Rugged::Commit)
+
+          obj = repo.rugged.rev_parse(commit_id)
+          commit = case obj
+                   when Rugged::Tag::Annotation then obj.target
+                   when Rugged::Commit then obj
+                   end
           decorate(commit) if commit
+        rescue Rugged::ReferenceError, Rugged::ObjectError
+          nil
         end
 
         # Get last commit for HEAD
@@ -50,7 +68,7 @@ module Gitlab
         #   Commit.last(repo)
         #
         def last(repo)
-          find(repo, nil)
+          find(repo)
         end
 
         # Get last commit for specified path and ref
@@ -78,6 +96,8 @@ module Gitlab
           repo.commits_between(base, head).map do |commit|
             decorate(commit)
           end
+        rescue Rugged::ReferenceError
+          []
         end
 
         # Delegate Repository#find_commits
@@ -98,7 +118,7 @@ module Gitlab
         elsif raw_commit.is_a?(Rugged::Commit)
           init_from_rugged(raw_commit)
         else
-          init_from_grit(raw_commit)
+          raise "Invalid raw commit type: #{raw_commit.class}"
         end
 
         @head = head
@@ -133,7 +153,6 @@ module Gitlab
       #
       # Cuts out the header and stats from #to_patch and returns only the diff.
       def to_diff
-        # see Grit::Commit#show
         patch = to_patch
 
         # discard lines before the diff
@@ -146,6 +165,17 @@ module Gitlab
         lines.join("\n")
       end
 
+      # Returns a diff object for the changes from this commit's first parent.
+      # If there is no parent, then the diff is between this commit and an
+      # empty repo.
+      def diff_from_parent
+        if raw_commit.parents.empty?
+          raw_commit.diff(reverse: true)
+        else
+          raw_commit.parents[0].diff(raw_commit)
+        end
+      end
+
       def has_zero_stats?
         stats.total.zero?
       rescue
@@ -167,11 +197,11 @@ module Gitlab
       end
 
       def diffs
-        raw_commit.diffs.map { |diff| Gitlab::Git::Diff.new(diff) }
+        diff_from_parent.map { |diff| Gitlab::Git::Diff.new(diff) }
       end
 
       def parents
-        raw_commit.parents
+        raw_commit.parents.map { |c| Gitlab::Git::Commit.new(c) }
       end
 
       def tree
@@ -179,14 +209,14 @@ module Gitlab
       end
 
       def stats
-        raw_commit.stats
+        Gitlab::Git::CommitStats.new(self)
       end
 
       def to_patch
-        raw_commit.to_patch
+        raw_commit.to_mbox
       end
 
-      # Get refs collection(Grit::Head or Grit::Remote or Grit::Tag)
+      # Get a collection of Rugged::Reference objects for this commit.
       #
       # Ex.
       #   commit.ref(repo)
@@ -201,24 +231,13 @@ module Gitlab
       #   commit.ref_names(repo)
       #
       def ref_names(repo)
-        refs(repo).map(&:name)
+        refs(repo).map do |ref|
+          ref.name.sub(%r{^refs/(heads|remotes|tags)/}, "")
+        end
       end
 
       private
 
-      def init_from_grit(grit)
-        @raw_commit = grit
-        @id = grit.id
-        @message = grit.message
-        @authored_date = grit.authored_date
-        @committed_date = grit.committed_date
-        @author_name = grit.author.name
-        @author_email = grit.author.email
-        @committer_name = grit.committer.name
-        @committer_email = grit.committer.email
-        @parent_ids = grit.parents.map(&:id)
-      end
-
       def init_from_hash(hash)
         raw_commit = hash.symbolize_keys
 

data/lib/gitlab_git/commit_stats.rb

@@ -0,0 +1,26 @@
+# Gitlab::Git::CommitStats counts the additions, deletions, and total changes
+# in a commit.
+module Gitlab
+  module Git
+    class CommitStats
+      attr_reader :id, :additions, :deletions, :total
+
+      # Instantiate a CommitStats object
+      def initialize(commit)
+        @id = commit.id
+        @additions = 0
+        @deletions = 0
+        @total = 0
+
+        diff = commit.diff_from_parent
+
+        diff.each_patch do |p|
+          # TODO: Use the new Rugged convenience methods when they're released
+          @additions += p.stat[0]
+          @deletions += p.stat[1]
+          @total += p.changes
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_git/diff.rb

@@ -1,10 +1,9 @@
-# Gitlab::Git::Diff is a wrapper around native Grit::Diff object
-# We dont want to use grit objects inside app/
-# It helps us easily migrate to rugged in future
+# Gitlab::Git::Diff is a wrapper around native Rugged::Diff object
 module Gitlab
   module Git
     class Diff
       class TimeoutError < StandardError; end
+      include EncodingHelper
 
       attr_accessor :raw_diff
 
@@ -21,11 +20,7 @@ module Gitlab
           # From the git documentation: "git diff A...B" is equivalent to "git diff $(git-merge-base A B) B"
           common_commit = repo.merge_base_commit(head, base)
 
-          repo.diff(common_commit, head, *paths).map do |diff|
-            Gitlab::Git::Diff.new(diff)
-          end
-        rescue Grit::Git::GitTimeout
-          raise TimeoutError.new("Diff.between exited with timeout")
+          repo.diff(common_commit, head, *paths)
         end
       end
 
@@ -34,8 +29,10 @@ module Gitlab
 
         if raw_diff.is_a?(Hash)
           init_from_hash(raw_diff)
+        elsif raw_diff.is_a?(Rugged::Patch)
+          init_from_rugged(raw_diff)
         else
-          init_from_grit(raw_diff)
+          raise "Invalid raw diff type: #{raw_diff.class}"
         end
       end
 
@@ -57,12 +54,19 @@ module Gitlab
 
       private
 
-      def init_from_grit(grit)
-        @raw_diff = grit
+      def init_from_rugged(rugged)
+        @raw_diff = rugged
 
-        serialize_keys.each do |key|
-          send(:"#{key}=", grit.send(key))
-        end
+        @diff = encode!(strip_diff_headers(rugged.to_s))
+
+        d = rugged.delta
+        @new_path = encode!(d.new_file[:path])
+        @old_path = encode!(d.old_file[:path])
+        @a_mode = d.old_file[:mode].to_s(8)
+        @b_mode = d.new_file[:mode].to_s(8)
+        @new_file = d.added?
+        @renamed_file = d.renamed?
+        @deleted_file = d.deleted?
       end
 
       def init_from_hash(hash)
@@ -72,6 +76,14 @@ module Gitlab
           send(:"#{key}=", raw_diff[key.to_sym])
         end
       end
+
+      # Strip out the information at the beginning of the patch's text to match
+      # Grit's output
+      def strip_diff_headers(diff_text)
+        lines = diff_text.split("\n")
+        lines.shift until lines.empty? || lines.first.match("^(---|Binary)")
+        lines.join("\n")
+      end
     end
   end
 end

data/lib/gitlab_git/git_stats.rb

@@ -9,22 +9,67 @@ module Gitlab
         @repo, @ref, @timeout = repo, ref, timeout
       end
 
+      # Returns a string of log information; equivalent to running 'git log`
+      # with these options:
+      #
+      # -6000
+      # --format=%aN%x0a%aE%x0a%cd
+      # --date=short
+      # --shortstat
+      # --no-merges
+      # --diff-filter=ACDM
       def log
-        log = nil
-        Grit::Git.with_timeout(timeout) do
-          # Limit log to 6k commits to avoid timeout for huge projects
-          args = [ref, '-6000', '--format=%aN%x0a%aE%x0a%cd', '--date=short', '--shortstat', '--no-merges', '--diff-filter=ACDM']
-          log = repo.git.native(:log, {}, args)
+        commit_strings = []
+        walker = Rugged::Walker.new(repo.rugged)
+        walker.push(repo.lookup(ref))
+        walker.each(limit: 6000) do |commit|
+          # Skip merge commits
+          next if commit.parents.length > 1
+
+          g_commit = Gitlab::Git::Commit.new(commit)
+
+          commit_strings << [
+            g_commit.author_name,
+            g_commit.author_email,
+            g_commit.committed_date.strftime("%Y-%m-%d"),
+            "",
+            status_string(g_commit)
+          ].join("\n")
         end
 
-        log
-      rescue Grit::Git::GitTimeout
-        nil
+        commit_strings.join("\n")
       end
 
       def parsed_log
         LogParser.parse_log(log)
       end
+
+      private
+
+      # Returns a string describing the files changed, additions and deletions
+      # for +commit+
+      def status_string(commit)
+        stats = commit.stats
+
+        status = "#{num_files_changed(commit)} files changed"
+        status << ", #{stats.additions} insertions" if stats.additions > 0
+        status << ", #{stats.deletions} deletions" if stats.deletions > 0
+        status
+      end
+
+      # Returns the number of files that were either added, copied, deleted, or
+      # modified by +commit+
+      def num_files_changed(commit)
+        count = 0
+
+        diff = commit.diff_from_parent
+        diff.find_similar!
+        diff.each_delta do |d|
+          count += 1 if d.added? || d.copied? || d.deleted? || d.modified?
+        end
+
+        count
+      end
     end
   end
 end

data/lib/gitlab_git/repository.rb

@@ -1,8 +1,7 @@
-# Gitlab::Git::Repository is a wrapper around native Grit::Repository object
-# We dont want to use grit objects inside app/
-# It helps us easily migrate to rugged in future
+# Gitlab::Git::Repository is a wrapper around native Rugged::Repository object
 require_relative 'encoding_helper'
 require 'tempfile'
+require "rubygems/package"
 
 module Gitlab
   module Git
@@ -20,9 +19,6 @@ module Gitlab
       # Directory name of repo
       attr_reader :name
 
-      # Grit repo object
-      attr_reader :grit
-
       # Rugged repo object
       attr_reader :rugged
 
@@ -32,15 +28,9 @@ module Gitlab
         @root_ref = discover_default_branch
       end
 
-      def grit
-        @grit ||= Grit::Repo.new(path)
-      rescue Grit::NoSuchPathError
-        raise NoRepository.new('no repository for such path')
-      end
-
       # Alias to old method for compatibility
       def raw
-        grit
+        rugged
       end
 
       def rugged
@@ -69,18 +59,8 @@ module Gitlab
 
       # Returns an Array of Tags
       def tags
-        rugged.refs.select do |ref|
-          ref.name =~ /\Arefs\/tags/
-        end.map do |rugged_ref|
-          target = rugged_ref.target
-          message = nil
-          if rugged_ref.target.is_a?(Rugged::Tag::Annotation) &&
-             rugged_ref.target.target.is_a?(Rugged::Commit)
-            unless rugged_ref.target.target.message == rugged_ref.target.message
-              message = rugged_ref.target.message.chomp
-            end
-          end
-          Tag.new(rugged_ref.name, target, message)
+        rugged.references.each("refs/tags/*").map do |ref|
+          Tag.new(ref.name, ref.target, ref.target.message.chomp)
         end.sort_by(&:name)
       end
 
@@ -91,7 +71,9 @@ module Gitlab
 
       # Deprecated. Will be removed in 5.2
       def heads
-        @heads ||= grit.heads.sort_by(&:name)
+        rugged.references.each("refs/heads/*").map do |head|
+          Gitlab::Git::Ref.new(head.name, head.target)
+        end.sort_by(&:name)
       end
 
       def has_commits?
@@ -137,12 +119,11 @@ module Gitlab
       # app_root/tmp/repositories/project_name/project_name-commit-id.tag.gz
       #
       def archive_repo(ref, storage_path, format = "tar.gz")
-        ref = ref || self.root_ref
+        ref ||= root_ref
         commit = Gitlab::Git::Commit.find(self, ref)
         return nil unless commit
 
         extension = nil
-        git_archive_format = nil
         pipe_cmd = nil
 
         case format
@@ -154,12 +135,10 @@ module Gitlab
           pipe_cmd = %W(cat)
         when "zip"
           extension = ".zip"
-          git_archive_format = "zip"
           pipe_cmd = %W(cat)
         else
           # everything else should fall back to tar.gz
           extension = ".tar.gz"
-          git_archive_format = nil
           pipe_cmd = %W(gzip -n)
         end
 
@@ -167,23 +146,8 @@ module Gitlab
         file_name = self.name.gsub("\.git", "") + "-" + commit.id.to_s + extension
         file_path = File.join(storage_path, self.name, file_name)
 
-        # Put files into a directory before archiving
-        prefix = File.basename(self.name) + "/"
-
         # Create file if not exists
-        unless File.exists?(file_path)
-          # create archive in temp file
-          tmp_file = Tempfile.new('gitlab-archive-repo', storage_path)
-          self.grit.archive_to_file(ref, prefix, tmp_file.path, git_archive_format, pipe_cmd)
-
-          # move temp file to persisted location
-          FileUtils.mkdir_p File.dirname(file_path)
-          FileUtils.move(tmp_file.path, file_path)
-
-          # delte temp file
-          tmp_file.close
-          tmp_file.unlink
-        end
+        create_archive(ref, pipe_cmd, file_path) unless File.exist?(file_path)
 
         file_path
       end
@@ -194,19 +158,24 @@ module Gitlab
         (size.to_f / 1024).round(2)
       end
 
+      # Returns an array of BlobSnippets for files at the specified +ref+ that
+      # contain the +query+ string.
       def search_files(query, ref = nil)
-        if ref.nil? || ref == ""
-          ref = root_ref
-        end
+        greps = []
+        ref ||= root_ref
 
-        greps = grit.grep(query, 3, ref)
+        populated_index(ref).each do |entry|
+          # Discard submodules
+          next if submodule?(entry)
 
-        greps.map do |grep|
-          Gitlab::Git::BlobSnippet.new(ref, grep.content, grep.startline, grep.filename)
+          content = rugged.lookup(entry[:oid]).content
+          greps += build_greps(content, query, ref, entry[:path])
         end
+
+        greps
       end
 
-      # Delegate log to Grit method
+      # Use the Rugged Walker API to build an array of commits.
       #
       # Usage.
       #   repo.log(
@@ -226,28 +195,61 @@ module Gitlab
         }
 
         options = default_options.merge(options)
+        options[:limit] ||= 0
+        options[:offset] ||= 0
+        actual_ref = options[:ref] || root_ref
+        sha = sha_from_ref(actual_ref)
+
+        build_log(sha, options)
+      rescue Rugged::OdbError, Rugged::InvalidError, Rugged::ReferenceError
+        # Return an empty array if the ref wasn't found
+        []
+      end
 
-        grit.log(
-          options[:ref] || root_ref,
-          options[:path],
-          max_count: options[:limit].to_i,
-          skip: options[:offset].to_i,
-          follow: options[:follow]
-        )
+      def sha_from_ref(ref)
+        sha = rugged.rev_parse_oid(ref)
+        object = rugged.lookup(sha)
+
+        if object.kind_of?(Rugged::Commit)
+          sha
+        elsif object.respond_to?(:target)
+          sha_from_ref(object.target.oid)
+        end
       end
 
-      # Delegate commits_between to Grit method
+      # Return a collection of Rugged::Commits between the two SHA arguments.
       #
       def commits_between(from, to)
-        grit.commits_between(from, to)
+        walker = Rugged::Walker.new(rugged)
+        walker.push(to)
+        walker.hide(from)
+        commits = walker.to_a
+        walker.reset
+
+        commits.reverse
       end
 
+      # Returns the SHA of the most recent common ancestor of +from+ and +to+
       def merge_base_commit(from, to)
-        grit.git.native(:merge_base, {}, [to, from]).strip
+        rugged.merge_base(from, to)
       end
 
+      # Return an array of Diff objects that represent the diff
+      # between +from+ and +to+.
       def diff(from, to, *paths)
-        grit.diff(from, to, *paths)
+        rugged.diff(from, to, paths: paths).patches.map do |p|
+          Gitlab::Git::Diff.new(p)
+        end
+      end
+
+      # Return the diff between +from+ and +to+ in a single patch string.
+      def diff_text(from, to, *paths)
+        # NOTE: It would be simpler to use the Rugged::Diff#patch method, but
+        # that formats the diff text differently than Rugged::Patch#to_s for
+        # changes to binary files.
+        rugged.diff(from, to, paths: paths).patches.map do |p|
+          p.to_s
+        end.join("\n")
       end
 
       # Returns commits collection
@@ -272,81 +274,92 @@ module Gitlab
 
         allowed_options = [:ref, :max_count, :skip, :contains, :order]
 
-        actual_options.keep_if do |key, value|
+        actual_options.keep_if do |key|
           allowed_options.include?(key)
         end
 
-        default_options = {pretty: 'raw', order: :date}
-
+        default_options = { skip: 0 }
         actual_options = default_options.merge(actual_options)
 
-        order = actual_options.delete(:order)
+        walker = Rugged::Walker.new(rugged)
 
-        case order
-        when :date
-          actual_options[:date_order] = true
-        when :topo
-          actual_options[:topo_order] = true
+        if actual_options[:ref]
+          walker.push(rugged.rev_parse_oid(actual_options[:ref]))
+        elsif actual_options[:contains]
+          branches_contains(actual_options[:contains]).each do |branch|
+            walker.push(branch.target_id)
+          end
+        else
+          rugged.references.each("refs/heads/*") do |ref|
+            walker.push(ref.target_id)
+          end
         end
 
-        ref = actual_options.delete(:ref)
-
-        containing_commit = actual_options.delete(:contains)
+        walker.sorting(Rugged::SORT_TOPO) if actual_options[:order] == :topo
 
-        args = []
-
-        if ref
-          args.push(ref)
-        elsif containing_commit
-          args.push(*branch_names_contains(containing_commit))
-        else
-          actual_options[:all] = true
+        commits = []
+        offset = actual_options[:skip]
+        limit = actual_options[:max_count]
+        walker.each(offset: offset, limit: limit) do |commit|
+          gitlab_commit = Gitlab::Git::Commit.decorate(commit)
+          commits.push(gitlab_commit)
         end
 
-        output = grit.git.native(:rev_list, actual_options, *args)
+        walker.reset
 
-        Grit::Commit.list_from_string(grit, output).map do |commit|
-          Gitlab::Git::Commit.decorate(commit)
-        end
-      rescue Grit::GitRuby::Repository::NoSuchShaFound
+        commits
+      rescue Rugged::OdbError
         []
       end
 
-      # Returns branch names collection that contains the special commit(SHA1 or name)
+      # Returns branch names collection that contains the special commit(SHA1
+      # or name)
       #
       # Ex.
       #   repo.branch_names_contains('master')
       #
       def branch_names_contains(commit)
-        output = grit.git.native(:branch, {contains: true}, commit)
+        branches_contains(commit).map { |c| c.target_id }
+      end
 
-        # Fix encoding issue
-        output = EncodingHelper::encode!(output)
+      # Returns branch collection that contains the special commit(SHA1 or name)
+      #
+      # Ex.
+      #   repo.branch_names_contains('master')
+      #
+      def branches_contains(commit)
+        sha = rugged.rev_parse_oid(commit)
+
+        walker = Rugged::Walker.new(rugged)
 
-        # The output is expected as follow
-        #   fix-aaa
-        #   fix-bbb
-        # * master
-        output.scan(/[^* \n]+/)
+        rugged.branches.select do |branch|
+          walker.push(branch.target_id)
+          result = walker.any? { |c| c.oid == sha }
+          walker.reset
+
+          result
+        end
       end
 
       # Get refs hash which key is SHA1
-      # and value is ref object(Grit::Head or Grit::Remote or Grit::Tag)
+      # and value is a Rugged::Reference
       def refs_hash
         # Initialize only when first call
         if @refs_hash.nil?
           @refs_hash = Hash.new { |h, k| h[k] = [] }
 
-          grit.refs.each do |r|
-            @refs_hash[r.commit.id] << r
+          rugged.references.each do |r|
+            sha = rev_parse_target(r.target.oid).oid
+
+            @refs_hash[sha] << r
           end
         end
         @refs_hash
       end
 
-      # Lookup for rugged object by oid
-      def lookup(oid)
-        rugged.lookup(oid)
+      # Lookup for rugged object by oid or ref name
+      def lookup(oid_or_ref_name)
+        rugged.rev_parse(oid_or_ref_name)
       end
 
       # Return hash with submodules info for this repository
@@ -364,7 +377,10 @@ module Gitlab
       #   }
       #
       def submodules(ref)
-        Grit::Submodule.config(grit, ref)
+        tree = rugged.lookup(rugged.rev_parse_oid(ref)).tree
+
+        content = blob_content(tree, ".gitmodules")
+        parse_gitmodules(tree, content)
       end
 
       # Return total commits count accessible from passed ref
@@ -374,6 +390,532 @@ module Gitlab
         walker.push(ref)
         walker.count
       end
+
+      # Sets HEAD to the commit specified by +ref+; +ref+ can be a branch or
+      # tag name or a commit SHA.  Valid +reset_type+ values are:
+      #
+      #  [:soft]
+      #    the head will be moved to the commit.
+      #  [:mixed]
+      #    will trigger a +:soft+ reset, plus the index will be replaced
+      #    with the content of the commit tree.
+      #  [:hard]
+      #    will trigger a +:mixed+ reset and the working directory will be
+      #    replaced with the content of the index. (Untracked and ignored files
+      #    will be left alone)
+      def reset(ref, reset_type)
+        rugged.reset(ref, reset_type)
+      end
+
+      # Mimic the `git clean` command and recursively delete untracked files.
+      # Valid keys that can be passed in the +options+ hash are:
+      #
+      # :d - Remove untracked directories
+      # :f - Remove untracked directories that are managed by a different
+      #      repository
+      # :x - Remove ignored files
+      #
+      # The value in +options+ must evaluate to true for an option to take
+      # effect.
+      #
+      # Examples:
+      #
+      #   repo.clean(d: true, f: true) # Enable the -d and -f options
+      #
+      #   repo.clean(d: false, x: true) # -x is enabled, -d is not
+      def clean(options = {})
+        strategies = [:remove_untracked]
+        strategies.push(:force) if options[:f]
+        strategies.push(:remove_ignored) if options[:x]
+
+        # TODO: implement this method
+      end
+
+      # Check out the specified ref. Valid options are:
+      #
+      #  :b - Create a new branch at +start_point+ and set HEAD to the new
+      #       branch.
+      #
+      #  * These options are passed to the Rugged::Repository#checkout method:
+      #
+      #  :progress ::
+      #    A callback that will be executed for checkout progress notifications.
+      #    Up to 3 parameters are passed on each execution:
+      #
+      #    - The path to the last updated file (or +nil+ on the very first
+      #      invocation).
+      #    - The number of completed checkout steps.
+      #    - The number of total checkout steps to be performed.
+      #
+      #  :notify ::
+      #    A callback that will be executed for each checkout notification
+      #    types specified with +:notify_flags+. Up to 5 parameters are passed
+      #    on each execution:
+      #
+      #    - An array containing the +:notify_flags+ that caused the callback
+      #      execution.
+      #    - The path of the current file.
+      #    - A hash describing the baseline blob (or +nil+ if it does not
+      #      exist).
+      #    - A hash describing the target blob (or +nil+ if it does not exist).
+      #    - A hash describing the workdir blob (or +nil+ if it does not
+      #      exist).
+      #
+      #  :strategy ::
+      #    A single symbol or an array of symbols representing the strategies
+      #    to use when performing the checkout. Possible values are:
+      #
+      #    :none ::
+      #      Perform a dry run (default).
+      #
+      #    :safe ::
+      #      Allow safe updates that cannot overwrite uncommitted data.
+      #
+      #    :safe_create ::
+      #      Allow safe updates plus creation of missing files.
+      #
+      #    :force ::
+      #      Allow all updates to force working directory to look like index.
+      #
+      #    :allow_conflicts ::
+      #      Allow checkout to make safe updates even if conflicts are found.
+      #
+      #    :remove_untracked ::
+      #      Remove untracked files not in index (that are not ignored).
+      #
+      #    :remove_ignored ::
+      #      Remove ignored files not in index.
+      #
+      #    :update_only ::
+      #      Only update existing files, don't create new ones.
+      #
+      #    :dont_update_index ::
+      #      Normally checkout updates index entries as it goes; this stops
+      #      that.
+      #
+      #    :no_refresh ::
+      #      Don't refresh index/config/etc before doing checkout.
+      #
+      #    :disable_pathspec_match ::
+      #      Treat pathspec as simple list of exact match file paths.
+      #
+      #    :skip_locked_directories ::
+      #      Ignore directories in use, they will be left empty.
+      #
+      #    :skip_unmerged ::
+      #      Allow checkout to skip unmerged files (NOT IMPLEMENTED).
+      #
+      #    :use_ours ::
+      #      For unmerged files, checkout stage 2 from index (NOT IMPLEMENTED).
+      #
+      #    :use_theirs ::
+      #      For unmerged files, checkout stage 3 from index (NOT IMPLEMENTED).
+      #
+      #    :update_submodules ::
+      #      Recursively checkout submodules with same options (NOT
+      #      IMPLEMENTED).
+      #
+      #    :update_submodules_if_changed ::
+      #      Recursively checkout submodules if HEAD moved in super repo (NOT
+      #      IMPLEMENTED).
+      #
+      #  :disable_filters ::
+      #    If +true+, filters like CRLF line conversion will be disabled.
+      #
+      #  :dir_mode ::
+      #    Mode for newly created directories. Default: +0755+.
+      #
+      #  :file_mode ::
+      #    Mode for newly created files. Default: +0755+ or +0644+.
+      #
+      #  :file_open_flags ::
+      #    Mode for opening files. Default:
+      #    <code>IO::CREAT | IO::TRUNC | IO::WRONLY</code>.
+      #
+      #  :notify_flags ::
+      #    A single symbol or an array of symbols representing the cases in
+      #    which the +:notify+ callback should be invoked. Possible values are:
+      #
+      #    :none ::
+      #      Do not invoke the +:notify+ callback (default).
+      #
+      #    :conflict ::
+      #      Invoke the callback for conflicting paths.
+      #
+      #    :dirty ::
+      #      Invoke the callback for "dirty" files, i.e. those that do not need
+      #      an update but no longer match the baseline.
+      #
+      #    :updated ::
+      #      Invoke the callback for any file that was changed.
+      #
+      #    :untracked ::
+      #      Invoke the callback for untracked files.
+      #
+      #    :ignored ::
+      #      Invoke the callback for ignored files.
+      #
+      #    :all ::
+      #      Invoke the callback for all these cases.
+      #
+      #  :paths ::
+      #    A glob string or an array of glob strings specifying which paths
+      #    should be taken into account for the checkout operation. +nil+ will
+      #    match all files.  Default: +nil+.
+      #
+      #  :baseline ::
+      #    A Rugged::Tree that represents the current, expected contents of the
+      #    workdir.  Default: +HEAD+.
+      #
+      #  :target_directory ::
+      #    A path to an alternative workdir directory in which the checkout
+      #    should be performed.
+      def checkout(ref, options = {}, start_point = "HEAD")
+        if options[:b]
+          rugged.branches.create(ref, start_point)
+          options.delete(:b)
+        end
+        default_options = { strategy: :safe_create }
+        rugged.checkout(ref, default_options.merge(options))
+      end
+
+      # Delete the specified branch from the repository
+      def delete_branch(branch_name)
+        rugged.branches.delete(branch_name)
+      end
+
+      # Return an array of this repository's remote names
+      def remote_names
+        rugged.remotes.each_name.to_a
+      end
+
+      # Delete the specified remote from this repository.
+      def remote_delete(remote_name)
+        rugged.remotes.delete(remote_name)
+      end
+
+      # Add a new remote to this repository.  Returns a Rugged::Remote object
+      def remote_add(remote_name, url)
+        rugged.remotes.create(remote_name, url)
+      end
+
+      # Update the specified remote using the values in the +options+ hash
+      #
+      # Example
+      # repo.update_remote("origin", url: "path/to/repo")
+      def remote_update(remote_name, options = {})
+        # TODO: Implement other remote options
+        remote = rugged.remotes[remote_name]
+        remote.url = options[:url] if options[:url]
+        remote.save
+      end
+
+      # Fetch the specified remote
+      def fetch(remote_name)
+        rugged.remotes[remote_name].fetch
+      end
+
+      # Push +*refspecs+ to the remote identified by +remote_name+.
+      def push(remote_name, *refspecs)
+        rugged.remotes[remote_name].push(refspecs)
+      end
+
+      # Return a String containing the mbox-formatted diff between +from+ and
+      # +to+
+      def format_patch(from, to)
+        rugged.diff(from, to).patch
+        from_sha = rugged.rev_parse_oid(from)
+        to_sha = rugged.rev_parse_oid(to)
+        commits_between(from_sha, to_sha).map do |commit|
+          commit.to_mbox
+        end.join("\n")
+      end
+
+      # Merge the +source_name+ branch into the +target_name+ branch. This is
+      # equivalent to `git merge --no_ff +source_name+`, since a merge commit
+      # is always created.
+      def merge(source_name, target_name, options = {})
+        our_commit = rugged.branches[target_name].target
+        their_commit = rugged.branches[source_name].target
+
+        raise "Invalid merge target" if our_commit.nil?
+        raise "Invalid merge source" if their_commit.nil?
+
+        merge_index = rugged.merge_commits(our_commit, their_commit)
+        return false if merge_index.conflicts?
+
+        actual_options = options.merge(
+          parents: [our_commit, their_commit],
+          tree: merge_index.write_tree(rugged),
+          update_ref: "refs/heads/#{target_name}"
+        )
+        Rugged::Commit.create(rugged, actual_options)
+      end
+
+      def commits_since(from_date)
+        walker = Rugged::Walker.new(rugged)
+        walker.sorting(Rugged::SORT_DATE | Rugged::SORT_REVERSE)
+
+        rugged.references.each("refs/heads/*") do |ref|
+          walker.push(ref.target_id)
+        end
+
+        commits = []
+        walker.each do |commit|
+          break if commit.author[:time].to_date < from_date
+          commits.push(commit)
+        end
+
+        commits
+      end
+
+      private
+
+      # Return the object that +revspec+ points to.  If +revspec+ is an
+      # annotated tag, then return the tag's target instead.
+      def rev_parse_target(revspec)
+        obj = rugged.rev_parse(revspec)
+        if obj.is_a?(Rugged::Tag::Annotation)
+          obj.target
+        else
+          obj
+        end
+      end
+
+      # Get the content of a blob for a given tree.  If the blob is a commit
+      # (for submodules) then return the blob's OID.
+      def blob_content(tree, blob_name)
+        blob_hash = tree.detect { |b| b[:name] == blob_name }
+
+        if blob_hash[:type] == :commit
+          blob_hash[:oid]
+        else
+          rugged.lookup(blob_hash[:oid]).content
+        end
+      end
+
+      # Parses the contents of a .gitmodules file and returns a hash of
+      # submodule information.
+      def parse_gitmodules(tree, content)
+        results = {}
+
+        current = ""
+        content.split("\n").each do |txt|
+          if txt.match(/^\[/)
+            current = txt.match(/(?<=").*(?=")/)[0]
+            results[current] = {}
+          else
+            match_data = txt.match(/(\w+) = (.*)/)
+            results[current][match_data[1]] = match_data[2]
+
+            if match_data[1] == "path"
+              results[current]["id"] = blob_content(tree, match_data[2])
+            end
+          end
+        end
+
+        results
+      end
+
+      # Return an array of log commits, given an SHA hash and a hash of
+      # options.
+      def build_log(sha, options)
+        # Instantiate a Walker and add the SHA hash
+        walker = Rugged::Walker.new(rugged)
+        walker.push(sha)
+
+        commits = []
+        skipped = 0
+        current_path = options[:path]
+
+        walker.each do |c|
+          break if options[:limit].to_i > 0 &&
+            commits.length >= options[:limit].to_i
+
+          if !current_path ||
+            commit_touches_path?(c, current_path, options[:follow])
+
+            # This is a commit we care about, unless we haven't skipped enough
+            # yet
+            skipped += 1
+            commits.push(c) if skipped > options[:offset]
+          end
+        end
+
+        walker.reset
+
+        commits
+      end
+
+      # Returns true if the given commit affects the given path.  If the
+      # +follow+ option is true and the file specified by +path+ was renamed,
+      # then the path value is set to the old path.
+      def commit_touches_path?(commit, path, follow)
+        if commit.parents.empty?
+          diff = commit.diff
+        else
+          diff = commit.parents[0].diff(commit)
+          diff.find_similar! if follow
+        end
+
+        # Check the commit's deltas to see if it touches the :path
+        # argument
+        diff.each_delta do |d|
+          if path_matches?(path, d.old_file[:path], d.new_file[:path])
+            if should_follow?(follow, d, path)
+              # Look for the old path in ancestors
+              path.replace(d.old_file[:path])
+            end
+
+            return true
+          end
+        end
+
+        false
+      end
+
+      # Used by the #commit_touches_path method to determine whether the
+      # specified file has been renamed and should be followed in ancestor
+      # commits.  Returns true if +follow_option+ is true, the file is renamed
+      # in this commit, and the new file's path matches the path option.
+      def should_follow?(follow_option, delta, path)
+        follow_option && delta.renamed? && path == delta.new_file[:path]
+      end
+
+      # Returns true if any of the strings in +*paths+ begins with the
+      # +path_to_match+ argument
+      def path_matches?(path_to_match, *paths)
+        paths.any? do |p|
+          p.match(/^#{Regexp.escape(path_to_match)}/)
+        end
+      end
+
+      # Create an archive with the repository's files
+      def create_archive(ref_name, pipe_cmd, file_path)
+        # Put files into a prefix directory in the archive
+        prefix = File.basename(name)
+        extension = Pathname.new(file_path).extname
+
+        if extension == ".zip"
+          create_zip_archive(ref_name, file_path, prefix)
+        else
+          # Create a tarfile in memory
+          tarfile = tar_string_io(ref_name, prefix)
+
+          if extension == ".tar"
+            File.new(file_path, "wb").write(tarfile.read)
+          else
+            compress_tar(tarfile, file_path, pipe_cmd)
+          end
+        end
+      end
+
+      # Return a StringIO with the contents of the repo's tar file
+      def tar_string_io(ref_name, prefix)
+        tarfile = StringIO.new
+        Gem::Package::TarWriter.new(tarfile) do |tar|
+          tar.mkdir(prefix, 33261)
+
+          populated_index(ref_name).each do |entry|
+            add_archive_entry(tar, prefix, entry)
+          end
+        end
+
+        tarfile.rewind
+        tarfile
+      end
+
+      # Create a zip file with the contents of the repo
+      def create_zip_archive(ref_name, archive_path, prefix)
+        Zip::File.open(archive_path, Zip::File::CREATE) do |zipfile|
+          populated_index(ref_name).each do |entry|
+            add_archive_entry(zipfile, prefix, entry)
+          end
+        end
+      end
+
+      # Add a file or directory from the index to the given tar or zip file
+      def add_archive_entry(archive, prefix, entry)
+        prefixed_path = File.join(prefix, entry[:path])
+        content = rugged.lookup(entry[:oid]).content unless submodule?(entry)
+
+        # Create a file in the archive for each index entry
+        if archive.is_a?(Zip::File)
+          unless submodule?(entry)
+            archive.get_output_stream(prefixed_path) do |os|
+              os.write(content)
+            end
+          end
+        else
+          if submodule?(entry)
+            # Create directories for submodules
+            archive.mkdir(prefixed_path, 33261)
+          else
+            # Write the blob contents to the file
+            archive.add_file(prefixed_path, entry[:mode]) do |tf|
+              tf.write(content)
+            end
+          end
+        end
+      end
+
+      # Returns true if the index entry has the special file mode that denotes
+      # a submodule.
+      def submodule?(index_entry)
+        index_entry[:mode] == 57344
+      end
+
+      # Send the +tar_string+ StringIO to +pipe_cmd+ for bzip2 or gzip
+      # compression.
+      def compress_tar(tar_string, file_path, pipe_cmd)
+        # Write the in-memory tarfile to a pipe
+        rd_pipe, rw_pipe = IO.pipe
+        tar_pid = fork do
+          rd_pipe.close
+          rw_pipe.write(tar_string.read)
+          rw_pipe.close
+        end
+
+        # Use the other end of the pipe to compress with bzip2 or gzip
+        FileUtils.mkdir_p(Pathname.new(file_path).dirname)
+        archive_file = File.new(file_path, "wb")
+        rw_pipe.close
+        compress_pid = spawn(*pipe_cmd, in: rd_pipe, out: archive_file)
+        rd_pipe.close
+
+        Process.waitpid(tar_pid)
+        Process.waitpid(compress_pid)
+
+        archive_file.close
+        tar_string.close
+      end
+
+      # Return a Rugged::Index that has read from the tree at +ref_name+
+      def populated_index(ref_name)
+        tree = rugged.lookup(rugged.rev_parse_oid(ref_name)).tree
+        index = rugged.index
+        index.read_tree(tree)
+        index
+      end
+
+      # Return an array of BlobSnippets for lines in +file_contents+ that match
+      # +query+
+      def build_greps(file_contents, query, ref, filename)
+        greps = []
+
+        file_contents.split("\n").each_with_index do |line, i|
+          next unless line.match(/#{Regexp.escape(query)}/i)
+
+          greps << Gitlab::Git::BlobSnippet.new(
+            ref,
+            file_contents.split("\n")[i - 3..i + 3],
+            i - 2,
+            filename
+          )
+        end
+
+        greps
+      end
     end
   end
 end