grit 2.0.0 → 2.1.0

data/lib/grit/diff.rb

@@ -4,20 +4,23 @@ module Grit
     attr_reader :a_path, :b_path
     attr_reader :a_blob, :b_blob
     attr_reader :a_mode, :b_mode
-    attr_reader :new_file, :deleted_file
-    attr_reader :diff
+    attr_reader :new_file, :deleted_file, :renamed_file
+    attr_reader :similarity_index
+    attr_accessor :diff
 
-    def initialize(repo, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff)
-      @repo = repo
+    def initialize(repo, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff, renamed_file = false, similarity_index = 0)
+      @repo   = repo
       @a_path = a_path
       @b_path = b_path
       @a_blob = a_blob =~ /^0{40}$/ ? nil : Blob.create(repo, :id => a_blob)
       @b_blob = b_blob =~ /^0{40}$/ ? nil : Blob.create(repo, :id => b_blob)
       @a_mode = a_mode
       @b_mode = b_mode
-      @new_file = new_file || @a_blob.nil?
-      @deleted_file = deleted_file || @b_blob.nil?
-      @diff = diff
+      @new_file         = new_file     || @a_blob.nil?
+      @deleted_file     = deleted_file || @b_blob.nil?
+      @renamed_file     = renamed_file
+      @similarity_index = similarity_index.to_i
+      @diff             = diff
     end
 
     def self.list_from_string(repo, text)
@@ -38,17 +41,23 @@ module Grit
           next
         end
 
-        new_file = false
+        sim_index    = 0
+        new_file     = false
         deleted_file = false
+        renamed_file = false
 
         if lines.first =~ /^new file/
           m, b_mode = lines.shift.match(/^new file mode (.+)$/)
-          a_mode = nil
-          new_file = true
+          a_mode    = nil
+          new_file  = true
         elsif lines.first =~ /^deleted file/
-          m, a_mode = lines.shift.match(/^deleted file mode (.+)$/)
-          b_mode = nil
+          m, a_mode    = lines.shift.match(/^deleted file mode (.+)$/)
+          b_mode       = nil
           deleted_file = true
+        elsif lines.first =~ /^similarity index (\d+)\%/
+          sim_index    = $1.to_i
+          renamed_file = true
+          2.times { lines.shift } # shift away the 2 `rename from/to ...` lines
         end
 
         m, a_blob, b_blob, b_mode = *lines.shift.match(%r{^index ([0-9A-Fa-f]+)\.\.([0-9A-Fa-f]+) ?(.+)?$})
@@ -60,7 +69,7 @@ module Grit
         end
         diff = diff_lines.join("\n")
 
-        diffs << Diff.new(repo, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff)
+        diffs << Diff.new(repo, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff, renamed_file, sim_index)
       end
 
       diffs

data/lib/grit/errors.rb

@@ -4,4 +4,7 @@ module Grit
 
   class NoSuchPathError < StandardError
   end
-end
+
+  class InvalidObjectType < StandardError
+  end
+end

data/lib/grit/git-ruby.rb

@@ -18,28 +18,33 @@ module Grit
       end
     end
 
-    def cat_file(options, ref)
+    def cat_file(options, sha)
       if options[:t]
-        file_type(ref)
+        file_type(sha)
       elsif options[:s]
-        file_size(ref)
+        file_size(sha)
       elsif options[:p]
-        try_run { ruby_git.cat_file(ref) }
+        try_run { ruby_git.cat_file(sha) }
       end
     rescue Grit::GitRuby::Repository::NoSuchShaFound
       ''
     end
 
+    def cat_ref(options, ref)
+      sha = rev_parse({}, ref)
+      cat_file(options, sha)
+    end
+
     # lib/grit/tree.rb:16:      output = repo.git.ls_tree({}, treeish, *paths)
     def ls_tree(options, treeish, *paths)
       sha = rev_parse({}, treeish)
-      ruby_git.ls_tree(sha, paths.flatten)
+      ruby_git.ls_tree(sha, paths.flatten, options.delete(:r))
     rescue Grit::GitRuby::Repository::NoSuchShaFound
       ''
     end
 
     # git diff --full-index 'ec037431382e83c3e95d4f2b3d145afbac8ea55d' 'f1ec1aea10986159456846b8a05615b87828d6c6'
-    def diff(options, sha1, sha2)
+    def diff(options, sha1, sha2 = nil)
       try_run { ruby_git.diff(sha1, sha2, options) }
     end
 
@@ -100,7 +105,7 @@ module Grit
       ## !! more - partials and such !!
 
       # revert to calling git - grr
-      return method_missing('rev-parse', {}, string).chomp
+      return method_missing('rev-parse', options, string).chomp
     end
 
     def refs(options, prefix)

data/lib/grit/git-ruby/git_object.rb

@@ -337,8 +337,8 @@ module Grit
     end
 
     def raw_content
-      "object %s\ntype %s\ntag %s\ntagger %s\n\n" % \
-        [@object, @type, @tag, @tagger] + @message
+      ("object %s\ntype %s\ntag %s\ntagger %s\n\n" % \
+        [@object, @type, @tag, @tagger]) + @message.to_s
     end
 
     def type

data/lib/grit/git-ruby/internal/loose.rb

@@ -29,7 +29,7 @@ module Grit
           begin
             return nil unless sha1[0...2] && sha1[2..39]
             path = @directory + '/' + sha1[0...2] + '/' + sha1[2..39]
-            get_raw_object(File.open(path, 'rb').read)
+            get_raw_object(File.read(path))
           rescue Errno::ENOENT
             nil
           end

data/lib/grit/git-ruby/internal/pack.rb

@@ -69,12 +69,14 @@ module Grit
           idx = FileWindow.new(idxfile, @version)
           yield idx
           idx.unmap
+        ensure
           idxfile.close
         end
 
         def with_packfile
           packfile = File.open(@name, 'rb')
           yield packfile
+        ensure
           packfile.close
         end
 

data/lib/grit/git-ruby/repository.rb

@@ -169,7 +169,8 @@ module Grit
       # returns the raw (cat-file) output for a tree
       # if given a commit sha, it will print the tree of that commit
       # if given a path limiter array, it will limit the output to those
-      def ls_tree(sha, paths = [])
+      # if asked for recrusive trees, will traverse trees
+      def ls_tree(sha, paths = [], recursive = false)
         if paths.size > 0
           # pathing
           part = []
@@ -178,20 +179,44 @@ module Grit
           end
           return part.join("\n")
         else
-          get_raw_tree(sha)
+          get_raw_tree(sha, recursive)
         end
       end
 
-      def get_raw_tree(sha)
+      def get_raw_tree(sha, recursive = false)
         o = get_raw_object_by_sha1(sha)
         if o.type == :commit
-          cat_file(get_object_by_sha1(sha).tree)
+          tree = get_object_by_sha1(sha).tree
         elsif o.type == :tag
           commit_sha = get_object_by_sha1(sha).object
-          cat_file(get_object_by_sha1(commit_sha).tree)
+          tree = get_object_by_sha1(commit_sha).tree
         elsif o.type == :tree
-          cat_file(sha)
+          tree = sha
+        else
+          return nil
         end
+
+        recursive ? get_raw_trees(tree) : cat_file(tree)
+      end
+
+      # Grabs tree contents recursively,
+      #   e.g. `git ls-tree -r sha`
+      def get_raw_trees(sha, path = '')
+        out = ''
+        cat_file(sha).split("\n").each do |line|
+          mode, type, sha, name = line.split(/\s/)
+
+          if type == 'tree'
+            full_name = path.empty? ? name : "#{path}/#{name}"
+            out << get_raw_trees(sha, full_name)
+          elsif path.empty?
+            out << line + "\n"
+          else
+            out << line.gsub(name, "#{path}/#{name}") + "\n"
+          end
+        end
+
+        out
       end
 
       # return array of tree entries
@@ -219,6 +244,7 @@ module Grit
               tree
             end
           else
+            raise NoSuchPath if tree.nil?
             next_path = paths.shift
             dir_name = tree.split("\n").select { |p| p.split("\t")[1] == next_path }.first
             raise NoSuchPath if !dir_name
@@ -231,6 +257,7 @@ module Grit
             end
           end
         else
+          raise NoSuchPath if tree.nil?
           tree = tree.split("\n")
           tree = tree.select { |p| p.split("\t")[1] == path }
           if append

data/lib/grit/git.rb

@@ -27,6 +27,12 @@ module Grit
       ruby_git.object_exists?(object_id)
     end
 
+    def select_existing_objects(object_ids)
+      object_ids.select do |object_id|
+        object_exists?(object_id)
+      end
+    end
+
     class << self
       attr_accessor :git_binary, :git_timeout, :git_max_size
     end
@@ -72,7 +78,7 @@ module Grit
     #
     # Returns the String contents of the file
     def fs_read(file)
-      File.open(File.join(self.git_dir, file)).read
+      File.read(File.join(self.git_dir, file))
     end
 
     # Write a normal file to the filesystem.
@@ -229,13 +235,12 @@ module Grit
       opt_args = transform_options(options)
 
       if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
-        ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|') ? a : "\"#{e(a)}\"" }
+        ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|' || Grit.no_quote) ? a : "\"#{e(a)}\"" }
         call = "#{prefix}#{Git.git_binary} --git-dir=\"#{self.git_dir}\" #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{e(postfix)}"
       else
-        ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|') ? a : "'#{e(a)}'" }
+        ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|' || Grit.no_quote) ? a : "'#{e(a)}'" }
         call = "#{prefix}#{Git.git_binary} --git-dir='#{self.git_dir}' #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{e(postfix)}"
       end
-
       Grit.log(call) if Grit.debug
       response, err = timeout ? sh(call) : wild_sh(call)
       Grit.log(response) if Grit.debug

data/lib/grit/index.rb

@@ -102,7 +102,7 @@ module Grit
             ctree = now_tree/k if now_tree
             sha = write_tree(v, ctree)
             sha = [sha].pack("H*")
-            str = "%s %s\0%s" % ['040000', k, sha]
+            str = "%s %s\0%s" % ['40000', k, sha]
             tree_contents[k + '/'] = str
         end
       end

data/lib/grit/ref.rb

@@ -63,7 +63,9 @@ module Grit
     def self.current(repo, options = {})
       head = repo.git.fs_read('HEAD').chomp
       if /ref: refs\/heads\/(.*)/.match(head)
-        self.new($1, repo.git.rev_parse(options, 'HEAD'))
+        id = repo.git.rev_parse(options, 'HEAD')
+        commit = Commit.create(repo, :id => id)
+        self.new($1, commit)
       end
     end
 

data/lib/grit/repo.rb

@@ -132,6 +132,30 @@ module Grit
       Tag.find_all(self)
     end
 
+    # Finds the most recent annotated tag name that is reachable from a commit.
+    #
+    #   @repo.recent_tag_name('master')
+    #   # => "v1.0-0-abcdef"
+    #
+    # committish - optional commit SHA, branch, or tag name.
+    # options    - optional hash of options to pass to git.
+    #              Default: {:always => true}
+    #              :tags => true      # use lightweight tags too.
+    #              :abbrev => Integer # number of hex digits to form the unique
+    #                name.  Defaults to 7.
+    #              :long => true      # always output tag + commit sha
+    #              # see `git describe` docs for more options.
+    #
+    # Returns the String tag name, or just the commit if no tag is
+    # found.  If there have been updates since the tag was made, a
+    # suffix is added with the number of commits since the tag, and
+    # the abbreviated object name of the most recent commit.
+    # Returns nil if the committish value is not found.
+    def recent_tag_name(committish = nil, options = {})
+      value = git.describe({:always => true}.update(options), committish.to_s).to_s.strip
+      value.size.zero? ? nil : value
+    end
+
     # An array of Remote objects representing the remote branches in
     # this repo
     #
@@ -251,6 +275,46 @@ module Grit
       end
     end
 
+    def objects(refs)
+      Grit.no_quote = true
+      obj = self.git.rev_list({:objects => true, :timeout => false}, refs).split("\n").map { |a| a[0, 40] }
+      Grit.no_quote = false
+      obj
+    end
+
+    def commit_objects(refs)
+      Grit.no_quote = true
+      obj = self.git.rev_list({:timeout => false}, refs).split("\n").map { |a| a[0, 40] }
+      Grit.no_quote = false
+      obj
+    end
+
+    def objects_between(ref1, ref2 = nil)
+      if ref2
+        refs = "#{ref2}..#{ref1}"
+      else
+        refs = ref1
+      end
+      self.objects(refs)
+    end
+
+    def diff_objects(commit_sha, parents = true)
+      revs = []
+      Grit.no_quote = true
+      if parents
+        # PARENTS:
+        cmd = "-r -t -m #{commit_sha}"
+        revs = self.git.diff_tree({:timeout => false}, cmd).strip.split("\n").map{ |a| r = a.split(' '); r[3] if r[1] != '160000' }
+      else
+        # NO PARENTS:
+        cmd = "-r -t #{commit_sha}"
+        revs = self.git.method_missing('ls-tree', {:timeout => false}, "-r -t #{commit_sha}").split("\n").map{ |a| a.split("\t").first.split(' ')[2] }
+      end
+      revs << self.commit(commit_sha).tree.id
+      Grit.no_quote = false
+      return revs.uniq.compact
+    end
+
     # The Tree object for the given treeish reference
     #   +treeish+ is the reference (default 'master')
     #   +paths+ is an optional Array of directory paths to restrict the tree (deafult [])
@@ -287,7 +351,14 @@ module Grit
     #   +b+ is the other commit
     #   +paths+ is an optional list of file paths on which to restrict the diff
     def diff(a, b, *paths)
-      self.git.diff({}, a, b, '--', *paths)
+      diff = self.git.native('diff', {}, a, b, '--', *paths)
+
+      if diff =~ /diff --git a/
+        diff = diff.sub(/.+?(diff --git a)/m, '\1')
+      else
+        diff = ''
+      end
+      Diff.list_from_string(self, diff)
     end
 
     # The commit diff for the given commit
@@ -314,6 +385,15 @@ module Grit
       self.new(path, repo_options)
     end
 
+    def self.init_bare_or_open(path, git_options = {}, repo_options = {})
+      git = Git.new(path)
+      if !git.exist?
+        git.fs_mkdir(path)
+        git.init(git_options)
+      end
+      self.new(path, repo_options)
+    end
+
     # Fork a bare git repository from this repo
     #   +path+ is the full path of the new repo (traditionally ends with /<name>.git)
     #   +options+ is any additional options to the git clone command (:bare and :shared are true by default)

data/lib/grit/tag.rb

@@ -1,15 +1,68 @@
 module Grit
 
   class Tag < Ref
+    lazy_reader :message
+    lazy_reader :tagger
+    lazy_reader :tag_date
+
     def self.find_all(repo, options = {})
       refs = repo.git.refs(options, prefix)
       refs.split("\n").map do |ref|
         name, id = *ref.split(' ')
-        cid = repo.git.commit_from_sha(id)
-        raise "Unknown object type." if cid == ''
-        commit = Commit.create(repo, :id => cid)
-        self.new(name, commit)
+        sha = repo.git.commit_from_sha(id)
+        raise "Unknown object type." if sha == ''
+        commit = Commit.create(repo, :id => sha)
+        new(name, commit)
+      end
+    end
+
+    # Parses the results from `cat-file -p`
+    #
+    # data - String tag object data.  Example:
+    #          object 7bcc0ee821cdd133d8a53e8e7173a334fef448aa
+    #          type commit
+    #          tag v0.7.0
+    #          tagger USER <EMAIL> DATE
+    #          
+    #          v0.7.0
+    #
+    # Returns parsed Hash.  Example: 
+    #   {:message => "...", :tagger => "bob", :tag_date => ...}
+    def self.parse_tag_data(data)
+      return unless data =~ /^object/
+      parsed = {}
+      lines  = data.split("\n")
+      lines.shift # type commit
+      lines.shift # tag name
+      lines.shift
+      author_line = lines.shift
+      parsed[:tagger], parsed[:tag_date] = Commit.actor(author_line)
+      if !parsed[:tagger] || !parsed[:tagger].name
+        parsed[:tag_date] ||= Time.utc(1970)
+        parsed[:tagger]     = Actor.from_string(author_line.sub(/^tagger /, ''))
+      end
+      lines.shift # blank line
+      parsed[:message] = []
+      while lines.first && lines.first !~ /-----BEGIN PGP SIGNATURE-----/
+        parsed[:message] << lines.shift
+      end
+      parsed[:message] = parsed[:message] * "\n"
+      parsed
+    end
+
+    def lazy_source
+      data         = commit.repo.git.cat_ref({:p => true}, name)
+      @message     = commit.short_message
+      @tagger      = commit.author
+      @tag_date    = commit.authored_date
+      return self if data.empty?
+
+      if parsed = self.class.parse_tag_data(data)
+        @message  = parsed[:message]
+        @tagger   = parsed[:tagger]
+        @tag_date = parsed[:tag_date]
       end
+      self
     end
   end