schacon-grit 0.9.4 → 1.1.1

data/lib/grit/index.rb

@@ -29,12 +29,20 @@ module Grit
       current[filename] = data
     end
         
+    # Sets the current tree
+    #   +tree+ the branch/tag/sha... to use - a string
+    #
+    # Returns index (self)
     def read_tree(tree)
       self.current_tree = self.repo.tree(tree)
     end
     
     # Commit the contents of the index
-    #   +message+ is the commit message
+    #   +message+ is the commit message [nil]
+    #   +parents+ is one or more commits to attach this commit to to form a new head [nil]
+    #   +actor+ is the details of the user making the commit [nil]
+    #   +last_tree+ is a tree to compare with - to avoid making empty commits [nil]
+    #   +head+ is the branch to write this head to [master]
     #
     # Returns a String of the SHA1 of the commit
     def commit(message, parents = nil, actor = nil, last_tree = nil, head = 'master')
@@ -62,16 +70,9 @@ module Grit
       contents << ''
       contents << message
       
-      commit_sha1 = self.repo.git.ruby_git.put_raw_object(contents.join("\n"), 'commit')      
-      
-      # self.repo.git.update_ref({}, 'HEAD', commit_sha1)
-      ref_heads = File.join(self.repo.path, 'refs', 'heads')
-      FileUtils.mkdir_p(ref_heads)
-      File.open(File.join(ref_heads, head), 'w') do |f|
-        f.write(commit_sha1)
-      end if commit_sha1
+      commit_sha1 = self.repo.git.put_raw_object(contents.join("\n"), 'commit')
       
-      commit_sha1
+      self.repo.update_ref(head, commit_sha1)
     end
     
     # Recursively write a tree to the index
@@ -92,12 +93,12 @@ module Grit
       # overwrite with new tree contents
       tree.each do |k, v|
         case v
-          when String:
+          when String
             sha = write_blob(v)
             sha = [sha].pack("H*")
             str = "%s %s\0%s" % ['100644', k, sha]
             tree_contents[k] = str
-          when Hash:
+          when Hash
             ctree = now_tree/k if now_tree
             sha = write_tree(v, ctree)
             sha = [sha].pack("H*")
@@ -106,7 +107,7 @@ 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
@@ -114,7 +115,7 @@ module Grit
     #
     # 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
   

data/lib/grit/merge.rb

@@ -0,0 +1,45 @@
+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)
+          status = STATUS_OURS
+          @conflicts += 1
+          section += 1
+        elsif line == '======='
+          status = STATUS_THEIRS
+        elsif /^>>>>>>> (.*?)/.match(line)
+          status = STATUS_BOTH          
+          section += 1
+        else
+          @text[section] ||= {}
+          @text[section][status] ||= []
+          @text[section][status] << line
+        end
+      end
+      @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

@@ -9,32 +9,13 @@ module Grit
       #   +options+ is a Hash of options
       #
       # Returns Grit::Ref[] (baked)
-      def find_all(repo, options = {})      
-        refs = []
-
-        Dir.chdir(repo.path) do
-          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])
-                refs << self.new(name, commit)
-              end
-            end
-          end
-          
-          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)
-            refs << self.new(name, commit)
-          end
+      def find_all(repo, options = {})
+        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
@@ -80,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
@@ -88,8 +69,6 @@ module Grit
 
   end # Head
 
-  class Tag < Ref ; end
-
   class Remote < Ref; end
-  
+
 end # Grit

data/lib/grit/repo.rb

@@ -13,6 +13,7 @@ module Grit
     
     # Create a new Repo instance
     #   +path+ is the path to either the root git directory or the bare git repo
+    #   +options+ :is_bare force to load a bare repo
     #
     # Examples
     #   g = Repo.new("/Users/tom/dev/grit")
@@ -37,7 +38,8 @@ module Grit
       
       self.git = Git.new(self.path)
     end
-    
+   
+    # Does nothing yet...
     def self.init(path)
       # !! TODO !!
       # create directory
@@ -49,8 +51,13 @@ module Grit
     #
     # Returns String
     def description
-      File.open(File.join(self.path, 'description')).read.chomp
+      self.git.fs_read('description').chomp
+    end
+
+    def blame(file, commit = nil)
+      Blame.new(self, file, commit)
     end
+
     
     # An array of Head objects representing the branch heads in
     # this repo
@@ -62,10 +69,14 @@ module Grit
     
     alias_method :branches, :heads
 
-    def is_head?(head_name)
+    def get_head(head_name)
       heads.find { |h| h.name == head_name }
     end
     
+    def is_head?(head_name)
+      get_head(head_name)
+    end
+    
     # Object reprsenting the current repo head.
     #
     # Returns Grit::Head (baked)
@@ -93,7 +104,7 @@ module Grit
       self.git.add({}, *files.flatten)
     end
 
-    # Adds files to the index
+    # Remove files from the index
     def remove(*files)
       self.git.rm({}, *files.flatten)
     end
@@ -128,6 +139,34 @@ module Grit
     def remotes
       Remote.find_all(self)
     end
+    
+    def remote_list
+      self.git.list_remotes
+    end
+    
+    def remote_add(name, url)
+      self.git.remote({}, 'add', name, url)
+    end
+
+    def remote_fetch(name)
+      self.git.fetch({}, name)
+    end
+
+    # takes an array of remote names and last pushed dates
+    # fetches from all of the remotes where the local fetch
+    # date is earlier than the passed date, then records the
+    # last fetched date 
+    #
+    # { 'origin' => date,
+    #   'peter => date,
+    # }
+    def remotes_fetch_needed(remotes)
+      remotes.each do |remote, date|
+        # TODO: check against date
+        self.remote_fetch(remote)
+      end
+    end
+    
 
     # An array of Ref objects representing the refs in
     # this repo
@@ -198,6 +237,53 @@ module Grit
       Commit.find_all(self, id, options).first
     end
     
+    # Returns a list of commits that is in +other_repo+ but not in self
+    #
+    # Returns Grit::Commit[]
+    def commit_deltas_from(other_repo, ref = "master", other_ref = "master")
+      # TODO: we should be able to figure out the branch point, rather than
+      # rev-list'ing the whole thing
+      repo_refs       = self.git.rev_list({}, ref).strip.split("\n")
+      other_repo_refs = other_repo.git.rev_list({}, other_ref).strip.split("\n")
+      
+      (other_repo_refs - repo_refs).map do |ref|
+        Commit.find_all(other_repo, ref, {:max_count => 1}).first
+      end
+    end
+
+    def objects(refs)
+      Grit.no_quote = true
+      obj = self.git.rev_list({:objects => true}, 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({}, 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', {}, "-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 [])
@@ -255,20 +341,31 @@ module Grit
     # Returns Grit::Repo (the newly created repo)
     def self.init_bare(path, git_options = {}, repo_options = {})
       git = Git.new(path)
+      git.fs_mkdir('..')
       git.init(git_options)
       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
+    #   +options+ is any additional options to the git clone command (:bare and :shared are true by default)
     #
     # Returns Grit::Repo (the newly forked repo)
     def fork_bare(path, options = {})
       default_options = {:bare => true, :shared => true}
       real_options = default_options.merge(options)
+      Git.new(path).fs_mkdir('..')
       self.git.clone(real_options, self.path, path)
-      Repo.new(path)
+      self.new(path)
     end
     
     # Archive the given treeish
@@ -310,23 +407,30 @@ module Grit
     def archive_tar_gz(treeish = 'master', prefix = nil)
       options = {}
       options[:prefix] = prefix if prefix
-      self.git.archive(options, treeish, "| gzip")
+      self.git.archive(options, treeish, "| gzip -n")
     end
 
-    # run archive directly to a file
-    def archive_to_file(treeish = 'master', prefix = nil, filename = 'archive.tar.gz')
+    # Write an archive directly to a file
+    #   +treeish+ is the treeish name/id (default 'master')
+    #   +prefix+ is the optional prefix (default nil)
+    #   +filename+ is the name of the file (default 'archive.tar.gz')
+    #   +format+ is the optional format (default nil)
+    #   +pipe+ is the command to run the output through (default 'gzip')
+    #
+    # Returns nothing
+    def archive_to_file(treeish = 'master', prefix = nil, filename = 'archive.tar.gz', format = nil, pipe = "gzip")
       options = {}
       options[:prefix] = prefix if prefix
-      self.git.archive(options, treeish, "| gzip > #{filename}")
+      options[:format] = format if format
+      self.git.archive(options, treeish, "| #{pipe} > #{filename}")
     end
 
-    
     # Enable git-daemon serving of this repository by writing the
     # git-daemon-export-ok file to its git directory
     #
     # Returns nothing
     def enable_daemon_serve
-      FileUtils.touch(File.join(self.path, DAEMON_EXPORT_FILE))
+      self.git.fs_write(DAEMON_EXPORT_FILE, '')
     end
     
     # Disable git-daemon serving of this repository by ensuring there is no
@@ -334,17 +438,20 @@ module Grit
     #
     # Returns nothing
     def disable_daemon_serve
-      FileUtils.rm_f(File.join(self.path, DAEMON_EXPORT_FILE))
+      self.git.fs_delete(DAEMON_EXPORT_FILE)
+    end
+    
+    def gc_auto
+      self.git.gc({:auto => true})
     end
     
     # The list of alternates for this repo
     #
     # Returns Array[String] (pathnames of alternates)
     def alternates
-      alternates_path = File.join(self.path, *%w{objects info alternates})
-      
-      if File.exist?(alternates_path)
-        File.read(alternates_path).strip.split("\n")
+      alternates_path = "objects/info/alternates"
+      if self.git.fs_exist?(alternates_path)
+        self.git.fs_read(alternates_path).strip.split("\n")
       else
         []
       end
@@ -362,11 +469,9 @@ module Grit
       end
       
       if alts.empty?
-        File.delete(File.join(self.path, *%w{objects info alternates}))
+        self.git.fs_write('objects/info/alternates', '')
       else
-        File.open(File.join(self.path, *%w{objects info alternates}), 'w') do |f|
-          f.write alts.join("\n")
-        end
+        self.git.fs_write('objects/info/alternates', alts.join("\n"))
       end
     end
     
@@ -378,6 +483,24 @@ module Grit
       Index.new(self)
     end
     
+    def update_ref(head, commit_sha)
+      return nil if !commit_sha || (commit_sha.size != 40)
+      self.git.fs_write("refs/heads/#{head}", commit_sha)
+      commit_sha
+    end
+    
+    # Rename the current repository directory.
+    #   +name+ is the new name
+    #
+    # Returns nothing
+    def rename(name)
+      if @bare
+        self.git.fs_move('/', "../#{name}")
+      else
+        self.git.fs_move('/', "../../#{name}")
+      end
+    end
+    
     # Pretty object inspection
     def inspect
       %Q{#<Grit::Repo "#{@path}">}