# -*- mode: org -*-
* v2.90.1   2018-11-16

- Added ~bug-reference-mode~ to ~git-commit-setup-hook~.  e19e8fb1e

- The "Version" column in ~magit-submodule-list-mode~ and
  ~magit-repolist-mode~ buffers now shows when a repository is dirty.
  0b86dbfd6

- Added new command ~magit-log-merged~.  This command requires
  ~git-when-merged~ (https://github.com/mhagger/git-when-merged).  It
  isn't bound in ~magit-log-popup~ by default.  To add it, you can use
  something like

  #+BEGIN_SRC emacs-lisp
    (magit-define-popup-action 'magit-log-popup
      ?m "Log commit's merge" 'magit-log-merged)
  #+END_SRC

  #3657

Bugfixes:

- Bumped the minimal required version of ~git-commit~ to the correct
  version.  e9bd33758

- Dropped the new "v" prefix that we started to add to release tags
  starting with the previous release in places where that prefix is
  undesirable.  f441cf6d7

- Staging and unstaging submodules while ~diff.submodule~'s value is ~log~
  broke shortly before the v2.90.0 release.  #3654

* v2.90.0   2018-11-08

Breaking changes:

- Dropped support for Emacs 24.4.  At least Emacs 25.1 is required
  now.

- Dropped support for Git 1.  At least Git 2.0.0 is required now.  The
  reason 2.0.0 is the new minimal version isn't its roundness but the
  discovery that some parts of Magit already depended on that release
  for two years.  Since we will soon drop support for versions before
  (probably) 2.4.0 anyway, we don't add a backward compatibility
  kludge for the feature that already requires 2.0.0 but instead bump
  the minimal version a first time.

- Many commands were renamed, making their names longer.  The old
  names are defined as aliases for now.  This is part one of a two
  part change.  In this release we rename, for example, ~magit-tag~ to
  ~magit-tag-create~ and in a later release ~magit-tag-popup~ will be
  renamed to ~magit-tag~.  #3619

- Removed many obsolete variable and function aliases.

- Removed many obsolete variables that are not mere aliases.

- Removed ~magit-section~ accessor functions.  Use the ~oref~ and ~oset~
  functions instead.

- The function ~magit-section-when~ has been deprecated in favor
  of ~magit-section-match~ or the new ~magit-section-value-if~.  The
  signatures of some related low-level functions have changed.  #3590

- The ~submodule~ section type has been renamed to ~module~, same for the
  plural variant and the related section-specific keymaps.  35f803c9c,
  59e3891fd

- Added a new function ~magit-completing-read-multiple*~, which is more
  like ~magit-completing-read~ than ~magit-completing-read-multiple~.
  Authors of extension should use the new function, which eventually
  will replace the old one.  cb4d59190

Changes:

- Added a new mode ~magit-wip-mode~, which enables automatic committing
  to work-in-progress refs whenever that makes sense.  Previously
  multiple ~magit-wip-*~ modes had to be enabled to accomplish the same.
  These modes still exist, the new mode is implemented on top of them,
  but their explicit use by the user is discouraged.  #3534

- Added a new option ~magit-wip-merge-branch~, which causes the current
  branch to be merged into its wip refs after creating a new commit on
  the current branch.  This isn't enabled by default yet because some
  additional tooling is required to deal with the fact that this
  prevents the wip refs from ever being garbage collected, and results
  in unwieldy commit graphs when history manipulation is involved.
  #3534

- Added new commands ~magit-wip-log-index~ and ~magit-wip-log-worktree~.
  #3534

- It is now possible to specify the major-mode used to edit commit
  messages on a per-repository basis.  The same major-mode is also
  used to prettify commit messages when displaying existing commit
  messages in ~magit-revision-mode~ buffers.

  To set the major-mode to be used for commit messages add an entry
  to the appropriate ~.dir-locals.el~ file using ~git-commit-mode~ as
  the key, as if that mode were a major-mode.  This can also be used
  to set other variables in the buffers used to /edit/ commit messages.

  If ~$GIT_WORK_TREE/.git~ is a file, then ~$GIT_WORK_TREE/.dir-locals.el~
  would normally not apply when editing a file inside ~$GIT_DIR~.  Magit
  uses it anyway unless ~$GIT_DIR/.dir-locals.el~ exists.

  55ba0534c, d7412da32, c5269547a

- Added a new major-mode ~git-commit-elisp-text-mode~ intended to be
  used when editing commit messages for Elisp projects.  It derives
  from ~text-mode~ and additionally highlights ~`symbols'~ and "strings".
  d7fa6632b

- Changed the order and the initial visibility of log sections in the
  status buffer to optimize for "usefulness".  Previously the focus
  was on making it more likely that the user did not ignore the less
  frequently useful logs, but that was quite annoying because it got
  in the way of the more frequently performed tasks.  #3518

- Added new option ~magit-status-initial-section~, which controls which
  section point is placed on when a status buffer is created.  The new
  default is to place point on the section that follows the headers,
  i.e., the second section.  This is quite flexible, you might want to
  read the doc-string.  87de83da8, #3562, #3518

- Added new commands ~magit-commit-absorb~ and ~magit-commit-absorb-popup~.
  These commands depend on the ~git-autofixup~ script, which is available
  from https://github.com/torbiak/git-autofixup.  #3053

- Began migrating from using section "types" to using section classes
  that can inherit from other classes.  #3590

- Removed many backward compatibility hacks, which are no longer
  necessary.

- Began to use features and many convenience functions that we
  couldn't use before because we still supported Emacs 24.4.

- ~magit-file-rename~ now reads the target from the same directory as
  the source.  This is more convenient because removing parts of the
  path is easier than adding them again.

- Added new ~magit-gitignore-popup~ and bound ~I~ to it, making it
  possible to use ~i~ for the ~magit-imerge-popup~ from the ~magit-imerge~
  package.

- Renamed the existing command ~magit-describe-section~ to
  ~magit-describe-section-briefly~ and added a new command
  ~magit-describe-section~, which pops up a ~*Help*~ buffer,
  which contains information about the function and hook
  used to insert the section.  #3539

- Added new ~magit-refname-pullreq~ face and a corresponding entry to
  ~magit-ref-namespaces~.

- Added new option ~magit-log-trace-definition-function~, which allows
  specifying the function that ~magit-log-trace-definition~ should use
  to determine the function at point.  The default is ~which-function~.
  Previously the less complete ~add-log-current-defun~ was used.
  #3483, 9ff266358

- fixup! and squash! are now highlighted like [keywords] in logs.
  426773040

- Added new stub commands ~magit-browse-thing~ and ~magit-edit-thing~.
  Like other ~magit-*-thing~ functions they are intend to be replaced
  in section-specific keymaps.  The ~forge~ package will use do so for
  these commands.  56fccaca6, 0fa3092eb

- In case they are bound when Magit is loaded then ~$GIT_DIR~ and
  ~$GIT_WORK_TREE~ are unset now.  Magit breaks if these variables are
  set and the most likely cause for them to be set is a user error.
  2d7d5d840

- ~magit-merge-into~ now only offers local branches for completion and
  defaults to the upstream.  If the upstream is a remote branch then
  it defaults to the respective local branch.  a52d70198

- It is now possible to set the face used to highlight the headings of
  certain sections using the new ~heading-highlight-face~ slot.  2319a1e0e

- The summary line of a commit message and the first line of notes are
  now emphasized more to make it more obvious what text is part of the
  commit message and what text was added by a note.  fda4b936c

- Detection of the branch at point was improved.  #3530

- Added new shortstat margin style for logs.  Performance isn't good
  yet, so you might want to avoid this for long logs.  #3035

- Added new variable ~magit-perl-executable~ for platforms that put ~perl~
  in unusual places.  We use ~perl~ for some one-liners that are embedded
  in lisp because we known that it is available because ~git~ depends on
  it.  #3538

- Added new command ~magit-reset-worktree~.  The existing ~magit-reset-*~
  commands already implemented the variants supported by ~git reset~,
  now Magit also implements the variant missing from that.  b4d5c2bee

- Improved ~magit-process-password-auth-source~'s entry matching.
  60a335e5c

- Added new hook ~magit-create-buffer~ hook.  2113dfc3d

- When the user "discards" a file with conflicts then they are asked
  which side of the conflict they want to keep.  When multiple files
  are selected, then it is now possible to decide for all of them at
  once.  #3553

- Added option ~--ignore-submodules~ to diff popups.  This option does
  not only affect diffs but also the dedicated module sections and can
  therefore be used to temporarily hide all information about modules,
  which can be expensive to calculate.  #3555, #3568

- Added ~--graph~ to the default value of ~magit-log-select-arguments~
  instead of hard-coding this argument for some of the users of the
  log-select machinery.  #3559

- The upstream of the current branch is no emphasized in logs, by
  default by making it italic.  #3573

- Added new command ~magit-submodule-remove~ and the new related option
  ~magit-submodule-remove-trash-gitdirs~.  The default is to not trash
  the gitdirs.  ~magit-submodule-add~ now offers to reuse an existing
  gitdir when re-adding a submodule.  #3585

- ~magit-submodule-add~ is run asynchronously now.  #3585

- Information about the running Git process is now also shown in the
  mode-line of buffers that were created after the process was
  started.  43264c873

- Rebase commands that continue a rebase sequence can now use ~git rbr~
  instead of ~git rebase~.  To initiate a rebase sequence using ~git rbr~
  you may use https://github.com/fanatoly/magit-rbr.  c2cd780b2

- The manual is now also available in epub format, but it isn't very
  pretty.  #3579

- Added new hooks ~magit-stage-hook~ and ~magit-unstage-hook~.  #3496

- Added new hook ~git-commit-post-finish-hook~, a hook that has been
  requested many times but which I did not implement before because it
  is impossible to make 100% reliable.  When the ~emacsclient~ returns,
  then that does not mean that the calling process is done too.  We
  avoid a race condition by waiting for ~HEAD~ to point to a different
  commit than it used to point to, before running the hook.  If it
  takes longer than a second for this to happen, then the hook is not
  run.  A few unsafe commands are also blacklisted because they
  perform other things after creating the commit and that would lead
  to another race condition.  #3615, d445a3d30, af4bf8df8

  This hook is used instead of ~with-editor-post-finish-hook~ (on which
  the former is build) to merge the current branch into its wip refs
  when ~magit-wip-merge-branch~ is non-nil.

- Added new hook ~magit-post-commit-hook~, which is only run after
  running a ~magit-commit-*~ command that does not require the user
  to edit the commit message.  #3615

- ~magit-format-patch~ can now be told to only include the changes to
  certain files in the patch.  It now also refreshes Magit buffers.
  #3601

- The list of related refs in ~magit-revision-mode~ buffers is no longer
  truncate when it doesn't fit on a single line.  Instead users can
  now specify the kinds of refs that should be inserted in such
  buffers using the option ~magit-revision-insert-related-refs~.  #3487

- Added new function ~magit-gitdir~ scheduled to replace ~magit-git-dir~
  eventually because the latter has a really strange signature.
  5f407a29a

- Created new libraries from existing code.  9efcb1e8b ff

- The option ~magit-revision-show-gravatar~ is now easier to customize.
  Customizing it to only show one of the two images actually works
  now.  f4b8fee66, b82228bc6

- The option ~magit-repository-directories~ has a non-nil default value
  now.  f77d1158b

- The list of stashes in the status buffer is initially collapsed now.
  4dc1d0593

- The commands ~magit-previous-line~ and ~magit-next-line~ are used by
  default now.  3ae75c865

- Added support for ~--left-right~ output in logs.  #3627

- Added new option ~magit-with-editor-envvar~.  Changing its value from
  ~GIT_EDITOR~ to ~GIT_SEQUENCE_EDITOR~ allows users to continue to use
  Magit (~git-rebase.el~ actually) to edit rebase sequence but to use
  another editor to edit commit messages and such.  #3629

- Added new option ~magit-clone-default-directory~.  #3635

- ~magit-ref-namespaces~ is now taken into account when colorizing
  branch names in buffers listing refs.  #3645

- Added new option ~magit-revision-fill-summary-line~.  #3610

Bugfixes:

- A confirmation prompt during rebase was wrong.  37d76f409

- ~magit-rebase-autosquash~ asked for confirmation when the user already
  confirmed earlier.  02e6c75b6

- ~magit-commit-add-log~ inserted after the diff that gets inserted if
  ~commit.verbose~ is ~true~.  #3480

- ~magit-log-wash-rev~ errored in ~magit-cherry-mode~, starting with Emacs
  26.1.

- ~magit-dired-jump~ failed, starting with Emacs 26.1.  #3469

- Magit used a completion function to make the built-in completion
  respect the collection's order.  Even though that wasn't necessary
  for Ivy and Helm it did the same here, which became a problem when a
  change in Helm caused fuzzy completion to break in combination with
  a completion function.  Likewise a change in Ivy caused Magit's sort
  order to be ignored, which we work around now.  #3476, #3477

- In some edge cases ~magit-branch-pull-request~ used to set Git
  variables to invalid values.  #3417

- The section visibility cache used ~eq~ when it should have used ~equal~.
  It also briefly used ~alist-get~, which we cannot do because that did
  not take a ~testfn~ argument in Emacs 25.  #3495, #3499

- Detecting whether a commit has already been pushed to a "publishing"
  branch was much slower than it had to be.  #3519

- ~magit-gitignore-popup~'s autoload definition was broken.

- When using cygwin, then ~git-commit-setup-font-lock~ could end up
  trying to run git in a non-existent directory.  #3505

- ~magit-completing-read~ did not protect the value of ~this-command~ even
  though there is code that assumes it does.  #3529

- ~magit-read-file-trace~ in some cases claimed that valid user input
  was invalid even though it was valid.  Now we don't try to validate
  it anymore.  #3531

- We didn't account for the surprising fact that asking whether the
  value of a local variable is risky can change point.  #3541

- ~magit-merge-into~ signaled an error if the upstream of the current
  branch isn't configured instead of letting the user pick a target.
  #3550

- Some of the more complex ~magit-cherry-*~ variants did not abort if
  the first step failed.  #3556

- Trying to visit a commit of a submodule directly from the status
  buffer of the super-projects resulted in an error.  #3563

- ~magit-file-rename~ failed to rename a file that is located at the
  top-level of the working tree.  #3569

- Magit didn't account for ~git rebase -i --root~ corrupting the root
  commit's author date field, resulting in its output being corrupted
  too.  #3574

- If given one invalid rev, then ~magit-rev-eq~ returned ~nil~, but when
  both revs are invalid, then it returned ~t~.  Now it returns ~nil~ in
  both cases.

- In an edge case ~magit-diff-type~ falsely concluded that the
  uncommitted changes in a diff buffer already are committed.  #2627

- ~magit--github-url-p~ failed to return ~t~ for an url for Github
  Enterprise instances.  #3572

- Trying to insert Gravatar images resulted in an error if the service
  is not reachable.  #3597

- ~magit-display-buffer~ always selected the appropriate frame even if
  that was already selected.  That is undesirable because selecting
  a frame has side-effects.  f07eb85c6

- A key binding was not updated when ~magit-submodule-deinit~ was renamed
  to ~magit-submodule-unpopulate~.  b06845208

- ~magit-submodule-visit~ could end up re-populating the visited module.
  3d794cd01

- The third-party ~git-annex~ program converts submodule gitdirs to
  symlinks, which we did not account for.  #3599

- ~magit-bisect-start~ did fail silently when invalid user input, which
  flipped the good and bad revisions, instead of providing an
  informative error message.  #3604

- ~magit-bisect-start~ did fail silently when there are uncommitted
  changes instead of providing an informative error message.  In some
  cases it actually is possible to bisect with uncommitted changes but
  that would be dangerous and we do not try to detect whether that is
  the case and just always error out.  #3604

- When applying changes, then the ~--unidiff-zero~ and ~-C0~ arguments
  were not automatically used when needed.  The former wasn't used
  because of a bug, the latter because I was not aware that there
  was an edge case that makes that necessary.  #3608

- Backported a fix (from Emacs 27) for an Emacs bug that sometimes
  caused ~git rebase~ to fail to acquire the ~index.lock~.  #2708,
  https://debbugs.gnu.org/cgi/bugreport.cgi?bug=21559

- Autoloading ~magit-submodules~ didn't work.  #3618

- Reverting files failed if the selection contained only binary files.
  c7bbe3e9a

- ~magit-read-repository~ failed when ~magit-repository-directories~ is
  non-nil but no repository can be found in those directories.  #3636

- Attempting to reverse changes to binary files failed with an error
  that wasn't informative enough.  #3625

- When a local branch is being renamed, then ~magit-branch-rename~ used
  to also rename the (remote) push-target, which is unsafe in some
  cases.  Now it always asks the user before doing so.  14c7b1381

* v2.13.1   2018-11-08

Bugfixes:

- The prompt used by ~magit-rebase-interactive-assert~ was wrong.
  37d76f409

- ~magit-rebase-autosquash~ asked for confirmation when the user
  already confirmed earlier.  02e6c75b6

- ~magit-log-wash-rev~ errored in ~magit-cherry-mode~, starting with
  Emacs 26.1.  1ee577b35

- Magit used a completion function to make the built-in completion
  respect the collection's order.  Even though that wasn't necessary
  for Ivy and Helm it did the same here, which became a problem when a
  change in Helm caused fuzzy completion to break in combination with
  a completion function.  Likewise a change in Ivy caused Magit's sort
  order to be ignored, which we work around now.  #3476, #3477

- When using cygwin, then ~git-commit-setup-font-lock~ could end up
  trying to run git in a non-existent directory.  #3505

- ~magit-insert-modules-unpushed-to-pushremote~ failed to insert
  anything due to a typo in the used commit range.  d4e159f35

* v2.13.0   2018-06-03

Breaking changes:

- As announced earlier, the obsolete option ~magit-no-confirm-default~
  has been removed.  #3232

Changes:

- Augmenting a file- or blob-visiting buffer with blame information
  was completely rewritten, making the implementation more robust and
  adding many new features.  It is now possible blame in order to get
  an answer to the question "what commits remove these lines".  It is
  no longer necessary for the buffer to be put into ~read-only-mode~,
  when displaying blame information.  New visualization styles were
  added and users can define their own styles.  New commands to visit
  blobs related to the current chunk were added.

- Added new command ~magit-tag-release~.  This is a fairly opinionated
  command and its only use to you might be to serve as a template for
  your own variant.

- Added new section inserter ~magit-insert-ignored-files~, which
  could be added to ~magit-status-sections-hook~.

- The mode ~global-magit-file-mode~ is now enabled by default, making
  the ~magit-file-popup~ available on "C-c M-g".  0ec28b97

- Added new commands ~magit-log-trace-definition~ and
  ~magit-diff-trace-definition~, which show a log with diffs about the
  definition at point.  #2588

- Added new commands ~magit-edit-line-commit~ and
  ~magit-diff-edit-hunk-commit~, which allow editing the commit that
  added the line at point.  febe79ba 22b13337

- The interactive prompts for the various reset commands now indicate
  the branch which is going to be reset.  #3438

- Added new option ~magit-published-branches~, providing an additional
  safety-net.  If you try to modify a commit that has been pushed to
  one of these branches already, then you are now being asked whether
  you really want to do that.  Do not rely on this exclusively, there
  are edge-cases that are ambiguous and are not always handled as you
  might have expected.  add4a7f3 ff

- Gravatar images are now being inserted asynchronously.  #3452

- After deleting the current worktree, ~magit-delete-worktree~ now
  shows the status buffer for another worktree.  d9cd4611

- Added new command ~magit-worktree-checkout-pull-request~.  a3d788ec

- New variable ~magit-get-previous-branch-timeout~ limits the amount
  of time spent in ~magit-get-previous-branch~.  #3457

Bugfixes:

- The recently added command ~magit-branch-pull-request~ had various
  issues concerning pull-requests referencing branches from the
  upstream repository.  #3416 #3417 #3461

- The values of diffstat sections was wrong for sections that
  represent renamed files.  66d9558f

- Time zones were not handled correctly when calculating times for
  blame headings.  #3443

* v2.12.1   2018-04-01

Bugfixes:

- Magit 2.12.0 depended on a non-existent Magit-Popup version.

- Key bindings in ~magit-remote-popup~ conflicted.

* v2.12.0   2018-03-29

- Added new commands ~magit-previous-line~ and ~magit-next-line~ as
  substitutes for ~previous-line~ and ~next-line~.  Magit's selection
  mechanism is based on the region but selects an area that is larger
  than the region.  This causes shift-selection to select two lines on
  the first invocation when using the vanilla commands.  On section
  headings and inside hunk bodies the new magit-specific variants
  don't move point on the first invocation and thereby they only
  select a single section or line.  Which inconsistency you prefer
  is a matter of preference.  #2912

  To use the Magit-specific variants add this to your init file:

    (define-key magit-mode-map [remap previous-line] ~magit-previous-line)
    (define-key magit-mode-map [remap next-line] ~magit-next-line)

- The command ~magit-refs-popup~ now remembers arguments and they are
  displayed in the header-line of ~magit-refs-mode~ buffers.  The popup
  command still invokes the default action by default when invoked from
  another buffer, but when invoked from a ~magit-refs-mode~ buffer it
  now shows the popup.  #2898

- The module overview section now shows a hash for modules that don't
  have a tag and column alignment is optimized.  #3160

- The diff that is being displayed while committing learned about a
  few more special cases.  #3095

- Added new command ~magit-branch-or-checkout~ as a potential
  substitute for ~magit-checkout~.  Setup instructions can be found in
  the manual.  #3104

- Added new customizable options ~magit-log-highlight-keywords~ and
  ~magit-diff-highlight-keywords~, which control whether text inside
  brackets is highlighted in magit-log and magit-diff buffers
  respectively.  #3190

- When the names of Magit buffers are not uniquified then their names
  now end with an asterisk.  When the ~uniquify~ package is used, then
  that still is not possible due to limitations in that package.  #2841

- When selecting a fixup target then the log graph, which makes it
  less likely that you attempt to modify a merged commit, which would
  result in the merges being lost when rebasing.  c0209c74d

- Added the existing commands ~magit-blame~ and ~magit-blob-next~ to
  the ~magit-file-popup~ popup.

- Added new command ~magit-blame-reverse~.  See the updated manual
  for information on how to best use this and other blaming commands.
  #3055

- Keywords in brackets are now being highlighted in ~magit-refs-mode~
  and ~git-rebase-mode~ buffers, and the headers of ~magit-status-mode~
  buffers, like they already were in logs.  #3179

- Added new variable ~magit-buffer-lock-functions~ to support
  third-party packages in creating Magit-like buffers.  #3191

- Improve padding of head-line and add new faces ~magit-header-line-key~
  and ~magit-header-line-log-select~.  #3194

- When a stash has a note attached to it, then show it in the
  ~magit-stash-mode~ buffer.  aff2fba8f

- Added new command ~magit-rebase-remove-commit~ to the rebase popup.

- The remote popup can now be used to set various remote related
  variables.  #3165

- Added new commands ~magit-patch-apply~ and ~magit-patch-apply-popup~.
  The latter is available from inside ~magit-am-popup~ ("w").  #2940

- Added new command ~magit-patch-save~ for saving a diff into a patch
  file.  In diff buffers it is bound to "C-x C-w".  #2950

- Added new command ~magit-stash-branch-here~, which — unlike the
  existing ~magit-stash-branch~ — creates a branch that starts at
  the current HEAD instead of at the commit that was current when
  the stash was created.  #2935

- Added new command ~magit-dired-log~ intended to be bound in
  ~dired-mode-map~.  #3011

- The list of rebase actions displayed in the status buffer now also
  shows "exec" actions.  #3003

- While it exists, the stash created by ~git rebase --autostash~ is
  now also displayed in the list of stashes.  #3146

- When the current branch has no upstream or when all commits have
  already been pushed there, then the status buffer now shows
  ~magit-log-section-commit-count~ recent commits.  If you previously
  used ~magit-insert-unpulled-from-upstream-or-recent~, then remove
  that from ~magit-status-sections-hook~, as it is an obsolete alias
  for ~magit-insert-unpulled-from-upstream~ now.  #3227

- When switching between showing "Unmerged into <upstream>" and
  "Recent commits", preserve the visibility of that section.  #3227

- When prompting for a branch to delete, the current branch is no
  longer offered as default choice, except in cases where it is likely
  that that is actually what the user wants.  #2924

- Added new popup ~magit-worktree-popup~ and bound "%" to it.  #2927

- The commands ~magit-file-delete~ and ~magit-file-untrack~ now act on
  the selected files and with a prefix argument they force the action.
  #2930

- When requesting the history of a single file that is no longer being
  tracked, use the ~--full-history~ argument.  Otherwise no history at
  all would be shown.  #3012

- Added new option ~magit-patch-save-arguments~.  #3218

- Leading tabs in files no longer cause misalignment in diffs.  This
  is done by overriding the mechanism used by the display engine to
  determine how wide a tab should be, which doesn't work when there
  are additional characters before the "leading" tabs that should
  count as an additional, but very short tab-stop.  #3185

- The command ~magit-visit-ref~ now drops the prefix argument before
  calling ~magit-show-commit~ when appropriate, and when using the
  ~create-branch~ variant and the branch exists, then it offers to
  simply checking it out instead of resetting it first.  #3009

- The output of ~magit-list-repositories~ is now sorted by module path
  instead of module name.  b6f6cf4a6

- For a long time Magit has supported selecting two or more sibling
  sections using the region and then acting on that selection instead
  of only on the current section.  Single-section selections were not
  supported and a region that did not span multiple siblings was not
  visualized as a selection.  Now that is supported.

  Not every section-aware command was adjusted to take single-section
  selections into account because in many cases that would have led to
  undesired changes in behavior.  #3026

- The command ~magit-branch-spinoff~ now spins off just HEAD when that
  constitutes the single-section selection.  Previously one could only
  spin off all commits that weren't in the upstream yet or at least
  two commits.  #2920

- Added switch ~--local-user~ to the tag popup.  #3237

- When discarding untracked files, then offer to delete the buffers
  visiting them.  #3243

- When there is a valid selection based on the region, then the region
  itself was never visualized.  Now it is, but only if it stays within
  a single line.  #3249

- Added new command ~magit-branch-checkout~ and bound "l" in the
  branch popup to it.  This command always checks out a local branch.
  Valid inputs are an existing local branch, a remote branch for which
  no corresponding local branch exists, and a new branch name that
  doesn't match the name of any existing local or remote branch.  #2906

- The command ~magit-show-commit~ now offers the revision at point as
  the default completion choice if the less generic mechanisms used to
  determine the "current" revision fail.  This is useful for visiting
  revisions mentioned in commit messages.  #2949

- Hashes inside commit messages are now turned into ~commit~ sections.
  Note that this can be disabled and that even if you do so you can
  still visit the commit at point using "RET".  #2949

- The documentation regarding completion, confirmation, the selection,
  and the hunk-internal region was significantly extended.  It might
  be worth reading that.

- Added new option ~magit-dwim-selection~, which allows configuring
  commands that would otherwise ask the user to select among possible
  candidates to use the default instead, with or without confirmation.
  #3232

- When there is a stash at point, then the commands ~magit-stash-drop~
  and ~magit-stash-pop~ now ask for confirmation.  The former command
  previously allowed users to select another stash instead and the
  latter used to act on the stash at point without giving the user a
  chance to abort.  These changes are implemented using the new option
  ~magit-dwim-selection~ and can easily be reverted.  #2916

- Aborting a commit is seen as an error by Git and like all such
  errors it was reported to users, which led to confusion and a few
  bug reports.  Now that non-error is being suppressed.  #2932

- The option ~magit-ref-namespaces~ was demoted to a variable and its
  format changed.  #2923

- Some refs that are being displayed in logs are now being compressed
  to save space while providing more information.  #2923

- Added new option ~magit-submodule-fetch-jobs~.  By default multiple
  modules are being fetched in parallel now.  #3261

- The command ~magit-show-commit~ now also shows notes specified using
  ~notes.displayRef~, not just those specified using ~core.notesRef~.
  #2857

- The package ~magit-popup~ is maintained in its own repository now.
  4d5d9bfac

- The popup ~magit-notes-popup~ now shows the values of the relevant
  variables and allows changing them.  #2857

- The cherry-picking commands now try to use or not use the
  ~--mainline~ argument as appropriate instead of erroring out.  #2980

- Added ~magit~ as an alias for ~magit-status~ because I have been
  told that that improves discoverability.  This might or might not
  make it easier for users to get started with Magit without taking
  a brief glimpse at the documentation.  #3290

- The command ~magit-log-buffer-file~ now also works in Dired buffers.

- The commands ~magit-stage-untracked~ has been taught about the Borg
  package manager.  When staging a package repository it now offers to
  also assimilate (aka install) that package.  dc857e2ed

- Added new command ~magit-browse-pull-request~, which reads an open
  pull request and then visits it in a browser.  For now this only
  supports Github, but other Git forges will be supported in the
  future.  #3134

- Added new commands ~magit-checkout-pull-request~ and
  ~magit-branch-pull-request~ to the branch popup.  For now they only
  support Github, but other Git forges will be supported in the future.
  #3134

- The command ~magit-branch-delete~ now offers to also delete the
  corresponding remote after deleting a local branch that was created
  with ~magit-branch-pull-request~ or ~magit-checkout-pull-request~,
  provided that remote has no other tracking branches.  #3134

- When it is not possible to blame in reverse, then the blame popup
  does not offer that command anymore.  c6ef61b2e

- The mode line process indicator, displayed in the mode line when Git
  is run for side-effects, is now more visible than before, and is
  additionally used to highlight process errors.

  New face ~magit-mode-line-process~ is applied to the mode line
  process indicator to improve the visibility of pending asynchronous
  processes (in particular), as Magit remains responsive after
  initiating such commands (for instance fetching or rebasing), but
  will not update its buffers until the process has completed, which
  might take longer than anticipated.  Customize this face if you wish
  to make this indicator more (or less) visible.  #3284

  If the Git process returns an error, the mode line process indicator
  is no longer removed, and new face ~magit-mode-line-process-error~
  is applied to highlight the error status.  Details of the error from
  the process buffer are also provided as a tool-tip.  The error
  indicator will remain visible in the mode line until a magit buffer
  is refreshed.  If you do not want errors to be indicated in the mode
  line, customize the ~magit-process-display-mode-line-error~ user
  option.  #3297

- When staging and unstaging at the file level and there are arguments
  that cause whitespace differences to be hidden, then apply the
  visible changes using ~git-apply~ instead of using ~git-add~ and
  ~git-rm~ because doing that would also un-/stage the invisible
  changes.  #3102

- Added new command ~magit-diff-visit-file-other-window~.  It isn't
  bound by default because that would result in changes to existing
  key bindings, which is something that is frowned upon.  To use this
  command add something like this to your init file.  #2833

    (define-key magit-file-section-map (kbd "SPC")
      ~magit-diff-visit-file-other-window)
    (define-key magit-hunk-section-map (kbd "SPC")
      ~magit-diff-visit-file-other-window)

- The widths of tabs in diffs can now be adjusted to match the widths
  that would be used in the corresponding file-visiting buffers.  This
  is disabled by default because it can be expensive to determine the
  appropriate values (and also unnecessary when using spaces for
  indentation).  Use the new option ~magit-diff-adjust-tab-width~ to
  control if and when the tab widths should be adjusted.  #2929

- Added documentation about how to contribute to the documentation.

- In the references buffer the remote part of the branch names are now
  hidden in the remote specific lists of branches by default, which is
  done to preserves space.  The option ~magit-refs-show-remote-prefix~
  can be used to revert this change.

- The mode ~git-commit-mode~ now offers three font-lock levels,
  including one that is fruitier than the previous font-lock level.
  Local and remote branches are shown using different colors now.
  7a50bfdb0 ff

- When a signed tag points at the shown revision, then the revision
  buffer now also contains information about the tag signature.  #3015

- The commands ~magit-remote-remove~ and ~magit-branch-delete~ now
  unset the relevant push-remote related variables, which Git fails to
  do, unlike for other variable affected by the removal of a remote or
  branch. Likewise the command ~magit-remote-rename~ now renames such
  variables.  #2850

- Depending on the value of the new ~magit-branch-rename-push-target~
  option the command ~magit-branch-rename~ may now also preserve the
  local branch's push-remote or even rename the push branch on the
  remote.  The default is to do both.  #2850

- Added argument ~--subject-prefix~ to the patch popup.  24ce90832

- The section visibility is now being cached for all sections.
  Previously this was only done for some sections.  When a section
  disappeared and later appeared again, then it went back to its
  initial visibility.  The option ~magit-section-cache-visibility~ can
  be used to restrict the cache to certain sections again.  #2780

- The section visibility cache can now also remember that a section
  should be expanded instead of being hidden when the latter is the
  default and the section reappears.  Previously only the opposite
  was possible.  #2780

- For ~magit-status-mode~ and ~magit-refs-mode~ buffers the visibility
  cache now persists when killing the buffer.  #2780

- Added command ~magit-remote-prune-refspec~, which is necessary
  because Git does not ignore invalid refspecs and instead refuses
  to fetch using only the refspecs that are still valid.  #3134

- Sections are now defined as classes instead of as structs.  This
  is only a first step towards taking advantage of generic methods.
  A few subclasses are already being defined and dedicated slot
  accessors have been deprecated in favor of ~oref~. 651a9abcc ff

- When asking the user whether to save modified file-visiting buffers
  during a refresh, then also allow them to remember the choice for
  the current session.  I still think it is better to just always save
  by setting the option ~magit-save-repository-buffers~ to ~dontask~.
  #3344

- The terminology about modules as used by Git is ambiguous.  Magit
  now avoids the term "initialized" and instead uses the term
  "populated" to refer to a module whose working directory exists.
  The names of commands have been adjusted accordingly.  For example,
  unlike "git submodule init", which does *not* actually "initialize"
  a module, ~magit-submodule-popuplate~ does "populate" a module
  (using "git submodule update --init").  #2911

- Most module commands now default to act on the selected modules or
  if no modules are selected the current module, if any.  Otherwise
  they fall back to read a single module from the user.  Previously
  some of these commands acted on all modules and it was not possible
  to perform the respective actions on a subset of modules.  Acting
  on all suitable modules is still possible using a prefix argument.
  #2911

- Many arguments have been added to the module popup.  #2911

- Added new option ~magit-refs-filter-alist~, which allows omitting
  some references from being displayed in ~magit-refs-mode~ buffers.

- Added new command ~magit-merge-squash~.  #3348

- Several new libraries were created from code previously in magit.el.
  0d6389680

- Added new commands ~magit-merge-absorb~ and ~magit-merge-into~,
  which not only merge a local branch into another but also remove
  the merged branch.  #2922.

- Added new commands ~magit-cherry-harvest~, ~magit-cherry-donate~,
  ~magit-cherry-spinout~ and ~magit-cherry-spinoff~, which move
  commits from one branch to another and also remove them from the
  branch where they were previously located.  #2921

- Added new command ~magit-diff-unmerged~ and taught ~magit-diff-dwim~
  about unmerged changes too.  #3382

- The command ~magit-push-refspecs~ got its own history variable.
  #3361

- By default the names of Magit buffers now either have a star at both
  ends, or at neither when using the ~uniquify~ package.  831372a4f

- Added new commands ~magit-branch-shelve~ and
  ~magit-branch-unshelve~.  Use them to replace a branch with a less
  visible ref while preserving the ref log.  This is useful for work
  that you probably but not certainly will end up discarding.  You
  might want to add these commands to the branch popup.  568b11f64

- The look of ~magit-refs-mode~ buffers was changed to save horizontal
  space and three new options ~magit-refs-primary-column-width~,
  ~magit-refs-focus-column-width~ and ~magit-refs-pad-commit-counts~
  were added.  #3378

- When the dispatch popup is invoked in non-Magit buffers, then certain
  actions that cannot be used there are no longer shown.  83cc91a30

- When the dispatch popup is invoked in a file-visiting buffer, then
  it now also lists the actions from the file popup.  40361273a

- Added new variable ~magit-log-format-message-function~.  #3384

- Added commands ~magit-commit-reshelve~ and ~magit-reshelve-since~,
  replacing and improving upon commands from the ~magit-rockstar~
  package, which was deprecated.  The former changes the dates of HEAD
  and the latter those of a range of commits leading up to HEAD.

- Added argument ~--reverse~ to the log popup.  When that argument is
  used, then the incompatible ~--graph~ is silently dropped.  07e1d69d2

- Added new option ~magit-log-header-line-function~.  #3395

- Added new command ~magit-remote-prune~.  6258dd92c

- Added new hook ~magit-unwind-refresh-hook~, which is like the
  existing ~magit-post-refresh-hook~ except that is runs even if an
  error occurs during the refresh.  9f838cc04

Bugfixes:

- ~git-commit-propertize-diff~ could end up making the buffer
  read-only.  746f2361b

- Fixed ~magit-popup~ issues.  bc1093846, c9689c670

- ~git-rebase-mode-show-keybindings~ failed to process non-English
  usage instructions in interactive rebase buffers.  #3175

- The refresh cache was not properly invalidated after creating a new
  repository.  7a1f1eb44

- The ~with-editor-mode~ minor-mode was sometimes enabled twice in the
  same buffer.  9be36868b

- For bare repositories all files were shown as being deleted in some
  contexts.  b5f05c457

- When a command was invoked from a popup and it set ~this-command~,
  then that was later overwritten.  a74c9b9d4

- While setting ~magit-credential-cache-daemon-socket~'s initial value
  an error occurred when ~credential.helper~'s value is the empty string.
  4b15d5825

- Fixup commands did not warn about merges in the rebase range until
  after creating the fixup commit.  #3176

- Instant fixup allowed selecting a commit that is not reachable from
  HEAD, which, for the instant variants (but only those), clearly is
  a user mistake that should be caught immediately.  #3176

- If ~magit-git-executable~ is an absolute path, then an error
  occurred in ~magit-debug-git-executable~.  9b7e34c29

- Fixed ~magit-branch-reset~ issue.  8ed2eb4f5

- The previous window configuration was not restored by
  ~magit-log-select-pick~ and ~magit-log-select-quit~.  #3211

- When ~magit-branch-spinoff~ failed to perform the checkout it
  never-the-less attempted to perform the subsequent steps.  #3210

- Jumping to the correct location in a man page failed for many
  switches and options.  deb482063 ff

- The default action of ~magit-branch-config-popup~ was a command that
  isn't even available in the popup.  eaa836fe2

- The command ~magit-branch-spinoff~ didn't try to prevent the user
  from entering a string containing whitespace as a branch name.
  bd6055ab2

- The command ~magit-commit~ failed to commit everything after asking
  for confirmation if it is called from a subdirectory.  #3221

- The command ~magit-completing-read~ didn't offer any completion
  candidates.  387257f20

- In some cases an error occurred when showing the remote popup because
  the length of the remotes name was not taken into account.  a9177e5b9

- The command ~magit-branch-rename~ failed to rename a local branch if
  a tag existed with the same name.  #3222

- The command ~magit-file-delete~ ignored the prefix argument instead
  of forcing the action as intended.  0df686bfd

- Fixed a broken highlighting special case.  #3238

- When staging all unstaged changes using "s" on "Unstaged changes"
  while there also are staged changes, then the user was not asked for
  confirmation.  #3238

- When reverting a commit users are required to edit the revert
  message on some platforms but not on others.  #3239

- In a secondary worktree ~magit-git-dir~ failed to return a remote
  path when the repository is accessed using Tramp.  #3228

- When the user chose the default offered by ~magit-patch-apply~,
  then that function failed to expand the file-name so that Git would
  understand it.  ab00c5ba2

- The face ~magit-graph~ was also used for the commit message, which
  only was noticeable when the face was customized.  It appears that
  nobody ever did that.  47e94767b

- When ~magit-branch-read-upstream-first~ is nil, then the value
  returned by ~magit-branch-read-args~ was broken.  #3268

- Fixed encoding of non-ascii filename arguments to git on
  ~windows-nt~ systems.  #3250

- A bug in ~magit-list-active-notes-refs~ slowed down
  ~magit-show-commit~.  #3275

- The command ~magit-worktree-checkout~ wasn't able to checkout
  arbitrary commits, just refs.  #3277

- Due to misunderstood ~flyspell~ implementation details
  ~git-commit-turn-on-flyspell~ did some unnecessary work and made
  claims that are not actually true.  24c966082

- When the git executable could not be found, then Magit often claimed
  that the user was doing something outside of a Git repository
  instead.  #3310

- The command ~magit-submodule-add~ always used a kludge that is
  only needed when using Ido, resulting in a unnecessary removal
  of functionality.  5e43377d2

- The function ~magit-maybe-save-repository-buffers~ in some cases
  needlessly redisplayed a message.  #3319

- The branch description was displayed in weird ways in a few places.
  d98c44bd7, 9003b85da

- When stashing untracked files, then the untracked files in
  subdirectories were not removed from the working tree.  #3334

- The command ~magit-worktree-delete~ failed to delete a worktree when
  its directory no longer existed.  #3355

- A kludge used to work around a bug in Emacs 24 prevented
  ~magit-copy-buffer-revision~ from deactivating the mark.  #3352

- When visiting the last blob that still had the line at point in a diff,
  then that only jumped to the correct line, but not the correct column.
  ebe3b5229

- For unpopulated modules ~magit-list-submodules~ showed information
  about the super-repository instead.  Now such modules are omitted.
  1c4fa9b14

- The commands ~magit-am-apply-patches~ and ~magit-am-apply-maildir~
  did not work over Tramp because they passed Tramp file names directly
  to git.  This was fixed in a way that should prevent similar issues
  elsewhere.  #3368

- The function ~magit-branch-commit-at-point~ preferred tags over
  branches, which is a strange default for most callers.  f2b318856

- The arguments set in the popup were ignored when displaying tags
  in refs buffers.  ae007a757

- When ~magit-diff-section-arguments~ calls for it, then all
  diff-related sections are supposed to be limited to a subdirectory,
  but sections listing untracked and tracked files ignored it.  #3376

- Saving wip refs often failed because ~magit-update-ref~ used the
  refresh cache.  e0e1a44f3

- Buffers listing repositories using ~tabulated-list-mode~ did not
  preserve point when being refreshed.  2f0302635

* v2.11.0   2017-09-13

- The popup ~magit-remote-popup~ now exposes the ~-f~ switch for ~git
  remote add~, which allows the user to control whether information
  from the remote is fetched after the remote is added.  The default
  behavior is still to fetch after adding a remote (i.e., the switch
  is enabled by default).  #2997

- Added option ~magit-list-refs-sortby~ to allow more control over the
  order of refs in prompts.  #2872

- The Magit wrappers around the default Emacs completion functions now
  override the default behavior of alphabetically sorting choices when
  displaying them in the "*Completions*" buffer.  In repositories with
  many release tags, the new behavior prevents completion prompts from
  being dominated by version tags instead of branch names.  #2925

- The commands ~magit-git-command~, ~magit-git-command-topdir~,
  ~magit-shell-command~, and ~magit-shell-command-topdir~ now use
  ~read-shell-command~ to read the command and a shell to run it.
  Packages like ~pcmpl-git~ and ~bash-completion~ can now be used
  to get command-line completion when using these commands.  #2951

- The commands ~magit-git-command~ and ~magit-git-command-topdir~ can
  now call arbitrary commands.  The initial-value when reading the
  command is "git ", and you can remove that to call something else.
  #2951

- Added option ~magit-shell-command-verbose-prompt~.  #2951

- The function ~magit-branch-or-commit-at-point~ now offers the
  appropriate default choice in a ~magit-merge-preview-mode~ buffer
  and in blob-visiting buffers.  #3039, #3066

- On Travis tests are now run against all supported Emacs releases, as
  well as against snapshots of the ~master~ and ~emacs-25~ branches.
  #3046

- Added command ~magit-debug-git-executable~.  #3044

- Added new function ~magit-display-file-buffer-other-window~ to be
  used as ~magit-display-file-buffer-function~.

- Added ~--mainline~ switch to ~magit-revert-popup~.  #3018

- Added ~magit-file-checkout~ to ~magit-reset-popup~.  #3052

- When a revision is shown from a log buffer, the revision buffer now
  inherits the file restriction of the log buffer.  #3056

- Added new command ~magit-diff-toggle-file-filter~.  #3062

- Added new option ~magit-use-sticky-arguments~ that provides more
  control over how diff and log commands reuse arguments from existing
  buffers.  #3074

- Added imenu support in log, revision, and status buffers.  #3022

- Added command ~magit-abort-dwim~ to abort the current operation.
  Depending on the context, this will abort a merge, a rebase, a
  patch application, a cherry-pick, a revert, or a bisect.  #3017

- The command ~magit-clone~ now suggests a directory name that more
  closely follows ~git clone~ when no directory is given.  #3079

- The commands ~magit-subtree-add~, ~magit-subtree-pull~, and
  ~magit-subtree-push~ now offer more completion candidates.  #3081

- The log buffer now shows the line range restriction (i.e., ~-L~
  argument) in its header.  #3075

- Added new functions ~magit-repolist-column-branches~ and
  ~magit-repolist-column-stashes~, which insert the count of branches
  and stashes into submodules and repository list buffers. By default
  they are used in submodule lists but not in the repository list.

- Text inside brackets in commit messages (including when shown in a
  log) are now highlighted using face ~magit-keyword~.

- Invocations of git are cached over the whole body of
  ~magit-run-git~, not just during the status buffer refresh.  This
  should make staging and unstaging slightly faster.  #3096

- When reading a value for the ~--reuse-message~ option, the popup
  ~magit-commit-popup~ now prompts with all ref names, offering
  ~ORIG_HEAD~ as the default if it exists.  #3110

- Added bookmark support in status, refs, log, reflog, stashes,
  cherry, diff, revision, stash, and submodule-list buffers.  #3113

- Added new function ~magit-insert-modules~, a wrapper around the
  existing ~magit-insert-modules-*~ functions.  Also added options
  ~magit-module-sections-hook~ and ~magit-module-sections-nested~,
  to allow tuning the behavior of this function.  #3141

- Renamed function ~magit-insert-submodules~ to
  ~magit-insert-modules-overview~ for consistency with other
  ~magit-insert-modules-*~ functions.  #3141

- Inserting module sections is much faster now.  #3141

- Added ~--no-verify~ switch to ~magit-rebase-popup~.  #3144

- The ~--no-verify~ switch in ~magit-commit-popup~ is now bound to "h"
  instead of "n" for consistency with ~magit-push-popup~ and
  ~magit-rebase-popup~.  #3144

- Added support for the file "EDIT_DESCRIPTION", which is used instead
  of "BRANCH_DESCRIPTION" for editing a branch's description as of Git
  2.13.0.  #3149

Bugfixes:

- Rebasing was sometimes interrupted by an error about the index lock
  already being held.  This happened because VC asynchronously checks
  for files with conflict, which involved using a git command that
  grabs the lock.  Magit now redefines that VC command to use a git
  command that does not grab the lock.  #2708, debbugs#21559

- Adding an untracked subdirectory as a submodule failed if a remote
  was not configured for the subdirectory repository.  #3047

- Parsing the log buffer failed if the log displayed a ref that
  contained parentheses in its name.  #3028

- Parsing the ~git show~ and ~git log~ output for a signed commit
  failed with the Git variable ~log.showSignature~ enabled.  #3061

- When deleting the current branch, ~magit-branch-delete~ did not ask
  for confirmation in some cases.  #3058

- When using a non-standard ~magit-display-file-buffer-function~ that
  does not select the window used to display the buffer, then the
  point in that window was not adjusted.  #3082

- ~git-rebase-mode~ did wrongly assume that there is no space after
  the comment character in action lines that are commented out.  #3085

- The command ~magit-show-commit~ mistakenly displayed a tag's commit
  when point was on a branch with the same name.  #3098

- The command ~magit-log-buffer-file~ miscalculated line numbers from
  the region.  #3075

- Staging a link failed when it points to a repository.

- When setting the upstream of a branch that isn't the current branch,
  the user was asked what branch to use as the upstream of the current
  branch anyway, even though the correct branch would then be modified.

- When deleting a branch that is merged into the current branch but
  not into its own upstream branch, then the user was not offered to
  force the deletion, causing it to fail.  #3107

- With ~find-file-visit-truename~ set to a non-nil value, the commands
  ~magit-status~ and ~magit-init~ failed to detect when their
  directory argument was a symlink that resolved to the output of
  ~magit-toplevel~.  #3115

- Using an url instead of a remote name as ~branch.<name>.remote~ was
  not properly supported, causing issues when trying to pull or push.
  #3116

- The log margin displayed invalid information for cherries.  #3163

* v2.10.3   2017-03-08

- The new command ~magit-do-async-shell-command~ opens the file at
  point with ~dired-do-async-shell-command~.  "&" is now bound to
  this command.  #2992

Bugfixes:

- The command ~magit-bisect-run~ now uses a shell to run the command
  entered in response to the "Enter shell command" prompt.  #3001

- Discarding a renamed file failed if the original file was within a
  directory that no longer existed.  #2998

- When inserting information about a rebase in progress into the
  status buffer, "exec" lines were treated as a commit, leading to an
  error.  #3002

- The command ~magit-blame~ failed in blob-visiting buffers if the
  corresponding file no longer exists in the HEAD or the index.

- The command ~magit-remote-add~ asked whether to set the new remote
  as the ~remote.pushDefault~, when that variable is already set and
  and it was configured not to ask in that case.  4f565039

* v2.10.2   2017-02-14

- The new command ~git-rebase-noop~ adds a noop action during a
  rebase.  It can be used to make git perform a rebase even if none
  of the commits are selected.  #2991

Bugfixes:

- Cherry-picking a commit with multiple parents was not possible,
  because "--mainline" was treated as a switch rather than an option,
  and because of a too-strict assertion that only single-parent commits
  can be cherry-picked.  #2978

- ~magit-abbrev-length~ mishandled two edge cases, returning 0 when
  called within an empty repository or outside of a repository.
  077740f5

- A bug fix in the last release broke the visit-file functionality in
  diff buffers displayed while committing.  #2988

- Diff buffers did not recognize "rev^-n" as a short-hand for
  "rev^n..rev" (new in Git v2.11), resulting in the buffer header
  incorrectly indicating that the diff was between "rev^-n" and the
  working tree.  293f0cc8

- In diff buffers created using the dotted range notation, the command
  ~magit-diff-visit-file~ incorrectly swapped which revision was
  visited for deleted and added lines.  For example, with the range
  "rev1..rev2", calling ~magit-diff-visit-file~ on a deleted line
  visited the blob for rev2.  c24f32cd

* v2.10.1   2017-01-28

- The command ~ido-enter-magit-status~ is now being autoloaded.  #2918

- The minor-mode ~bug-reference-mode~ is now being suggested when
  customizing ~magit-revision-mode-hook~ and ~git-commit-setup-hook~.
  e0d57c49

- The function ~magit-version~ can now deal with the Magit libraries
  being symlinked to, which is required for the new ~straight~ package
  manager.  #2967

Bugfixes:

- When multiple stashes were selected by the region, responding "no"
  when asked to confirm the deletion of these stashes resulted in a
  type error.  #2917

- The function ~magit-split-range~ choked on ranges if one of the
  revisions was omitted, breaking a diff variant and potentially
  other uses as well.  #2928

- The function ~magit-commit-setup~ called without an argument, which
  causes the option ~enable-local-variables~ to be ignored.  #2946

- When committing inside a repository that was created using ~git
  init --separate-git-dir~, the diff buffer was empty, instead of
  showing the changes about to be committed.  For some reason that
  git command, unlike other commands that do essentially the same
  thing, does not set ~core.worktree~, which confused Magit.  #2955

- In the repository list buffer, the columns that are supposed to list
  unpushed and unpulled commit counts, were blank.  #2960

- The command ~magit-reflog-head~ did not properly format reflog lines
  for branch renaming events.  2a268e20

- The commands ~magit-diff-show-or-scroll-down~ and
  ~magit-diff-or-scroll-up~ scrolled instead of updated the revision
  or stash buffer, when that already showed the requested reference
  but that reference no longer pointed at the same revision.  #2966

* v2.10.0   2017-01-04

- Many new, well organized, libraries were added, consisting of code
  that was previously located inside a messier "magit.el".  #2908

- The function ~magit-display-buffer~ now sets the focus on the frame
  used to display the selected window.  #2865

- The Custom groups are better organized now.  New groups were added,
  but many options also moved between groups that already existed
  before.  422d776e, 33c5c1ca

- Many Custom groups and options now link to the relevant Info nodes
  and to other relevant groups.  810d7fb4

- Many doc-strings were improved, added, and fixed.  47aae617

- Added the function ~magit-repolist-column-dirty~, which can be added
  to ~magit-repolist-columns~ and ~magit-submodule-list-columns~.  #2907

- The obsolete variable ~magit-repository-directory-depth~ is no
  longer defined as an option.  09993c39

- The obsolete hook variable ~magit-status-refresh-hook~ is no longer
  defined explicitly.  7e96e831

Bugfixes:

- Customizations of hooks were ignored, if the ~custom-set-variables~
  form was evaluated before the Magit libraries were loaded.  #2902

- When rebase stopped at a commit, point was no longer placed on that
  commit.  #2884

- When creating a commit, ~magit-display-buffer-fullcolumn-most-v1~
  filled the entire frame, hiding the commit message buffer.  #2891

- The commands ~magit-reflog~ and ~magit-reflog-current~ reported
  a revision's reflog as empty when the name of a file in the
  repository, relative to the top-level directory, matched the
  revision name.  5264ffcb

- The function ~magit-repolist-column-upstream~ returned the current
  branch instead of its upstream.  46acbd6d

- The functions ~magit-repolist-column-unpulled-from-upstream~ and
  ~magit-repolist-column-unpushed-to-upstream~ raised a type error
  if the upstream was configured but did not exist.  #2904

- The default values of the options ~magit-submodule-list-columns~
  and ~magit-repolist-columns~ didn't match the documentation and the
  Custom type.  But the code that that uses these values is resilient
  against that defect and so the only effect was that the values were
  reported as mismatched in the Custom interface.  79f6af23

- The Custom type of option ~magit-update-other-window-delay~ didn't
  match the default value.  eb6d8bde

- The shell command generated by ~magit-emacs-Q-command~ could end
  up trying to load a directory as a library, due to a bug in Emacs.
  83980c66, debbugs#16406

* v2.9.0    2016-12-07

Breaking changes:

- For historic reasons "RET" behaved differently in ~magit-refs-mode~
  than anywhere else.  "RET" is one of Magit's most essential key
  bindings and users quickly learn that regardless of what is actually
  at point, it always shows more information about that thing in
  another buffer.  It can be very confusing if the references buffer
  breaks this convention.

  Now ~magit-visit-ref~ behaves just like ~magit-show-commit~ even in
  ~magit-refs-mode~ buffers.  By default at least; you can easily
  revert this change using:

    (setq magit-visit-ref-behavior '(checkout-any focus-on-ref))

  However we recommend that you instead press "b b RET" to checkout
  the reference at point, just like you always had to do in other
  buffers.  And "C-u y o RET" to make commit counts and lists of
  cherries commits relative to the reference at point.

  Furthermore the option ~magit-visit-ref-create~ was removed.  If you
  previously had that set to ~t~, then you can achieve the same using:

    (add-to-list ~magit-visit-ref-behavior ~create-branch)

  However we recommend that you instead press "b c RET RET", just like
  you always had to do in other buffers.  #2868

- The option ~magit-popup-show-common-commands~ now defaults to ~nil~.

  This was done to make popups less noisy but increases the odds
  that some users will never become aware of the common commands.
  To counter that, the usage instructions displayed in the echo area
  now also mention the key that can be used to show these commands
  temporarily.  #2868

  You can easily revert this change using:

    (setq magit-popup-show-common-commands t)

- The option ~magit-popup-use-prefix-argument~ defaults to ~default~
  now, meaning that the use of a prefix argument causes the popup's
  default action to be invoked directly without the popup being shown
  first.

  Previously the use of a prefix argument did not invoke the popup
  or its default action, and instead informed users that they had to
  choose what behavior they wanted and that they had to set the option
  accordingly.  Doing that was necessary three years ago, when the
  default behavior changed when "magit-key-mode.el" was replaced with
  "magit-popup.el".  Now we don't need that safety net anymore.  #2868

- If, and only if, point is on a removed line in a diff, then "RET"
  now jumps to the last commit which still had that line, not the
  commit which removed that line.  Staged changes are excluded from
  this new behavior because in that case it seems favorable to always
  visit the file in the working tree to make further changes.  #2755

  You can easily revert this change using:

    (setq magit-diff-visit-previous-blob nil)

- The margin that by default is displayed in pure log buffers and
  optionally in some other buffers that contain logs is now more
  flexible and easier to customize and to change on the fly.

  The popup that "L" is bound to now features three commands that
  for changing the appearance of the margin: ~magit-toggle-margin~,
  ~magit-toggle-margin-details~ and ~magit-cycle-margin-style~.

  The binding for ~magit-toggle-margin~ has changed from "L t" to the
  simpler "L L".  You can easily revert this change using:

    (magit-change-popup-key 'magit-log-refresh-popup :action ?L ?t)
    (magit-change-popup-key 'magit-margin-popup :action ?L ?t)

  For each mode that supports the margin there now exists a dedicated
  option named ~magit-*-margin~, which controls whether the margin is
  shown initially, whether the author name is displayed in addition
  to the committer date, and how that committer date is formatted.
  All of these options can be found in the new ~magit-margin~ Custom
  group.

  It is now possible to show the actual committer date, using a time
  format of your choosing.  Previously the only option was to display
  the age of the commit.

  The old options that were previously used to configure the margin
  have been removed.  If you have customized ~magit-log-show-margin~,
  ~magit-reflog-show-margin~ and/or ~magit-refs-show-margin~, then you
  now have to customize the respective new variable whose names do not
  contain "-show".  The same applies if you have previously changed
  the value of ~magit-log-margin-spec~.  Unfortunately this cannot be
  automated because the format of the values has changed and because
  the old customizations do not unambiguously map to the new options.

  You might also want to customize the options ~magit-status-margin~,
  ~magit-stashes-margin~ and ~magit-log-select-margin~, for all of
  which no corresponding ~magit-*-show-margin~ used to exist.  Another
  new option is ~magit-refs-margin-for-tags~.

  If you choose to display the commit dates instead of the commit
  ages in all supported modes, then you should set ~magit-log-margin~
  before loading ~magit~.  If you do that then the default values of
  the other ~magit-*-margin~ options will use the same commit date
  style without you having to customize each option individually.
  #2885, #2792

- By default Git-Commit no longer complains about a summary line that
  is too long by some standards.  You can easily revert this change
  using:                                                      2f115d51

    (add-to-list 'git-commit-style-convention-checks
                 'overlong-summary-line)

- In buffers used to write commit messages ~fill-column~ is no longer
  set to 72.  Instead the default value 70 is used (or whatever local
  or global value is set up through other means).  You can easily
  revert this change using:                               #2848, #2852

    (setq git-commit-fill-column 72)

- When it takes too long to parse diffs, then Magit used to stop
  expanding diff sections after one second.  This was a constant
  source of confusion and one second is a very long time anyway, so
  this did not really help hiding the slowness, so this kludge was
  effectively dropped.  You can easily revert this change using:

    (setq magit-diff-expansion-threshold 1.0)

  By the way, improving performance will soon be a priority again.
  #2886

Changes:

- Magit has a new shiny logo!  It was created by Dmitriy A. from
  Prospect One.  Thanks a lot!

- The new option ~magit-branch-adjust-remote-upstream-alist~ can be
  used to configure what branch to use as upstream when branching a
  remote branch.  Without setting this option the upstream ends up
  being the same branch as the one referred to by the push-remote.
  85c3053d

- The per-refresh cache, which is used to save calls to git because
  that is surprisingly slow on Windows, has been improved for calls to
  ~git config~.  Instead of just avoiding identical calls to ~git
  config~ as for other sub-commands, we now call ~git config --list~
  only once per refresh to obtain a list of all variables and their
  values.  #2743

- When visiting a file or blob buffer by pressing "RET" while point is
  inside a diff, then the position this jumps to is now accurate (even
  when jumping to the file in the working tree from a diff that wasn't
  about changes in the working tree).  #2828

- When visiting a file or blob buffer by pressing "RET" while point is
  inside a diff, then the buffer may be widened but only if necessary.
  If it isn't necessary to widen the buffer to jump to the appropriate
  location, because that position falls into the narrowed region, then
  that the buffer isn't widened.  #2804, #2818

- Hunk refinement is now faster.  Users who previously set
  ~magit-diff-refine-hunk~ to ~nil~ due to performance issues may
  find that it now works well even when set to ~all~.  #2834

- The new options ~magit-diff-highlight-hunk-region-functions~ and
  ~magit-diff-unmarked-lines-keep-foreground~ (which was previously
  defined as an undocumented variable) allow tuning the appearance
  of the hunk-internal region.

  The new function ~magit-diff-highlight-hunk-region-using-face~,
  provides a new style; it makes the hunk-internal region bold (or
  italic).  I recommend you customize the above option to use this
  function instead of one of the functions mentioned below.

  The new functions ~magit-diff-highlight-hunk-region-using-overlays~
  and ~magit-diff-highlight-hunk-region-using-underline~ draw one-pixel
  lines before and after the hunk-internal region.  Both of these
  functions have (different) glitches and due to limitations of Emacs'
  display engine it is not possible to fix those.  #2293, #2758, #2791

- Added command ~magit-find-git-config-file~ and variants to make it
  easier to open a file located in the git directory when ".git" is
  a regular file whose contents describe the location of the real git
  directory.  8664223c

- Added command ~magit-emacs-Q-command~ to make troubleshooting and
  bug reporting easier for users not installing from the git
  repository.  #2856

- The command ~magit-branch-spinoff~ learned to remove only a subset
  of commits from the previously current branch, instead of resetting
  it to its upstream, when the region selects commits reachable from
  HEAD.  1e652b87

- The command ~magit-branch-delete~ now falls back to deleting the
  tracking branch when the user attempts to delete a remote branch
  which does not actually exist on the remote anymore.  #2778

- The command ~magit-diff-dwim~ learned about additional cases.  On
  a non-current branch it now shows the diff for "CURRENT...BRANCH"
  (instead of "BRANCH..CURRENT") and inside a stash buffer it shows
  the diff for the commit at point.  #2812

- The command ~magit-push~, which "o" is bound to in the push popup,
  now offers the push-branch as default choice.  Only if that is not
  set does it default to the upstream as before.  And when pushing a
  commit that is reachable from HEAD, then it offers to push to the
  push-branch or upstream of the current branch (which still has to
  be forced explicitly).  #2820

- Log commands now support completion of refs in the "refs/tags" and
  "refs/pull" namespaces.  #2878

- Added option ~magit-no-confirm-default~ to allow specifying commands
  which should just use the default choice instead of having the user
  confirm that by pressing RET.  I recommend you don't use this, but
  if you think that the defaults are so good that you always want to
  use them, then this might make it a bit easier for you.  #2741

- Added option ~magit-slow-confirm~ for users who are afraid they
  would answer ~y-or-n-p~ questions to quickly.  One action, deleting
  all stashes, now defaults to having to be confirmed with "yes RET".
  #2752

- Added option ~magit-view-git-manual-method~ to allow following links
  to the Git Info manual by visiting the respective manpage instead.
  de38266a

- The option ~magit-branch-prefer-remote-upstream~ now also supports
  regexps as members instead of only complete branch names.  #2823

- The option ~magit-branch-read-upstream-first~ used to be a boolean.
  Now it supports a third value ~fallback~, which means to read the
  upstream first like ~t~, but if the value provided by the user does
  not reference an existing revision, then it is treated as the name of
  the new branch and the upstream is read using the second prompt, as
  if the value of this option were ~nil~.  #2741

- When deleting a stash, the hash is now logged to the process log
  buffer in addition to *Messages*, making it more likely that a
  user who accidentally deleted a stash would find the information
  required to undo that.  #2746

- The environment variable ~INSIDE_EMACS~ is now set when calling git.
  #2789

- ~magit-define-popup~ now allows specifying ~:max-action-columns~ per
  section by using a function that returns a different value based on
  the heading, which is passed as argument.  964fcbe0

- Added support for new gpg status letters X, Y, R, and E.  #2845

- Added ~hl-line-mode~ to ~magit-repolist-hook~ and
  ~magit-submodule-list-hook~ and defined those hooks explicitly.
  9f806732

- Added the ~--gpg-sign=~ option to the revert popup.  916e4599

- Added the ~--sort=~ option to the show-refs popup.  (Use "C-u y" to
  show the popup instead of invoking its default action as "y" does.)
  8ab81f06

- Added new faces ~git-rebase-comment-heading~
  and ~git-rebase-comment-hash~.  #2769

- ~whitespace-mode~ is not compatible with Magit buffers, where it is
  now actively prevented from being turned on by the user.  #2821

Bugfixes:

- The command ~magit-list-repositories~ failed on empty repositories.
  09fac022

- The Git variable ~pull.rebase~ was ignored when determining whether
  the current branch is being rebased onto its upstream in order to
  display that information in the status buffer.  9c946ee3

- On 32-bit systems ~magit-format-log-margin~ failed because it tried
  to truncate a time float that was too large for that.  #2765

- On Emacs v25.1 the hunk-internal region flashed briefly on
  mouse-down-1 events and the delimiting horizontal lines could end
  up having the height of a regular line instead of just a single
  pixel.  #2758

- On Windows, when using a ~windows-nt~ Emacs together with a cygwin
  Git, we failed to instruct Emacs to not use dos shell quoting when
  calling git.  And if Git wasn't available, then that caused an
  error, which prevented Magit from being loaded.  #2842

- The encoding of commit messages is controlled by the Git variable
  ~i18n.logOutputEncoding~ but we failed to take that into account.
  Fixes by setting ~i18n.logOutputEncoding~ to UTF-8, but only inside
  Magit and only for ~window-nt~.  #2738, #2813

- It wasn't taken into account, until a few days after the release,
  that as of Git v2.11, the default abbreviation size is no longer
  hardcoded as 7 but instead scales with the repository size.  #2880

- File and directory local variables were not honored in the buffers
  used to write commit messages.  #2852

- The caching mechanism that is supposed to ensure that sections of
  unpulled and unpushed commits remain collapsed even when they
  disappear was broken for a while.  0ad041c4

- Process sentinels did not in all cases ensure that the correct
  buffer was current before doing something that assumes that this is
  the case.  Almost always that did not matter because it was the case
  anyway, but if other timers are running then it is possible that
  those make the wrong buffer current.  #2836

- Process sentinels and filters used when blaming assumed that the
  ~exit~ process status indicates success.  #2836

- The commands ~magit-clone~ and ~magit-init~ did not work over Tramp.
  #2806, #2807

- The commands ~magit-worktree-checkout~ and ~magit-worktree-branch~
  did not expand the path they pass to git, which is necessary because
  git does not know the meaning of "~/".  #2796

- The commands which create fixup/squash commands and then immediately
  squash them into the target commit did not remove ~--gpg-sign~ or
  add ~--no-gpg-sign~.  Signing such commits is not only unnecessary;
  unless the passphrase was cached earlier, trying to sign resulted in
  the process indefinitely waiting for the passphrase to arrive with
  no way for the user to actually provide it.  #2799

- Depending on the value of ~magit-save-repository-buffers~ the user
  might have been asked whether s/he wants to save "git-rebase-todo",
  which is never necessary and just a distraction.  #2770, #2771

- The function ~magit-save-repository-buffers~ did not follow symlinks.
  #2843

- Directories whose names begin with a period were filtered out when
  using ~magit-repository-directories~ to calculate a list of repos.
  #2830

- The user name and email, which are displayed when reading a gpg key
  from the user, were not stripped from the chosen value before being
  handed off to git.  #2761

- When the upstream of the current branch is a remote whose url isn't
  configured then that caused an error when refreshing the status
  buffer.  #2858

- Buffers visiting a blob used the file's ~default-directory~
  even when that directory did not exist in the working tree.  The
  top-level directory is now used as ~default-directory~ when the
  subdirectory does not exist.  cfe46766

- When visiting a directory by displaying a Dired buffer, we used to
  display a buffer for the parent of the directory in question and
  placed point on the name of the directory.  But the intention always
  was to show the Dired buffer for the directory itself.  5665ba94

- Visiting or deleting a submodule listed inside "Modules" failed.
  The latter is now done by de-initalizing the module.  c26b746e

- In the list of commits that are being rebased in the status buffer,
  HEAD was sometimes prefixed with "same" when "stop" would have been
  correct.  #2877

- The highlighting of a non-empty second line in a commit message was
  not automatically updated.  #2777

- When ~--force-with-lease~ was added to the ~magit-push-popup~,
  ~--force~ was removed, but sometimes the former just isn't enough.
  be39a9ba

- The face ~magit-diff-file-heading-highlight~ used to inherit from
  ~magit-diff-file-heading~, which by default makes text bold.  That
  resulted in the complete current heading to be bold, but only the
  file-name part is supposed to be bold.  a4b52516

- The manual stated that "DEL" in Git Rebase mode was bound to
  ~magit-diff-show-or-scroll-down~, which was not the case.  A new
  command ~git-rebase-show-or-scroll-down~ has been added and bound
  to "DEL" to provide this functionality.  #2863

- The function ~magit-repolist-status~ did not expand the filename
  which may be necessary when listing submodules.  cc8c1385

- The macro ~magit-with-temp-index~ did honor the refresh cache, even
  though its BODY may contain calls to git that are identical to
  outside calls during the same refresh, but which are expected to
  return a different value due to the use of a different index.  #2883

- The log margin did not show the author of stashes.  #2846

- The status header about the upstream did not take
  ~branch.NAME.rebase~ into account.  e65f15d0

- Highlighting overlays could not be garbage collected until after a
  refresh.  #2888

* v2.8.0    2016-08-21

- Added several new functions that are suitable values for
  ~magit-display-buffer-function~:
  ~magit-display-buffer-same-window-except-diff-v1~,
  ~magit-display-buffer-fullframe-status-v1~,
  ~magit-display-buffer-fullframe-status-topleft-v1~, and
  ~magit-display-buffer-fullcolumn-most-v1~.

- Added new commands ~magit-list-repositories~ and related new option
  ~magit-repolist-columns~.

- Added new commands ~magit-list-submodules and related new option
  ~magit-submodule-list-columns~.

- Added new command ~magit-branch-orphan~.

- Added new command ~magit-log-move-to-parent~.

- Added support for globbing in file arguments of diff and log
  commands.

- Added support for showing and copying bad commit identified by git
  bisect.

- Added new option ~magit-log-output-coding-system~.

- Added new option ~magit-no-message~, which can be used to suppress
  certain messages whose usefulness are being disputed.

- Taught ~magit-find-file-noselect~ and ~magit-find-index-noselect~ to
  use Emacs~ encoding detection, and enable ~revert-buffer~ to work in
  those buffers.  This makes ~magit-ediff-*~ commands more useful for
  files with non-standard encoding.

- Taught ~magit-insert-bisect-rest~ to show the log graph by default.
  The new option ~magit-bisect-show-graph~ controls this.

- Taught ~magit-insert-submodules~ to display more information.

- When a refresh causes the previously current hunk section to
  disappear, which happens when it was applied in some way, then we
  attempt to move to a sibling hunk.  When that succeeds, then that is
  now considered a proper move and ~magit-section-movement-hook~ is
  called, which in turn may cause the current hunk to be recentered.

- In addition to the directory, each member of the value of option
  ~magit-repository-directories~ can now specify the depth to look for
  repositories inside that directory, overriding the default depth
  specified using the option ~magit-repository-directories-depth~.

- Blob visiting buffers can now be reverted, which is useful when they
  visit a reference.

- Command ~magit-stage~ can now be used outside of Magit buffers.

- Commands that read a branch or commit from the user now also offer
  tags as completion candidates.

- Taught ~magit-insert-worktrees~ to use relative filenames.

Bugfixes:

- Function ~magit-get-all~ did split multi-line values into multiple
  values.

- Function ~magit-subtree-read-prefix~ which is used in order to read
  the ~--prefix~ argument from the subtree popup was missing.

- Command ~magit-blame~ failed when run in a blob buffer for a file
  located in a subdirectory.

- Command ~magit-diff-visit-file~ didn't visit a blob when called
  inside a ~magit-stash-mode~ buffer.

- Command ~magit-submodule-add~ did not allow picking a path that
  does not exist yet and read the path before the url.

- Command ~magit-submodule-setup~ did update existing modules, which
  can cause them to become detached.

- Command ~magit-popup-describe-function~ could create an extra window
  on wide frames.

- Commands ~magit-diff-show-or-scroll-{up,down}~ failed to scroll
  stash buffers.

- Mode ~git-rebase-mode~ did not respect the Git variable
  ~core.commentChar~.

- Sections in the process buffer sometimes had invalid parent
  sections, causing movement and visibility commands to fail, and
  expected Git errors not to be handled gracefully in some cases.

- Merges where not performed asynchronously, which made it impossible
  to read a passphrase from the user, needed for commit signing.

- In bare repositories tracked files were listed as deleted.

* v2.7.0    2016-05-19

- Added new popup ~magit-subtree-popup~ and bound "O" to it.

- Added new popup ~magit-branch-config-popup~ and made it available
  from the popups ~magit-branch-popup~, ~magit-pull-and-fetch-popup~,
  ~magit-pull-popup~, ~magit-fetch-popup~, and ~magit-push-popup~.

  With a prefix argument it reads a branch to be configured in the
  minibuffer instead of using the current branch.

- Added new option ~magit-branch-popup-show-variables~, defaulting to
  t to avoid changing key bindings.  When set to nil, no variables are
  displayed directly in the ~magit-branch-popup~, instead the subpopup
  ~magit-branch-config-popup~ has to be used.

- Added new popup command ~magit-log-buffer-file-popup~.

- Added new command ~magit-diff-buffer-file~ and new option
  ~magit-diff-buffer-file-locked~.  When the value of the option is
  non-nil, the default, then the command uses a dedicated buffer.

- Added new option ~magit-log-buffer-file-locked~.  When its value is
  non-nil, the default, then ~magit-log-buffer-file~ uses a dedicated
  buffer.

- Added new commands ~magit-worktree-checkout~,
  ~magit-worktree-branch~, ~magit-worktree-delete~,
  and ~magit-worktree-status~.

- Added new section inserter ~magit-insert-worktrees~

- The command ~magit-clone~ now runs asynchronously, which avoids
  blocking Emacs and allows handling password prompts.

- The command ~magit-stage~ learned to stage an untracked file while
  leaving its content unstaged (i.e., ~git add --intent-to-add~) when
  called with a prefix argument.

- The command ~magit-reverse~ learned to use ~--reject~ to ensure that
  non-conflicting hunks are applied and that conflicting hunks are put
  into reject files.

- When the command ~magit-discard~ is used on staged changes, then
  that is done by first reversing the changes in the index and then in
  the working tree.  The second step could fail due to conflicts.  Now
  the ~--reject~ argument is used, which ensures that non-conflicting
  hunks are applied and that conflicting hunks are put into reject
  files.

- The command ~magit-rebase-continue~ learned to reuse the old commit
  message as-is when called with a prefix argument.

- In the refs buffer symbolic refs, such as "remotes/origin/HEAD", are
  no longer omitted from the lists of local and remote branches.

* v2.6.2    2016-04-25

- Added new section inserter ~magit-insert-submodules~.  For each
  submodule it inserts the module path and a description of its tip.

- When re-adding an already configured but for some reason unstaged
  submodule, then ~magit-submodule-add~ now offers the configured
  submodule name as default choice.

Bugfixes:

- When possible ~git merge (--no-commit|--edit)~ perform fast-forward
  merges, which isn't what one would expect.  ~magit-merge-nocommit~
  and ~magit-merge-editmsg~ now work around that by always using
  ~--no-ff~.

- The command ~magit-log~, when called with ~--patch~ but without
  ~--graph~, deleted the first two characters of file names in the
  diff.

- When performing an instant fixup/squash, the rebase often failed
  because the commit process still held the lock on ~index.lock~.

- The command ~magit-submodule-add~ offered an invalid default choice
  for the module path and allowed selecting a file that isn't a
  repository.

- ~git-rebase-mode~ failed to prevent ~save-place-mode~ from having an
  effect.

- The section inserter ~magit-insert-unpulled-from-upstream-or-recent~
  failed to insert the recent commits instead when no upstream is
  configured.

- Two key bindings in ~magit-pull-and-fetch-popup~ conflicted.

- The default value for ~magit-cygwin-mount-points~ checked if
  "git.exe" was a cygwin flavor of git, instead of the (possibly user
  customized) value of ~magit-git-executable~.

* v2.6.1    2016-04-14
Bugfixes:

- When a submodule is manually removed without staging the removal,
  then the status buffer could no longer be updated.

- In some cases not all modified submodules were shown in the status
  buffer.

- Visiting a blob did turn on ~diff-hl-mode~ if the global mode is on.

- Stash and wipref were needlessly signed if signing is enabled.

- The command ~git-commit-save-message~ did not strip diffs produced
  by ~git commit --verbose~.

- Diffs produced by ~git commit --verbose~ were not completely
  highlighted in the commit message buffer.

- When the commit message buffer contains nothing but a single line
  that does not end with a newline, then a warning was shown about
  there being a non-empty second line.

- When installing from Melpa, ~async-bytecomp-package-mode~ was no
  longer activated early enough.

* v2.6.0    2016-03-29

- Added a cache, which memorizes the values of some function calls for
  the duration of a refresh.  This cuts the calls to git in half.

- Added new option ~magit-diff-hide-trailing-cr-characters~.  When its
  value is non-nil (the default on Windows), then ^M characters at the
  end of diff lines are hidden.

- Added new command ~magit-diff-buffer-file-popup~ intended for use in
  file-visiting buffers.  It shows the same popup as ~magit-diff-popup~
  but starts out already limited to the visited file.

- Added new command ~magit-ediff-show-stash~, which is available in
  the Ediff popup and will be used when ~magit-ediff-dwim~ is called
  with point on a stash.

- Added new command ~magit-reset-popup~ featuring all the available
  reset variants.

- Added new command ~magit-push-refspecs~, which allows pushing using
  one or more comma-separated and refspecs, which are explicitly typed
  in the minibuffer.

- Added new commands ~magit-fetch-refspec~ and ~magit-fetch-branch~.

- Added new section inserters
  ~magit-insert-modules-unpulled-from-pushremote~ and
  ~magit-insert-modules-unpushed-to-pushremote~, and renamed
  ~magit-insert-unpulled-module-commits~ to
  ~magit-insert-modules-unpulled-from-upstream~ and
  ~magit-insert-unpushed-module-commits~ to
  ~magit-insert-modules-unpushed-to-upstream~.

- The command ~magit-submodule-add~ now allows using a module name
  different from the path of the module.

- If ~magit-push-current-set-remote-if-missing's value is ~default~,
  then the command ~magit-push-current-to-pushremote~ now offers to
  set ~remote.pushDefault~ unless the push-remote is already set in
  some way.  Previously this command offered to set the local value
  ~branch.NAME.pushRemote~ for all non-nil values of the option.

- When washing the diff that is to be displayed while writing a
  commit message takes too long, then it is now possible to abort that
  by pressing ~C-g~.  Previously that would have aborted the commit.

- When ~magit-process-raise-error~ is non-nil, then the displayed
  error message now also mentions the ~default-directory~, which is
  useful when using Magit as a library in another packages that runs
  git in many different repositories.

- The ~magit-insert-section~ macro's TYPE argument can now have the
  form ~(eval FORM)~ instead of a symbol.  An atomic TYPE is never
  evaluated, but FORM is evaluated at run-time.

Bugfixes:

- Staging hunks/regions belonging to files with CRLF line endings on
  Windows (or, to be precise, when ~default-process-coding-system~ had
  CRLF end-of-line conversion) ended up erroneously staging changes
  with LF line endings.  Magit now ensures line endings are preserved
  by enforcing a ~process-coding-system~ with LF end-of-line
  conversion.  The new behavior may be disabled by setting the option
  ~magit-process-ensure-unix-line-ending~ to ~nil~.

- If the user sets the variable ~magit-auto-revert-mode~ or the
  obsolete alias ~magit-revert-buffers~ to nil anytime during startup
  (before or after ~magit-autorevert~ is loaded) then the mode is now
  no longer turned on (actually it is explicitly turned off).

- When a revision buffer was limited to a set of files, its header
  line did not say so.

- The function ~magit-run-git-with-input~ had stopped calling
  ~magit-pre-call-git-hook~ and logging its git command to the
  magit-process buffer.

- The function ~magit-diff-wash-submodule did not handle some less
  common cases.

- The command ~magit-section-cycle-diffs~ hung when hiding sections.

- Invoking ~magit-commit-popup's default action by invoking the popup
  command with a prefix argument failed due to a typo.

- The command ~magit-toggle-buffer-lock~ failed if another buffer is
  already locked to the same value.

- The command ~magit-clone~ did not switch to the cloned repository
  before trying to delete the symbolic-ref "origin/HEAD".

- The commands ~magit-insert-unpulled-from-pushremote~ and
  ~magit-insert-unpushed-to-pushremote~ missed an edge case when
  checking whether their section should be inserted into the status
  buffer.

- The command ~magit-merge-preview~ did not recognize sections for
  added or deleted files.

- The command ~magit-show-stash~ did not properly handle untracked
  files that were within subdirectories.

- On ~windows-nt~ systems, having ~mount~ in ~exec-path~ caused Magit
  to assume that git is from Cygwin.

- Added a kludge to work around a bug in Apple's OS X which causes
  ~file-accessible-directory-p~ to return incorrect results.

* v2.5.0    2016-01-30

- The library ~with-editor.el~ reincarnated as a separate repository.

  It was already available as a separate package, and since it can be
  of use for packages that have absolutely nothing to do with ~magit~
  it makes sense to maintain it separately.  That wasn't done before
  because that would have made it harder to change it and its users
  within the magit repository in parallel.  I expect there will be
  few such changes in the future.

- Added new library ~magit-submodule.el~.  It contains code that was
  previously spread across various libraries.

- Added new option ~auto-revert-buffer-list-filter~ and redefined
  ~auto-revert-buffers~ from ~autorevert.el~ to use it.  Added new
  predicates ~magit-auto-revert-buffer-p~ and the more restrictive
  ~magit-auto-revert-repository-buffer-p~, which are both intended
  to be used as potential value of the option.

  For now the option defaults to ~nil~, but that might change in a
  future release.  When Magit explicitly calls ~auto-revert-buffers~
  (as opposed to when that is called due to a file notification event
  or by a timer), and ~auto-revert-buffer-list-filter~ is ~nil~, then
  it is let-bound to ~magit-auto-revert-repository-buffer-p~.

  Users who use Tramp and experience delays, should consider setting
  the option to ~magit-auto-revert-repository-buffer-p~.

- By default, invoking ~magit-unstage~ on a committed change now
  performs an action which is somewhat similar to unstaging.  The
  change is reverted in the index, but not the working tree.  This
  allows extracting changes from HEAD.

  Setting the new option ~magit-unstage-committed~ to nil, disables
  this behavior.  Attempting to unstage a committed change would then
  result in an error again.

- Because file notifications may arrive with a delay, the option
  ~magit-auto-revert-immediately~ now defaults to ~t~ even when file
  notifications can be used,

- Like ~magit-refresh~ already did, ~magit-refresh-all~ now runs the
  hooks ~magit-pre-refresh-hook~ and ~magit-post-refresh-hook~.

- The heading of the section which lists commits that exist in the
  current branch but not in its upstream was changed from "Unpushed
  to <upstream>" to "Unmerged into <upstream>", because one usually
  should merge into that branch instead of pushing to it.

- Added new commands ~magit-remote-set-head~ and
  ~magit-remote-unset-head~.

- By default ~magit-clone~ now deletes the symbolic-ref "origin/HEAD"
  right after running ~git clone~, which insists on creating it.

  The new option ~magit-clone-set-remote-head~ can be set to ~t~ to
  go back to keeping that symbolic-ref.  We default to removing it,
  because it does not actually get automatically updated when the
  HEAD of the remote changes, which makes it rather pointless.

- Added new option ~magit-prefer-remote-upstream~ which controls
  whether commands which read the upstream or starting-point from
  the user would rather offer a local or a remote branch as default
  completion candidate.

- Added the switch ~--cover-letter~ to ~magit-patch-popup~, and taught
  ~magit-format-patch~ to immediately open the letter in a buffer.

- Added new option ~++order~ to the various log popups.  This option
  and its value are converted to ~--VALUE-order~ before calling ~git~.
  This option was added instead of the switches ~--author-date-order~,
  ~--date-order~, and ~--topo-order~ because adding all three would be
  too noisy and because they are mutually exclusive.

Bugfixes:

- Creating a stash in a secondary working tree failed if no other
  stash already existed in the repository.

- Creating a Magit buffer failed if ~uniquify-buffer-name-style's
  value is ~nil~.

- Resetting a branch to an arbitrary commit caused its upstream
  configuration to be mangled.

- Resetting a branch to another branch caused the former to be
  configured as the upstream of the latter.  That behavior was
  introduced by accident when the argument ~--track~ was replaced with
  the variable ~branch.autoSetupMerge~ in the popup.  Because it would
  be undesirable to restore the ~--track~ argument in the popup, one
  now has to use a prefix argument to set the upstream while resetting.

- The manually set state of the margin in log and reflog buffers was
  not preserved and instead reset to the default state when a command
  was invoked which changes what log/reflog is being displayed.

- Pressing RET on a variable in a popup caused an error.

* v2.4.1    2016-01-19

- Added new utility functions ~magit-rev-abbrev~, ~magit-ref-p~, and
  ~magit-tag-p~.

Bugfixes:

- When determining the emacsclient executable most suitable for the
  current emacs instance, With-Editor ignored any executable that is
  actually named "emacsclient-snapshot".

- When determining the most suitable git executable, an error occurred
  if "Git for Windows 1.x" is used and an cygpath executable is
  available.

- An error occurred when refreshing the status buffer when there is a
  new, staged but not yet committed, submodule.

* v2.4.0    2016-01-18

- The new mode ~magit-auto-revert-mode~, a magit-specific globalized
  variant of ~auto-revert-mode~, replaces the old implementation, which
  was configured using the option ~magit-revert-buffers~.  The new mode
  is enabled for all users by default.  It may be disabled before
  loading magit by setting ~magit-auto-revert-mode~ (or the obsolete
  alias ~magit-revert-buffers~) to nil.  To disable the mode after
  loading magit, a call to (magit-auto-revert-mode -1) is required.
  #2474

- The option ~magit-refresh-status-buffer~ was added, allowing users
  to prevent automatic refreshes of the status buffer for performance
  reasons.

- All of Git's push-related variables are now honored.  #2414

- In addition to the upstream branch, the push-remote (configured
  using ~branch.<name>.pushRemote~ or ~remote.pushDefault~) is now
  also fully supported.  #2414

- The status buffer now features up to four logs listing unpulled and
  unpushed commits.  Two for the upstream and two for the push-remote.
  #2414

- The branch popup now shows the most important Git variables that are
  in some way related to branches.  The values of these variables can
  now be conveniently changed from that popup.  #2414

- The fetch, pull, push, and rebase popups now feature an action which
  acts on the push-remote, another which acts on the upstream, and yet
  another which acts on any other source or target.  For each of these
  actions the respective branch is shown in the popup.

  The actions in the push popup are displayed even if the respective
  variables are unset - they then offer to set these variables before
  pushing.  Setting ~magit-push-current-set-remote-if-missing~ to nil
  disables this.

  Many key bindings were changed for consistency and safety reasons.
  Likewise many commands were renamed and their behavior was adjusted.
  Some new commands, related to the push-remote, were added.  #2414

- The command ~magit-push-implicitly~ was removed from the push popup.
  The command's doc-string explains how to put it back.  If these
  instructions are followed, then the popup shows what will happen if
  the command is used.  #2453

- The command ~magit-push-to-remote~ was added.  The command's
  doc-string explains how to add it to the push popup.  #2453

- The option ~magit-push-always-verify~ was removed.  That was only a
  temporary kludge to keep users from shooting themselves in the foot.
  This is no longer necessary because one now always sees where one is
  about to push to.  #2414

- The popup command ~magit-pull-and-fetch-popup~ was added as a
  possible replacement for the separate ~magit-push-popup~ and
  ~magit-fetch-popup~.  #2452

- The option ~magit-branch-prefer-remote-upstream~ was added for users
  who prefer to always use remote branches as upstreams.  #2447

- The options ~magit-clone-set-remote.pushDefault~ and
  ~magit-remote-add-set-remote.pushDefault~ were added.  #2447

- When Git is run for side-effects and exits with a non-zero status,
  then the respective error message is now inserted into the status
  buffer.  This should help those users who do not see that message
  when it is being displayed in the echo area.

- Popups gained support for a new event type ~:variable~, which can be
  used to change the value of Git variables.  This can only be used in
  combination with Magit (just ~magit-popup.el~ by itself is not
  sufficient).  #2409

- The backward-compatibility kludge ~magit-branch-manager~ has been
  removed.  The one and only binding to show the refs buffer now is
  "y"; the "b v" binding has been removed.

- The command ~with-editor-finish~ now runs the new hook
  ~with-editor-post-finish-hook~.

- The command ~magit-diff-visit-file~ now runs the new hook
  ~magit-diff-visit-file-hook~.

- When the upstream branch or push remote is configured but the
  respective branch does not actually exist, then that is now reported
  in the header of the status buffer.  #2390

- The header line about the upstream branch in the status buffer is
  now prefixed with either "Merge" or "Rebase", depending on the value
  of ~branch.<current-branch>.rebase~. #2390

- ~magit-define-popup~ learned two new arguments, ~:setup-function~ and
  ~:refresh-function~.  These arguments should be used instead of the
  MODE argument, which is now deprecated.  #2389

- Negative text properties are no longer faked; that was just too ugly
  and inefficient.  Since v2.1.0 Magit no longer sets the background
  color for any faces except for those related to diffs.  Third-party
  themes which still set the background color of non-diff faces have
  to be adjusted, because the background color of these faces would be
  shadowed by the highlighting of the current section.  This does not
  apply to diff-related faces because diff sections are highlighted
  differently from other sections.  #2387

- The commands ~git-rebase-move-line-up~ and ~git-rebase-move-line-down~
  have been extended.  When a region is active, they now operate on
  all lines touched by the region, not just the current line.  In
  addition, a numeric prefix can now be given to specify how many
  lines the current line or selection is moved across.

- The option ~magit-popup-display-action~ was added.

* v2.3.1    2015-11-11

Bugfixes:

- ~magit-stash-drop~ now shows a message with the hash of the dropped
  stash to make it easier to recover from dropping the wrong stash.

- ~magit-revert-buffers~ now avoids needlessly connecting to unrelated
  hosts.  It first checks whether a given file is on the same host as
  the repository, and only if that is so it checks whether the file is
  located inside the repository, using ~file-in-directory-p~, which,
  for Tramp files, requires connecting to the remote host.

- ~magit-commit-message-buffer~ no longer hangs when a symlink to the
  repository is involved.

* v2.3.0    2015-10-28

- Added ~--interactive~ switch to ~magit-rebase-popup~ so that rebase
  variants which normally perform a non-interactive rebase can be used
  to perform an interactive rebase too.  #2186

- Commands that perform an interactive rebase should no longer be used
  non-interactively (i.e., they should only be used as commands).  #2187

- Rebasing commands now can start with a root commit.  Root commits
  are detected automatically, so users don't have to use the ~--root~
  switch explicitly.  #2187

- Added new command ~magit-checkout-file~.

- Added new option ~magit-bury-buffer-function~ to give users more
  control over how Magit buffers are buried, replacing the old binary
  option ~magit-restore-window-configuration~.  The default is still
  the same, i.e., ~magit-restore-window-configuration~ is used.  #2193

- Added new function ~magit-mode-quit-window~ as a simpler variant to
  ~magit-restore-window-configuration~.  #2193

- Information about related refs in ~magit-revision-mode~ buffers are
  now grouped in the same section as other headers and are formatted
  like those other headers instead of like diffstats.  The redundant
  header which previously grouped the related refs section is gone.
  All headers are inserted by the new ~magit-insert-revision-headers~
  section inserter.  #2216

- No longer avoid calling git more than absolutely necessary when
  creating a ~magit-revision-mode~ buffer.  This simplifies parsing,
  makes it simpler to prettify how information is presented, allows
  users to customize how and in what order information is presented,
  and prepares for faster, asynchronously created diffs.  #2216

- The various sections in revision buffers are now inserted using new
  section inserters named ~magit-insert-revision-{*}~, all of which
  are part of the default value of ~magit-revision-sections-hook~.
  #2216

- The various sections in diff buffers are now inserted using new
  section inserters named ~magit-insert-diff-{*}~, all of which are
  part of the default value of ~magit-diff-sections-hook~.  #2216

- Added new option ~magit-revision-headers-format~ whose value is
  passed to ~git show --format=~ to insert most of the headers,
  excluding the related-refs headers.  The default value now uses
  placeholders which respect information in the file ".mailmap".
  #2216

- Removed options ~magit-revision-show-notes~,
  ~magit-diff-show-xref-buttons~, ~magit-revision-show-xref-buttons~,
  ~magit-diff-show-diffstat~, and ~magit-revision-show-diffstat~.
  Whether these sections are inserted is now controlled using the
  hooks ~magit-diff-section-hook~ and ~magit-revision-section-hook~.
  #2216

- Gravatar images can now be shown in ~magit-revision-buffers~.  New
  option ~magit-revision-show-gravatars~ controls whether these images
  should be inserted and can also be used to adjust to customizations
  of ~magit-revision-headers-format~.

  This feature is not enabled by default due to privacy concerns.

  Gravatar images are spliced into two halves which are then displayed
  on separate lines.  On OS X the splicing has a bug in some Emacs
  builds, which causes the top and bottom halves to be interchanged.
  Setting the new option ~magit-revision-use-gravatar-kludge~ to ~t~
  works around this issue.  #2216

- After using the region to stage or discard parts of a hunk, point is
  now placed on the beginning of the next or previous block of changed
  lines.  Previously we just jumped to the beginning of the hunk at
  the same index as the previous hunk, but that often was very far
  away from where point was before the refresh.  #2227

- The function ~magit-toplevel~ was refactored and many tests were
  added.  It now returns the correct value when a symlink to a
  sub-directory of a working tree is involved.  #2242

- New option ~magit-keep-region-overlay~ allows displaying the region
  overlay together with the visualization of a valid Magit selection.
  See the doc-string for why we think you shouldn't do that, but if
  you disagree then you can now have it your way.  #2091

- Avoid the inefficiency of ~git log --graph --max-count=N REV~ (it
  calculates the graph for all reachable commits, not just the N
  commits), by additionally limiting the history using a range
  calculated from REV and N, when possible.  #2243

- Renamed ~magit-file-buffer-mode~ to ~magit-file-mode~.  Related
  symbols were renamed accordingly.

- Added new minor mode ~magit-blob-mode~ and new commands
  ~magit-blob-previous~ and ~magit-blob-next~.  #2195

- Added new commands ~magit-branch-spinoff~ and ~magit-branch-reset~.
  #2191

- Added new option ~magit-status-expand-stashes~.

- In addition to ~default-directory~ also set ~list-buffers-directory~
  to the top-level of the working tree in Magit buffers, causing that
  directory to be displayed in the "File" column of the *Buffer List*
  buffer.

- Added a kludge to keep Cygwin and MYSYS2 executables from expanding
  globs when called from a native Windows Emacs executable.  #2281

- Added a revision stack.  The new commands ~magit-copy-section-value~
  and ~magit-copy-buffer-revision~, which are intended for use inside
  Magit buffers, push an entry to the stack, and the new command
  ~magit-pop-revision-stack~ inserts a representation into an editable
  buffer.  New option ~magit-pop-revision-stack-format~ controls how
  the representation of the revision is formatted.  The old commands
  ~magit-copy-as-kill~ and ~magit-copy-buffer-thing-as-kill~ have been
  removed.  #2225

- The default values of options ~magit-commit-extend-override-date~
  and ~magit-commit-extend-override-date~ changed to ~t~.

- Added new option ~magit-log-show-margin~.

- Added new option ~magit-log-remove-graph-args~.  #2226

- Added support for showing actionable diffs inside logs.  #2226

- Added basic support for tracing the evolution of a region.  #2226

- Added new command ~magit-stash-format-patch~.

- All apply variants learned how to apply multiple hunks at once. #2271

- Regular apply learned how to apply multiple files at once. #2271

- ~git-commit-setup~ learned to handle Cygwin paths.  It had to be
  taught about that separately from the rest of Magit, because, for
  historic reasons, we try to keep the ~git-commit~ package usable
  without Magit.

- The signatures of ~magit-mode-setup~ and ~magit-mode-get-buffer~
  have changed, and ~magit-mode-get-buffer-create~ has been removed.
  Extensions have to be adjusted accordingly.  #2282.

- All Magit-Mode buffers (including process buffers, but excluding
  popup, blob-visiting, and file-visiting buffers, whose major-modes
  do not derive from ~magit-mode~ and therefore aren't "Magit-Mode
  buffers") are now displayed using ~magit-display-buffer~, which is a
  wrapper around the low-level ~display-buffer~.  High-level functions
  such as ~pop-to-buffer~ and ~switch-to-buffer~ are no longer used to
  display Magit buffers.

  ~magit-display-buffer~ uses the function specified by the new option
  ~magit-display-buffer-function~ to actually display the buffer in
  some window.  The default value is ~magit-display-buffer-traditional~.
  By implementing their own variant to wrap around ~display-buffer~,
  users can take complete control over how Magit buffers are displayed.
  It's also possible to use ~display-buffer~ directly and specify the
  display actions in ~display-buffer-alist~.

  Added new options ~magit-pre-display-buffer-hook~ and
  ~magit-post-display-buffer-hook~, and removed the options
  ~magit-status-buffer-switch-function~ and
  ~magit-diff-switch-buffer-function~.  #2282

- Added new options ~magit-generate-buffer-name-function~,
  ~magit-buffer-name-format~, and ~magit-uniquify-buffer-names~,
  replacing the various ~magit-{*}-buffer-name-format~ options.  #2282

- Added new command ~magit-toggle-buffer-lock~.  Previously it was
  possible to prevent Magit from reusing an existing buffer to display
  something else, using the command ~magit-rename-buffer~ (which was
  removed).  Now this is done by locking the buffer to its value.
  #2282

- The status buffer is now always refreshed after running a Magit
  command triggers a refresh.  Previously that was only the case if
  the buffer in which the command was invoked was a Magit buffer too.

- Added optional support for refreshing the status buffer every time a
  buffer visiting a file, which is tracked in the current repository,
  is saved.  To enable this add ~magit-after-save-refresh-buffers~ to
  ~after-save-hook~.

- Added new functions ~magit-log-maybe-update-revision-buffer~,
  ~magit-log-maybe-update-blob-buffer~,
  ~magit-status-maybe-update-revision-buffer~, and
  ~magit-status-maybe-update-blob-buffer~, and added some of them to
  ~magit-section-movement-hook~.  Removed the function
  ~magit-log-maybe-show-commit~, which served about the same purpose
  as these new functions.  Previously one had to customize the option
  ~magit-diff-auto-show~ to control when the other buffer was updated,
  now one does so by adding or removing the above functions to or from
  ~magit-section-movement-hook~.  The other window is only ever
  updated now, to initially create it, use ~SPC~.  #2338

- Added new hook ~magit-process-find-password-functions~, with no
  default members.  These functions, if any, are run when git requests
  a password from the user, if there are no such functions, or if they
  fail, then the user has to type the password as before.  Added new
  function ~magit-process-password-auth-source~.  It can be added to
  that hook and uses ~auth-source~ to get the password from one of the
  sources it supports.  #2311

- Removed broken support for unicode log graphs.

- ~magit-expand-git-file-name~ learned to use the output of ~mount~ to
  map Cygwin paths into native Windows paths.  ~git-commit-setup~ now
  uses ~magit-expand-git-file-name~ if available.  #2348

- Added new function ~magit-define-popup-sequence-action~ and taught
  related functions about ~:sequence-actions~.

- Added new hook ~magit-credential-hook~ and added new hook function
  ~magit-maybe-start-credential-cache-daemon~ to it.  This allows
  starting Git's credential daemon separately, which is necessary
  because Emacs sends SIGHUP and closes the pty when e.g ~git push~
  (which started the daemon) finishes.  Upon receiving that signal
  the daemon terminates.  We work around this by starting the daemon
  directly before invoking the git subcommand which might need
  credentials.  #2360

* v2.2.2    2015-09-03

Bugfixes:

- ~magit-diff-wash-diff~ choked on unmerged binary files.  #2211

- ~magit-blame-popup~ did not allow empty input when reading a value
  for "-C" or "-M".  #2208

- The ~emacsclient~ executables belonging to non-current alternative
  installations of Emacs on Debian were not considered when setting
  the default value of ~with-editor-emacsclient-executable~.  #2217

- ~server-edit~, which switches to a buffer preferably one with
  another client, was used when finishing or aborting a ~with-editor~
  session.  When ~emacsclient~ was used to connect to a server and
  then a commit or rebase was invoked, then there would be another
  client and switching to its buffer after finishing the commit or
  rebase would be undesirable.  Now we use ~server-done~ instead.
  #2197

- When ~--stat~ abbreviates the name of a file, then that name was
  stored in the section object instead of the full name.  #2199

- ~magit-file-relative-name~ with non-nil TRACKED failed in Tramp
  repositories.  #2206

- After failing to clone, ~magit-clone~ also tried to show the status
  of the non-existent clone.  #2203

- ~magit-wip-log~ did not display a log if the working tree or index
  ref did not exist.

* v2.2.1    2015-08-24

Bugfixes:

- The version strings in the manual were not set to "2.2" when v2.2.0
  was released.

- Some menu bindings were not adjusted when commands were renamed.

- The "next" tag was never shown in the "Tag(s)" header of the status
  buffer.

- Blaming did not abort gracefully when the user killed the buffer.

- Blaming failed on indirect buffers.

- Blaming did not detect when a file was untracked.

- Blaming passed the wrong line range when the file's buffer was
  narrowed.

- ~magit-shell-command-topdir~ used ~magit-git-command~ instead of
  ~magit-shell-command~.

- ~magit-copy-as-kill~ added "nil" to the ~kill-ring~ when there was
  nothing useful to put there.

- ~magit-find-file-hook~, ~magit-find-index-hook~,
  ~magit-refresh-popup-buffer-hook~ were used without being defined
  using ~defvar~.

- ~magit-format-ref-labels~ failed to work around a Git bug, resulting
  in refnames not being colorized when ~--simplify-by-decoration~ is
  used.

* v2.2.0    2015-08-16

- The Elpa packages ~with-editor~ and ~magit-popup~ now depend on the
  package ~async~ and turn on the mode ~async-bytecomp-package-mode~.
  If available, the mode is turned on even when these packages have
  not been installed from an Elpa archive.  It is being turned on in
  both of these libraries because any one of them might be the first
  package from the Magit repository that is being updated.

  It is possible to prevent the mode from being turned on when loading
  these libraries by setting ~async-bytecomp-allowed-packages~ to nil
  before loading them.  If you do that, then you must mention that you
  have done so when reporting a bug (which might therefore be due to
  miscompiled files).

  Turning on ~async-bytecomp-package-mode~ advises ~package--compile~,
  instructing it to compile Magit and its dependencies (as well as
  others packages listed in ~async-bytecomp-allowed-packages~ and
  their dependencies) in a separate Emacs instance.

  Unfortunately it is necessary that we do this because when an old
  version of a package is already loaded when a new version is being
  installed, then the old version sometimes interferes during
  compilation of the new version, leading to miscompiled files.

  This usually does not happen very often, but when updating from
  Magit v1 to v2 then it is expected, which is why users were
  instructed to uninstall the old version before installing v2.1.0.
  Unfortunately many users never saw those instructions, so we have
  no choice but to use this approach to get rid of miscompiled files.

- Two new commands have been added to the diff refresh popup that
  allow the range of the previous diff to be manipulated.
  ~magit-diff-flip-revs~ swaps the revisions of the range, and
  ~magit-diff-switch-range-type~ toggles between ".." and "..." range
  types.

- The commands ~magit-ediff-show-unstaged~, ~magit-ediff-show-staged~,
  ~magit-ediff-show-commit~, and ~magit-ediff-show-working-tree~ have
  been added to the Ediff popup.

- New option ~magit-ediff-dwim-show-on-hunks~ controls whether calling
  ~magit-ediff-dwim~ runs a show variant (~magit-ediff-show-unstaged~
  or ~magit-ediff-show-staged~) rather than ~magit-ediff-stage~ when
  point is on an uncommitted hunk.

- ~magit-diff~ and ~magit-ediff-compare~ no longer prompt the user for
  confirmation when constructing a range from the last and first
  commits selected by a region.  A prefix argument can now be used to
  specify that the diff is between the second revision and the common
  ancestor of both revisions (i.e., the "..." range type is used).

- ~magit-ediff-*~ variants now limit file choices to those that have
  changed between the revisions of interest.  If only one file has
  changed, this file is used without prompting.

- ~magit-diff~ and ~magit-ediff-compare~ now consider the location at
  point when choosing the default for the prompt, and this default
  value usually corresponds with the actions of their DWIM
  counterparts.

- The key in Ediff popup for ~magit-ediff-compare~ has changed from
  "d" to "r" to be consistent with the key in the diff popup for the
  similarly behaved ~magit-diff~.

- Entering a single commit for the range to ~magit-ediff-compare~ now
  compares the commit with the working tree (like ~magit-diff~ and
  ~git diff~) rather than the previous commit.

- The popup ~magit-diff-refresh-popup~ and its suffix commands and
  helper functions were fixed.  Most importantly file arguments and
  diff-type arguments are no longer lost when this popup is used -
  it only changes those arguments it is supposed to change.  Also
  the popup only lists the arguments which can actually be used in
  the current buffer (in status buffers fewer are supported than in
  diff-only buffers).

- The popup ~magit-diff-popup~ and its suffix commands now use the
  arguments currently in the ~magit-diff-mode~ buffer of the current
  repository.  Previously the arguments were always reset to the
  default value of ~magit-diff-arguments~.

- The default values of ~magit-diff-section-arguments~ and
  ~magit-diff-arguments~ now contain the ~--no-ext-diff~ switch.

- New popup ~magit-log-refresh-popup~ allows changing the log
  arguments used in the current buffer.  This allows changing the
  arguments used in a log buffer without having to specify the
  reference(s) again.  And it makes it possible to change the log
  arguments used in the status buffer, which previously required that
  option ~magit-log-section-arguments~ was customized manually.

- When a log is displayed for the purpose of having the user select
  a commit, then this is now displayed in a buffer separate from the
  regular log buffer.  New option ~magit-log-select-buffer-name-format~
  controls the name of that buffer and new option
  ~magit-log-select-arguments~ controls the arguments.

- The default value of ~magit-log-section-arguments~ now contains the
  ~--decorate~ switch.

- ~magit-log-buffer-file~ respects the log arguments currently in
  effect in the repositories log buffer, or if that doesn't exist the
  default value of ~magit-log-arguments~.  Because this command is not
  invoked from the log popup, it's now also possible to turn on the
  ~--follow~ using a prefix argument.

- Log graphs are no longer shown in color by default, because turning
  the control sequences into faces is very inefficient.  To allow
  users to get back the colorful graphs, the ~--color~ switch has been
  added to the log popup.

- In the refs manager, ~RET~ on a local branch again "visits" that
  branch by checking it out (like in v1.4).  With a prefix argument it
  instead "visits" the branch by showing information about other refs
  relative to the visited one (like in v2.1 even without a prefix
  argument).

  When the new option ~magit-visit-ref-create~ is non-nil, then a
  remote branch is "visited" by creating a new local branch that
  tracks that remote branch, and checking out that local branch.

- To avoid losing any standard functionality, ~C-w~ and ~M-w~ now
  fallback to ~kill-ring-save~ when the region is active.  They also
  work in more places and in some cases copy more useful information
  than before.

- New option ~magit-push-always-verify~ has been added because changes
  in v2.1 caused many users to accidentally push to ~master~ instead
  of a remote feature branch as intended.  All users should set this
  option to nil, but only after having read the documentation.  The
  commands that respect this option instruct users to consult its
  documentation.

- Moving through a log using ~n~ and ~p~ is now much faster because
  the revision buffer is no longer recreated for each commit along the
  way.  Because Emacs does not support key-down-events this had to be
  implemented using a timer, which has the unfortunate effect that it
  leads to a delay even when only pressing one of these keys briefly
  to move by a single line.  This delay can be adjusted using the new
  option ~magit-diff-auto-show-delay~.

- When creating a new branch, first reading the starting point and
  only then the name of the new branch has advantages.  But many users
  disagree, so the option ~magit-branch-read-upstream-first~ has been
  added.  It defaults to t.

- New commands ~magit-wip-log~ and ~magit-wip-log-current~ allow
  showing log for a branch and its wip refs (which the various wip
  modes commit to).

- New command ~magit-submodule-deinit~.

- New command ~magit-commit-augment~ allows the user to pick a commit
  to squash into and edit the squash commit message.

- New push commands ~magit-push-implicitly~ and ~magit-push-quickly~.

- When reading user input, many commands now offer a better default
  choice and better completion candidates.

- All apply variants now use ~--3way~ when called with a prefix
  argument.

- Log commands now respect the entries in the .mailmap file.

- The command ~magit-pull-current~ now also fetches tags by default.

- When a file has conflicts then the type of conflict is shown now.

- New option ~magit-log-show-refname-after-summary~.

- New section inserter ~magit-insert-user-header~.

- New face ~magit-section-secondary-heading~.

- New commands ~magit-run-gitk-all~ and ~magit-run-gitk-branches~.
  The existing command ~magit-run-gitk~ now always calls ~gitk~
  without any arguments.

- New commands ~magit-shell-command~ and ~magit-shell-command-topdir~.

* v2.1.0    2015-07-01

This release marks the end of a commit marathon that lasted for more
than 4700 commits.  It is the first major release in over two and a
half years.  The last major release was 1.2.0, which was released
under old leadership.  Version 1.4.0, which I released earlier this
year, for the most part consisted of changes that prepared for this
release (so you might want to read the respective release notes too).

This release comes with many new and exciting features, but the most
important change is the massive increase in consistency both in the
user interface and the internal abstractions.

Magit always provided a very intuitive staging interface, which is
vastly superior to ~git add --interactive~.  This release extends this
to other apply variants.  Starting with this release, other areas have
also begun to be more than just incremental improvements over what Git
itself provides.  But this is still limited to certain features which
have gotten more attention than others (most prominently rebasing).

Interlude:

The code base is finally in a state that allows me to concentrate on
implementing my vision of what version control could be like.  But
this will only be possible if, unlike during the last two and a half
years, I am being paid for my work.

I intend to run a fund-raising campaign, but you can already donate
now (see http://magit.vc/donations.html).  I am also looking for
corporate sponsorship and/or employment.  One area where Magit
actually lags behind other Git clients is integration with Git hosting
platforms and code review tools.  I hope that these platforms have an
interest in being supported by the best Git client and are willing to
pay for it.

I am very interested in a job that would let me work on Magit *and* on
other projects, which would benefit from the skills I have acquired
integrating two complex systems and dealing with all the social and
technical challenges that arise when running a popular project.

Changes:

- A new manual has been added.  It's much more comprehensive than the
  old manual and instead of just documenting the various commands and
  options, it also explains concepts and plumbing functions, and
  comes with extensive indices for commands, functions, and options.

  Actually three new manuals were added; the packages ~magit-popup~
  and ~with-editor~ are documented in separate manuals.

  The manuals are written in Org mode and then exported to Texinfo.

- Performance is much better now.  In most cases this was achieved by
  delaying work until it is actually needed.  Most importantly diffs
  are only partially washed until being fully expanded.  Some
  features come in a fancy and in a fast variant; when that is the
  case, we now usually default to the fast variant.

- Many options can now be set on a per-repository basis, and the
  manual describes how to do so.  (Actually this was always possible
  but, because it was undocumented, nobody did it.)  It's possible to
  define "repository classes", e.g. "huge repositories", and then add
  the respective repositories to that class.  This is very useful in
  order to turn off certain features only in repositories where they
  would have a negative impact on performance, without having to do
  it for each repository individually.

- Many faces have been simplified.  Most importantly, section heading
  faces no longer set a background color (except for hunk headings)
  and instead just use the default background.  Refname faces no
  longer set the background color or the box property.

- Many, probably the majority of, functions, variables, and faces
  have been renamed, which was necessary because there was very
  little consistency before.

  Most importantly, the names of commands and options now begin with
  a prefix that includes the name of the respective git sub-command.
  For example, the names of all commands and options related to
  diffing now begin with ~magit-diff-~.

  Many plumbing functions and variables were also renamed.  In some
  cases, that also lead to shared prefixes, such as ~magit-process-~,
  ~magit-mode-~, ~magit-git-~, and ~magit-insert-~.  But many
  plumbing functions and variables continue to use names whose only
  common part is the ~magit-~ prefix.

  Future renames will be performed at well defined times and obsolete
  function/variable definitions will be provided for backward
  compatibility.  No renames are planned at present.

- The external libraries ~git-commit-mode.el~ and ~git-rebase-mode.el~
  are no longer required and have to be uninstalled because they
  conflict with their successors ~git-commit.el~ and ~git-rebase.el~,
  which are now maintained inside the Magit repository instead of the
  Git-Modes repository.

  The library ~git-commit.el~ can be used without Magit, so it is
  distributed as a separate Elpa package.  However, ~git-rebase.el~
  now depends on several Magit libraries and is therefore distributed
  as part of the ~magit~ package.

- The library ~magit-key-mode.el~ was removed and replaced with
  ~magit-popup.el~.  The new implementation is much more flexible and
  easier to use than the old one.  Major new features include setting
  default arguments directly inside the popup and macros for defining
  new popups and extending existing popups.

- This new library can also be used by packages that are not related
  to Magit and is therefore available as a separate Elpa package.

- The library ~with-editor.el~ was added.  Its purpose is to use the
  emacsclient as $GIT_EDITOR when git is started as a subprocess and
  requires an editor.  This is used while committing and rebasing.
  This also works over Tramp, where a "sleeping editor" shell script
  is used to communicate over standard output instead of a socket
  like the emacsclient does.

  The ~1.4.0~ release already supported this, but this release splits
  this feature into a separate library.  And now that it is a separate
  library, it can also be used by packages that are not related to
  Magit.  ~with-editor.el~ is distributed as a separate Elpa package.

- All libraries are now located in the new ~lisp/~ subdirectory.

- The library ~magit.el~ has been split into many new libraries.
  The code base is now much better organized.  Together with the
  description of plumbing commands in the manual, this should make it
  much easier for contributors to get started.

- The library ~magit-wip.el~ has been rewritten from scratch and no
  longer depends on the external and unmaintained shell script from
  https://github.com/bartman/git-wip.

- There are now three different modes that commit to the
  work-in-progress refs before/after certain events, and in addition
  to the old working tree wip refs, these modes now also commit to
  index wip refs.  When these new modes are turned on, Git's
  protection of committed (but dangling) changes is effectively
  extended to uncommitted changes (which some exceptions).  These
  modes are not enabled by default due to performance concerns.

- The library ~magit-blame.el~ has been rewritten from scratch.  The
  new implementation can blame recursively, jump to the next/previous
  chunk from the same commit, replace headings with separator lines,
  scroll the revision buffer for the chunk at point (like log buffers),
  and fine-tune the arguments for ~git blame~ using a popup.

- The new library ~magit-ediff.el~ replaces the old Ediff support.
  The new implementation comes with a dwim command and a popup, and
  it relies less on high-level functions provided by VC and Ediff
  itself, because many of those turned out to be unsuitable.

- The popular third-party library ~dash.el~ is now required.  This
  is the only mandatory external dependency now, except for Git and
  Emacs themselves, of course.

- When using Ido inside Magit, users now have to install the
  third-party library ~ido-completing-read+.el~.  This is necessary
  because the function ~ido-completing-read~, which is part of the
  built-in library ~ido.el~, is not a sufficient drop-in replacement
  for ~completing-read~.

- The new macro ~magit-insert-section~ replaces ~magit-with-section~.
  The macros ~magit-cmd-insert-section~ and ~magit-git-insert-section~
  were removed without a direct replacement.

- The new functions ~magit-insert~ and ~magit-put-face-property~ take
  care of working around the fact that negative overlay priorities
  are not supported, i.e., that overlays always take precedence
  against text properties.  Previously this was done in various
  places, and not always correctly (e.g., in some cases overlays did
  not evaporate).

- The section visibility and movement commands were rewritten from
  scratch.  All those commands now share the prefix ~magit-section-~
  and edge cases are handled better.  New commands were added that
  allow cycling the visibility of sections and their children.  From
  a user perspective Magit's section handling is now quite similar to
  that of Org mode.

- The macro ~magit-section-action~ was removed.  The related macro
  ~magit-section-case~ still exists and will continue to do so.  The
  action variant provided user-customizable hooks, but these hooks
  were rarely, if ever, used.  Instead of such action hooks, users who
  wish to extend Magit now have to use type-specific section keymaps.

- Section highlighting was rewritten from scratch.  The new
  implementation uses hooks to allow washing certain section types
  differently than others - without obfuscating the simple cases.
  Washing diffs is much more complicated than washing all other
  sections, and that part has been factored out.  The washing of
  all other section types is now quite simple.

- The appearance of the region now indicates whether it is valid as a
  selection.  As far as Magit is concerned, valid selections are hunk
  internal regions and regions that mark sibling sections of the same
  type.  When a region does not satisfy one of these, then it is
  displayed the sames as in other buffers and Magit cannot act on it.

- The new option ~magit-no-confirm~ makes it easy to forgo having to
  confirm potentially dangerous actions.  Many of these actions are
  only dangerous for users who don't know how to undo them.  When the
  wip modes are turned on, many more previously fatal actions can be
  easily undone.  Adding ~safe-with-wip~ here makes it unnecessary to
  confirm these actions.

- The new Refs buffer combines the features of the old Wazzup and
  Branch Manager buffers into one, more powerful and efficient
  synthesis.  For each reference, cherries can be shown by expanding
  the ref section, but unlike in the Wazzup buffer, the cherries are
  not calculated until the expansion happens, making it vastly more
  efficient.  Besides local and remote branches, the buffer now also
  lists tags, and users can add additional sections listing other
  refs, e.g., stashes.  The format of refs headers is now
  customizable.

- File-visiting buffers are now reverted without using code from the
  built-in ~autorevert.el~ library.  The function we previously used
  was intended for internal use only and indeed, changes made there
  broke Magit in the past.

- The new option ~magit-revert-buffers~ controls whether and how
  buffers visiting tracked files are reverted.  As before, such
  buffers are reverted by default.  But by default this is now done
  rather noisily to encourage users to read the doc-string and
  pick what is right for them.  It's now also possible to revert
  asynchronously and for the user to be asked every time there are
  buffers that could be reverted.  This option replaces
  ~magit-auto-revert-mode~.

- Many new section inserters are available.  Some are variations of
  default inserters; ~magit-insert-unpulled-cherries~, for example, is
  like ~magit-insert-unpulled-commits~ but prefixes each commit with
  "+" or "-" to indicate its "cherry state". Other inserters are
  completely new (e.g., ~magit-insert-unpulled-module-commits~).

- The header sections in status buffers can now be customized using
  the new ~magit-status-headers-hook~.  This is an additional section
  insertion hook; separating it from ~magit-status-sections-hook~
  gives users complete control over what information is displayed in
  the headers, while still making the first header the parent section
  of all the other header lines.

- Many commands that previously could only act on the section at
  point can now act on all sections selected by a region, which can
  span sibling sections of the same type.

- Many commands now more intelligently dwim based on the section at
  point.

- Where it makes sense, completion and confirmation have been merged
  into a single user action.  Many commands that previously allowed
  carrying out or aborting some action now also allow the user to act
  on something different from the default choice.  Where one
  previously had to confirm with ~yes RET~, one now confirms with just
  ~RET~ (to accept the default choice, which previously was the only
  choice).

- The distinction between the various "apply variants" has been
  clearly worked out, and they now all provide the same feature set.
  The variants are: stage, unstage, discard, reverse, and "regular
  apply".  In all cases, it is possible to act on a file or hunk, or
  part of a hunk.  When acting on the hunk level, all variants are
  implemented on top of ~git apply~, thus the name "apply variants".

  Un-/staging has always been one of Magit's most beloved features,
  and this release takes it to the next level by making the other
  apply variants just as consistent, powerful, and intuitive to use.

  All apply variants are context aware, meaning that, for example, the
  stage variant knows that an already staged change cannot be staged.
  That leads to better error messages.

- The committing prefix now features additional variants.  It was
  already possible to quickly create a fixup or squash commit; the
  new variants do that and then also instantly perform a rebase to
  actually combine these commits with their intended target commits.

- Rebase sequences are now initiated from the new rebasing prefix.
  Several rebasing variants exist, of course including basic
  "rebase onto something" and interactive rebase.  Other variants
  automatically detect and combine squash and fixup commits with
  their intended targets.  Others let the user edit or reword a
  single commit, without having to go through the steps that are
  irrelevant in these cases.

- When a rebase sequence stops at a commit, then the rebasing prefix
  instead features suffix commands for continuing, editing, or
  aborting the sequence; or skipping the current commit.

- When a rebase sequence stops, the status buffer displays a list of
  the already applied and yet-to-be applied commits.  These commits
  can be acted on like those in logs.

- Cherry-picking, reverting, and applying patches using ~git am~ are
  treated the same way as rebasing.  A prefix command features
  several variants to initiate the sequence.  When a sequence is in
  progress, then the same prefix instead features suffix commands for
  continuing or aborting the sequence, and the status buffer lists
  the relevant commits.

- The magit-specific "rewriting" feature has been removed because it
  was a hybrid of "rebasing" and "cherry-picking" and vastly
  inferior to both of them.

- The merging prefix features several new convenient merge variants.

- Merges can now be previewed before actually carrying them out.

- When a merge results in conflicts then the commits being merged are
  listed in the status buffer, making it easier to review conflicting
  changes in the context they were created.

- Its now possible to discard one side of a conflict directly from
  the hunk containing the conflict, using the regular discard key
  ~k~.  It's also possible to restore a conflict.

- When using an existing branch as the starting-point of a new
  branch, it is now automatically configured as the upstream branch.

- The branching prefix now features suffix commands for un-/setting
  the upstream branch.  Previously this was coupled with pushing in
  a truly obscure way.

- Branch descriptions can now be displayed in the refs or status
  buffer, and the description can be edited using a suffix command
  from the branching prefix.

- The URL of a remote can now be changed from the remoting prefix.

- A new pulling prefix command was added, which features several new
  pulling variants.  Previously only one pulling command existed and
  it had to be controlled using prefix arguments, which was very
  cumbersome.

- A new pushing prefix command was added, which features several new
  pushing variants.  Previously only one pushing command existed and
  it had to be controlled using prefix arguments, which was very
  cumbersome.

- The various tagging commands are now suffix commands of the new
  tagging prefix command.

- It is now possible to stash, or create a snapshot from, just the
  staged or the unstaged changes, instead of both.  Suffix commands
  for branching, listing, and showing stashes were added to the
  stashing prefix

- When creating stashes the new implementation in ~magit-wip.el~ is
  used instead of ~git stash~.  This allows the user to create
  snapshot stashes without touching any files in the working tree.

- The submodule prefix now features new suffix commands for adding,
  setting up, and fetching modules.

- Submodules with unmerged commits can now be displayed in the status
  buffer.  Sections representing submodules can be expanded to show
  their unpulled commits.  These commits can be acted on like commits
  belonging to the super-project.

- Support for displaying diffs inside the log buffer instead of in a
  separate diff buffer has been removed.  It might come back one day,
  but the old implementation had just fallen behind regular one-line
  log too much.

- The logging prefix features many new infix arguments and suffix
  commands, which can now be combined in more flexible ways than
  before.

- Many commands that previously read a single commit, branch, or
  file in the minibuffer, can now read multiple, comma-separated items
  from the user, while providing completion candidates for all of
  them.  Likewise, when selecting a range, completion is available
  for the second commit too.

- All of Git's reset variants are now exposed as individual commands,
  but not all of them have a key binding by default.

This was just the tip of the iceberg.
