eac_tools 0.86.1 → 0.86.2

data/sub/eac_git/vendor/git-subrepo/note/design.swim

@@ -0,0 +1,137 @@
+git-subrepo Design
+==================
+
+How the subrepo commands should work.
+
+Glossary:
+
+- `subrepo` :: An external repository integrated as a repo subdirectory
+- `subdir` :: The directory in the work tree where the subrepo lives
+- `upstream` :: The remote repo that the subrepo is tracking
+- `local` :: The local parts of the subrepo
+- `.gitrepo` :: The subrepo state file
+- `remote` :: The subrepo url
+- `branch` :: The remote branch the subrepo is tracking
+- `commit` ::  The upstream commit id that we last synced to
+- `former` :: The local commit that we last synced to
+
+== clone
+
+This is the action that adds a new subrepo. It feels very much like a clone,
+so we call it that.
+
+Usages:
+
+  # Add a subrepo into a subdir (track remote HEAD branch):
+  git subrepo clone <remote> <subdir>
+  # Guess subdir from remote url:
+  git subrepo clone <remote>
+  # Use a named branch instead of the remote HEAD:
+  git subrepo clone <remote> [<subdir>] -b <branch>
+
+Steps:
+
+* Assert clean, and chdir to root (adjusting subdir)
+* Determine the remote HEAD
+  * Else error, branch (-b) needed
+* Fetch the remote branch commits
+* Subtree merge the remote subrepo history into the subdir
+* Squash the history to a single commit
+* Merge the subtree commit into the mainline HEAD
+* Add a .gitrepo file to the subdir
+* Amend the .gitrepo into the HEAD merge commit
+* Create a branch .git/refs/subrepo/remote/<subdir>
+* Add a remote called subrepo/<subdir>
+
+== pull
+
+Fetch and merge the remote content. This could be a single operation, or may
+require a manual process: (see checkout)
+
+Usages:
+
+  # Fetch and rebase subdir/subrepo:
+  git subrepo pull --rebase subdir
+  # Strategies: --rebase --ours --theirs --merge (recursive):
+  git subrepo pull --<merge-strategy> subdir
+  # Pull all the subrepos:
+  git subrepo pull --<strategy> --all
+  # Change the tracking branch and pull it:
+  git subrepo pull --<strategy> -b <branch> <subdir>
+  # Pull in the hand merged branch:
+  # git subrepo pull <subdir>
+
+Steps:
+
+* Assert clean, and chdir to root (adjusting subdir)
+* Fetch the remote branch content
+* Update remotes and the refs in .git/
+  * The might not be the same repo that did the clone
+* If not hand merged
+  * Create a branch called subrepo/<subdir>
+  * Checkout the new branch
+  * Apply the merge strategy to the remote branch
+  * If not clean
+    * Error message
+    * Reset to starting state
+* Subtree merge the subrepo/<subdir> branch into repo
+    git subrepo clone <remote> <subdir>
+* Squash the upstream history
+* Merge the subtree into mainline
+* Update the .gitrepo file
+* Amend .gitrepo into HEAD
+* Delete the subrepo/<subdir> branch
+
+== push
+
+Push a merged subrepo history to the remote. This could be a single operation,
+or may require a manual process.
+
+Usages:
+
+  # Fetch, apply strategy, push to remote:
+  git subrepo push <subdir>
+  # Do all subrepos:
+  git subrepo push --all
+
+Steps:
+
+* Assert clean, and chdir to root (adjusting subdir)
+* Update remotes and the refs in .git/
+* Fetch the remote branch content
+* Make sure we have pulled the latest remote changes
+* Checkout subrepo/<subdir> branch
+* Rebase the local change s on top
+* Push it to subrepo/<subdir> remote
+
+== checkout
+
+Create a branch of the local changes to the subrepo and checkout it. Also
+fetch the remote tracking branch, so it can can be used for merges. This
+command is used to do a pull/merge by hand. After you merge, use the `pull`
+command to finish up.
+
+Usages:
+
+  # Checkout a subdir/subrepo
+  git checkout <subdir>
+
+Steps:
+
+* Assert clean, and chdir to root (adjusting subdir)
+* Assert repo is on a branch
+* Update remotes and the refs in .git/
+* Fetch the remote branch content
+* Create a branch of local subrepo changes subrepo/local/<subdir>
+* Checkout the new branch
+
+== status
+
+Give a full status of specific subrepos or all of them.
+
+Usages:
+
+  # Get status for all subrepos:
+  git subrepo status
+  # Get status for specific subrepos:
+  git subrepo status <subdir> [<subdir> ...]

data/sub/eac_git/vendor/git-subrepo/note/design2.swim

@@ -0,0 +1,85 @@
+git-subrepo Design
+==================
+
+This document details wow the git-subrepo commands should work.
+
+Glossary:
+
+- `subrepo` :: An external repository integrated as a repo subdirectory
+- `subdir` :: The directory in the work tree where the subrepo lives
+- `upstream` :: The remote repo that the subrepo is tracking
+- `local` :: The local parts of the subrepo
+- `.gitrepo` :: The subrepo state file
+- `remote` :: The subrepo url
+- `branch` :: The remote branch the subrepo is tracking
+- `commit` ::  The upstream commit id that we last synced to
+- `former` :: The local commit that we last synced to
+
+= Commands and usages:
+
+There are 4 main commands:
+
+* git subrepo clone
+* git subrepo pull
+* git subrepo push
+* git subrepo checkout
+
+  # Clone forms:
+  git subrepo clone git@github.com:you/foo.git
+  git subrepo clone git@github.com:you/foo.git ext/subfoo
+  git subrepo clone git@github.com:you/foo.git -b alternate-branch
+
+  # Single command pull:
+  git subrepo pull --rebase ext/foo
+  git subrepo pull --merge  ext/foo -b remote-branch
+  git subrepo pull --ours   ext/foo -B remote-branch  # change .gitrepo
+  git subrepo pull --rebase --all
+
+  # Manual pull:
+  git subrepo checkout ext/foo
+  git rebase subrepo/remote/ext/foo subrepo/ext/foo
+  make test
+  git subrepo pull ext/foo --continue
+
+  # Push forms:
+  git subrepo push ext/foo
+  git subrepo push ext/foo -b remote-branch
+  git subrepo push ext/foo -B remote-branch
+  git subrepo push --all
+
+  # Manual push:
+  git subrepo checkout ext/foo --rebase
+  <maybe rewrite commit info>
+  make test
+  git subrepo push ext/foo --continue
+
+  # Checkout forms:
+  git subrepo checkout ext/foo
+  git subrepo checkout ext/foo --<merge-straegy>
+  git subrepo checkout ext/foo --fetch
+  git subrepo checkout -b create-local-branch-name
+  git subrepo checkout --all
+
+= Command Logic
+
+This section goes over all the things that a command needs to do:
+
+== Setup
+
+There are certain steps that each command must do first:
+
+* Assert that the system commands and git version are correct.
+* Assert that the repository is in a clean state.
+* Assert that the repo is on a branch.
+* Assert that the current dir is top level of repo.
+* Assert the command arguments are valid.
+* Assert the subdir is a valid subrepo dir.
+  * For `clone` make sure subdir does not exist yet.
+* Read the .gitrepo file (not for clone).
+* For `clone`, make sure we know what upstream branch to use.
+* Note the starting point (branch and commit).
+
+== Clone command:
+
+* Fetch upstream content for our tracking branch.
+

data/sub/eac_git/vendor/git-subrepo/note/init-test

@@ -0,0 +1,38 @@
+#!/bin/bash
+
+set -ex
+cat $0    # Show this script in the output
+
+REPO=${1:-ingydotnet/djson-pm}
+REPODIR="${REPO#*/}"
+SUBDIR=${2:-test}
+SUBREPO=$REPO-$SUBDIR
+SUBREPODIR="${SUBREPO#*/}"
+
+git hub repo-delete "$SUBREPO" || true
+rm -fr "$REPODIR"
+git hub clone "$REPO"
+(
+  exit
+  cd "$REPODIR"
+  git subrepo init test -r "git@github.com:$SUBREPO" # -b foo
+  git hub repo-new "$SUBREPO"
+  git hub repo "$SUBREPO"
+  cat "$SUBDIR/.gitrepo"
+  git subrepo push "$SUBDIR"
+  git subrepo status "$SUBDIR"
+  git hub clone "$SUBREPO"
+  [[ -e "$SUBREPODIR/decode.t" ]] && echo PASS || echo FAIL
+)
+(
+  cd "$REPODIR"
+  git subrepo init test
+  git hub repo-new "$SUBREPO"
+  git hub repo "$SUBREPO"
+  cat "$SUBDIR/.gitrepo"
+  git subrepo push -u "$SUBDIR" -r "git@github.com:$SUBREPO" -b foo
+  git subrepo status "$SUBDIR"
+  git hub clone "$SUBREPO"
+  [[ -e "$SUBREPODIR/decode.t" ]] && echo PASS || echo FAIL
+  bash -i
+)

data/sub/eac_git/vendor/git-subrepo/note/pull-dance.txt

@@ -0,0 +1,18 @@
+== Pull Dancing
+
+(
+    git sr pull --rebase ext/bar
+)
+
+(
+    git sr checkout ext/bar --rebase
+    make test
+    git sr pull --continue
+)
+
+(
+    git sr checkout ext/bar
+    git rebase subrepo/remote/ext/bar
+    make test
+    git sr pull --continue
+)

data/sub/eac_git/vendor/git-subrepo/note/recreate-rebase-conflict.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+set -e
+set -x
+
+# Make a directory to work in:
+{
+  ROOT=${BASH_SOURCE%.sh}
+  [ -n "$ROOT" ] || exit 1
+  rm -fr "$ROOT"
+  mkdir "$ROOT"
+}
+
+(
+  cd "$ROOT"
+
+  # Start a new repo:
+  git init
+
+  # Make an empty file called `file`:
+  touch file
+  git add file
+
+  # Make 3 commits to `file`:
+  for n in {1..3}; do
+    echo "Line $n" >> file
+    git commit -a -m "Commit #$n"
+  done
+
+  # Now `file` has 3 lines.
+
+  # Make a new branch with one commit where the file has 3 lines:
+  git checkout --orphan subrepo-fake
+  git commit -a -m 'Initial commit on subrepo-fake branch'
+
+  # Return to master and lop off the last commit, so that the `file` has 2
+  # lines (and 2 commits):
+  git checkout master
+  git reset --hard HEAD^
+
+  # Now we rebase like `git subrepo push` does where master is the upstream
+  # with 2 commits, and `subrepo-fake` is our fake subrepo branch with one
+  # commit:
+  git rebase master subrepo-fake || true
+
+  # Command fails on conflict but `|| true` prevents `set -e` from stopping
+  # here.
+
+  # Show the current branch status:
+  git status
+
+  # Show the rebase conflict:
+  cat file
+
+  # This is exactly what is happening with a `git subrepo push`.
+)

data/sub/eac_git/vendor/git-subrepo/note/subtree-rebase-fail-example/test.bash

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -ex
+
+rm -fr repo{1,2,3}
+mkdir repo{1,2}
+(
+  cd repo1/
+  git init
+  touch foo
+  git add foo
+  git commit -m "First commit"
+)
+(
+  cd repo2
+  git init
+  touch bar
+  git add bar
+  git commit -m "add bar"
+)
+git clone repo1 repo3
+(
+  cd repo3/
+  git subrepo clone ../repo2 subrepo
+  bash
+  git rebase -i HEAD^
+  git log -p 
+  ls
+)

data/sub/eac_git/vendor/git-subrepo/note/test-subrepo-push.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+set -ex
+
+# Make a directory to work in:
+{
+  ROOT=${BASH_SOURCE%.sh}
+  [ -n "$ROOT" ] || exit 1
+  rm -fr "$ROOT"
+  mkdir "$ROOT"
+}
+
+(
+  cd "$ROOT"
+
+  # Create "bare" repos to act as pushable upstreams
+  git init --bare parent-upstream
+  git init --bare child-upstream
+
+  # Clone the upstreams into local repos
+  git clone parent-upstream parent
+  git clone child-upstream child
+
+  (
+    cd parent
+    echo 'Initial parent commit' > parent.txt
+    git add parent.txt
+    git commit -m 'initial parent commit'
+    git push
+  )
+
+  (
+    cd child
+    echo 'Initial child commit' > child.txt
+    git add child.txt
+    git commit -m 'Initial child commit'
+    git push
+  )
+
+  (
+    cd parent
+    git subrepo clone ../child-upstream childrepo
+  )
+
+  (
+    cd child
+    echo 'Commit from child' >> child.txt
+    git commit -a -m 'commit from child'
+    git push
+  )
+
+  (
+    cd parent
+    git subrepo pull childrepo
+  )
+
+  (
+    cd parent
+    echo 'Commit from parent for pushing' >> childrepo/child.txt
+    echo 'Commit from parent for pushing' >> parent.txt
+    git commit -a -m 'Commit from parent for pushing'
+    git push
+  )
+
+  (
+    cd parent
+    git subrepo push childrepo -d || bash -i
+  )
+)

data/sub/eac_git/vendor/git-subrepo/note/test.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+set -x
+
+# Take some random github repo
+repo=${1:-ingydotnet/boolean-pm}
+
+# Delete test dir
+rm -fr test-repo
+
+# Clone repo into test dir
+git clone "git@github.com:$repo" test-repo
+
+(
+  # cd into test-repo
+  cd test-repo
+  # Tag original head
+  git tag o
+  # Pick a commit in the middle of the commit history
+  S=$(git rev-parse HEAD^^^^)
+  # Reset to the middle commit
+  git reset --hard $S
+  # Tag that history as 'a'
+  git tag a
+  # Reset to original
+  git reset --hard o
+  # Take the tail of the history.
+  git filter-branch -f --parent-filter "sed 's/-p $S//'" $S..HEAD
+  # Mark that sequence as 'b'
+  git tag b
+  # Reset to a
+  git reset --hard a
+  # Add a commit
+  echo foobar >> README
+  git commit README -m 'a change'
+  # Tag as a2
+  git tag a2
+  # Find commits for top of 'a' and root of 'b'
+  A=$(git rev-parse a)
+  RB=$(git rev-list --max-parents=0 b)
+  # Graft them together
+  echo "$RB $A" >> .git/info/grafts
+
+  git rebase --abort; git rebase -s recursive -X patience a2 b
+#   # Make the graft permanent. ie join head+tail
+#   # The commits should rewrite to match original history
+#   git filter-branch -f $RB^..b
+#   # Get commits for new 'b' and original
+#   B=$(git rev-parse b)
+#   O=$(git rev-parse o)
+#   # Check to see if it works
+#   if [ "$B" == "$O" ]; then
+#     echo "It worked: $B"
+#   else
+#     echo "If failed: $B, $O"
+#   fi
+  bash
+)

data/sub/eac_git/vendor/git-subrepo/pkg/bin/generate-completion.pl

@@ -0,0 +1,210 @@
+#!/usr/bin/env perl
+
+use strict;
+# use XXX;
+
+sub main {
+    my ($cmd) = @_;
+    my $input = do { local $/; <> };
+    my $input2 = do { local $/; <> };
+    my ($options_spec) = $input2 =~ m/ ^ GETOPT_SPEC="\\ $ (.*?) ^ " $/xsm;
+    $options_spec =~ s/.*Options:\n--//s;
+
+    my @options;
+    for my $line (split m/\n/, $options_spec) {
+        next unless $line =~ m/\S/;
+        my $arg = 0;
+        my ($key, $desc) = split ' ', $line, 2;
+        if ($key =~ s/=$//) {
+            $arg = 1;
+        }
+        my @keys = split m/,/, $key;
+        push @options, { keys => \@keys, arg => $arg, desc => $desc };
+    }
+
+
+    $input =~ s/.*?\n= Commands\n//s;
+    $input =~ s/(.*?\n)==? .*/$1/s;
+    my @list;
+    my @subdir_cmds;
+    while ($input =~ s/.*?^- (.*?\n)(?=- |== |\z)//ms) {
+        my $text = $1;
+        $text =~ /\A(.*)\n/
+            or die "Bad text '$text'";
+        my $usage = $1;
+        $usage =~ s/\A`(.*)`\z/$1/
+            or die "Bad usage: '$text'";
+        my ($x1, $x2, $name) = split / +/, $usage;
+        push @list, $name;
+        if ($usage =~ m#\Q$name\E \[?<subdir>\]?# and $name ne "init") {
+            push @subdir_cmds, $name;
+        }
+    }
+    @subdir_cmds = sort @subdir_cmds;
+    @list = sort @list;
+
+    if ($cmd eq "bash") {
+        generate_bash(\@list, \@subdir_cmds, \@options);
+    }
+    else {
+        generate_zsh(\@list, \@subdir_cmds, \@options);
+    }
+
+}
+
+sub generate_zsh {
+    my ($list, $subdir_cmds, $options) = @_;
+    my $options_string = '';
+    for my $opt (@$options) {
+        my $keys = $opt->{keys};
+        my $desc = $opt->{desc};
+        $desc =~ s/'/'"'"'/g;
+        # examples:
+        #'(-c --count)'{-c,--count}'[Number of list items to show]:count' \
+        #'--remote[Remote name (like "origin")]:remote' \
+        my $arg = '';
+        if ($opt->{arg}) {
+            $arg = ":$keys->[0]";
+        }
+        my @keystrings = map { (length $_ > 1 ? "--" : "-") . $_ } @$keys;
+        if (@$keys == 1) {
+            $options_string .= sprintf "        '%s[%s]%s' \\\n",
+                $keystrings[0], $desc, $arg;
+        }
+        elsif (@$keys > 1) {
+            $options_string .= sprintf "        '(%s)'{%s}'[%s]%s' \\\n",
+                (join ' ', @keystrings), (join ',', @keystrings), $desc, $arg;
+        }
+    }
+    print <<'...';
+#compdef git-subrepo -P git\ ##subrepo
+#description perform git-subrepo operations
+
+# DO NOT EDIT. This file generated by pkg/bin/generate-completion.pl.
+
+if [[ -z $GIT_SUBREPO_ROOT ]]; then
+	echo 'GIT_SUBREPO_ROOT is null; has `/path/to/git-subrepo/.rc` been sourced?'
+	return 3
+fi
+
+_git-subrepo() {
+    typeset -A opt_args
+    local curcontext="$curcontext" state line context
+
+    _arguments -s \
+        '1: :->subcmd' \
+        '*: :->args' \
+...
+    print <<"...";
+$options_string && ret=0
+
+    case \$state in
+    subcmd)
+        compadd @$list
+    ;;
+
+    args)
+        case \$line[1] in
+
+        clone)
+            _arguments -C \\
+                '1: :->subcmd' \\
+                '2: :->repo' \\
+                '*: :->subdir' \\
+                    && ret=0
+                case \$state in
+                subdir|repo)
+                    _files
+                ;;
+                esac
+        ;;
+
+        @{[ join '|', @$subdir_cmds ]})
+            _compadd_subdirs
+        ;;
+
+        init)
+            _files
+        ;;
+
+        help)
+            compadd @$list
+        ;;
+        esac
+    ;;
+    esac
+
+\}
+
+_compadd_subdirs() {
+    local subrepos
+    IFS=\$'\\n' set -A subrepos `git subrepo status -q`
+    compadd -X "subrepos: " \$subrepos
+}
+...
+}
+
+sub generate_bash {
+
+    my ($list, $subdir_cmds, $options, $complete_fetch_limit) = @_;
+    my $options_string = '';
+    for my $opt (@$options) {
+        my $keys = $opt->{keys};
+        my $arg = '';
+        if ($opt->{arg}) {
+            $arg = "=";
+        }
+        my @keystrings = map { (length $_ > 1 ? "--" : "-") . $_ } @$keys;
+        for my $key (@keystrings) {
+            $options_string .= " $key$arg";
+        }
+    }
+
+    print <<"...";
+#!bash
+
+# DO NOT EDIT. This file generated by pkg/bin/generate-completion.pl.
+
+_git_subrepo() {
+    local _opts="$options_string"
+    local subcommands="@$list"
+    local subdircommands="@$subdir_cmds"
+    local subcommand="\$(__git_find_on_cmdline "\$subcommands")"
+
+    if [ -z "\$subcommand" ]; then
+        # no subcommand yet
+        case "\$cur" in
+        -*)
+            __gitcomp "\$_opts"
+        ;;
+        *)
+            __gitcomp "\$subcommands"
+        esac
+
+    else
+
+        case "\$cur" in
+        -*)
+            __gitcomp "\$_opts"
+            return
+        ;;
+        esac
+
+        if [[ "\$subcommand" == "help" ]]; then
+            __gitcomp "\$subcommands"
+            return
+        fi
+
+        local subdircommand="\$(__git_find_on_cmdline "\$subdircommands")"
+        if [ ! -z "\$subdircommand" ]; then
+            local git_subrepos=`git subrepo status -q`
+            __gitcomp "\$git_subrepos"
+        fi
+
+    fi
+}
+...
+
+}
+
+main(shift);