while ($changed) {
$changed = 0;
while (my ($text, $included) = each %include) {
- print STDERR "Looking at $text...\n";
for my $i (keys %$included) {
- print STDERR "$text includes $i.\n";
# $text has include::$i; if $i includes $j
# $text indirectly includes $j.
if (exists $include{$i}) {
- print STDERR "$i includes something.\n";
for my $j (keys %{$include{$i}}) {
- print STDERR "$text includes $i include $j\n";
if (!exists $include{$text}{$j}) {
$include{$text}{$j} = 1;
$included{$j} = 1;
SYNOPSIS
--------
-'git-tag' [-a | -s | -u <key-id>] [-f] [-m <msg>] <name> [<head>]
+'git-tag' [-a | -s | -u <key-id>] [-f | -d] [-m <msg>] <name> [<head>]
DESCRIPTION
-----------
committer identity for the current user is used to find the
GnuPG key for signing.
+`-d <tag>` deletes the tag.
+
Author
------
-Tony
-Last updated w.r.t. GIT 0.99.5
+Last updated w.r.t. GIT 0.99.9f
Linux subsystem maintenance using GIT
-------------------------------------
These can be easily kept up to date by merging from the "linus" branch:
- $ git checkout test && git resolve test linus "Auto-update from upstream"
- $ git checkout release && git resolve release linus "Auto-update from upstream"
+ $ git checkout test && git merge "Auto-update from upstream" test linus
+ $ git checkout release && git merge "Auto-update from upstream" release linus
Set up so that you can push upstream to your public tree (you need to
log-in to the remote system and create an empty tree there before the
When you are happy with the state of this change, you can pull it into the
"test" branch in preparation to make it public:
- $ git checkout test && git resolve test speed-up-spinlocks "Pull speed-up-spinlock changes"
+ $ git checkout test && git merge "Pull speed-up-spinlock changes" test speed-up-spinlocks
It is unlikely that you would have any conflicts here ... but you might if you
spent a while on this step and had also pulled new versions from upstream.
see the value of keeping each patch (or patch series) in its own branch. It
means that the patches can be moved into the "release" tree in any order.
- $ git checkout release && git resolve release speed-up-spinlocks "Pull speed-up-spinlock changes"
+ $ git checkout release && git merge "Pull speed-up-spinlock changes" release speed-up-spinlocks
After a while, you will have a number of branches, and despite the
well chosen names you picked for each of them, you may forget what
case "$1" in
test|release)
- git checkout $1 && git resolve $1 linus "Auto-update from upstream"
+ git checkout $1 && git merge "Auto-update from upstream" $1 linus
;;
linus)
before=$(cat .git/refs/heads/linus)
echo $1 already merged into $2 1>&2
exit 1
fi
- git checkout $2 && git resolve $2 $1 "Pull $1 into $2 branch"
+ git checkout $2 && git merge "Pull $1 into $2 branch" $2 $1
;;
*)
usage
will install the git programs in your own ~/bin/ directory. If you want
to do a global install, you can do
- make prefix=/usr install
+ $ make prefix=/usr ;# as yourself
+ # make prefix=/usr install ;# as root
-(or prefix=/usr/local, of course). Some day somebody may send me a RPM
-spec file or something, and you can do "make rpm" or whatever.
+(or prefix=/usr/local, of course). Just like any program suite
+that uses $prefix, the built results have some paths encoded,
+which are derived from $prefix, so "make all; make prefix=/usr
+install" would not work.
Issues of note:
struct patch {
char *new_name, *old_name, *def_name;
unsigned int old_mode, new_mode;
- int is_rename, is_copy, is_new, is_delete;
+ int is_rename, is_copy, is_new, is_delete, is_binary;
int lines_added, lines_deleted;
int score;
struct fragment *fragments;
patchsize = parse_single_patch(buffer + offset + hdrsize, size - offset - hdrsize, patch);
- if (!patchsize && !metadata_changes(patch))
- die("patch with only garbage at line %d", linenr);
+ if (!patchsize && !metadata_changes(patch)) {
+ static const char binhdr[] = "Binary files ";
+
+ if (sizeof(binhdr) - 1 < size - offset - hdrsize &&
+ !memcmp(binhdr, buffer + hdrsize, sizeof(binhdr)-1))
+ patch->is_binary = 1;
+
+ if (patch->is_binary && !apply && !check)
+ ;
+ else
+ die("patch with only garbage at line %d", linenr);
+ }
return offset + hdrsize + patchsize;
}
add = (add * max + max_change / 2) / max_change;
del = total - add;
}
- printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
- len, name, patch->lines_added + patch->lines_deleted,
- add, pluses, del, minuses);
+ if (patch->is_binary)
+ printf(" %s%-*s | Bin\n", prefix, len, name);
+ else
+ printf(" %s%-*s |%5d %.*s%.*s\n", prefix,
+ len, name, patch->lines_added + patch->lines_deleted,
+ add, pluses, del, minuses);
if (qname)
free(qname);
}
rudimentary tools that can be used as a SCM, but you should look
elsewhere for tools for ordinary humans layered on top of this.
+%package svn
+Summary: Git tools for importing Subversion repositories.
+Group: Development/Tools
+Requires: subversion
+%description svn
+Git tools for importing Subversion repositories.
+
+%package cvs
+Summary: Git tools for importing CVS repositories.
+Group: Development/Tools
+Requires: cvs
+%description cvs
+Git tools for importing CVS repositories.
+
+%package email
+Summary: Git tools for sending email.
+Group: Development/Tools
+%description email
+Git tools for sending email.
+
%prep
%setup -q
%build
-make %{_smp_mflags} CFLAGS="$RPM_OPT_FLAGS" WITH_OWN_SUBPROCESS_PY=YesPlease \
+make %{_smp_mflags} CFLAGS="$RPM_OPT_FLAGS" WITH_OWN_SUBPROCESS_PY=YesPlease WITH_SEND_EMAIL=1 \
prefix=%{_prefix} all %{!?_without_docs: doc}
%install
rm -rf $RPM_BUILD_ROOT
-make %{_smp_mflags} DESTDIR=$RPM_BUILD_ROOT WITH_OWN_SUBPROCESS_PY=YesPlease \
+make %{_smp_mflags} DESTDIR=$RPM_BUILD_ROOT WITH_OWN_SUBPROCESS_PY=YesPlease WITH_SEND_EMAIL=1 \
prefix=%{_prefix} mandir=%{_mandir} \
install %{!?_without_docs: install-doc}
+(find $RPM_BUILD_ROOT%{_bindir} -type f | grep -vE "svn|cvs|email" | sed -e s@^$RPM_BUILD_ROOT@@) > bin-man-files
+%if %{!?_without_docs:1}0
+(find $RPM_BUILD_ROOT%{_mandir} -type f | grep -vE "svn|cvs|email" | sed -e s@^$RPM_BUILD_ROOT@@ -e 's/$/*/' ) >> bin-man-files
+%endif
+
%clean
rm -rf $RPM_BUILD_ROOT
-%files
+%files svn
+%{_bindir}/*svn*
+%{!?_without_docs: %{_mandir}/man1/*svn*.1*}
+
+%files cvs
+%{_bindir}/*cvs*
+%{!?_without_docs: %{_mandir}/man1/*cvs*.1*}
+
+%files email
+%{_bindir}/*email*
+%{!?_without_docs: %{_mandir}/man1/*email*.1*}
+
+%files -f bin-man-files
%defattr(-,root,root)
-%{_bindir}/*
%{_datadir}/git-core/
%doc README COPYING Documentation/*.txt
%{!?_without_docs: %doc Documentation/*.html }
-%{!?_without_docs: %{_mandir}/man1/*.1*}
-%{!?_without_docs: %{_mandir}/man7/*.7*}
%changelog
+* Tue Sep 27 2005 Jim Radford <radford@blackbean.org>
+- Move programs with non-standard dependencies (svn, cvs, email)
+ into separate packages
+
* Tue Sep 27 2005 H. Peter Anvin <hpa@zytor.com>
- parallelize build
- COPTS -> CFLAGS
last;
}; # found it
die "Did not find $parent in the parents for this commit!";
-s }
+ }
} else { # we don't have a parent from the cmdline...
if (@parents == 1) { # it's safe to get it from the commit
$parent = $parents[0];
# Low level file merging, update and removal
# ------------------------------------------
-MERGE_NONE = 0
-MERGE_TRIVIAL = 1
-MERGE_3WAY = 2
def mergeFile(oPath, oSha, oMode, aPath, aSha, aMode, bPath, bSha, bMode,
branch1Name, branch2Name):
- merge = MERGE_NONE
+ merge = False
clean = True
if stat.S_IFMT(aMode) != stat.S_IFMT(bMode):
sha = bSha
else:
if aSha != oSha and bSha != oSha:
- merge = MERGE_TRIVIAL
+ merge = True
if aMode == oMode:
mode = bMode
os.unlink(src1)
os.unlink(src2)
- merge = MERGE_3WAY
clean = (code == 0)
else:
assert(stat.S_ISLNK(aMode) and stat.S_ISLNK(bMode))
else:
raise
+ branch = branch.replace('/', '_')
newPath = path + '_' + branch
suffix = 0
while newPath in currentFileSet or \
if merge or not clean:
print 'Renaming', fmtRename(path, ren1.dstName)
- if merge == MERGE_3WAY:
+ if merge:
print 'Auto-merging', ren1.dstName
if not clean:
if merge or not clean:
print 'Renaming', fmtRename(ren1.srcName, ren1.dstName)
- if merge == MERGE_3WAY:
+ if merge:
print 'Auto-merging', ren1.dstName
if not clean:
. git-sh-setup || die "Not a git archive"
usage () {
- echo >&2 "Usage: git-tag [-a | -s | -u <key-id>] [-f] [-m <msg>] <tagname> [<head>]"
+ echo >&2 "Usage: git-tag [-a | -s | -u <key-id>] [-f | -d] [-m <msg>] <tagname> [<head>]"
exit 1
}
shift
username="$1"
;;
+ -d)
+ shift
+ tag_name="$1"
+ rm "$GIT_DIR/refs/tags/$tag_name" && \
+ echo "Deleted tag $tag_name."
+ exit $?
+ ;;
-*)
usage
;;
}
#ifdef USE_CURL_MULTI
-void process_curl_messages(void)
+static void process_curl_messages(void)
{
int num_messages;
struct active_request_slot *slot;
}
}
-void process_request_queue(void)
+static void process_request_queue(void)
{
struct transfer_request *request = request_queue_head;
struct active_request_slot *slot = active_queue_head;
}
}
-int refresh_lock(struct active_lock *lock)
+static int refresh_lock(struct active_lock *lock)
{
struct active_request_slot *slot;
char *if_header;
}
#ifdef USE_CURL_MULTI
-void process_curl_messages(void)
+static void process_curl_messages(void)
{
int num_messages;
struct active_request_slot *slot;
}
}
-void process_request_queue(void)
+static void process_request_queue(void)
{
struct transfer_request *request = request_queue_head;
struct active_request_slot *slot = active_queue_head;
}
#endif
-void process_waiting_requests(void)
+static void process_waiting_requests(void)
{
struct active_request_slot *slot = active_queue_head;
}
}
-void add_request(unsigned char *sha1, struct active_lock *lock)
+static void add_request(unsigned char *sha1, struct active_lock *lock)
{
struct transfer_request *request = request_queue_head;
struct packed_git *target;
return 0;
}
-static int fetch_indices()
+static int fetch_indices(void)
{
unsigned char sha1[20];
char *url;
}
}
-struct active_lock *lock_remote(char *file, long timeout)
+static struct active_lock *lock_remote(char *file, long timeout)
{
struct active_request_slot *slot;
struct buffer out_buffer;
return new_lock;
}
-int unlock_remote(struct active_lock *lock)
+static int unlock_remote(struct active_lock *lock)
{
struct active_request_slot *slot;
char *lock_token_header;
return rc;
}
-int check_locking()
+static int check_locking(void)
{
struct active_request_slot *slot;
struct buffer in_buffer;
return 1;
}
-int is_ancestor(unsigned char *sha1, struct commit *commit)
+static int is_ancestor(unsigned char *sha1, struct commit *commit)
{
struct commit_list *parents;
return 0;
}
-void get_delta(unsigned char *sha1, struct object *obj,
- struct active_lock *lock)
+static void get_delta(unsigned char *sha1, struct object *obj,
+ struct active_lock *lock)
{
struct commit *commit;
struct commit_list *parents;
}
}
-int update_remote(unsigned char *sha1, struct active_lock *lock)
+static int update_remote(unsigned char *sha1, struct active_lock *lock)
{
struct active_request_slot *slot;
char *out_data;
T = $(wildcard t[0-9][0-9][0-9][0-9]-*.sh)
-all:
- @$(foreach t,$T,echo "*** $t ***"; $(call shellquote,$(SHELL_PATH)) $t $(GIT_TEST_OPTS) || exit; )
- @rm -fr trash
+all: $(T) clean
+
+$(T):
+ @echo "*** $@ ***"; $(call shellquote,$(SHELL_PATH)) $@ $(GIT_TEST_OPTS)
clean:
rm -fr trash
+
+.PHONY: $(T) clean
+.NOPARALLEL:
+
'
. ./test-lib.sh
+TAR=${TAR:-tar}
test_expect_success \
'populate workdir' \
shellquote = '$(call shq,$(1))'
all: boilerplates.made custom
- find blt
# Put templates that can be copied straight from the source
# in a file direc--tory--file in the source. They will be