git 1.0.1

data/lib/git/path.rb

@@ -0,0 +1,23 @@
+module Git
+  class Path
+    
+    attr_accessor :path
+    
+    def initialize(path, check_path = true)
+      if !check_path || File.exists?(path)
+        @path = File.expand_path(path)
+      else
+        raise ArgumentError, "path does not exist", File.expand_path(path)
+      end
+    end
+    
+    def readable?
+      File.readable?(@path)
+    end
+
+    def writable?
+      File.writable?(@path)
+    end
+    
+  end
+end

data/lib/git/remote.rb

@@ -0,0 +1,42 @@
+module Git
+  class Remote < Path
+    
+    attr_accessor :name, :url, :fetch_opts
+    
+    @base = nil
+    
+    def initialize(base, name)
+      @base = base
+      config = @base.lib.config_remote(name)
+      @name = name
+      @url = config['url']
+      @fetch_opts = config['fetch']
+    end
+    
+    def remove
+      @base.remote_remove(@name)
+    end
+    
+    def fetch
+      @base.fetch(@name)
+    end
+    
+    # merge this remote locally
+    def merge(branch = 'master')
+      @base.merge("#{@name}/#{branch}")
+    end
+    
+    def branch(branch = 'master')
+      Git::Branch.new(@base, "#{@name}/#{branch}")
+    end
+    
+    def remove
+      @base.lib.remote_remove(@name)     
+    end
+    
+    def to_s
+      @name
+    end
+    
+  end
+end

data/lib/git/repository.rb

@@ -0,0 +1,4 @@
+module Git
+  class Repository < Path
+  end
+end

data/lib/git/status.rb

@@ -0,0 +1,118 @@
+module Git
+  
+  class Status
+    include Enumerable
+    
+    @base = nil
+    @files = nil
+    
+    def initialize(base)
+      @base = base
+      construct_status
+    end
+    
+    def changed
+      @files.select { |k, f| f.type == 'M' }
+    end
+    
+    def added
+      @files.select { |k, f| f.type == 'A' }
+    end
+
+    def deleted
+      @files.select { |k, f| f.type == 'D' }
+    end
+    
+    def untracked
+      @files.select { |k, f| f.untracked }
+    end
+    
+    def pretty
+      out = ''
+      self.each do |file|
+        out << file.path
+        out << "\n\tsha(r) " + file.sha_repo.to_s + ' ' + file.mode_repo.to_s
+        out << "\n\tsha(i) " + file.sha_index.to_s + ' ' + file.mode_index.to_s
+        out << "\n\ttype   " + file.type.to_s
+        out << "\n\tstage  " + file.stage.to_s
+        out << "\n\tuntrac " + file.untracked.to_s
+        out << "\n"
+      end
+      out << "\n"
+      out
+    end
+    
+    # enumerable method
+    
+    def [](file)
+      @files[file]
+    end
+    
+    def each
+      @files.each do |k, file|
+        yield file
+      end
+    end
+    
+    class StatusFile
+      attr_accessor :path, :type, :stage, :untracked
+      attr_accessor :mode_index, :mode_repo
+      attr_accessor :sha_index, :sha_repo
+      
+      @base = nil
+      
+      def initialize(base, hash)
+        @base = base
+        @path = hash[:path]
+        @type = hash[:type]
+        @stage = hash[:stage]
+        @mode_index = hash[:mode_index]
+        @mode_repo = hash[:mode_repo]
+        @sha_index = hash[:sha_index]
+        @sha_repo = hash[:sha_repo]
+        @untracked = hash[:untracked]
+      end
+      
+      def blob(type = :index)
+        if type == :repo
+          @base.object(@sha_repo)
+        else
+          @base.object(@sha_index) rescue @base.object(@sha_repo)
+        end
+      end
+      
+      
+    end
+    
+    private
+    
+      def construct_status
+        @files = @base.lib.ls_files
+        
+        # find untracked in working dir
+        Dir.chdir(@base.dir.path) do
+          Dir.glob('**/*') do |file|
+            if !@files[file]
+              @files[file] = {:path => file, :untracked => true} if !File.directory?(file)
+            end
+          end
+        end
+
+        # find modified in tree
+        @base.lib.diff_files.each do |path, data|
+          @files[path] ? @files[path].merge!(data) : @files[path] = data
+        end
+        
+        # find added but not committed - new files
+        @base.lib.diff_index('HEAD').each do |path, data|
+          @files[path] ? @files[path].merge!(data) : @files[path] = data
+        end
+        
+        @files.each do |k, file_hash|
+          @files[k] = StatusFile.new(@base, file_hash)
+        end
+      end
+      
+  end
+  
+end

data/lib/git/working_directory.rb

@@ -0,0 +1,4 @@
+module Git
+  class WorkingDirectory < Git::Path
+  end
+end

data/tests/all_tests.rb

@@ -0,0 +1,4 @@
+Dir.chdir(File.dirname(__FILE__)) do
+  Dir.glob('**/test_*.rb') { |test_case| require test_case }
+  #Dir.glob('**/test_index.rb') { |test_case| require test_case }
+end

data/tests/files/working.git/HEAD

@@ -0,0 +1 @@
+ref: refs/heads/master

data/tests/files/working.git/config

@@ -0,0 +1,4 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = true

data/tests/files/working.git/description

@@ -0,0 +1 @@
+Unnamed repository; edit this file to name it for gitweb.

data/tests/files/working.git/hooks/applypatch-msg

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, make this file executable.
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/commit-msg" &&
+	exec "$GIT_DIR/hooks/commit-msg" ${1+"$@"}
+:

data/tests/files/working.git/hooks/commit-msg

@@ -0,0 +1,21 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by git-commit with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, make this file executable.
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

data/tests/files/working.git/hooks/post-commit

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script that is called after a successful
+# commit is made.
+#
+# To enable this hook, make this file executable.
+
+: Nothing

data/tests/files/working.git/hooks/post-receive

@@ -0,0 +1,16 @@
+#!/bin/sh
+#
+# An example hook script for the post-receive event
+#
+# This script is run after receive-pack has accepted a pack and the
+# repository has been updated.  It is passed arguments in through stdin
+# in the form
+#  <oldrev> <newrev> <refname>
+# For example:
+#  aa453216d1b3e49e7f6f98441fa56946ddcd6a20 68f7abf4e6f922807889f52bc043ecd31b79f814 refs/heads/master
+#
+# see contrib/hooks/ for an sample, or uncomment the next line (on debian)
+#
+
+
+#. /usr/share/doc/git-core/contrib/hooks/post-receive-email

data/tests/files/working.git/hooks/post-update

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, make this file executable by "chmod +x post-update".
+
+exec git-update-server-info

data/tests/files/working.git/hooks/pre-applypatch

@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, make this file executable.
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+	exec "$GIT_DIR/hooks/pre-commit" ${1+"$@"}
+:

data/tests/files/working.git/hooks/pre-commit

@@ -0,0 +1,70 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by git-commit with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, make this file executable.
+
+# This is slightly modified from Andrew Morton's Perfect Patch.
+# Lines you introduce should not have trailing whitespace.
+# Also check for an indentation that has SP before a TAB.
+
+if git-rev-parse --verify HEAD 2>/dev/null
+then
+	git-diff-index -p -M --cached HEAD
+else
+	# NEEDSWORK: we should produce a diff with an empty tree here
+	# if we want to do the same verification for the initial import.
+	:
+fi |
+perl -e '
+    my $found_bad = 0;
+    my $filename;
+    my $reported_filename = "";
+    my $lineno;
+    sub bad_line {
+	my ($why, $line) = @_;
+	if (!$found_bad) {
+	    print STDERR "*\n";
+	    print STDERR "* You have some suspicious patch lines:\n";
+	    print STDERR "*\n";
+	    $found_bad = 1;
+	}
+	if ($reported_filename ne $filename) {
+	    print STDERR "* In $filename\n";
+	    $reported_filename = $filename;
+	}
+	print STDERR "* $why (line $lineno)\n";
+	print STDERR "$filename:$lineno:$line\n";
+    }
+    while (<>) {
+	if (m|^diff --git a/(.*) b/\1$|) {
+	    $filename = $1;
+	    next;
+	}
+	if (/^@@ -\S+ \+(\d+)/) {
+	    $lineno = $1 - 1;
+	    next;
+	}
+	if (/^ /) {
+	    $lineno++;
+	    next;
+	}
+	if (s/^\+//) {
+	    $lineno++;
+	    chomp;
+	    if (/\s$/) {
+		bad_line("trailing whitespace", $_);
+	    }
+	    if (/^\s* 	/) {
+		bad_line("indent SP followed by a TAB", $_);
+	    }
+	    if (/^(?:[<>=]){7}/) {
+		bad_line("unresolved merge conflict", $_);
+	    }
+	}
+    }
+    exit($found_bad);
+'

data/tests/files/working.git/hooks/pre-rebase

@@ -0,0 +1,150 @@
+#!/bin/sh
+#
+# Copyright (c) 2006 Junio C Hamano
+#
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD`
+fi
+
+case "$basebranch,$topic" in
+master,refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Is topic fully merged to master?
+not_in_master=`git-rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git-rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git-rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git-rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up-to-date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git-rev-list --pretty=oneline ^${publish} "$topic"`
+	perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+exit 0
+
+################################################################
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git-rev-list ^master ^topic next
+	git-rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git-rev-list master..topic
+
+	if this is empty, it is fully merged to "master".