eac_tools 0.84.2 → 0.85.1

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

@@ -1,137 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,38 +0,0 @@
-#!/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

@@ -1,18 +0,0 @@
-== 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

@@ -1,56 +0,0 @@
-#!/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

@@ -1,29 +0,0 @@
-#!/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

@@ -1,69 +0,0 @@
-#!/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

@@ -1,58 +0,0 @@
-#!/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

@@ -1,210 +0,0 @@
-#!/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);