avm-tools 0.50.0 → 0.51.0

data/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/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/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/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/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);

data/vendor/git-subrepo/pkg/bin/generate-help-functions.pl

@@ -0,0 +1,89 @@
+#!/usr/bin/env perl
+
+use strict;
+
+sub main {
+    my $input = do { local $/; <> };
+    $input =~ s/.*?\n= Commands\n//s;
+    $input =~ s/(.*?)\n= Command Options\n.*?\n==? .*/$1/s;
+    my @list;
+    while ($input =~ s/.*?^- (.*?)(?=\n- |\n== |\z)//ms) {
+        my $text = $1;
+        $text =~ /\A(.*)\n((?s:.*?))\n*\z/
+            or die "Bad text '$text'";
+        my ($usage, $desc) = ($1, $2);
+        $usage =~ s/\A`(.*)`\z/$1/
+            or die "Bad usage: '$text' '$usage' '$desc'";
+        $usage =~ s/^git subrepo //;
+        (my $name = $usage) =~ s/ .*//;
+        push @list, [$name, $usage, $desc];
+    }
+    @list = sort { $a->[0] cmp $b->[0] } @list;
+    write_start();
+    write_all_function(@list);
+    for my $item (@list) {
+        write_usage_function(@$item);
+    }
+    write_finish();
+}
+
+sub write_start {
+    print <<'...';
+#!/usr/bin/env bash
+
+# DO NOT EDIT. This file generated by pkg/bin/generate-help-functions.pl.
+
+set -e
+...
+}
+
+sub write_all_function {
+    my (@list) = @_;
+    my $out = '';
+    for my $item (@list) {
+        $out .= sprintf "%-20s %s\n", $item->[0], $item->[1];
+    }
+    chomp $out;
+    print <<"....";
+
+help:all() {
+    cat <<'...'
+$out
+...
+}
+....
+}
+
+sub write_usage_function {
+    my ($name, $usage, $desc) = @_;
+    print <<"....";
+
+help:$name() {
+    cat <<'...'
+
+  Usage: git subrepo $usage
+
+$desc
+...
+}
+....
+}
+
+sub write_help_function {
+    my ($name, $usage, $desc) = @_;
+}
+
+sub write_finish {
+    print <<'...';
+
+# vim: set sw=2 lisp:
+...
+}
+
+main;
+
+__END__
+Bad usage: '`help`
+  Show this manpage.
+' '' '  Show this manpage.' at tool/gerate-help-functions.pl line 15, <> line 1.
+