![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
| author | David A. Greene <greened@obbligato.org> | |
| Tue, 10 Apr 2012 01:22:55 +0000 (20:22 -0500) | ||
| committer | David A. Greene <greened@obbligato.org> | |
| Tue, 10 Apr 2012 01:22:55 +0000 (20:22 -0500) |
git-subtree-dir: contrib/subtree
git-subtree-mainline: e8dde3e5f9ddb7cf95a6ff3cea6cf07c3a2db80d
git-subtree-split: d3a04e06c77d57978bb5230361c64946232cc346
git-subtree-mainline: e8dde3e5f9ddb7cf95a6ff3cea6cf07c3a2db80d
git-subtree-split: d3a04e06c77d57978bb5230361c64946232cc346
15 files changed:
diff --combined contrib/subtree/.gitignore
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..7e77c9d0229e949c034c8c46811e19d2325e9cca
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,5 @@@
++*~
++git-subtree.xml
++git-subtree.1
++mainline
++subproj
diff --combined contrib/subtree/COPYING
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..d511905c1647a1e311e8b20d5930a37a9c2531cd
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/contrib/subtree/COPYING
@@@ -1,0 -1,0 +1,339 @@@
++ GNU GENERAL PUBLIC LICENSE
++ Version 2, June 1991
++
++ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++ Everyone is permitted to copy and distribute verbatim copies
++ of this license document, but changing it is not allowed.
++
++ Preamble
++
++ The licenses for most software are designed to take away your
++freedom to share and change it. By contrast, the GNU General Public
++License is intended to guarantee your freedom to share and change free
++software--to make sure the software is free for all its users. This
++General Public License applies to most of the Free Software
++Foundation's software and to any other program whose authors commit to
++using it. (Some other Free Software Foundation software is covered by
++the GNU Lesser General Public License instead.) You can apply it to
++your programs, too.
++
++ When we speak of free software, we are referring to freedom, not
++price. Our General Public Licenses are designed to make sure that you
++have the freedom to distribute copies of free software (and charge for
++this service if you wish), that you receive source code or can get it
++if you want it, that you can change the software or use pieces of it
++in new free programs; and that you know you can do these things.
++
++ To protect your rights, we need to make restrictions that forbid
++anyone to deny you these rights or to ask you to surrender the rights.
++These restrictions translate to certain responsibilities for you if you
++distribute copies of the software, or if you modify it.
++
++ For example, if you distribute copies of such a program, whether
++gratis or for a fee, you must give the recipients all the rights that
++you have. You must make sure that they, too, receive or can get the
++source code. And you must show them these terms so they know their
++rights.
++
++ We protect your rights with two steps: (1) copyright the software, and
++(2) offer you this license which gives you legal permission to copy,
++distribute and/or modify the software.
++
++ Also, for each author's protection and ours, we want to make certain
++that everyone understands that there is no warranty for this free
++software. If the software is modified by someone else and passed on, we
++want its recipients to know that what they have is not the original, so
++that any problems introduced by others will not reflect on the original
++authors' reputations.
++
++ Finally, any free program is threatened constantly by software
++patents. We wish to avoid the danger that redistributors of a free
++program will individually obtain patent licenses, in effect making the
++program proprietary. To prevent this, we have made it clear that any
++patent must be licensed for everyone's free use or not licensed at all.
++
++ The precise terms and conditions for copying, distribution and
++modification follow.
++
++ GNU GENERAL PUBLIC LICENSE
++ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
++
++ 0. This License applies to any program or other work which contains
++a notice placed by the copyright holder saying it may be distributed
++under the terms of this General Public License. The "Program", below,
++refers to any such program or work, and a "work based on the Program"
++means either the Program or any derivative work under copyright law:
++that is to say, a work containing the Program or a portion of it,
++either verbatim or with modifications and/or translated into another
++language. (Hereinafter, translation is included without limitation in
++the term "modification".) Each licensee is addressed as "you".
++
++Activities other than copying, distribution and modification are not
++covered by this License; they are outside its scope. The act of
++running the Program is not restricted, and the output from the Program
++is covered only if its contents constitute a work based on the
++Program (independent of having been made by running the Program).
++Whether that is true depends on what the Program does.
++
++ 1. You may copy and distribute verbatim copies of the Program's
++source code as you receive it, in any medium, provided that you
++conspicuously and appropriately publish on each copy an appropriate
++copyright notice and disclaimer of warranty; keep intact all the
++notices that refer to this License and to the absence of any warranty;
++and give any other recipients of the Program a copy of this License
++along with the Program.
++
++You may charge a fee for the physical act of transferring a copy, and
++you may at your option offer warranty protection in exchange for a fee.
++
++ 2. You may modify your copy or copies of the Program or any portion
++of it, thus forming a work based on the Program, and copy and
++distribute such modifications or work under the terms of Section 1
++above, provided that you also meet all of these conditions:
++
++ a) You must cause the modified files to carry prominent notices
++ stating that you changed the files and the date of any change.
++
++ b) You must cause any work that you distribute or publish, that in
++ whole or in part contains or is derived from the Program or any
++ part thereof, to be licensed as a whole at no charge to all third
++ parties under the terms of this License.
++
++ c) If the modified program normally reads commands interactively
++ when run, you must cause it, when started running for such
++ interactive use in the most ordinary way, to print or display an
++ announcement including an appropriate copyright notice and a
++ notice that there is no warranty (or else, saying that you provide
++ a warranty) and that users may redistribute the program under
++ these conditions, and telling the user how to view a copy of this
++ License. (Exception: if the Program itself is interactive but
++ does not normally print such an announcement, your work based on
++ the Program is not required to print an announcement.)
++
++These requirements apply to the modified work as a whole. If
++identifiable sections of that work are not derived from the Program,
++and can be reasonably considered independent and separate works in
++themselves, then this License, and its terms, do not apply to those
++sections when you distribute them as separate works. But when you
++distribute the same sections as part of a whole which is a work based
++on the Program, the distribution of the whole must be on the terms of
++this License, whose permissions for other licensees extend to the
++entire whole, and thus to each and every part regardless of who wrote it.
++
++Thus, it is not the intent of this section to claim rights or contest
++your rights to work written entirely by you; rather, the intent is to
++exercise the right to control the distribution of derivative or
++collective works based on the Program.
++
++In addition, mere aggregation of another work not based on the Program
++with the Program (or with a work based on the Program) on a volume of
++a storage or distribution medium does not bring the other work under
++the scope of this License.
++
++ 3. You may copy and distribute the Program (or a work based on it,
++under Section 2) in object code or executable form under the terms of
++Sections 1 and 2 above provided that you also do one of the following:
++
++ a) Accompany it with the complete corresponding machine-readable
++ source code, which must be distributed under the terms of Sections
++ 1 and 2 above on a medium customarily used for software interchange; or,
++
++ b) Accompany it with a written offer, valid for at least three
++ years, to give any third party, for a charge no more than your
++ cost of physically performing source distribution, a complete
++ machine-readable copy of the corresponding source code, to be
++ distributed under the terms of Sections 1 and 2 above on a medium
++ customarily used for software interchange; or,
++
++ c) Accompany it with the information you received as to the offer
++ to distribute corresponding source code. (This alternative is
++ allowed only for noncommercial distribution and only if you
++ received the program in object code or executable form with such
++ an offer, in accord with Subsection b above.)
++
++The source code for a work means the preferred form of the work for
++making modifications to it. For an executable work, complete source
++code means all the source code for all modules it contains, plus any
++associated interface definition files, plus the scripts used to
++control compilation and installation of the executable. However, as a
++special exception, the source code distributed need not include
++anything that is normally distributed (in either source or binary
++form) with the major components (compiler, kernel, and so on) of the
++operating system on which the executable runs, unless that component
++itself accompanies the executable.
++
++If distribution of executable or object code is made by offering
++access to copy from a designated place, then offering equivalent
++access to copy the source code from the same place counts as
++distribution of the source code, even though third parties are not
++compelled to copy the source along with the object code.
++
++ 4. You may not copy, modify, sublicense, or distribute the Program
++except as expressly provided under this License. Any attempt
++otherwise to copy, modify, sublicense or distribute the Program is
++void, and will automatically terminate your rights under this License.
++However, parties who have received copies, or rights, from you under
++this License will not have their licenses terminated so long as such
++parties remain in full compliance.
++
++ 5. You are not required to accept this License, since you have not
++signed it. However, nothing else grants you permission to modify or
++distribute the Program or its derivative works. These actions are
++prohibited by law if you do not accept this License. Therefore, by
++modifying or distributing the Program (or any work based on the
++Program), you indicate your acceptance of this License to do so, and
++all its terms and conditions for copying, distributing or modifying
++the Program or works based on it.
++
++ 6. Each time you redistribute the Program (or any work based on the
++Program), the recipient automatically receives a license from the
++original licensor to copy, distribute or modify the Program subject to
++these terms and conditions. You may not impose any further
++restrictions on the recipients' exercise of the rights granted herein.
++You are not responsible for enforcing compliance by third parties to
++this License.
++
++ 7. If, as a consequence of a court judgment or allegation of patent
++infringement or for any other reason (not limited to patent issues),
++conditions are imposed on you (whether by court order, agreement or
++otherwise) that contradict the conditions of this License, they do not
++excuse you from the conditions of this License. If you cannot
++distribute so as to satisfy simultaneously your obligations under this
++License and any other pertinent obligations, then as a consequence you
++may not distribute the Program at all. For example, if a patent
++license would not permit royalty-free redistribution of the Program by
++all those who receive copies directly or indirectly through you, then
++the only way you could satisfy both it and this License would be to
++refrain entirely from distribution of the Program.
++
++If any portion of this section is held invalid or unenforceable under
++any particular circumstance, the balance of the section is intended to
++apply and the section as a whole is intended to apply in other
++circumstances.
++
++It is not the purpose of this section to induce you to infringe any
++patents or other property right claims or to contest validity of any
++such claims; this section has the sole purpose of protecting the
++integrity of the free software distribution system, which is
++implemented by public license practices. Many people have made
++generous contributions to the wide range of software distributed
++through that system in reliance on consistent application of that
++system; it is up to the author/donor to decide if he or she is willing
++to distribute software through any other system and a licensee cannot
++impose that choice.
++
++This section is intended to make thoroughly clear what is believed to
++be a consequence of the rest of this License.
++
++ 8. If the distribution and/or use of the Program is restricted in
++certain countries either by patents or by copyrighted interfaces, the
++original copyright holder who places the Program under this License
++may add an explicit geographical distribution limitation excluding
++those countries, so that distribution is permitted only in or among
++countries not thus excluded. In such case, this License incorporates
++the limitation as if written in the body of this License.
++
++ 9. The Free Software Foundation may publish revised and/or new versions
++of the General Public License from time to time. Such new versions will
++be similar in spirit to the present version, but may differ in detail to
++address new problems or concerns.
++
++Each version is given a distinguishing version number. If the Program
++specifies a version number of this License which applies to it and "any
++later version", you have the option of following the terms and conditions
++either of that version or of any later version published by the Free
++Software Foundation. If the Program does not specify a version number of
++this License, you may choose any version ever published by the Free Software
++Foundation.
++
++ 10. If you wish to incorporate parts of the Program into other free
++programs whose distribution conditions are different, write to the author
++to ask for permission. For software which is copyrighted by the Free
++Software Foundation, write to the Free Software Foundation; we sometimes
++make exceptions for this. Our decision will be guided by the two goals
++of preserving the free status of all derivatives of our free software and
++of promoting the sharing and reuse of software generally.
++
++ NO WARRANTY
++
++ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
++FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
++OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
++PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
++OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
++MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
++TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
++PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
++REPAIR OR CORRECTION.
++
++ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
++WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
++REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
++INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
++OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
++TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
++YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
++PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
++POSSIBILITY OF SUCH DAMAGES.
++
++ END OF TERMS AND CONDITIONS
++
++ How to Apply These Terms to Your New Programs
++
++ If you develop a new program, and you want it to be of the greatest
++possible use to the public, the best way to achieve this is to make it
++free software which everyone can redistribute and change under these terms.
++
++ To do so, attach the following notices to the program. It is safest
++to attach them to the start of each source file to most effectively
++convey the exclusion of warranty; and each file should have at least
++the "copyright" line and a pointer to where the full notice is found.
++
++ <one line to give the program's name and a brief idea of what it does.>
++ Copyright (C) <year> <name of author>
++
++ This program is free software; you can redistribute it and/or modify
++ it under the terms of the GNU General Public License as published by
++ the Free Software Foundation; either version 2 of the License, or
++ (at your option) any later version.
++
++ This program is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ GNU General Public License for more details.
++
++ You should have received a copy of the GNU General Public License along
++ with this program; if not, write to the Free Software Foundation, Inc.,
++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
++
++Also add information on how to contact you by electronic and paper mail.
++
++If the program is interactive, make it output a short notice like this
++when it starts in an interactive mode:
++
++ Gnomovision version 69, Copyright (C) year name of author
++ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
++ This is free software, and you are welcome to redistribute it
++ under certain conditions; type `show c' for details.
++
++The hypothetical commands `show w' and `show c' should show the appropriate
++parts of the General Public License. Of course, the commands you use may
++be called something other than `show w' and `show c'; they could even be
++mouse-clicks or menu items--whatever suits your program.
++
++You should also get your employer (if you work as a programmer) or your
++school, if any, to sign a "copyright disclaimer" for the program, if
++necessary. Here is a sample; alter the names:
++
++ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
++ `Gnomovision' (which makes passes at compilers) written by James Hacker.
++
++ <signature of Ty Coon>, 1 April 1989
++ Ty Coon, President of Vice
++
++This General Public License does not permit incorporating your program into
++proprietary programs. If your program is a subroutine library, you may
++consider it more useful to permit linking proprietary applications with the
++library. If this is what you want to do, use the GNU Lesser General
++Public License instead of this License.
diff --combined contrib/subtree/INSTALL
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..81ac702ad22f4e7116459fde665e2159842aa85a
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/contrib/subtree/INSTALL
@@@ -1,0 -1,0 +1,22 @@@
++
++HOW TO INSTALL git-subtree
++==========================
++
++You simply need to copy the file 'git-subtree.sh' to where
++the rest of the git scripts are stored.
++
++From the Git bash window just run:
++
++install.sh
++
++Or if you have the full Cygwin installed, you can use make:
++
++make install
++
++That will make a 'git subtree' (note: space instead of dash) command
++available. See the file git-subtree.txt for more.
++
++You can also install the man page by doing:
++
++ make doc
++ cp git-subtree.1 /usr/share/man/man1/
diff --combined contrib/subtree/Makefile
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..91e0cc08ea514a954bd3bab035baf0eadac6644e
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/contrib/subtree/Makefile
@@@ -1,0 -1,0 +1,45 @@@
++prefix ?= /usr/local
++mandir ?= $(prefix)/share/man
++gitdir ?= $(shell git --exec-path)
++
++gitver ?= $(word 3,$(shell git --version))
++
++# this should be set to a 'standard' bsd-type install program
++INSTALL ?= install
++INSTALL_DATA = $(INSTALL) -c -m 0644
++INSTALL_EXE = $(INSTALL) -c -m 0755
++INSTALL_DIR = $(INSTALL) -c -d -m 0755
++
++default:
++ @echo "git-subtree doesn't need to be built."
++ @echo "Just copy it somewhere on your PATH, like /usr/local/bin."
++ @echo
++ @echo "Try: make doc"
++ @echo " or: make test"
++ @false
++
++install: install-exe install-doc
++
++install-exe: git-subtree.sh
++ $(INSTALL_DIR) $(DESTDIR)/$(gitdir)
++ $(INSTALL_EXE) $< $(DESTDIR)/$(gitdir)/git-subtree
++
++install-doc: git-subtree.1
++ $(INSTALL_DIR) $(DESTDIR)/$(mandir)/man1/
++ $(INSTALL_DATA) $< $(DESTDIR)/$(mandir)/man1/
++
++doc: git-subtree.1
++
++%.1: %.xml
++ xmlto -m manpage-normal.xsl man $^
++
++%.xml: %.txt
++ asciidoc -b docbook -d manpage -f asciidoc.conf \
++ -agit_version=$(gitver) $^
++
++test:
++ ./test.sh
++
++clean:
++ rm -f *~ *.xml *.html *.1
++ rm -rf subproj mainline
diff --combined contrib/subtree/README
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..c686b4a69b12579a2bcbba887d0c69e0382ae152
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/contrib/subtree/README
@@@ -1,0 -1,0 +1,8 @@@
++
++Please read git-subtree.txt for documentation.
++
++Please don't contact me using github mail; it's slow, ugly, and worst of
++all, redundant. Email me instead at apenwarr@gmail.com and I'll be happy to
++help.
++
++Avery
diff --combined contrib/subtree/asciidoc.conf
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..dc76e7f073f23cd911da0b0d0d49b72726576f1a
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,91 @@@
++## linkgit: macro
++#
++# Usage: linkgit:command[manpage-section]
++#
++# Note, {0} is the manpage section, while {target} is the command.
++#
++# Show GIT link as: <command>(<section>); if section is defined, else just show
++# the command.
++
++[macros]
++(?su)[\\]?(?P<name>linkgit):(?P<target>\S*?)\[(?P<attrlist>.*?)\]=
++
++[attributes]
++asterisk=*
++plus=+
++caret=^
++startsb=[
++endsb=]
++tilde=~
++
++ifdef::backend-docbook[]
++[linkgit-inlinemacro]
++{0%{target}}
++{0#<citerefentry>}
++{0#<refentrytitle>{target}</refentrytitle><manvolnum>{0}</manvolnum>}
++{0#</citerefentry>}
++endif::backend-docbook[]
++
++ifdef::backend-docbook[]
++ifndef::git-asciidoc-no-roff[]
++# "unbreak" docbook-xsl v1.68 for manpages. v1.69 works with or without this.
++# v1.72 breaks with this because it replaces dots not in roff requests.
++[listingblock]
++<example><title>{title}</title>
++<literallayout>
++ifdef::doctype-manpage[]
++ .ft C
++endif::doctype-manpage[]
++|
++ifdef::doctype-manpage[]
++ .ft
++endif::doctype-manpage[]
++</literallayout>
++{title#}</example>
++endif::git-asciidoc-no-roff[]
++
++ifdef::git-asciidoc-no-roff[]
++ifdef::doctype-manpage[]
++# The following two small workarounds insert a simple paragraph after screen
++[listingblock]
++<example><title>{title}</title>
++<literallayout>
++|
++</literallayout><simpara></simpara>
++{title#}</example>
++
++[verseblock]
++<formalpara{id? id="{id}"}><title>{title}</title><para>
++{title%}<literallayout{id? id="{id}"}>
++{title#}<literallayout>
++|
++</literallayout>
++{title#}</para></formalpara>
++{title%}<simpara></simpara>
++endif::doctype-manpage[]
++endif::git-asciidoc-no-roff[]
++endif::backend-docbook[]
++
++ifdef::doctype-manpage[]
++ifdef::backend-docbook[]
++[header]
++template::[header-declarations]
++<refentry>
++<refmeta>
++<refentrytitle>{mantitle}</refentrytitle>
++<manvolnum>{manvolnum}</manvolnum>
++<refmiscinfo class="source">Git</refmiscinfo>
++<refmiscinfo class="version">{git_version}</refmiscinfo>
++<refmiscinfo class="manual">Git Manual</refmiscinfo>
++</refmeta>
++<refnamediv>
++ <refname>{manname}</refname>
++ <refpurpose>{manpurpose}</refpurpose>
++</refnamediv>
++endif::backend-docbook[]
++endif::doctype-manpage[]
++
++ifdef::backend-xhtml11[]
++[linkgit-inlinemacro]
++<a href="{target}.html">{target}{0?({0})}</a>
++endif::backend-xhtml11[]
diff --combined contrib/subtree/git-subtree
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..7d7539894e3058f9b8365ecd5cdafc2f6e4106c6
new file mode 120000 (symlink)
new file mode 120000 (symlink)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,1 @@@
++git-subtree.sh
diff --combined contrib/subtree/git-subtree.sh
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..920c664bb7c7a4e1aa455479e2caef3d6c6dc786
new file mode 100755 (executable)
new file mode 100755 (executable)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,712 @@@
++#!/bin/bash
++#
++# git-subtree.sh: split/join git repositories in subdirectories of this one
++#
++# Copyright (C) 2009 Avery Pennarun <apenwarr@gmail.com>
++#
++if [ $# -eq 0 ]; then
++ set -- -h
++fi
++OPTS_SPEC="\
++git subtree add --prefix=<prefix> <commit>
++git subtree merge --prefix=<prefix> <commit>
++git subtree pull --prefix=<prefix> <repository> <refspec...>
++git subtree push --prefix=<prefix> <repository> <refspec...>
++git subtree split --prefix=<prefix> <commit...>
++--
++h,help show the help
++q quiet
++d show debug messages
++P,prefix= the name of the subdir to split out
++m,message= use the given message as the commit message for the merge commit
++ options for 'split'
++annotate= add a prefix to commit message of new commits
++b,branch= create a new branch from the split subtree
++ignore-joins ignore prior --rejoin commits
++onto= try connecting new tree to an existing one
++rejoin merge the new branch back into HEAD
++ options for 'add', 'merge', 'pull' and 'push'
++squash merge subtree changes as a single commit
++"
++eval "$(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)"
++
++PATH=$PATH:$(git --exec-path)
++. git-sh-setup
++
++require_work_tree
++
++quiet=
++branch=
++debug=
++command=
++onto=
++rejoin=
++ignore_joins=
++annotate=
++squash=
++message=
++
++debug()
++{
++ if [ -n "$debug" ]; then
++ echo "$@" >&2
++ fi
++}
++
++say()
++{
++ if [ -z "$quiet" ]; then
++ echo "$@" >&2
++ fi
++}
++
++assert()
++{
++ if "$@"; then
++ :
++ else
++ die "assertion failed: " "$@"
++ fi
++}
++
++
++#echo "Options: $*"
++
++while [ $# -gt 0 ]; do
++ opt="$1"
++ shift
++ case "$opt" in
++ -q) quiet=1 ;;
++ -d) debug=1 ;;
++ --annotate) annotate="$1"; shift ;;
++ --no-annotate) annotate= ;;
++ -b) branch="$1"; shift ;;
++ -P) prefix="$1"; shift ;;
++ -m) message="$1"; shift ;;
++ --no-prefix) prefix= ;;
++ --onto) onto="$1"; shift ;;
++ --no-onto) onto= ;;
++ --rejoin) rejoin=1 ;;
++ --no-rejoin) rejoin= ;;
++ --ignore-joins) ignore_joins=1 ;;
++ --no-ignore-joins) ignore_joins= ;;
++ --squash) squash=1 ;;
++ --no-squash) squash= ;;
++ --) break ;;
++ *) die "Unexpected option: $opt" ;;
++ esac
++done
++
++command="$1"
++shift
++case "$command" in
++ add|merge|pull) default= ;;
++ split|push) default="--default HEAD" ;;
++ *) die "Unknown command '$command'" ;;
++esac
++
++if [ -z "$prefix" ]; then
++ die "You must provide the --prefix option."
++fi
++
++case "$command" in
++ add) [ -e "$prefix" ] &&
++ die "prefix '$prefix' already exists." ;;
++ *) [ -e "$prefix" ] ||
++ die "'$prefix' does not exist; use 'git subtree add'" ;;
++esac
++
++dir="$(dirname "$prefix/.")"
++
++if [ "$command" != "pull" -a "$command" != "add" -a "$command" != "push" ]; then
++ revs=$(git rev-parse $default --revs-only "$@") || exit $?
++ dirs="$(git rev-parse --no-revs --no-flags "$@")" || exit $?
++ if [ -n "$dirs" ]; then
++ die "Error: Use --prefix instead of bare filenames."
++ fi
++fi
++
++debug "command: {$command}"
++debug "quiet: {$quiet}"
++debug "revs: {$revs}"
++debug "dir: {$dir}"
++debug "opts: {$*}"
++debug
++
++cache_setup()
++{
++ cachedir="$GIT_DIR/subtree-cache/$$"
++ rm -rf "$cachedir" || die "Can't delete old cachedir: $cachedir"
++ mkdir -p "$cachedir" || die "Can't create new cachedir: $cachedir"
++ mkdir -p "$cachedir/notree" || die "Can't create new cachedir: $cachedir/notree"
++ debug "Using cachedir: $cachedir" >&2
++}
++
++cache_get()
++{
++ for oldrev in $*; do
++ if [ -r "$cachedir/$oldrev" ]; then
++ read newrev <"$cachedir/$oldrev"
++ echo $newrev
++ fi
++ done
++}
++
++cache_miss()
++{
++ for oldrev in $*; do
++ if [ ! -r "$cachedir/$oldrev" ]; then
++ echo $oldrev
++ fi
++ done
++}
++
++check_parents()
++{
++ missed=$(cache_miss $*)
++ for miss in $missed; do
++ if [ ! -r "$cachedir/notree/$miss" ]; then
++ debug " incorrect order: $miss"
++ fi
++ done
++}
++
++set_notree()
++{
++ echo "1" > "$cachedir/notree/$1"
++}
++
++cache_set()
++{
++ oldrev="$1"
++ newrev="$2"
++ if [ "$oldrev" != "latest_old" \
++ -a "$oldrev" != "latest_new" \
++ -a -e "$cachedir/$oldrev" ]; then
++ die "cache for $oldrev already exists!"
++ fi
++ echo "$newrev" >"$cachedir/$oldrev"
++}
++
++rev_exists()
++{
++ if git rev-parse "$1" >/dev/null 2>&1; then
++ return 0
++ else
++ return 1
++ fi
++}
++
++rev_is_descendant_of_branch()
++{
++ newrev="$1"
++ branch="$2"
++ branch_hash=$(git rev-parse $branch)
++ match=$(git rev-list -1 $branch_hash ^$newrev)
++
++ if [ -z "$match" ]; then
++ return 0
++ else
++ return 1
++ fi
++}
++
++# if a commit doesn't have a parent, this might not work. But we only want
++# to remove the parent from the rev-list, and since it doesn't exist, it won't
++# be there anyway, so do nothing in that case.
++try_remove_previous()
++{
++ if rev_exists "$1^"; then
++ echo "^$1^"
++ fi
++}
++
++find_latest_squash()
++{
++ debug "Looking for latest squash ($dir)..."
++ dir="$1"
++ sq=
++ main=
++ sub=
++ git log --grep="^git-subtree-dir: $dir/*\$" \
++ --pretty=format:'START %H%n%s%n%n%b%nEND%n' HEAD |
++ while read a b junk; do
++ debug "$a $b $junk"
++ debug "{{$sq/$main/$sub}}"
++ case "$a" in
++ START) sq="$b" ;;
++ git-subtree-mainline:) main="$b" ;;
++ git-subtree-split:) sub="$b" ;;
++ END)
++ if [ -n "$sub" ]; then
++ if [ -n "$main" ]; then
++ # a rejoin commit?
++ # Pretend its sub was a squash.
++ sq="$sub"
++ fi
++ debug "Squash found: $sq $sub"
++ echo "$sq" "$sub"
++ break
++ fi
++ sq=
++ main=
++ sub=
++ ;;
++ esac
++ done
++}
++
++find_existing_splits()
++{
++ debug "Looking for prior splits..."
++ dir="$1"
++ revs="$2"
++ main=
++ sub=
++ git log --grep="^git-subtree-dir: $dir/*\$" \
++ --pretty=format:'START %H%n%s%n%n%b%nEND%n' $revs |
++ while read a b junk; do
++ case "$a" in
++ START) sq="$b" ;;
++ git-subtree-mainline:) main="$b" ;;
++ git-subtree-split:) sub="$b" ;;
++ END)
++ debug " Main is: '$main'"
++ if [ -z "$main" -a -n "$sub" ]; then
++ # squash commits refer to a subtree
++ debug " Squash: $sq from $sub"
++ cache_set "$sq" "$sub"
++ fi
++ if [ -n "$main" -a -n "$sub" ]; then
++ debug " Prior: $main -> $sub"
++ cache_set $main $sub
++ cache_set $sub $sub
++ try_remove_previous "$main"
++ try_remove_previous "$sub"
++ fi
++ main=
++ sub=
++ ;;
++ esac
++ done
++}
++
++copy_commit()
++{
++ # We're going to set some environment vars here, so
++ # do it in a subshell to get rid of them safely later
++ debug copy_commit "{$1}" "{$2}" "{$3}"
++ git log -1 --pretty=format:'%an%n%ae%n%ad%n%cn%n%ce%n%cd%n%s%n%n%b' "$1" |
++ (
++ read GIT_AUTHOR_NAME
++ read GIT_AUTHOR_EMAIL
++ read GIT_AUTHOR_DATE
++ read GIT_COMMITTER_NAME
++ read GIT_COMMITTER_EMAIL
++ read GIT_COMMITTER_DATE
++ export GIT_AUTHOR_NAME \
++ GIT_AUTHOR_EMAIL \
++ GIT_AUTHOR_DATE \
++ GIT_COMMITTER_NAME \
++ GIT_COMMITTER_EMAIL \
++ GIT_COMMITTER_DATE
++ (echo -n "$annotate"; cat ) |
++ git commit-tree "$2" $3 # reads the rest of stdin
++ ) || die "Can't copy commit $1"
++}
++
++add_msg()
++{
++ dir="$1"
++ latest_old="$2"
++ latest_new="$3"
++ if [ -n "$message" ]; then
++ commit_message="$message"
++ else
++ commit_message="Add '$dir/' from commit '$latest_new'"
++ fi
++ cat <<-EOF
++ $commit_message
++
++ git-subtree-dir: $dir
++ git-subtree-mainline: $latest_old
++ git-subtree-split: $latest_new
++ EOF
++}
++
++add_squashed_msg()
++{
++ if [ -n "$message" ]; then
++ echo "$message"
++ else
++ echo "Merge commit '$1' as '$2'"
++ fi
++}
++
++rejoin_msg()
++{
++ dir="$1"
++ latest_old="$2"
++ latest_new="$3"
++ if [ -n "$message" ]; then
++ commit_message="$message"
++ else
++ commit_message="Split '$dir/' into commit '$latest_new'"
++ fi
++ cat <<-EOF
++ $commit_message
++
++ git-subtree-dir: $dir
++ git-subtree-mainline: $latest_old
++ git-subtree-split: $latest_new
++ EOF
++}
++
++squash_msg()
++{
++ dir="$1"
++ oldsub="$2"
++ newsub="$3"
++ newsub_short=$(git rev-parse --short "$newsub")
++
++ if [ -n "$oldsub" ]; then
++ oldsub_short=$(git rev-parse --short "$oldsub")
++ echo "Squashed '$dir/' changes from $oldsub_short..$newsub_short"
++ echo
++ git log --pretty=tformat:'%h %s' "$oldsub..$newsub"
++ git log --pretty=tformat:'REVERT: %h %s' "$newsub..$oldsub"
++ else
++ echo "Squashed '$dir/' content from commit $newsub_short"
++ fi
++
++ echo
++ echo "git-subtree-dir: $dir"
++ echo "git-subtree-split: $newsub"
++}
++
++toptree_for_commit()
++{
++ commit="$1"
++ git log -1 --pretty=format:'%T' "$commit" -- || exit $?
++}
++
++subtree_for_commit()
++{
++ commit="$1"
++ dir="$2"
++ git ls-tree "$commit" -- "$dir" |
++ while read mode type tree name; do
++ assert [ "$name" = "$dir" ]
++ assert [ "$type" = "tree" -o "$type" = "commit" ]
++ [ "$type" = "commit" ] && continue # ignore submodules
++ echo $tree
++ break
++ done
++}
++
++tree_changed()
++{
++ tree=$1
++ shift
++ if [ $# -ne 1 ]; then
++ return 0 # weird parents, consider it changed
++ else
++ ptree=$(toptree_for_commit $1)
++ if [ "$ptree" != "$tree" ]; then
++ return 0 # changed
++ else
++ return 1 # not changed
++ fi
++ fi
++}
++
++new_squash_commit()
++{
++ old="$1"
++ oldsub="$2"
++ newsub="$3"
++ tree=$(toptree_for_commit $newsub) || exit $?
++ if [ -n "$old" ]; then
++ squash_msg "$dir" "$oldsub" "$newsub" |
++ git commit-tree "$tree" -p "$old" || exit $?
++ else
++ squash_msg "$dir" "" "$newsub" |
++ git commit-tree "$tree" || exit $?
++ fi
++}
++
++copy_or_skip()
++{
++ rev="$1"
++ tree="$2"
++ newparents="$3"
++ assert [ -n "$tree" ]
++
++ identical=
++ nonidentical=
++ p=
++ gotparents=
++ for parent in $newparents; do
++ ptree=$(toptree_for_commit $parent) || exit $?
++ [ -z "$ptree" ] && continue
++ if [ "$ptree" = "$tree" ]; then
++ # an identical parent could be used in place of this rev.
++ identical="$parent"
++ else
++ nonidentical="$parent"
++ fi
++
++ # sometimes both old parents map to the same newparent;
++ # eliminate duplicates
++ is_new=1
++ for gp in $gotparents; do
++ if [ "$gp" = "$parent" ]; then
++ is_new=
++ break
++ fi
++ done
++ if [ -n "$is_new" ]; then
++ gotparents="$gotparents $parent"
++ p="$p -p $parent"
++ fi
++ done
++
++ if [ -n "$identical" ]; then
++ echo $identical
++ else
++ copy_commit $rev $tree "$p" || exit $?
++ fi
++}
++
++ensure_clean()
++{
++ if ! git diff-index HEAD --exit-code --quiet 2>&1; then
++ die "Working tree has modifications. Cannot add."
++ fi
++ if ! git diff-index --cached HEAD --exit-code --quiet 2>&1; then
++ die "Index has modifications. Cannot add."
++ fi
++}
++
++cmd_add()
++{
++ if [ -e "$dir" ]; then
++ die "'$dir' already exists. Cannot add."
++ fi
++
++ ensure_clean
++
++ if [ $# -eq 1 ]; then
++ "cmd_add_commit" "$@"
++ elif [ $# -eq 2 ]; then
++ "cmd_add_repository" "$@"
++ else
++ say "error: parameters were '$@'"
++ die "Provide either a refspec or a repository and refspec."
++ fi
++}
++
++cmd_add_repository()
++{
++ echo "git fetch" "$@"
++ repository=$1
++ refspec=$2
++ git fetch "$@" || exit $?
++ revs=FETCH_HEAD
++ set -- $revs
++ cmd_add_commit "$@"
++}
++
++cmd_add_commit()
++{
++ revs=$(git rev-parse $default --revs-only "$@") || exit $?
++ set -- $revs
++ rev="$1"
++
++ debug "Adding $dir as '$rev'..."
++ git read-tree --prefix="$dir" $rev || exit $?
++ git checkout -- "$dir" || exit $?
++ tree=$(git write-tree) || exit $?
++
++ headrev=$(git rev-parse HEAD) || exit $?
++ if [ -n "$headrev" -a "$headrev" != "$rev" ]; then
++ headp="-p $headrev"
++ else
++ headp=
++ fi
++
++ if [ -n "$squash" ]; then
++ rev=$(new_squash_commit "" "" "$rev") || exit $?
++ commit=$(add_squashed_msg "$rev" "$dir" |
++ git commit-tree $tree $headp -p "$rev") || exit $?
++ else
++ commit=$(add_msg "$dir" "$headrev" "$rev" |
++ git commit-tree $tree $headp -p "$rev") || exit $?
++ fi
++ git reset "$commit" || exit $?
++
++ say "Added dir '$dir'"
++}
++
++cmd_split()
++{
++ debug "Splitting $dir..."
++ cache_setup || exit $?
++
++ if [ -n "$onto" ]; then
++ debug "Reading history for --onto=$onto..."
++ git rev-list $onto |
++ while read rev; do
++ # the 'onto' history is already just the subdir, so
++ # any parent we find there can be used verbatim
++ debug " cache: $rev"
++ cache_set $rev $rev
++ done
++ fi
++
++ if [ -n "$ignore_joins" ]; then
++ unrevs=
++ else
++ unrevs="$(find_existing_splits "$dir" "$revs")"
++ fi
++
++ # We can't restrict rev-list to only $dir here, because some of our
++ # parents have the $dir contents the root, and those won't match.
++ # (and rev-list --follow doesn't seem to solve this)
++ grl='git rev-list --topo-order --reverse --parents $revs $unrevs'
++ revmax=$(eval "$grl" | wc -l)
++ revcount=0
++ createcount=0
++ eval "$grl" |
++ while read rev parents; do
++ revcount=$(($revcount + 1))
++ say -n "$revcount/$revmax ($createcount)\r"
++ debug "Processing commit: $rev"
++ exists=$(cache_get $rev)
++ if [ -n "$exists" ]; then
++ debug " prior: $exists"
++ continue
++ fi
++ createcount=$(($createcount + 1))
++ debug " parents: $parents"
++ newparents=$(cache_get $parents)
++ debug " newparents: $newparents"
++
++ tree=$(subtree_for_commit $rev "$dir")
++ debug " tree is: $tree"
++
++ check_parents $parents
++
++ # ugly. is there no better way to tell if this is a subtree
++ # vs. a mainline commit? Does it matter?
++ if [ -z $tree ]; then
++ set_notree $rev
++ if [ -n "$newparents" ]; then
++ cache_set $rev $rev
++ fi
++ continue
++ fi
++
++ newrev=$(copy_or_skip "$rev" "$tree" "$newparents") || exit $?
++ debug " newrev is: $newrev"
++ cache_set $rev $newrev
++ cache_set latest_new $newrev
++ cache_set latest_old $rev
++ done || exit $?
++ latest_new=$(cache_get latest_new)
++ if [ -z "$latest_new" ]; then
++ die "No new revisions were found"
++ fi
++
++ if [ -n "$rejoin" ]; then
++ debug "Merging split branch into HEAD..."
++ latest_old=$(cache_get latest_old)
++ git merge -s ours \
++ -m "$(rejoin_msg $dir $latest_old $latest_new)" \
++ $latest_new >&2 || exit $?
++ fi
++ if [ -n "$branch" ]; then
++ if rev_exists "refs/heads/$branch"; then
++ if ! rev_is_descendant_of_branch $latest_new $branch; then
++ die "Branch '$branch' is not an ancestor of commit '$latest_new'."
++ fi
++ action='Updated'
++ else
++ action='Created'
++ fi
++ git update-ref -m 'subtree split' "refs/heads/$branch" $latest_new || exit $?
++ say "$action branch '$branch'"
++ fi
++ echo $latest_new
++ exit 0
++}
++
++cmd_merge()
++{
++ revs=$(git rev-parse $default --revs-only "$@") || exit $?
++ ensure_clean
++
++ set -- $revs
++ if [ $# -ne 1 ]; then
++ die "You must provide exactly one revision. Got: '$revs'"
++ fi
++ rev="$1"
++
++ if [ -n "$squash" ]; then
++ first_split="$(find_latest_squash "$dir")"
++ if [ -z "$first_split" ]; then
++ die "Can't squash-merge: '$dir' was never added."
++ fi
++ set $first_split
++ old=$1
++ sub=$2
++ if [ "$sub" = "$rev" ]; then
++ say "Subtree is already at commit $rev."
++ exit 0
++ fi
++ new=$(new_squash_commit "$old" "$sub" "$rev") || exit $?
++ debug "New squash commit: $new"
++ rev="$new"
++ fi
++
++ version=$(git version)
++ if [ "$version" \< "git version 1.7" ]; then
++ if [ -n "$message" ]; then
++ git merge -s subtree --message="$message" $rev
++ else
++ git merge -s subtree $rev
++ fi
++ else
++ if [ -n "$message" ]; then
++ git merge -Xsubtree="$prefix" --message="$message" $rev
++ else
++ git merge -Xsubtree="$prefix" $rev
++ fi
++ fi
++}
++
++cmd_pull()
++{
++ ensure_clean
++ git fetch "$@" || exit $?
++ revs=FETCH_HEAD
++ set -- $revs
++ cmd_merge "$@"
++}
++
++cmd_push()
++{
++ if [ $# -ne 2 ]; then
++ die "You must provide <repository> <refspec>"
++ fi
++ if [ -e "$dir" ]; then
++ repository=$1
++ refspec=$2
++ echo "git push using: " $repository $refspec
++ git push $repository $(git subtree split --prefix=$prefix):refs/heads/$refspec
++ else
++ die "'$dir' must already exist. Try 'git subtree add'."
++ fi
++}
++
++"cmd_$command" "$@"
diff --combined contrib/subtree/git-subtree.txt
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..0c44fda011bcfd39fd8c464c35017df620a91ff9
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,366 @@@
++git-subtree(1)
++==============
++
++NAME
++----
++git-subtree - Merge subtrees together and split repository into subtrees
++
++
++SYNOPSIS
++--------
++[verse]
++'git subtree' add -P <prefix> <commit>
++'git subtree' pull -P <prefix> <repository> <refspec...>
++'git subtree' push -P <prefix> <repository> <refspec...>
++'git subtree' merge -P <prefix> <commit>
++'git subtree' split -P <prefix> [OPTIONS] [<commit>]
++
++
++DESCRIPTION
++-----------
++Subtrees allow subprojects to be included within a subdirectory
++of the main project, optionally including the subproject's
++entire history.
++
++For example, you could include the source code for a library
++as a subdirectory of your application.
++
++Subtrees are not to be confused with submodules, which are meant for
++the same task. Unlike submodules, subtrees do not need any special
++constructions (like .gitmodule files or gitlinks) be present in
++your repository, and do not force end-users of your
++repository to do anything special or to understand how subtrees
++work. A subtree is just a subdirectory that can be
++committed to, branched, and merged along with your project in
++any way you want.
++
++They are also not to be confused with using the subtree merge
++strategy. The main difference is that, besides merging
++the other project as a subdirectory, you can also extract the
++entire history of a subdirectory from your project and make it
++into a standalone project. Unlike the subtree merge strategy
++you can alternate back and forth between these
++two operations. If the standalone library gets updated, you can
++automatically merge the changes into your project; if you
++update the library inside your project, you can "split" the
++changes back out again and merge them back into the library
++project.
++
++For example, if a library you made for one application ends up being
++useful elsewhere, you can extract its entire history and publish
++that as its own git repository, without accidentally
++intermingling the history of your application project.
++
++[TIP]
++In order to keep your commit messages clean, we recommend that
++people split their commits between the subtrees and the main
++project as much as possible. That is, if you make a change that
++affects both the library and the main application, commit it in
++two pieces. That way, when you split the library commits out
++later, their descriptions will still make sense. But if this
++isn't important to you, it's not *necessary*. git subtree will
++simply leave out the non-library-related parts of the commit
++when it splits it out into the subproject later.
++
++
++COMMANDS
++--------
++add::
++ Create the <prefix> subtree by importing its contents
++ from the given <refspec> or <repository> and remote <refspec>.
++ A new commit is created automatically, joining the imported
++ project's history with your own. With '--squash', imports
++ only a single commit from the subproject, rather than its
++ entire history.
++
++merge::
++ Merge recent changes up to <commit> into the <prefix>
++ subtree. As with normal 'git merge', this doesn't
++ remove your own local changes; it just merges those
++ changes into the latest <commit>. With '--squash',
++ creates only one commit that contains all the changes,
++ rather than merging in the entire history.
++
++ If you use '--squash', the merge direction doesn't
++ always have to be forward; you can use this command to
++ go back in time from v2.5 to v2.4, for example. If your
++ merge introduces a conflict, you can resolve it in the
++ usual ways.
++
++pull::
++ Exactly like 'merge', but parallels 'git pull' in that
++ it fetches the given commit from the specified remote
++ repository.
++
++push::
++ Does a 'split' (see above) using the <prefix> supplied
++ and then does a 'git push' to push the result to the
++ repository and refspec. This can be used to push your
++ subtree to different branches of the remote repository.
++
++split::
++ Extract a new, synthetic project history from the
++ history of the <prefix> subtree. The new history
++ includes only the commits (including merges) that
++ affected <prefix>, and each of those commits now has the
++ contents of <prefix> at the root of the project instead
++ of in a subdirectory. Thus, the newly created history
++ is suitable for export as a separate git repository.
++
++ After splitting successfully, a single commit id is
++ printed to stdout. This corresponds to the HEAD of the
++ newly created tree, which you can manipulate however you
++ want.
++
++ Repeated splits of exactly the same history are
++ guaranteed to be identical (ie. to produce the same
++ commit ids). Because of this, if you add new commits
++ and then re-split, the new commits will be attached as
++ commits on top of the history you generated last time,
++ so 'git merge' and friends will work as expected.
++
++ Note that if you use '--squash' when you merge, you
++ should usually not just '--rejoin' when you split.
++
++
++OPTIONS
++-------
++-q::
++--quiet::
++ Suppress unnecessary output messages on stderr.
++
++-d::
++--debug::
++ Produce even more unnecessary output messages on stderr.
++
++-P <prefix>::
++--prefix=<prefix>::
++ Specify the path in the repository to the subtree you
++ want to manipulate. This option is mandatory
++ for all commands.
++
++-m <message>::
++--message=<message>::
++ This option is only valid for add, merge and pull (unsure).
++ Specify <message> as the commit message for the merge commit.
++
++
++OPTIONS FOR add, merge, push, pull
++----------------------------------
++--squash::
++ This option is only valid for add, merge, push and pull
++ commands.
++
++ Instead of merging the entire history from the subtree
++ project, produce only a single commit that contains all
++ the differences you want to merge, and then merge that
++ new commit into your project.
++
++ Using this option helps to reduce log clutter. People
++ rarely want to see every change that happened between
++ v1.0 and v1.1 of the library they're using, since none of the
++ interim versions were ever included in their application.
++
++ Using '--squash' also helps avoid problems when the same
++ subproject is included multiple times in the same
++ project, or is removed and then re-added. In such a
++ case, it doesn't make sense to combine the histories
++ anyway, since it's unclear which part of the history
++ belongs to which subtree.
++
++ Furthermore, with '--squash', you can switch back and
++ forth between different versions of a subtree, rather
++ than strictly forward. 'git subtree merge --squash'
++ always adjusts the subtree to match the exactly
++ specified commit, even if getting to that commit would
++ require undoing some changes that were added earlier.
++
++ Whether or not you use '--squash', changes made in your
++ local repository remain intact and can be later split
++ and send upstream to the subproject.
++
++
++OPTIONS FOR split
++-----------------
++--annotate=<annotation>::
++ This option is only valid for the split command.
++
++ When generating synthetic history, add <annotation> as a
++ prefix to each commit message. Since we're creating new
++ commits with the same commit message, but possibly
++ different content, from the original commits, this can help
++ to differentiate them and avoid confusion.
++
++ Whenever you split, you need to use the same
++ <annotation>, or else you don't have a guarantee that
++ the new re-created history will be identical to the old
++ one. That will prevent merging from working correctly.
++ git subtree tries to make it work anyway, particularly
++ if you use --rejoin, but it may not always be effective.
++
++-b <branch>::
++--branch=<branch>::
++ This option is only valid for the split command.
++
++ After generating the synthetic history, create a new
++ branch called <branch> that contains the new history.
++ This is suitable for immediate pushing upstream.
++ <branch> must not already exist.
++
++--ignore-joins::
++ This option is only valid for the split command.
++
++ If you use '--rejoin', git subtree attempts to optimize
++ its history reconstruction to generate only the new
++ commits since the last '--rejoin'. '--ignore-join'
++ disables this behaviour, forcing it to regenerate the
++ entire history. In a large project, this can take a
++ long time.
++
++--onto=<onto>::
++ This option is only valid for the split command.
++
++ If your subtree was originally imported using something
++ other than git subtree, its history may not match what
++ git subtree is expecting. In that case, you can specify
++ the commit id <onto> that corresponds to the first
++ revision of the subproject's history that was imported
++ into your project, and git subtree will attempt to build
++ its history from there.
++
++ If you used 'git subtree add', you should never need
++ this option.
++
++--rejoin::
++ This option is only valid for the split command.
++
++ After splitting, merge the newly created synthetic
++ history back into your main project. That way, future
++ splits can search only the part of history that has
++ been added since the most recent --rejoin.
++
++ If your split commits end up merged into the upstream
++ subproject, and then you want to get the latest upstream
++ version, this will allow git's merge algorithm to more
++ intelligently avoid conflicts (since it knows these
++ synthetic commits are already part of the upstream
++ repository).
++
++ Unfortunately, using this option results in 'git log'
++ showing an extra copy of every new commit that was
++ created (the original, and the synthetic one).
++
++ If you do all your merges with '--squash', don't use
++ '--rejoin' when you split, because you don't want the
++ subproject's history to be part of your project anyway.
++
++
++EXAMPLE 1. Add command
++----------------------
++Let's assume that you have a local repository that you would like
++to add an external vendor library to. In this case we will add the
++git-subtree repository as a subdirectory of your already existing
++git-extensions repository in ~/git-extensions/:
++
++ $ git subtree add --prefix=git-subtree --squash \
++ git://github.com/apenwarr/git-subtree.git master
++
++'master' needs to be a valid remote ref and can be a different branch
++name
++
++You can omit the --squash flag, but doing so will increase the number
++of commits that are incldued in your local repository.
++
++We now have a ~/git-extensions/git-subtree directory containing code
++from the master branch of git://github.com/apenwarr/git-subtree.git
++in our git-extensions repository.
++
++EXAMPLE 2. Extract a subtree using commit, merge and pull
++---------------------------------------------------------
++Let's use the repository for the git source code as an example.
++First, get your own copy of the git.git repository:
++
++ $ git clone git://git.kernel.org/pub/scm/git/git.git test-git
++ $ cd test-git
++
++gitweb (commit 1130ef3) was merged into git as of commit
++0a8f4f0, after which it was no longer maintained separately.
++But imagine it had been maintained separately, and we wanted to
++extract git's changes to gitweb since that time, to share with
++the upstream. You could do this:
++
++ $ git subtree split --prefix=gitweb --annotate='(split) ' \
++ 0a8f4f0^.. --onto=1130ef3 --rejoin \
++ --branch gitweb-latest
++ $ gitk gitweb-latest
++ $ git push git@github.com:whatever/gitweb.git gitweb-latest:master
++
++(We use '0a8f4f0^..' because that means "all the changes from
++0a8f4f0 to the current version, including 0a8f4f0 itself.")
++
++If gitweb had originally been merged using 'git subtree add' (or
++a previous split had already been done with --rejoin specified)
++then you can do all your splits without having to remember any
++weird commit ids:
++
++ $ git subtree split --prefix=gitweb --annotate='(split) ' --rejoin \
++ --branch gitweb-latest2
++
++And you can merge changes back in from the upstream project just
++as easily:
++
++ $ git subtree pull --prefix=gitweb \
++ git@github.com:whatever/gitweb.git master
++
++Or, using '--squash', you can actually rewind to an earlier
++version of gitweb:
++
++ $ git subtree merge --prefix=gitweb --squash gitweb-latest~10
++
++Then make some changes:
++
++ $ date >gitweb/myfile
++ $ git add gitweb/myfile
++ $ git commit -m 'created myfile'
++
++And fast forward again:
++
++ $ git subtree merge --prefix=gitweb --squash gitweb-latest
++
++And notice that your change is still intact:
++
++ $ ls -l gitweb/myfile
++
++And you can split it out and look at your changes versus
++the standard gitweb:
++
++ git log gitweb-latest..$(git subtree split --prefix=gitweb)
++
++EXAMPLE 3. Extract a subtree using branch
++-----------------------------------------
++Suppose you have a source directory with many files and
++subdirectories, and you want to extract the lib directory to its own
++git project. Here's a short way to do it:
++
++First, make the new repository wherever you want:
++
++ $ <go to the new location>
++ $ git init --bare
++
++Back in your original directory:
++
++ $ git subtree split --prefix=lib --annotate="(split)" -b split
++
++Then push the new branch onto the new empty repository:
++
++ $ git push <new-repo> split:master
++
++
++AUTHOR
++------
++Written by Avery Pennarun <apenwarr@gmail.com>
++
++
++GIT
++---
++Part of the linkgit:git[1] suite
diff --combined contrib/subtree/install.sh
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..1f87a624341ab6cff60e517b78da2d9676f0fd44
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,2 @@@
++# copy Git to where the rest of the Git scripts are found.
++cp git-subtree.sh "$(git --exec-path)"/git-subtree
diff --combined contrib/subtree/manpage-base.xsl
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..a264fa616093cf4e28a1080dd76747b008859e19
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,35 @@@
++<!-- manpage-base.xsl:
++ special formatting for manpages rendered from asciidoc+docbook -->
++<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
++ version="1.0">
++
++<!-- these params silence some output from xmlto -->
++<xsl:param name="man.output.quietly" select="1"/>
++<xsl:param name="refentry.meta.get.quietly" select="1"/>
++
++<!-- convert asciidoc callouts to man page format;
++ git.docbook.backslash and git.docbook.dot params
++ must be supplied by another XSL file or other means -->
++<xsl:template match="co">
++ <xsl:value-of select="concat(
++ $git.docbook.backslash,'fB(',
++ substring-after(@id,'-'),')',
++ $git.docbook.backslash,'fR')"/>
++</xsl:template>
++<xsl:template match="calloutlist">
++ <xsl:value-of select="$git.docbook.dot"/>
++ <xsl:text>sp </xsl:text>
++ <xsl:apply-templates/>
++ <xsl:text> </xsl:text>
++</xsl:template>
++<xsl:template match="callout">
++ <xsl:value-of select="concat(
++ $git.docbook.backslash,'fB',
++ substring-after(@arearefs,'-'),
++ '. ',$git.docbook.backslash,'fR')"/>
++ <xsl:apply-templates/>
++ <xsl:value-of select="$git.docbook.dot"/>
++ <xsl:text>br </xsl:text>
++</xsl:template>
++
++</xsl:stylesheet>
diff --combined contrib/subtree/manpage-normal.xsl
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..a48f5b11f3dcc9227131d3a5caf1de4f857f0b28
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,13 @@@
++<!-- manpage-normal.xsl:
++ special settings for manpages rendered from asciidoc+docbook
++ handles anything we want to keep away from docbook-xsl 1.72.0 -->
++<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
++ version="1.0">
++
++<xsl:import href="manpage-base.xsl"/>
++
++<!-- these are the normal values for the roff control characters -->
++<xsl:param name="git.docbook.backslash">\</xsl:param>
++<xsl:param name="git.docbook.dot" >.</xsl:param>
++
++</xsl:stylesheet>
diff --combined contrib/subtree/shellopts.sh
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..42644cd019a2a0ac29f4514551edbf4bf877b34a
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,1 @@@
++export PATH=$PWD:$PATH
diff --combined contrib/subtree/t/t7900-subtree.sh
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..585f8d5751eb1fba2c1ca4c7c5cf7189570d2f2e
new file mode 100755 (executable)
new file mode 100755 (executable)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,506 @@@
++#!/bin/sh
++#
++# Copyright (c) 2012 Avery Pennaraum
++#
++test_description='Basic porcelain support for subtrees
++
++This test verifies the basic operation of the merge, pull, add
++and split subcommands of git subtree.
++'
++
++. ./test-lib.sh
++
++create()
++{
++ echo "$1" >"$1"
++ git add "$1"
++}
++
++
++check_equal()
++{
++ test_debug 'echo'
++ test_debug "echo \"check a:\" \"{$1}\""
++ test_debug "echo \" b:\" \"{$2}\""
++ if [ "$1" = "$2" ]; then
++ return 0
++ else
++ return 1
++ fi
++}
++
++fixnl()
++{
++ t=""
++ while read x; do
++ t="$t$x "
++ done
++ echo $t
++}
++
++multiline()
++{
++ while read x; do
++ set -- $x
++ for d in "$@"; do
++ echo "$d"
++ done
++ done
++}
++
++undo()
++{
++ git reset --hard HEAD~
++}
++
++last_commit_message()
++{
++ git log --pretty=format:%s -1
++}
++
++# 1
++test_expect_success 'init subproj' '
++ test_create_repo subproj
++'
++
++# To the subproject!
++cd subproj
++
++# 2
++test_expect_success 'add sub1' '
++ create sub1 &&
++ git commit -m "sub1" &&
++ git branch sub1 &&
++ git branch -m master subproj
++'
++
++# 3
++test_expect_success 'add sub2' '
++ create sub2 &&
++ git commit -m "sub2" &&
++ git branch sub2
++'
++
++# 4
++test_expect_success 'add sub3' '
++ create sub3 &&
++ git commit -m "sub3" &&
++ git branch sub3
++'
++
++# Back to mainline
++cd ..
++
++# 5
++test_expect_success 'add main4' '
++ create main4 &&
++ git commit -m "main4" &&
++ git branch -m master mainline &&
++ git branch subdir
++'
++
++# 6
++test_expect_success 'fetch subproj history' '
++ git fetch ./subproj sub1 &&
++ git branch sub1 FETCH_HEAD
++'
++
++# 7
++test_expect_success 'no subtree exists in main tree' '
++ test_must_fail git subtree merge --prefix=subdir sub1
++'
++
++# 8
++test_expect_success 'no pull from non-existant subtree' '
++ test_must_fail git subtree pull --prefix=subdir ./subproj sub1
++'
++
++# 9
++test_expect_success 'check if --message works for add' '
++ git subtree add --prefix=subdir --message="Added subproject" sub1 &&
++ check_equal ''"$(last_commit_message)"'' "Added subproject" &&
++ undo
++'
++
++# 10
++test_expect_success 'check if --message works as -m and --prefix as -P' '
++ git subtree add -P subdir -m "Added subproject using git subtree" sub1 &&
++ check_equal ''"$(last_commit_message)"'' "Added subproject using git subtree" &&
++ undo
++'
++
++# 11
++test_expect_success 'check if --message works with squash too' '
++ git subtree add -P subdir -m "Added subproject with squash" --squash sub1 &&
++ check_equal ''"$(last_commit_message)"'' "Added subproject with squash" &&
++ undo
++'
++
++# 12
++test_expect_success 'add subproj to mainline' '
++ git subtree add --prefix=subdir/ FETCH_HEAD &&
++ check_equal ''"$(last_commit_message)"'' "Add '"'subdir/'"' from commit '"'"'''"$(git rev-parse sub1)"'''"'"'"
++'
++
++# 13
++# this shouldn't actually do anything, since FETCH_HEAD is already a parent
++test_expect_success 'merge fetched subproj' '
++ git merge -m "merge -s -ours" -s ours FETCH_HEAD
++'
++
++# 14
++test_expect_success 'add main-sub5' '
++ create subdir/main-sub5 &&
++ git commit -m "main-sub5"
++'
++
++# 15
++test_expect_success 'add main6' '
++ create main6 &&
++ git commit -m "main6 boring"
++'
++
++# 16
++test_expect_success 'add main-sub7' '
++ create subdir/main-sub7 &&
++ git commit -m "main-sub7"
++'
++
++# 17
++test_expect_success 'fetch new subproj history' '
++ git fetch ./subproj sub2 &&
++ git branch sub2 FETCH_HEAD
++'
++
++# 18
++test_expect_success 'check if --message works for merge' '
++ git subtree merge --prefix=subdir -m "Merged changes from subproject" sub2 &&
++ check_equal ''"$(last_commit_message)"'' "Merged changes from subproject" &&
++ undo
++'
++
++# 19
++test_expect_success 'check if --message for merge works with squash too' '
++ git subtree merge --prefix subdir -m "Merged changes from subproject using squash" --squash sub2 &&
++ check_equal ''"$(last_commit_message)"'' "Merged changes from subproject using squash" &&
++ undo
++'
++
++# 20
++test_expect_success 'merge new subproj history into subdir' '
++ git subtree merge --prefix=subdir FETCH_HEAD &&
++ git branch pre-split &&
++ check_equal ''"$(last_commit_message)"'' "Merge commit '"'"'"$(git rev-parse sub2)"'"'"' into mainline"
++'
++
++# 21
++test_expect_success 'Check that prefix argument is required for split' '
++ echo "You must provide the --prefix option." > expected &&
++ test_must_fail git subtree split > actual 2>&1 &&
++ test_debug "echo -n expected: " &&
++ test_debug "cat expected" &&
++ test_debug "echo -n actual: " &&
++ test_debug "cat actual" &&
++ test_cmp expected actual &&
++ rm -f expected actual
++'
++
++# 22
++test_expect_success 'Check that the <prefix> exists for a split' '
++ echo "'"'"'non-existent-directory'"'"'" does not exist\; use "'"'"'git subtree add'"'"'" > expected &&
++ test_must_fail git subtree split --prefix=non-existent-directory > actual 2>&1 &&
++ test_debug "echo -n expected: " &&
++ test_debug "cat expected" &&
++ test_debug "echo -n actual: " &&
++ test_debug "cat actual" &&
++ test_cmp expected actual
++# rm -f expected actual
++'
++
++# 23
++test_expect_success 'check if --message works for split+rejoin' '
++ spl1=''"$(git subtree split --annotate='"'*'"' --prefix subdir --onto FETCH_HEAD --message "Split & rejoin" --rejoin)"'' &&
++ git branch spl1 "$spl1" &&
++ check_equal ''"$(last_commit_message)"'' "Split & rejoin" &&
++ undo
++'
++
++# 24
++test_expect_success 'check split with --branch' '
++ spl1=$(git subtree split --annotate='"'*'"' --prefix subdir --onto FETCH_HEAD --message "Split & rejoin" --rejoin) &&
++ undo &&
++ git subtree split --annotate='"'*'"' --prefix subdir --onto FETCH_HEAD --branch splitbr1 &&
++ check_equal ''"$(git rev-parse splitbr1)"'' "$spl1"
++'
++
++# 25
++test_expect_success 'check split with --branch for an existing branch' '
++ spl1=''"$(git subtree split --annotate='"'*'"' --prefix subdir --onto FETCH_HEAD --message "Split & rejoin" --rejoin)"'' &&
++ undo &&
++ git branch splitbr2 sub1 &&
++ git subtree split --annotate='"'*'"' --prefix subdir --onto FETCH_HEAD --branch splitbr2 &&
++ check_equal ''"$(git rev-parse splitbr2)"'' "$spl1"
++'
++
++# 26
++test_expect_success 'check split with --branch for an incompatible branch' '
++ test_must_fail git subtree split --prefix subdir --onto FETCH_HEAD --branch subdir
++'
++
++
++# 27
++test_expect_success 'check split+rejoin' '
++ spl1=''"$(git subtree split --annotate='"'*'"' --prefix subdir --onto FETCH_HEAD --message "Split & rejoin" --rejoin)"'' &&
++ undo &&
++ git subtree split --annotate='"'*'"' --prefix subdir --onto FETCH_HEAD --rejoin &&
++ check_equal ''"$(last_commit_message)"'' "Split '"'"'subdir/'"'"' into commit '"'"'"$spl1"'"'"'"
++'
++
++# 28
++test_expect_success 'add main-sub8' '
++ create subdir/main-sub8 &&
++ git commit -m "main-sub8"
++'
++
++# To the subproject!
++cd ./subproj
++
++# 29
++test_expect_success 'merge split into subproj' '
++ git fetch .. spl1 &&
++ git branch spl1 FETCH_HEAD &&
++ git merge FETCH_HEAD
++'
++
++# 30
++test_expect_success 'add sub9' '
++ create sub9 &&
++ git commit -m "sub9"
++'
++
++# Back to mainline
++cd ..
++
++# 31
++test_expect_success 'split for sub8' '
++ split2=''"$(git subtree split --annotate='"'*'"' --prefix subdir/ --rejoin)"''
++ git branch split2 "$split2"
++'
++
++# 32
++test_expect_success 'add main-sub10' '
++ create subdir/main-sub10 &&
++ git commit -m "main-sub10"
++'
++
++# 33
++test_expect_success 'split for sub10' '
++ spl3=''"$(git subtree split --annotate='"'*'"' --prefix subdir --rejoin)"'' &&
++ git branch spl3 "$spl3"
++'
++
++# To the subproject!
++cd ./subproj
++
++# 34
++test_expect_success 'merge split into subproj' '
++ git fetch .. spl3 &&
++ git branch spl3 FETCH_HEAD &&
++ git merge FETCH_HEAD &&
++ git branch subproj-merge-spl3
++'
++
++chkm="main4 main6"
++chkms="main-sub10 main-sub5 main-sub7 main-sub8"
++chkms_sub=$(echo $chkms | multiline | sed 's,^,subdir/,' | fixnl)
++chks="sub1 sub2 sub3 sub9"
++chks_sub=$(echo $chks | multiline | sed 's,^,subdir/,' | fixnl)
++
++# 35
++test_expect_success 'make sure exactly the right set of files ends up in the subproj' '
++ subfiles=''"$(git ls-files | fixnl)"'' &&
++ check_equal "$subfiles" "$chkms $chks"
++'
++
++# 36
++test_expect_success 'make sure the subproj history *only* contains commits that affect the subdir' '
++ allchanges=''"$(git log --name-only --pretty=format:'"''"' | sort | fixnl)"'' &&
++ check_equal "$allchanges" "$chkms $chks"
++'
++
++# Back to mainline
++cd ..
++
++# 37
++test_expect_success 'pull from subproj' '
++ git fetch ./subproj subproj-merge-spl3 &&
++ git branch subproj-merge-spl3 FETCH_HEAD &&
++ git subtree pull --prefix=subdir ./subproj subproj-merge-spl3
++'
++
++# 38
++test_expect_success 'make sure exactly the right set of files ends up in the mainline' '
++ mainfiles=''"$(git ls-files | fixnl)"'' &&
++ check_equal "$mainfiles" "$chkm $chkms_sub $chks_sub"
++'
++
++# 39
++test_expect_success 'make sure each filename changed exactly once in the entire history' '
++ # main-sub?? and /subdir/main-sub?? both change, because those are the
++ # changes that were split into their own history. And subdir/sub?? never
++ # change, since they were *only* changed in the subtree branch.
++ allchanges=''"$(git log --name-only --pretty=format:'"''"' | sort | fixnl)"'' &&
++ check_equal "$allchanges" ''"$(echo $chkms $chkm $chks $chkms_sub | multiline | sort | fixnl)"''
++'
++
++# 40
++test_expect_success 'make sure the --rejoin commits never make it into subproj' '
++ check_equal ''"$(git log --pretty=format:'"'%s'"' HEAD^2 | grep -i split)"'' ""
++'
++
++# 41
++test_expect_success 'make sure no "git subtree" tagged commits make it into subproj' '
++ # They are meaningless to subproj since one side of the merge refers to the mainline
++ check_equal ''"$(git log --pretty=format:'"'%s%n%b'"' HEAD^2 | grep "git-subtree.*:")"'' ""
++'
++
++# prepare second pair of repositories
++mkdir test2
++cd test2
++
++# 42
++test_expect_success 'init main' '
++ test_create_repo main
++'
++
++cd main
++
++# 43
++test_expect_success 'add main1' '
++ create main1 &&
++ git commit -m "main1"
++'
++
++cd ..
++
++# 44
++test_expect_success 'init sub' '
++ test_create_repo sub
++'
++
++cd sub
++
++# 45
++test_expect_success 'add sub2' '
++ create sub2 &&
++ git commit -m "sub2"
++'
++
++cd ../main
++
++# check if split can find proper base without --onto
++
++# 46
++test_expect_success 'add sub as subdir in main' '
++ git fetch ../sub master &&
++ git branch sub2 FETCH_HEAD &&
++ git subtree add --prefix subdir sub2
++'
++
++cd ../sub
++
++# 47
++test_expect_success 'add sub3' '
++ create sub3 &&
++ git commit -m "sub3"
++'
++
++cd ../main
++
++# 48
++test_expect_success 'merge from sub' '
++ git fetch ../sub master &&
++ git branch sub3 FETCH_HEAD &&
++ git subtree merge --prefix subdir sub3
++'
++
++# 49
++test_expect_success 'add main-sub4' '
++ create subdir/main-sub4 &&
++ git commit -m "main-sub4"
++'
++
++# 50
++test_expect_success 'split for main-sub4 without --onto' '
++ git subtree split --prefix subdir --branch mainsub4
++'
++
++# at this point, the new commit parent should be sub3 if it is not,
++# something went wrong (the "newparent" of "master~" commit should
++# have been sub3, but it was not, because its cache was not set to
++# itself)
++
++# 51
++test_expect_success 'check that the commit parent is sub3' '
++ check_equal ''"$(git log --pretty=format:%P -1 mainsub4)"'' ''"$(git rev-parse sub3)"''
++'
++
++# 52
++test_expect_success 'add main-sub5' '
++ mkdir subdir2 &&
++ create subdir2/main-sub5 &&
++ git commit -m "main-sub5"
++'
++
++# 53
++test_expect_success 'split for main-sub5 without --onto' '
++ # also test that we still can split out an entirely new subtree
++ # if the parent of the first commit in the tree is not empty,
++ # then the new subtree has accidently been attached to something
++ git subtree split --prefix subdir2 --branch mainsub5 &&
++ check_equal ''"$(git log --pretty=format:%P -1 mainsub5)"'' ""
++'
++
++# make sure no patch changes more than one file. The original set of commits
++# changed only one file each. A multi-file change would imply that we pruned
++# commits too aggressively.
++joincommits()
++{
++ commit=
++ all=
++ while read x y; do
++ #echo "{$x}" >&2
++ if [ -z "$x" ]; then
++ continue
++ elif [ "$x" = "commit:" ]; then
++ if [ -n "$commit" ]; then
++ echo "$commit $all"
++ all=
++ fi
++ commit="$y"
++ else
++ all="$all $y"
++ fi
++ done
++ echo "$commit $all"
++}
++
++# 54
++test_expect_success 'verify one file change per commit' '
++ x= &&
++ list=''"$(git log --pretty=format:'"'commit: %H'"' | joincommits)"'' &&
++# test_debug "echo HERE" &&
++# test_debug "echo ''"$list"''" &&
++ (git log --pretty=format:'"'commit: %H'"' | joincommits |
++ ( while read commit a b; do
++ test_debug "echo Verifying commit "''"$commit"''
++ test_debug "echo a: "''"$a"''
++ test_debug "echo b: "''"$b"''
++ check_equal "$b" ""
++ x=1
++ done
++ check_equal "$x" 1
++ ))
++'
++
++test_done
diff --combined contrib/subtree/todo
index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..7e44b0024fa35ae76f62875704fcd24e3f690c7d
new file mode 100644 (file)
new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/contrib/subtree/todo
@@@ -1,0 -1,0 +1,50 @@@
++
++ delete tempdir
++
++ 'git subtree rejoin' option to do the same as --rejoin, eg. after a
++ rebase
++
++ --prefix doesn't force the subtree correctly in merge/pull:
++ "-s subtree" should be given an explicit subtree option?
++ There doesn't seem to be a way to do this. We'd have to
++ patch git-merge-subtree. Ugh.
++ (but we could avoid this problem by generating squashes with
++ exactly the right subtree structure, rather than using
++ subtree merge...)
++
++ add a 'push' subcommand to parallel 'pull'
++
++ add a 'log' subcommand to see what's new in a subtree?
++
++ add to-submodule and from-submodule commands
++
++ automated tests for --squash stuff
++
++ "add" command non-obviously requires a commitid; would be easier if
++ it had a "pull" sort of mode instead
++
++ "pull" and "merge" commands should fail if you've never merged
++ that --prefix before
++
++ docs should provide an example of "add"
++
++ note that the initial split doesn't *have* to have a commitid
++ specified... that's just an optimization
++
++ if you try to add (or maybe merge?) with an invalid commitid, you
++ get a misleading "prefix must end with /" message from
++ one of the other git tools that git-subtree calls. Should
++ detect this situation and print the *real* problem.
++
++ "pull --squash" should do fetch-synthesize-merge, but instead just
++ does "pull" directly, which doesn't work at all.
++
++ make a 'force-update' that does what 'add' does even if the subtree
++ already exists. That way we can help people who imported
++ subtrees "incorrectly" (eg. by just copying in the files) in
++ the past.
++
++ guess --prefix automatically if possible based on pwd
++
++ make a 'git subtree grafts' that automatically expands --squash'd
++ commits so you can see the full history if you want it.