libv8 8.4.255.0

data/vendor/depot_tools/man/src/git-mark-merge-base.txt

@@ -0,0 +1,46 @@
+git-mark-merge-base(1)
+======================
+
+NAME
+----
+git-mark-merge-base -
+include::_git-mark-merge-base_desc.helper.txt[]
+
+SYNOPSIS
+--------
+[verse]
+'git mark-merge-base'
+'git mark-merge-base' <commit hash>
+'git mark-merge-base' [-d | --delete]
+
+DESCRIPTION
+-----------
+
+Inspect, set or delete the current merge-base marker for the current branch.
+This should not be needed, but is useful if things get into a snarled state.
+Pass no arguments to view the current value. If you provide <commit hash>, then
+`git mark-merge-base` will attempt to set that as the merge-base value.
+
+It is invalid to pick a commit which is not an ancestor of the current branch.
+
+See linkgit:git-rebase-update[1]'s description of the `branch.<name>.base`
+configuration variable for more info on what the merge base markers are for.
+
+OPTIONS
+-------
+
+-d::
+--delete::
+  Delete the merge-base marker for the current branch.
+
+<commit hash>::
+  The new value to set for the current branch's merge-base marker.
+
+SEE ALSO
+--------
+linkgit:git-rebase-update[1], linkgit:git-reparent-branch[1],
+linkgit:git-rename-branch[1], linkgit:git-upstream-diff[1]
+
+include::_footer.txt[]
+
+// vim: ft=asciidoc:

data/vendor/depot_tools/man/src/git-nav-downstream.demo.1.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+. demo_repo.sh
+
+silent git checkout origin/master
+
+run git map-branches
+pcommand git nav-downstream
+git nav-downstream --pick 0 2>&1
+run git map-branches
+run git nav-downstream  2>&1
+run git map-branches
+

data/vendor/depot_tools/man/src/git-nav-downstream.txt

@@ -0,0 +1,40 @@
+git-nav-downstream(1)
+=====================
+
+NAME
+----
+git-nav-downstream -
+include::_git-nav-downstream_desc.helper.txt[]
+
+SYNOPSIS
+--------
+[verse]
+'git nav-downstream'
+
+DESCRIPTION
+-----------
+
+'git-nav-downstream' takes the current branch and discovers all branches
+downstream of it. If there is only one branch downstream of the current branch,
+the command will check that out. If there\'s more than one downstream branch, the
+command will prompt you with a selection of the branches.
+
+EXAMPLE
+-------
+demo:1[]
+
+include::_aliases.txt[]
+
+----
+[alias]
+  git down = nav-downstream
+----
+
+
+SEE ALSO
+--------
+linkgit:git-map-branches[1], linkgit:git-nav-upstream[1]
+
+include::_footer.txt[]
+
+// vim: ft=asciidoc:

data/vendor/depot_tools/man/src/git-nav-upstream.demo.1.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+. demo_repo.sh
+
+silent git checkout subfeature
+
+run git map-branches
+run git nav-upstream  2>&1
+run git map-branches
+callout 3
+run git nav-upstream  2>&1
+run git map-branches
+

data/vendor/depot_tools/man/src/git-nav-upstream.txt

@@ -0,0 +1,39 @@
+git-nav-upstream(1)
+=====================
+
+NAME
+----
+git-nav-upstream -
+include::_git-nav-upstream_desc.helper.txt[]
+
+SYNOPSIS
+--------
+[verse]
+'git nav-upstream'
+
+DESCRIPTION
+-----------
+
+'git-nav-upstream' takes the current branch, finds it\'s upstream branch, and
+checks that out.
+
+EXAMPLE
+-------
+demo:1[]
+1. Note that being in a 'detached HEAD' state is OK. You'll just want to create
+a linkgit:git-new-branch[1] from here.
+
+include::_aliases.txt[]
+
+----
+[alias]
+  git up = nav-upstream
+----
+
+SEE ALSO
+--------
+linkgit:git-map-branches[1], linkgit:git-nav-downstream[1]
+
+include::_footer.txt[]
+
+// vim: ft=asciidoc:

data/vendor/depot_tools/man/src/git-new-branch.demo.1.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+. demo_repo.sh
+
+run git map-branches -v
+run git new-branch independent_cl
+run git map-branches -v
+praw vi foo \&\& git add -A \&\& git commit -m 'foo'
+silent echo 'foo' >foo
+silent git add -A
+silent git commit -m 'foo'
+run git map-branches -v
+run git new-branch --upstream subfeature nested_cl
+callout 3
+run git map-branches -v
+run git checkout cool_feature 2>&1
+run git new-branch --upstream_current cl_depends_on_cool_feature
+run git map-branches -v

data/vendor/depot_tools/man/src/git-new-branch.txt

@@ -0,0 +1,82 @@
+git-new-branch(1)
+=================
+
+NAME
+----
+git-new-branch -
+include::_git-new-branch_desc.helper.txt[]
+
+SYNOPSIS
+--------
+[verse]
+'git new-branch' <branch_name>
+'git new-branch' --upstream_current <branch_name>
+'git new-branch' --upstream <REF> <branch_name>
+'git new-branch' --lkgr <branch_name>
+
+DESCRIPTION
+-----------
+
+Creates a new branch. By default the new branch will track the configured
+upstream for the repo (defaults to 'origin/master'). If one of the other options
+is specified, it will track that other ref instead.
+
+Conceptually, each branch in your repo represents one 'Change List (CL)'. If you
+have many independent CLs (i.e. the changes in one do not interact with/depend
+on the changes in another), then you should create them as new branches tracking
+the default upstream (i.e. `git new-branch <branch_name>`). If you have features
+which depend on each other, you should create stacked branches using `git
+new-branch --upstream_current <branch_name>`.
+
+OPTIONS
+-------
+
+--upstream_current::
+  Set the tracking (upstream) branch to the currently-checked-out branch.
+
+--upstream <REF>::
+  Set the tracking (upstream) branch to <REF>. <REF> may be a local branch,
+  remote branch, or a tag.
+
+--lkgr::
+  Alias for `--upstream lkgr`.
+
+<branch_name>::
+  The name for the new branch.
+
+
+CONFIGURATION VARIABLES
+-----------------------
+
+depot-tools.upstream
+~~~~~~~~~~~~~~~~~~~~
+
+This configures the default 'upstream' for all new branches. If it is unset, it
+defaults to 'origin''s default branch or 'origin/master' if that can't be found.
+This is considered to be the 'root' branch.
+
+EXAMPLE
+-------
+demo:1[]
+
+1. Note that both branches are cyan because they are currently the same
+'commit' object. See linkgit:git-map-branches[1] for more detail.
+
+include::_aliases.txt[]
+
+----
+[alias]
+  git nb = new-branch
+  git tb = new-branch --upstream_current  <1>
+----
+<1> mnemonic: tb -> "track branch"
+
+
+SEE ALSO
+--------
+linkgit:git-rebase-update[1], linkgit:git-reparent-branch[1],
+linkgit:git-rename-branch[1], linkgit:git-upstream-diff[1]
+
+include::_footer.txt[]
+
+// vim: ft=asciidoc:

data/vendor/depot_tools/man/src/git-rebase-update.txt

@@ -0,0 +1,141 @@
+git-rebase-update(1)
+====================
+
+NAME
+----
+git-rebase-update -
+include::_git-rebase-update_desc.helper.txt[]
+
+SYNOPSIS
+--------
+[verse]
+'git rebase-update' [-v | --verbose] [-n | --no-fetch] [-k | --keep-going]
+
+DESCRIPTION
+-----------
+
+Brings all branches up-to-date with their tracking branches. This involves
+several phases:
+
+Preparation::
+  If you currently have a branch checked out, any changes on that branch are
+  'frozen' (See linkgit:git-freeze[1] for more detail). Additionally, the current
+  branch is recorded for the 'Restoration' phase later (see 'CONFIGURATION
+  VARIABLES' for details on `depot-tools.rebase-update.starting-branch`).
+
+Fetching::
+  All branches are examined to find their upstream references. The correct set
+  of git remotes is determined, and fetched accordingly. Note that if any
+  branches have a tag as their upstream, we are forced to pull all remotes.
++
+Pass `--no-fetch` to skip this phase.
+
+Rebasing::
+  All branches are rebased in topological order from roots (upstreams) to
+  leaves.  Each branch is rebased from its marked merge-base (see 'CONFIGURATION
+  VARIABLES') to the branch tip on top of its parent branch. If the parent
+  branch is 'frozen' (see linkgit:git-freeze[1]), the branch will be rebased
+  onto the last non-freeze commit on the parent branch.
++
+Things get interesting when there are merge conflicts on rebase. The *most
+common* cause for conflicts is when your branch has been committed to the
+upstream in squashed form, ala linkgit:git-squash-branch[1], which is what
+linkgit:git-cl[1] and the 'Commit Queue' will do. Because of that, `git
+rebase-update` will attempt to squash your conflicted branch to see if the
+squashed version applies cleanly to its upstream.
++
+If it does not apply cleanly, then your original (non-squashed) branch will be
+left in mid-rebase and `git rebase-update` will exit. You can deal with this
+like any other conflicted rebase. When you're done, just `git rebase-update`
+again to pick up where you left off.
+
+If you'd like to rebase all rebaseable branches in one pass and manually process
+the unrebaseable ones later, use -k or --keep-going. Cleanup will not happen
+until all branches apply cleanly.
+
+Cleanup::
+  Once all the branches have been rebased, any empty branches (i.e. branches
+  with no commits on them) are removed. If a branch is removed in this fashion,
+  any branches which depend on it are reparented to the parent of the removed
+  branch (see linkgit:git-reparent-branch[1]).
+
+Restoration::
+  `git rebase-update` checks out the branch that you started on, and 'thaws' it,
+  if necessary (see linkgit:git-thaw[1]). If the branch you started on got
+  cleaned up, `git rebase-update` will checkout the 'root' ref (defaults to
+  'origin''s default branch, as configured by `depot-tools.upstream`, see
+  linkgit:git-new-branch[1]).
+
+
+OPTIONS
+-------
+
+-k::
+--keep-going::
+  Keep processing past failed rebases.
+
+-n::
+--no-fetch::
+  Skip the `git fetch` phase of rebase-update.
+
+-v::
+--verbose::
+  More text than your terminal can handle.
+
+--current::
+  Only rebase the current branch.
+
+
+CONFIGURATION VARIABLES
+-----------------------
+
+depot-tools.rebase-update.starting-branch
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When `git rebase-update` first runs, it will record the current branch here so
+that when it completes successfully, it will return back to the same branch you
+started on, even if `git rebase-update` is interrupted due to rebase conflicts.
+When `git rebase-update` completes successfully, this configuration variable is
+removed.
+
+branch.<name>.dormant
+~~~~~~~~~~~~~~~~~~~~~
+
+If `true`, will cause rebase-update to skip all processing on the branch.
+Useful for old/high-conflict branches which you want to keep for posterity, but
+don't want to deal with when running `git rebase-update`
+
+branch.<name>.base
+~~~~~~~~~~~~~~~~~~
+
+Holds the 'base' reference for this branch. By default this is equivalent to
+`git merge-base <name> <name>@{upstream}`. However, it can diverge if
+`<name>@{upstream}` is manually rebased. In this case, it correctly preserves
+the value it had before, where `git merge-base` would now report the wrong
+value.
+
+All of the tools in the linkgit:depot_tools[1] suite collude to keep this value
+as up-to-date as possible, including linkgit:git-reparent-branch[1], and
+linkgit:git-new-branch[1]. linkgit:git-map[1] also shows the location of these
+marker values in [black-background white]**white**.
+
+linkgit:git-mark-merge-base[1] allows easy manual interaction for this value,
+in the unlikely event that it gets out of sync.
+
+include::_aliases.txt[]
+
+----
+[alias]
+  git reup = rebase-update
+----
+
+
+SEE ALSO
+--------
+linkgit:git-new-branch[1], linkgit:git-reparent-branch[1],
+linkgit:git-rename-branch[1], linkgit:git-upstream-diff[1],
+linkgit:git-freeze[1], linkgit:git-mark-merge-base[1]
+
+include::_footer.txt[]
+
+// vim: ft=asciidoc:

data/vendor/depot_tools/man/src/git-rename-branch.txt

@@ -0,0 +1,28 @@
+git-rename-branch(1)
+====================
+
+NAME
+----
+git-rename-branch -
+include::_git-rename-branch_desc.helper.txt[]
+
+SYNOPSIS
+--------
+[verse]
+'git rename-branch' <new_name>
+'git rename-branch' <old_name> <new_name>
+
+DESCRIPTION
+-----------
+
+Rename the current (or specified) branch, then update all dowstream branches'
+tracking information to preserve inter-branch dependencies.
+
+SEE ALSO
+--------
+linkgit:git-rebase-update[1], linkgit:git-reparent-branch[1],
+linkgit:git-new-branch[1], linkgit:git-upstream-diff[1]
+
+include::_footer.txt[]
+
+// vim: ft=asciidoc:

data/vendor/depot_tools/man/src/git-reparent-branch.txt

@@ -0,0 +1,61 @@
+git-reparent-branch(1)
+=====================
+
+NAME
+----
+git-reparent-branch -
+include::_git-reparent-branch_desc.helper.txt[]
+
+SYNOPSIS
+--------
+[verse]
+'git reparent-branch' <new_parent>
+'git reparent-branch' --lkgr
+'git reparent-branch' --root
+
+DESCRIPTION
+-----------
+
+Change the 'upstream' of the current branch, and then run
+linkgit:git-rebase-update[1] to move the commits in the current branch, as well
+as the commits in all descendant branches, onto the new parent.
+
+`<new_parent>` may be either a local branch, remote branch, OR a tag (such as
+`lkgr`).
+
+This is particularly useful to reparent an independent CL to become dependent on
+another CL, or vice versa. This could happen if you started both on the
+assumption that they were independent, but later realized that this was not the
+case.
+
+
+OPTIONS
+-------
+
+<new_parent>::
+  The new parent to set as the upstream for this branch. May be a branch ref or
+  a tag.
+
+--lkgr::
+  Reparent to track lkgr.
+
+--root::
+  Reparent to track the 'root' branch. Defaults to 'origin/master'. See
+  linkgit:git-new-branch[1]'s CONFIGURATION VARIABLES section..
+
+
+include::_aliases.txt[]
+
+----
+[alias]
+  git rp = reparent-branch
+----
+
+SEE ALSO
+--------
+linkgit:git-rebase-update[1], linkgit:git-rename-branch[1],
+linkgit:git-new-branch[1], linkgit:git-upstream-diff[1]
+
+include::_footer.txt[]
+
+// vim: ft=asciidoc: