+sub git_check_unmodified () {
+ foreach my $cached (qw(0 1)) {
+ my @cmd = qw(git diff --quiet);
+ push @cmd, qw(--cached) if $cached;
+ push @cmd, qw(HEAD);
+ debugcmd "+",@cmd;
+ $!=0; $?=-1; system @cmd;
+ return if !$?;
+ if ($?==256) {
+ fail
+ $cached
+ ? __ "git index contains changes (does not match HEAD)"
+ : __ "working tree is dirty (does not match HEAD)";
+ } else {
+ failedcmd @cmd;
+ }
+ }
+}
+
+sub upstream_commitish_search ($$) {
+ my ($upstream_version, $tried) = @_;
+ # todo: at some point maybe use git-deborig to do this
+ foreach my $tagpfx ('', 'v', 'upstream/') {
+ my $tag = $tagpfx.(dep14_version_mangle $upstream_version);
+ my $new_upstream = git_get_ref "refs/tags/$tag";
+ push @$tried, $tag;
+ return $new_upstream if length $new_upstream;
+ }
+}
+
+sub resolve_upstream_version ($$) {
+ my ($new_upstream, $upstream_version) = @_;
+
+ my $used = $new_upstream;
+ my $message = __ 'using specified upstream commitish';
+ if (!defined $new_upstream) {
+ my @tried;
+ $new_upstream = upstream_commitish_search $upstream_version, \@tried;
+ if (!length $new_upstream) {
+ fail f_
+ "Could not determine appropriate upstream commitish.\n".
+ " (Tried these tags: %s)\n".
+ " Check version, and specify upstream commitish explicitly.",
+ "@tried";
+ }
+ $used = $tried[-1];
+ $message = f_ 'using upstream from git tag %s', $used;
+ } elsif ($new_upstream =~ m{^refs/tags/($versiontag_re)$}s) {
+ $message = f_ 'using upstream from git tag %s', $1;
+ $used = $1;
+ }
+ $new_upstream = git_rev_parse $new_upstream;
+
+ return ($new_upstream, $used, $message);
+ # used is a human-readable idea of what we found
+}
+
+sub is_fast_fwd ($$) {
+ my ($ancestor,$child) = @_;
+ my @cmd = (qw(git merge-base), $ancestor, $child);
+ my $mb = cmdoutput_errok @cmd;
+ if (defined $mb) {
+ return git_rev_parse($mb) eq git_rev_parse($ancestor);
+ } else {
+ $?==256 or failedcmd @cmd;
+ return 0;
+ }
+}
+
+sub git_reflog_action_msg ($) {
+ my ($msg) = @_;
+ my $rla = $ENV{GIT_REFLOG_ACTION};
+ $msg = "$rla: $msg" if length $rla;
+ return $msg;
+}
+
+sub git_update_ref_cmd {
+ # returns qw(git update-ref), qw(-m), @_
+ # except that message may be modified to honour GIT_REFLOG_ACTION
+ my $msg = shift @_;
+ $msg = git_reflog_action_msg $msg;
+ return qw(git update-ref -m), $msg, @_;
+}
+
+sub rm_subdir_cached ($) {
+ my ($subdir) = @_;
+ runcmd qw(git rm --quiet -rf --cached --ignore-unmatch), $subdir;
+}
+
+sub read_tree_subdir ($$) {
+ my ($subdir, $new_tree_object) = @_;
+ # If $new_tree_object is '', the subtree is deleted.
+ confess unless defined $new_tree_object;
+ rm_subdir_cached $subdir;
+ runcmd qw(git read-tree), "--prefix=$subdir/", $new_tree_object
+ if length $new_tree_object;
+}
+
+sub read_tree_debian ($) {
+ my ($treeish) = @_;
+ read_tree_subdir 'debian', "$treeish:debian";
+ rm_subdir_cached 'debian/patches';
+}
+
+sub read_tree_upstream ($;$$) {
+ my ($treeish, $keep_patches, $tree_with_debian) = @_;
+ # if $tree_with_debian is supplied, will use that for debian/
+ # otherwise will save and restore it. If $tree_with_debian
+ # is '' then debian/ is deleted.
+ my $debian =
+ defined $tree_with_debian ? "$tree_with_debian:debian"
+ : cmdoutput qw(git write-tree --prefix=debian/);
+ runcmd qw(git read-tree), $treeish;
+ read_tree_subdir 'debian', $debian;
+ rm_subdir_cached 'debian/patches' unless $keep_patches;
+}
+
+sub changedir ($) {
+ my ($newdir) = @_;
+ printdebug "CD $newdir\n";
+ chdir $newdir or confess "chdir: $newdir: $!";
+}
+
+sub git_slurp_config_src ($) {
+ my ($src) = @_;
+ # returns $r such that $r->{KEY}[] = VALUE
+ my @cmd = (qw(git config -z --get-regexp), "--$src", qw(.*));
+ debugcmd "|",@cmd;
+
+ local ($debuglevel) = $debuglevel-2;
+ local $/="\0";
+
+ my $r = { };
+ open GITS, "-|", @cmd or confess "$!";
+ while (<GITS>) {
+ chomp or confess;
+ printdebug "=> ", (messagequote $_), "\n";
+ m/\n/ or confess "$_ ?";
+ push @{ $r->{$`} }, $'; #';
+ }
+ $!=0; $?=0;
+ close GITS
+ or ($!==0 && $?==256)
+ or failedcmd @cmd;
+ return $r;
+}
+
+sub gdr_ffq_prev_branchinfo ($) {
+ my ($symref) = @_;
+ # => ('status', "message", [$symref, $ffq_prev, $gdrlast])
+ # 'status' may be
+ # branch message is undef
+ # weird-symref } no $symref,
+ # notbranch } no $ffq_prev
+ return ('detached', __ 'detached HEAD') unless defined $symref;
+ return ('weird-symref', __ 'HEAD symref is not to refs/')
+ unless $symref =~ m{^refs/};
+ my $ffq_prev = "refs/$ffq_refprefix/$'";
+ my $gdrlast = "refs/$gdrlast_refprefix/$'";
+ printdebug "ffq_prev_branchinfo branch current $symref\n";
+ return ('branch', undef, $symref, $ffq_prev, $gdrlast);
+}
+
+sub parsecontrolfh ($$;$) {
+ my ($fh, $desc, $allowsigned) = @_;
+ our $dpkgcontrolhash_noissigned;
+ my $c;
+ for (;;) {
+ my %opts = ('name' => $desc);
+ $opts{allow_pgp}= $allowsigned || !$dpkgcontrolhash_noissigned;
+ $c = Dpkg::Control::Hash->new(%opts);
+ $c->parse($fh,$desc) or fail f_ "parsing of %s failed", $desc;
+ last if $allowsigned;
+ last if $dpkgcontrolhash_noissigned;
+ my $issigned= $c->get_option('is_pgp_signed');
+ if (!defined $issigned) {
+ $dpkgcontrolhash_noissigned= 1;
+ seek $fh, 0,0 or confess "seek $desc: $!";
+ } elsif ($issigned) {
+ fail f_
+ "control file %s is (already) PGP-signed. ".
+ " Note that dgit push needs to modify the .dsc and then".
+ " do the signature itself",
+ $desc;
+ } else {
+ last;
+ }
+ }
+ return $c;
+}
+
+sub parsecontrol {
+ my ($file, $desc, $allowsigned) = @_;
+ my $fh = new IO::Handle;
+ open $fh, '<', $file or fail f_ "open %s (%s): %s", $file, $desc, $!;
+ my $c = parsecontrolfh($fh,$desc,$allowsigned);
+ $fh->error and confess "$!";
+ close $fh;
+ return $c;
+}
+
+sub parsechangelog {
+ my $c = Dpkg::Control::Hash->new(name => 'parsed changelog');
+ my $p = new IO::Handle;
+ my @cmd = (qw(dpkg-parsechangelog), @_);
+ open $p, '-|', @cmd or confess "$!";
+ $c->parse($p);
+ $?=0; $!=0; close $p or failedcmd @cmd;
+ return $c;
+}
+
+sub getfield ($$) {
+ my ($dctrl,$field) = @_;
+ my $v = $dctrl->{$field};
+ return $v if defined $v;
+ fail f_ "missing field %s in %s", $field, $dctrl->get_option('name');
+}
+
+sub parsechangelog_loop ($$$) {
+ my ($clogcmd, $descbase, $fn) = @_;
+ # @$clogcmd is qw(dpkg-parsechangelog ...some...options...)
+ # calls $fn->($thisstanza, $desc);
+ debugcmd "|",@$clogcmd;
+ open CLOGS, "-|", @$clogcmd or confess "$!";
+ for (;;) {
+ my $stanzatext = do { local $/=""; <CLOGS>; };
+ printdebug "clogp stanza ".Dumper($stanzatext) if $debuglevel>1;
+ last if !defined $stanzatext;
+
+ my $desc = "$descbase, entry no.$.";
+ open my $stanzafh, "<", \$stanzatext or confess;
+ my $thisstanza = parsecontrolfh $stanzafh, $desc, 1;
+
+ $fn->($thisstanza, $desc);
+ }
+ confess "$!" if CLOGS->error;
+ close CLOGS or $?==SIGPIPE or failedcmd @$clogcmd;
+}
+
+sub make_commit ($$) {
+ my ($parents, $message_paras) = @_;
+ my $tree = cmdoutput qw(git write-tree);
+ my @cmd = (qw(git commit-tree), $tree);
+ push @cmd, qw(-p), $_ foreach @$parents;
+ push @cmd, qw(-m), $_ foreach @$message_paras;
+ return cmdoutput @cmd;
+}
+
+sub hash_commit ($) {
+ my ($file) = @_;
+ return cmdoutput qw(git hash-object -w -t commit), $file;
+}
+
+sub hash_commit_text ($) {
+ my ($text) = @_;
+ my ($out, $in);
+ my @cmd = (qw(git hash-object -w -t commit --stdin));
+ debugcmd "|",@cmd;
+ print Dumper($text) if $debuglevel > 1;
+ my $child = open2($out, $in, @cmd) or confess "$!";
+ my $h;
+ eval {
+ print $in $text or confess "$!";
+ close $in or confess "$!";
+ $h = <$out>;
+ $h =~ m/^\w+$/ or confess;
+ $h = $&;
+ printdebug "=> $h\n";
+ };
+ close $out;
+ waitpid $child, 0 == $child or confess "$child $!";
+ $? and failedcmd @cmd;
+ return $h;
+}
+
+sub reflog_cache_insert ($$$) {
+ my ($ref, $cachekey, $value) = @_;
+ # you must call this in $maindir
+ # you must have called record_maindir
+
+ # When we no longer need to support squeeze, use --create-reflog
+ # instead of this:
+ my $parent = $ref; $parent =~ s{/[^/]+$}{};
+ ensurepath "$maindir_gitcommon/logs", "$parent";
+ my $makelogfh = new IO::File "$maindir_gitcommon/logs/$ref", '>>'
+ or confess "$!";
+
+ my $oldcache = git_get_ref $ref;
+
+ if ($oldcache eq $value) {
+ my $tree = cmdoutput qw(git rev-parse), "$value:";
+ # git update-ref doesn't always update, in this case. *sigh*
+ my $authline = (ucfirst _us()).
+ ' <'._us().'@example.com> 1000000000 +0000';
+ my $dummy = hash_commit_text <<ENDU.(__ <<END);
+tree $tree
+parent $value
+author $authline
+committer $authline
+
+ENDU
+Dummy commit - do not use
+END
+ runcmd qw(git update-ref -m), _us()." - dummy", $ref, $dummy;
+ }
+ runcmd qw(git update-ref -m), $cachekey, $ref, $value;
+}
+
+sub reflog_cache_lookup ($$) {
+ my ($ref, $cachekey) = @_;
+ # you may call this in $maindir or in a playtree
+ # you must have called record_maindir
+ my @cmd = (qw(git log -g), '--pretty=format:%H %gs', $ref);
+ debugcmd "|(probably)",@cmd;
+ my $child = open GC, "-|"; defined $child or confess "$!";
+ if (!$child) {
+ chdir $maindir or confess "$!";
+ if (!stat "$maindir_gitcommon/logs/$ref") {
+ $! == ENOENT or confess "$!";
+ printdebug ">(no reflog)\n";
+ finish 0;
+ }
+ exec @cmd; die f_ "exec %s: %s\n", $cmd[0], $!;
+ }
+ while (<GC>) {
+ chomp;
+ printdebug ">| ", $_, "\n" if $debuglevel > 1;
+ next unless m/^(\w+) (\S.*\S)$/ && $2 eq $cachekey;
+ close GC;
+ return $1;
+ }
+ confess "$!" if GC->error;
+ failedcmd unless close GC;
+ return undef;
+}
+
+# ========== playground handling ==========
+
+# terminology:
+#
+# $maindir user's git working tree
+# playground area in .git/ where we can make files, unpack, etc. etc.
+# playtree git working tree sharing object store with the user's
+# inside playground, or identical to it
+#
+# other globals
+#
+# $local_git_cfg hash of arrays of values: git config from $maindir
+#
+# expected calling pattern
+#
+# firstly
+#
+# [record_maindir]
+# must be run in directory containing .git
+# assigns to $maindir if not already set
+# also calls git_slurp_config_src to record git config
+# in $local_git_cfg, unless it's already set
+#
+# fresh_playground SUBDIR_PATH_COMPONENTS
+# e.g fresh_playground 'dgit/unpack' ('.git/' is implied)
+# default SUBDIR_PATH_COMPONENTS is playground_subdir
+# calls record_maindir
+# sets up a new playground (destroying any old one)
+# returns playground pathname
+# caller may call multiple times with different subdir paths
+# createing different playgrounds
+#
+# ensure_a_playground SUBDIR_PATH_COMPONENTS
+# like fresh_playground except:
+# merely ensures the directory exists; does not delete an existing one
+#
+# then can use
+#
+# changedir playground
+# changedir $maindir
+#
+# playtree_setup
+# # ^ call in some (perhaps trivial) subdir of playground
+#
+# rmtree playground
+
+# ----- maindir -----
+
+our $local_git_cfg;
+
+sub record_maindir () {
+ if (!defined $maindir) {
+ $maindir = must_getcwd();
+ if (!stat "$maindir/.git") {
+ fail f_ "cannot stat %s/.git: %s", $maindir, $!;
+ }
+ if (-d _) {
+ # we fall back to this in case we have a pre-worktree
+ # git, which may not know git rev-parse --git-common-dir
+ $maindir_gitdir = "$maindir/.git";
+ $maindir_gitcommon = "$maindir/.git";
+ } else {
+ $maindir_gitdir = cmdoutput qw(git rev-parse --git-dir);
+ $maindir_gitcommon = cmdoutput qw(git rev-parse --git-common-dir);
+ }
+ }
+ $local_git_cfg //= git_slurp_config_src 'local';
+}
+
+# ----- playgrounds -----
+
+sub ensure_a_playground_parent ($) {
+ my ($spc) = @_;
+ record_maindir();
+ $spc = "$maindir_gitdir/$spc";
+ my $parent = dirname $spc;
+ mkdir $parent or $!==EEXIST or fail f_
+ "failed to mkdir playground parent %s: %s", $parent, $!;
+ return $spc;
+}
+
+sub ensure_a_playground ($) {
+ my ($spc) = @_;
+ $spc = ensure_a_playground_parent $spc;
+ mkdir $spc or $!==EEXIST or fail f_
+ "failed to mkdir a playground %s: %s", $spc, $!;
+ return $spc;
+}
+
+sub fresh_playground ($) {
+ my ($spc) = @_;
+ $spc = ensure_a_playground_parent $spc;
+ rmtree $spc;
+ mkdir $spc or fail f_
+ "failed to mkdir the playground %s: %s", $spc, $!;
+ return $spc;
+}
+
+# ----- playtrees -----
+
+sub playtree_setup () {
+ # for use in the playtree
+ # $maindir must be set, eg by calling record_maindir or fresh_playground
+ # this is confusing: we have
+ # . playtree, not a worktree, has .git/, our cwd
+ # $maindir might be a worktree so
+ # $maindir_gitdir contains our main working "dgit", HEAD, etc.
+ # $maindir_gitcommon the shared stuff, including .objects
+
+ # we need to invoke git-playtree-create via git because
+ # there may be config options it needs which are only available
+ # to us, sensibly, in @git
+
+ # And, we look for it in @INC too. This is a bit perverse.
+ # We do this because in the Debian packages we want to have
+ # a copy of this script in each binary package, rather than
+ # making yet another .deb or tangling the dependencies.
+ # @INC is conveniently available.
+ my $newpath = join ':', +(grep { !m/:/ } @INC),
+ '/usr/share/dgit', $ENV{PATH};
+ runcmd qw(env), "PATH=$newpath", @git, qw(playtree-create .);
+
+ ensuredir '.git/info';
+ open GA, "> .git/info/attributes" or confess "$!";
+ print GA "* $negate_harmful_gitattrs\n" or confess "$!";
+ close GA or confess "$!";
+}
+