grit 1.1.1 → 2.0.0

data/lib/grit/git.rb

@@ -1,5 +1,6 @@
+require 'tempfile'
 module Grit
-  
+
   class Git
     class GitTimeout < RuntimeError
       attr_reader :command, :bytes_read
@@ -11,36 +12,195 @@ module Grit
     end
 
     undef_method :clone
-    
+
     include GitRuby
-    
+
+    def exist?
+      File.exist?(self.git_dir)
+    end
+
+    def put_raw_object(content, type)
+      ruby_git.put_raw_object(content, type)
+    end
+
+    def object_exists?(object_id)
+      ruby_git.object_exists?(object_id)
+    end
+
     class << self
       attr_accessor :git_binary, :git_timeout, :git_max_size
     end
-  
-    self.git_binary   = "/usr/bin/env git"
+
+    if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
+      self.git_binary   = "git" # using search path
+    else
+      self.git_binary   = "/usr/bin/env git"
+    end
     self.git_timeout  = 10
     self.git_max_size = 5242880 # 5.megabytes
-    
+
     def self.with_timeout(timeout = 10.seconds)
       old_timeout = Grit::Git.git_timeout
       Grit::Git.git_timeout = timeout
       yield
       Grit::Git.git_timeout = old_timeout
     end
-    
-    attr_accessor :git_dir, :bytes_read
-    
+
+    attr_accessor :git_dir, :bytes_read, :work_tree
+
     def initialize(git_dir)
       self.git_dir    = git_dir
+      self.work_tree  = git_dir.gsub(/\/\.git$/,'')
       self.bytes_read = 0
     end
-    
+
     def shell_escape(str)
       str.to_s.gsub("'", "\\\\'").gsub(";", '\\;')
     end
     alias_method :e, :shell_escape
-    
+
+    # Check if a normal file exists on the filesystem
+    #   +file+ is the relative path from the Git dir
+    #
+    # Returns Boolean
+    def fs_exist?(file)
+      File.exist?(File.join(self.git_dir, file))
+    end
+
+    # Read a normal file from the filesystem.
+    #   +file+ is the relative path from the Git dir
+    #
+    # Returns the String contents of the file
+    def fs_read(file)
+      File.open(File.join(self.git_dir, file)).read
+    end
+
+    # Write a normal file to the filesystem.
+    #   +file+ is the relative path from the Git dir
+    #   +contents+ is the String content to be written
+    #
+    # Returns nothing
+    def fs_write(file, contents)
+      path = File.join(self.git_dir, file)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, 'w') do |f|
+        f.write(contents)
+      end
+    end
+
+    # Delete a normal file from the filesystem
+    #   +file+ is the relative path from the Git dir
+    #
+    # Returns nothing
+    def fs_delete(file)
+      FileUtils.rm_rf(File.join(self.git_dir, file))
+    end
+
+    # Move a normal file
+    #   +from+ is the relative path to the current file
+    #   +to+ is the relative path to the destination file
+    #
+    # Returns nothing
+    def fs_move(from, to)
+      FileUtils.mv(File.join(self.git_dir, from), File.join(self.git_dir, to))
+    end
+
+    # Make a directory
+    #   +dir+ is the relative path to the directory to create
+    #
+    # Returns nothing
+    def fs_mkdir(dir)
+      FileUtils.mkdir_p(File.join(self.git_dir, dir))
+    end
+
+    # Chmod the the file or dir and everything beneath
+    #   +file+ is the relative path from the Git dir
+    #
+    # Returns nothing
+    def fs_chmod(mode, file = '/')
+      FileUtils.chmod_R(mode, File.join(self.git_dir, file))
+    end
+
+    def list_remotes
+      remotes = []
+      Dir.chdir(File.join(self.git_dir, 'refs/remotes')) do
+        remotes = Dir.glob('*')
+      end
+      remotes
+    rescue
+      []
+    end
+
+    def create_tempfile(seed, unlink = false)
+      path = Tempfile.new(seed).path
+      File.unlink(path) if unlink
+      return path
+    end
+
+    def commit_from_sha(id)
+      git_ruby_repo = GitRuby::Repository.new(self.git_dir)
+      object = git_ruby_repo.get_object_by_sha1(id)
+
+      if object.type == :commit
+        id
+      elsif object.type == :tag
+        object.object
+      else
+        ''
+      end
+    end
+
+    def check_applies(head_sha, applies_sha)
+      git_index = create_tempfile('index', true)
+      (o1, exit1) = raw_git("git read-tree #{head_sha} 2>/dev/null", git_index)
+      (o2, exit2) = raw_git("git diff #{applies_sha}^ #{applies_sha} | git apply --check --cached >/dev/null 2>/dev/null", git_index)
+      return (exit1 + exit2)
+    end
+
+    def get_patch(applies_sha)
+      git_index = create_tempfile('index', true)
+      (patch, exit2) = raw_git("git diff #{applies_sha}^ #{applies_sha}", git_index)
+      patch
+    end
+
+    def apply_patch(head_sha, patch)
+      git_index = create_tempfile('index', true)
+
+      git_patch = create_tempfile('patch')
+      File.open(git_patch, 'w+') { |f| f.print patch }
+
+      raw_git("git read-tree #{head_sha} 2>/dev/null", git_index)
+      (op, exit) = raw_git("git apply --cached < #{git_patch}", git_index)
+      if exit == 0
+        return raw_git("git write-tree", git_index).first.chomp
+      end
+      false
+    end
+
+    # RAW CALLS WITH ENV SETTINGS
+    def raw_git_call(command, index)
+      tmp = ENV['GIT_INDEX_FILE']
+      ENV['GIT_INDEX_FILE'] = index
+      out = `#{command}`
+      after = ENV['GIT_INDEX_FILE'] # someone fucking with us ??
+      ENV['GIT_INDEX_FILE'] = tmp
+      if after != index
+        raise 'environment was changed for the git call'
+      end
+      [out, $?.exitstatus]
+    end
+
+    def raw_git(command, index)
+      output = nil
+      Dir.chdir(self.git_dir) do
+        output = raw_git_call(command, index)
+      end
+      output
+    end
+    # RAW CALLS WITH ENV SETTINGS END
+
+
+
     # Run the given git command with the specified arguments and return
     # the result as a String
     #   +cmd+ is the command
@@ -55,14 +215,27 @@ module Grit
       run('', cmd, '', options, args)
     end
 
+    # Bypass any pure Ruby implementations and go straight to the native Git command
+    #
+    # Returns String
+    def native(cmd, options = {}, *args)
+      method_missing(cmd, options, *args)
+    end
+
     def run(prefix, cmd, postfix, options, args)
       timeout  = options.delete(:timeout) rescue nil
       timeout  = true if timeout.nil?
 
       opt_args = transform_options(options)
-      ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|') ? a : "'#{e(a)}'" }
 
-      call = "#{prefix}#{Git.git_binary} --git-dir='#{self.git_dir}' #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{e(postfix)}"
+      if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
+        ext_args = args.reject { |a| a.empty? }.map { |a| (a == '--' || a[0].chr == '|') ? 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)}'" }
+        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
@@ -120,6 +293,8 @@ module Grit
         if opt.to_s.size == 1
           if options[opt] == true
             args << "-#{opt}"
+          elsif options[opt] == false
+            # ignore
           else
             val = options.delete(opt)
             args << "-#{opt.to_s} '#{e(val)}'"
@@ -127,6 +302,8 @@ module Grit
         else
           if options[opt] == true
             args << "--#{opt.to_s.gsub(/_/, '-')}"
+          elsif options[opt] == false
+            # ignore
           else
             val = options.delete(opt)
             args << "--#{opt.to_s.gsub(/_/, '-')}='#{e(val)}'"
@@ -136,5 +313,5 @@ module Grit
       args
     end
   end # Git
-  
+
 end # Grit

data/lib/grit/index.rb

@@ -1,14 +1,14 @@
 module Grit
-  
+
   class Index
     attr_accessor :repo, :tree, :current_tree
-    
+
     def initialize(repo)
       self.repo = repo
       self.tree = {}
       self.current_tree = nil
     end
-    
+
     # Add a file to the index
     #   +path+ is the path (including filename)
     #   +data+ is the binary contents of the file
@@ -17,18 +17,18 @@ module Grit
     def add(file_path, data)
       path = file_path.split('/')
       filename = path.pop
-      
+
       current = self.tree
-      
+
       path.each do |dir|
         current[dir] ||= {}
         node = current[dir]
         current = node
       end
-      
+
       current[filename] = data
     end
-        
+
     # Sets the current tree
     #   +tree+ the branch/tag/sha... to use - a string
     #
@@ -36,7 +36,7 @@ module Grit
     def read_tree(tree)
       self.current_tree = self.repo.tree(tree)
     end
-    
+
     # Commit the contents of the index
     #   +message+ is the commit message [nil]
     #   +parents+ is one or more commits to attach this commit to to form a new head [nil]
@@ -48,11 +48,11 @@ module Grit
     def commit(message, parents = nil, actor = nil, last_tree = nil, head = 'master')
       tree_sha1 = write_tree(self.tree, self.current_tree)
       return false if tree_sha1 == last_tree # don't write identical commits
-      
+
       contents = []
       contents << ['tree', tree_sha1].join(' ')
       parents.each do |p|
-        contents << ['parent', p].join(' ') if p        
+        contents << ['parent', p].join(' ') if p
       end if parents
 
       if actor
@@ -63,25 +63,25 @@ module Grit
         name = config['user.name']
         email = config['user.email']
       end
-    
+
       author_string = "#{name} <#{email}> #{Time.now.to_i} -0700" # !! TODO : gotta fix this
       contents << ['author', author_string].join(' ')
       contents << ['committer', author_string].join(' ')
       contents << ''
       contents << message
-      
-      commit_sha1 = self.repo.git.ruby_git.put_raw_object(contents.join("\n"), 'commit')      
-      
+
+      commit_sha1 = self.repo.git.put_raw_object(contents.join("\n"), 'commit')
+
       self.repo.update_ref(head, commit_sha1)
     end
-    
+
     # Recursively write a tree to the index
     #   +tree+ is the tree
     #
     # Returns the SHA1 String of the tree
     def write_tree(tree, now_tree = nil)
       tree_contents = {}
-            
+
       # fill in original tree
       now_tree.contents.each do |obj|
         sha = [obj.id].pack("H*")
@@ -89,7 +89,7 @@ module Grit
         k += '/' if (obj.class == Grit::Tree)
         tree_contents[k] = "%s %s\0%s" % [obj.mode.to_s, obj.name, sha]
       end if now_tree
-      
+
       # overwrite with new tree contents
       tree.each do |k, v|
         case v
@@ -107,16 +107,16 @@ module Grit
         end
       end
       tr = tree_contents.sort.map { |k, v| v }.join('')
-      self.repo.git.ruby_git.put_raw_object(tr, 'tree')
+      self.repo.git.put_raw_object(tr, 'tree')
     end
-    
+
     # Write the blob to the index
     #   +data+ is the data to write
     #
     # Returns the SHA1 String of the blob
     def write_blob(data)
-      self.repo.git.ruby_git.put_raw_object(data, 'blob')
+      self.repo.git.put_raw_object(data, 'blob')
     end
   end # Index
-  
+
 end # Grit

data/lib/grit/lazy.rb

@@ -1,6 +1,6 @@
 ##
 # Allows attributes to be declared as lazy, meaning that they won't be
-# computed until they are asked for. 
+# computed until they are asked for.
 #
 # Works by delegating each lazy_reader to a cached lazy_source method.
 #

data/lib/grit/merge.rb

@@ -1,20 +1,20 @@
 module Grit
-  
+
   class Merge
-    
+
     STATUS_BOTH = 'both'
     STATUS_OURS = 'ours'
     STATUS_THEIRS = 'theirs'
-    
+
     attr_reader :conflicts, :text, :sections
-    
+
     def initialize(str)
       status = STATUS_BOTH
-      
+
       section = 1
       @conflicts = 0
       @text = {}
-      
+
       lines = str.split("\n")
       lines.each do |line|
         if /^<<<<<<< (.*?)/.match(line)
@@ -24,7 +24,7 @@ module Grit
         elsif line == '======='
           status = STATUS_THEIRS
         elsif /^>>>>>>> (.*?)/.match(line)
-          status = STATUS_BOTH          
+          status = STATUS_BOTH
           section += 1
         else
           @text[section] ||= {}
@@ -35,11 +35,11 @@ module Grit
       @text = @text.values
       @sections = @text.size
     end
-    
+
     # Pretty object inspection
     def inspect
       %Q{#<Grit::Merge}
     end
   end # Merge
-  
+
 end # Grit

data/lib/grit/ref.rb

@@ -10,37 +10,12 @@ module Grit
       #
       # Returns Grit::Ref[] (baked)
       def find_all(repo, options = {})
-        refs = []
-        already = {}
-        Dir.chdir(repo.path) do
-          files = Dir.glob(prefix + '/**/*')
-          files.each do |ref|
-            next if !File.file?(ref)
-            id = File.read(ref).chomp
-            name = ref.sub("#{prefix}/", '')
-            commit = Commit.create(repo, :id => id)
-            if !already[name]
-              refs << self.new(name, commit)
-              already[name] = true
-            end
-          end
-
-          if File.file?('packed-refs')
-            File.readlines('packed-refs').each do |line|
-              if m = /^(\w{40}) (.*?)$/.match(line)
-                next if !Regexp.new('^' + prefix).match(m[2])
-                name = m[2].sub("#{prefix}/", '')
-                commit = Commit.create(repo, :id => m[1])
-                if !already[name]
-                  refs << self.new(name, commit)
-                  already[name] = true
-                end
-              end
-            end
-          end
+        refs = repo.git.refs(options, prefix)
+        refs.split("\n").map do |ref|
+          name, id = *ref.split(' ')
+          commit = Commit.create(repo, :id => id)
+          self.new(name, commit)
         end
-
-        refs
       end
 
       protected
@@ -86,7 +61,7 @@ module Grit
     #
     # Returns Grit::Head (baked)
     def self.current(repo, options = {})
-      head = File.open(File.join(repo.path, 'HEAD')).read.chomp
+      head = repo.git.fs_read('HEAD').chomp
       if /ref: refs\/heads\/(.*)/.match(head)
         self.new($1, repo.git.rev_parse(options, 'HEAD'))
       end