mojombo-grit 0.8.1 → 0.9.3

data/lib/grit/git.rb

@@ -19,6 +19,8 @@ module Grit
 
     undef_method :clone
     
+    include GitRuby
+    
     class << self
       attr_accessor :git_binary, :git_timeout
     end
@@ -44,31 +46,41 @@ module Grit
     #
     # Returns String
     def method_missing(cmd, options = {}, *args)
+      run('', cmd, '', options, args)
+    end
+
+    def run(prefix, cmd, postfix, options, args)
       timeout  = options.delete(:timeout)
       timeout  = true if timeout.nil?
 
       opt_args = transform_options(options)
       ext_args = args.map { |a| a == '--' ? a : "'#{a}'" }
       
-      call = "#{Git.git_binary} --git-dir='#{self.git_dir}' #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}"
-      puts call if Grit.debug
-      response = timeout ? sh(call) : wild_sh(call)
-      puts response if Grit.debug
+      call = "#{prefix}#{Git.git_binary} --git-dir='#{self.git_dir}' #{cmd.to_s.gsub(/_/, '-')} #{(opt_args + ext_args).join(' ')}#{postfix}"
+      Grit.log(call) if Grit.debug
+      response, err = timeout ? sh(call) : wild_sh(call)
+      Grit.log(response) if Grit.debug
+      Grit.log(err) if Grit.debug
       response
     end
 
     def sh(command)
-      pid, _, io, _ = Open4.popen4(command)
-      ret = Timeout.timeout(self.class.git_timeout) { io.read }
-      @bytes_read += ret.size
+      ret, pid, err = nil, nil, nil
+      Open4.popen4(command) do |id, _, stdout, stderr|
+        pid = id
+        ret = Timeout.timeout(self.class.git_timeout) { stdout.read }
+        err = stderr.read
+        @bytes_read += ret.size
 
-      if @bytes_read > 5242880 # 5.megabytes
-        bytes = @bytes_read
-        @bytes_read = 0
-        raise GitTimeout.new(command, bytes) 
+        if @bytes_read > 5242880 # 5.megabytes
+          bytes = @bytes_read
+          @bytes_read = 0
+          raise GitTimeout.new(command, bytes) 
+        end
       end
-
-      ret
+      [ret, err]
+    rescue Errno::ECHILD
+      [ret, err]
     rescue Object => e
       Process.kill('KILL', pid) rescue nil
       bytes = @bytes_read
@@ -77,8 +89,14 @@ module Grit
     end
 
     def wild_sh(command)
-      pid, _, io, _ = Open4.popen4(command)
-      io.read
+      ret, err = nil, nil
+      Open4.popen4(command) {|pid, _, stdout, stderr|
+        ret = stdout.read
+        err = stderr.read
+      }
+      [ret, err]
+    rescue Errno::ECHILD
+      [ret, err]
     end
 
     # Transform Ruby style options into git command line options

data/lib/grit/head.rb

@@ -29,8 +29,11 @@ module Grit
     #
     # Returns Grit::Head[] (baked)
     def self.find_all(repo, options = {})
-      default_options = {:sort => "committerdate",
-                         :format => "%(refname)%00%(objectname)"}
+      default_options = {
+        :sort    => "committerdate",
+        :format  => "%(refname)%00%(objectname)",
+        :timeout => false
+      }
                          
       actual_options = default_options.merge(options)
       
@@ -38,19 +41,7 @@ module Grit
                  
       self.list_from_string(repo, output)
     end
-
-   # Get the HEAD revision of the repo.
-    #   +repo+ is the Repo
-    #   +options+ is a Hash of options
-    #
-    # Returns Grit::Head (baked)
-    def self.current(repo, options = {})
-      head = File.open(File.join(repo.path, 'HEAD')).read.chomp
-      if /ref: refs\/heads\/(.*)/.match(head)
-        self.new($1, repo.git.rev_parse(options, 'HEAD'))
-      end
-    end
-
+    
     # Parse out head information into an array of baked head objects
     #   +repo+ is the Repo
     #   +text+ is the text output from the git command

data/lib/grit/index.rb

@@ -0,0 +1,121 @@
+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
+    #
+    # Returns nothing
+    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
+        
+    def read_tree(tree)
+      self.current_tree = self.repo.tree(tree)
+    end
+    
+    # Commit the contents of the index
+    #   +message+ is the commit message
+    #
+    # Returns a String of the SHA1 of the commit
+    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        
+      end if parents
+
+      if actor
+        name = actor.name
+        email = actor.email
+      else
+        config = Config.new(self.repo)
+        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')      
+      
+      # 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
+    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*")
+        k = obj.name
+        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
+          when String:
+            sha = write_blob(v)
+            sha = [sha].pack("H*")
+            str = "%s %s\0%s" % ['100644', k, sha]
+            tree_contents[k] = str
+          when Hash:
+            ctree = now_tree/k if now_tree
+            sha = write_tree(v, ctree)
+            sha = [sha].pack("H*")
+            str = "%s %s\0%s" % ['040000', k, sha]
+            tree_contents[k + '/'] = str
+        end
+      end
+      tr = tree_contents.sort.map { |k, v| v }.join('')
+      self.repo.git.ruby_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')
+    end
+  end # Index
+  
+end # Grit

data/lib/grit/ref.rb

@@ -0,0 +1,95 @@
+module Grit
+
+  class Ref
+
+    class << self
+
+      # Find all Refs
+      #   +repo+ is the Repo
+      #   +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
+        end
+                
+        refs
+      end
+
+      protected
+
+        def prefix
+          "refs/#{name.to_s.gsub(/^.*::/, '').downcase}s"
+        end
+
+    end
+
+    attr_reader :name
+    attr_reader :commit
+
+    # Instantiate a new Head
+    #   +name+ is the name of the head
+    #   +commit+ is the Commit that the head points to
+    #
+    # Returns Grit::Head (baked)
+    def initialize(name, commit)
+      @name = name
+      @commit = commit
+    end
+
+    # Pretty object inspection
+    def inspect
+      %Q{#<#{self.class.name} "#{@name}">}
+    end
+  end # Ref
+
+  # A Head is a named reference to a Commit. Every Head instance contains a name
+  # and a Commit object.
+  #
+  #   r = Grit::Repo.new("/path/to/repo")
+  #   h = r.heads.first
+  #   h.name       # => "master"
+  #   h.commit     # => #<Grit::Commit "1c09f116cbc2cb4100fb6935bb162daa4723f455">
+  #   h.commit.id  # => "1c09f116cbc2cb4100fb6935bb162daa4723f455"
+  class Head < Ref
+
+    # Get the HEAD revision of the repo.
+    #   +repo+ is the Repo
+    #   +options+ is a Hash of options
+    #
+    # Returns Grit::Head (baked)
+    def self.current(repo, options = {})
+      head = File.open(File.join(repo.path, 'HEAD')).read.chomp
+      if /ref: refs\/heads\/(.*)/.match(head)
+        self.new($1, repo.git.rev_parse(options, 'HEAD'))
+      end
+    end
+
+  end # Head
+
+  class Tag < Ref ; end
+
+  class Remote < Ref; end
+  
+end # Grit

data/lib/grit/repo.rb

@@ -5,6 +5,7 @@ module Grit
     
     # The path of the git repo as a String
     attr_accessor :path
+    attr_accessor :working_dir
     attr_reader :bare
     
     # The git command line interface object
@@ -18,13 +19,14 @@ module Grit
     #   g = Repo.new("/Users/tom/public/grit.git")
     #
     # Returns Grit::Repo
-    def initialize(path)
+    def initialize(path, options = {})
       epath = File.expand_path(path)
       
       if File.exist?(File.join(epath, '.git'))
+        self.working_dir = epath
         self.path = File.join(epath, '.git')
         @bare = false
-      elsif File.exist?(epath) && epath =~ /\.git$/
+      elsif File.exist?(epath) && (epath =~ /\.git$/ || options[:is_bare])
         self.path = epath
         @bare = true
       elsif File.exist?(epath)
@@ -36,6 +38,13 @@ module Grit
       self.git = Git.new(self.path)
     end
     
+    def self.init(path)
+      # !! TODO !!
+      # create directory
+      # generate initial git directory
+      # create new Grit::Repo on that dir, return it
+    end
+    
     # The project's description. Taken verbatim from GIT_REPO/description
     #
     # Returns String
@@ -53,6 +62,10 @@ module Grit
     
     alias_method :branches, :heads
 
+    def is_head?(head_name)
+      heads.find { |h| h.name == head_name }
+    end
+    
     # Object reprsenting the current repo head.
     #
     # Returns Grit::Head (baked)
@@ -60,6 +73,47 @@ module Grit
       Head.current(self)
     end
 
+
+    # Commits current index
+    #
+    # Returns true/false if commit worked
+    def commit_index(message)
+      self.git.commit({}, '-m', message)
+    end
+
+    # Commits all tracked and modified files
+    #
+    # Returns true/false if commit worked
+    def commit_all(message)
+      self.git.commit({}, '-a', '-m', message)
+    end
+
+    # Adds files to the index
+    def add(*files)
+      self.git.add({}, *files.flatten)
+    end
+
+    # Adds files to the index
+    def remove(*files)
+      self.git.rm({}, *files.flatten)
+    end
+    
+
+    def blame_tree(commit, path = nil)
+      commit_array = self.git.blame_tree(commit, path)
+      
+      final_array = {}
+      commit_array.each do |file, sha|
+        final_array[file] = commit(sha)
+      end
+      final_array
+    end
+    
+    def status
+      Status.new(self)
+    end
+
+
     # An array of Tag objects that are available in this repo
     #
     # Returns Grit::Tag[] (baked)
@@ -67,9 +121,32 @@ module Grit
       Tag.find_all(self)
     end
     
+    # An array of Remote objects representing the remote branches in
+    # this repo
+    #
+    # Returns Grit::Remote[] (baked)
+    def remotes
+      Remote.find_all(self)
+    end
+
+    # An array of Ref objects representing the refs in
+    # this repo
+    #
+    # Returns Grit::Ref[] (baked)
+    def refs
+      [ Head.find_all(self), Tag.find_all(self), Remote.find_all(self) ].flatten
+    end
+
+    def commit_stats(start = 'master', max_count = 10, skip = 0)
+      options = {:max_count => max_count,
+                 :skip => skip}
+      
+      CommitStats.find_all(self, start, options)
+    end
+    
     # An array of Commit objects representing the history of a given ref/commit
     #   +start+ is the branch/commit name (default 'master')
-    #   +max_count+ is the maximum number of commits to return (default 10)
+    #   +max_count+ is the maximum number of commits to return (default 10, use +false+ for all)
     #   +skip+ is the number of commits to skip (default 0)
     #
     # Returns Grit::Commit[] (baked)
@@ -176,10 +253,10 @@ module Grit
     #   Grit::Repo.init_bare('/var/git/myrepo.git')
     #
     # Returns Grit::Repo (the newly created repo)
-    def self.init_bare(path, options = {})
+    def self.init_bare(path, git_options = {}, repo_options = {})
       git = Git.new(path)
-      git.init(options)
-      self.new(path)
+      git.init(git_options)
+      self.new(path, repo_options)
     end
     
     # Fork a bare git repository from this repo
@@ -235,6 +312,14 @@ module Grit
       options[:prefix] = prefix if prefix
       self.git.archive(options, treeish, "| gzip")
     end
+
+    # run archive directly to a file
+    def archive_to_file(treeish = 'master', prefix = nil, filename = 'archive.tar.gz')
+      options = {}
+      options[:prefix] = prefix if prefix
+      self.git.archive(options, treeish, "| gzip > #{filename}")
+    end
+
     
     # Enable git-daemon serving of this repository by writing the
     # git-daemon-export-ok file to its git directory
@@ -289,6 +374,10 @@ module Grit
       @config ||= Config.new(self)
     end
     
+    def index
+      Index.new(self)
+    end
+    
     # Pretty object inspection
     def inspect
       %Q{#<Grit::Repo "#{@path}">}