magit-remote.el 30.7 KB
Newer Older
1
;;; magit-remote.el --- transfer Git commits  -*- lexical-binding: t -*-
2

Jonas Bernoulli's avatar
Jonas Bernoulli committed
3
;; Copyright (C) 2008-2016  The Magit Project Contributors
4
;;
5 6
;; You should have received a copy of the AUTHORS.md file which
;; lists all contributors.  If not, see http://magit.vc/authors.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

;; Author: Jonas Bernoulli <jonas@bernoul.li>
;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>

;; Magit is free software; you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 3, or (at your option)
;; any later version.
;;
;; Magit is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
;; License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with Magit.  If not, see http://www.gnu.org/licenses.

24 25 26 27 28 29
;;; Commentary:

;; This library implements support for interacting with remote
;; repositories.  Commands for cloning, fetching, pulling, and
;; pushing are defined here.

30 31 32 33 34 35
;;; Code:

(require 'magit)

;;; Clone

36 37 38 39 40 41
(defcustom magit-clone-set-remote-head nil
  "Whether cloning creates the symbolic-ref `<remote>/HEAD'."
  :package-version '(magit . "2.4.2")
  :group 'magit-commands
  :type 'boolean)

42 43
(defcustom magit-clone-set-remote.pushDefault 'ask
  "Whether to set the value of `remote.pushDefault' after cloning.
44 45 46 47 48

If t, then set without asking.  If nil, then don't set.  If
`ask', then ask."
  :package-version '(magit . "2.4.0")
  :group 'magit-commands
49 50 51
  :type '(choice (const :tag "set" t)
                 (const :tag "ask" ask)
                 (const :tag "don't set" nil)))
52

53 54
;;;###autoload
(defun magit-clone (repository directory)
55 56
  "Clone the REPOSITORY to DIRECTORY.
Then show the status buffer for the new repository."
57
  (interactive
58
   (let  ((url (magit-read-string-ns "Clone repository")))
59 60 61 62 63
     (list url (read-directory-name
                "Clone to: " nil nil nil
                (and (string-match "\\([^./]+\\)\\(\\.git\\)?$" url)
                     (match-string 1 url))))))
  (setq directory (file-name-as-directory (expand-file-name directory)))
64
  (magit-run-git-async "clone" repository
65
                       (magit-convert-filename-for-git directory))
66 67 68 69 70 71 72 73 74 75
  ;; Don't refresh the buffer we're calling from.
  (process-put magit-this-process 'inhibit-refresh t)
  (set-process-sentinel
   magit-this-process
   (lambda (process event)
     (when (memq (process-status process) '(exit signal))
       (let ((magit-process-raise-error t))
         (magit-process-sentinel process event)))
     (when (and (eq (process-status process) 'exit)
                (= (process-exit-status process) 0))
76 77 78 79
       (let ((default-directory directory))
         (when (or (eq  magit-clone-set-remote.pushDefault t)
                   (and magit-clone-set-remote.pushDefault
                        (y-or-n-p "Set `remote.pushDefault' to \"origin\"? ")))
80
           (setf (magit-get "remote.pushDefault") "origin"))
81 82
         (unless magit-clone-set-remote-head
           (magit-remote-unset-head "origin")))
83 84
       (with-current-buffer (process-get process 'command-buf)
         (magit-status-internal directory))))))
85 86 87

;;; Setup

88 89
(defcustom magit-remote-add-set-remote.pushDefault 'ask-if-unset
  "Whether to set the value of `remote.pushDefault' after adding a remote.
90 91 92 93 94 95 96 97

If `ask', then always ask.  If `ask-if-unset', then ask, but only
if the variable isn't set already.  If nil, then don't ever set.
If the value is a string, then set without asking, provided the
name of the name of the added remote is equal to that string and
the variable isn't already set."
  :package-version '(magit . "2.4.0")
  :group 'magit-commands
98 99 100 101
  :type '(choice (const  :tag "ask if unset" ask-if-unset)
                 (const  :tag "always ask" ask)
                 (string :tag "set if named")
                 (const  :tag "don't set")))
102

Jonas Bernoulli's avatar
Jonas Bernoulli committed
103
;;;###autoload (autoload 'magit-remote-popup "magit-remote" nil t)
104 105
(magit-define-popup magit-remote-popup
  "Popup console for remote commands."
106
  'magit-commands nil nil
107
  :man-page "git-remote"
108 109 110 111
  :actions  '((?a "Add"     magit-remote-add)
              (?r "Rename"  magit-remote-rename)
              (?k "Remove"  magit-remote-remove)
              (?u "Set url" magit-remote-set-url)))
112

113 114 115 116 117 118
(defun magit-read-url (prompt &optional initial-input)
  (let ((url (magit-read-string-ns prompt initial-input)))
    (if (string-prefix-p "~" url)
        (expand-file-name url)
      url)))

119 120
;;;###autoload
(defun magit-remote-add (remote url)
121
  "Add a remote named REMOTE and fetch it."
122
  (interactive (list (magit-read-string-ns "Remote name")
123
                     (magit-read-url "Remote url")))
124 125
  (if (pcase (list magit-remote-add-set-remote.pushDefault
                   (magit-get "remote.defaultPush"))
126
        (`(,(pred stringp) ,_) t)
127
        ((or `(ask ,_) `(ask-if-unset nil))
128
         (y-or-n-p (format "Set `remote.pushDefault' to \"%s\"? " remote))))
129
      (progn (magit-call-git "remote" "add" "-f" remote url)
130
             (setf (magit-get "remote.pushDefault") remote)
131 132
             (magit-refresh))
    (magit-run-git-async "remote" "add" "-f" remote url)))
133 134 135

;;;###autoload
(defun magit-remote-rename (old new)
136
  "Rename the remote named OLD to NEW."
137 138
  (interactive
   (let  ((remote (magit-read-remote "Rename remote")))
139
     (list remote (magit-read-string-ns (format "Rename %s to" remote)))))
140 141 142
  (unless (string= old new)
    (magit-run-git "remote" "rename" old new)))

143 144 145 146
;;;###autoload
(defun magit-remote-set-url (remote url)
  "Change the url of the remote named REMOTE to URL."
  (interactive
147
   (let  ((remote (magit-read-remote "Set url of remote")))
148
     (list remote (magit-read-url
149
                   "Url" (magit-get "remote" remote "url")))))
150
  (magit-run-git "remote" "set-url" remote url))
151

152 153 154 155 156 157
;;;###autoload
(defun magit-remote-remove (remote)
  "Delete the remote named REMOTE."
  (interactive (list (magit-read-remote "Delete remote")))
  (magit-run-git "remote" "rm" remote))

158 159 160 161 162 163 164 165 166 167 168
;;;###autoload
(defun magit-remote-set-head (remote &optional branch)
  "Set the local representation of REMOTE's default branch.
Query REMOTE and set the symbolic-ref refs/remotes/<remote>/HEAD
accordingly.  With a prefix argument query for the branch to be
used, which allows you to select an incorrect value if you fancy
doing that."
  (interactive
   (let  ((remote (magit-read-remote "Set HEAD for remote")))
     (list remote
           (and current-prefix-arg
169 170
                (magit-read-remote-branch (format "Set %s/HEAD to" remote)
                                          remote nil nil t)))))
171 172 173 174 175 176 177 178 179
  (magit-run-git "remote" "set-head" remote (or branch "--auto")))

;;;###autoload
(defun magit-remote-unset-head (remote)
  "Unset the local representation of REMOTE's default branch.
Delete the symbolic-ref \"refs/remotes/<remote>/HEAD\"."
  (interactive (list (magit-read-remote "Unset HEAD for remote")))
  (magit-run-git "remote" "set-head" remote "--delete"))

180 181
;;; Fetch

Jonas Bernoulli's avatar
Jonas Bernoulli committed
182
;;;###autoload (autoload 'magit-fetch-popup "magit-remote" nil t)
183 184
(magit-define-popup magit-fetch-popup
  "Popup console for fetch commands."
185
  'magit-commands
186
  :man-page "git-fetch"
187
  :switches '((?p "Prune deleted branches" "--prune"))
188 189 190
  :actions  '("Configure"
              (?C "variables..."           magit-branch-config-popup)
              "Fetch from"
191
              (?p magit-get-push-remote    magit-fetch-from-pushremote)
192
              (?u magit-get-remote         magit-fetch-from-upstream)
193 194 195
              (?e "elsewhere"              magit-fetch)
              (?a "all remotes"            magit-fetch-all)
              "Fetch"
196 197
              (?o "another branch"         magit-fetch-branch)
              (?r "explicit refspec"       magit-fetch-refspec)
198 199 200
              (?m "submodules"             magit-submodule-fetch))
  :default-action 'magit-fetch
  :max-action-columns 1)
201

202 203
(defun magit-git-fetch (remote args)
  (run-hooks 'magit-credential-hook)
204
  (magit-run-git-async "fetch" remote args))
205

206
;;;###autoload
207 208 209
(defun magit-fetch-from-pushremote (args)
  "Fetch from the push-remote of the current branch."
  (interactive (list (magit-fetch-arguments)))
210
  (--if-let (magit-get-push-remote)
211
      (magit-git-fetch it args)
212
    (--if-let (magit-get-current-branch)
213 214 215 216 217 218 219 220 221
        (user-error "No push-remote is configured for %s" it)
      (user-error "No branch is checked out"))))

;;;###autoload
(defun magit-fetch-from-upstream (args)
  "Fetch from the upstream repository of the current branch."
  (interactive (list (magit-fetch-arguments)))
  (--if-let (magit-get-remote)
      (magit-git-fetch it args)
222
    (--if-let (magit-get-current-branch)
223 224
        (user-error "No upstream is configured for %s" it)
      (user-error "No branch is checked out"))))
225

226
;;;###autoload
227
(defun magit-fetch (remote args)
228
  "Fetch from another repository."
229
  (interactive (list (magit-read-remote "Fetch remote")
230
                     (magit-fetch-arguments)))
231
  (magit-git-fetch remote args))
232

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
;;;###autoload
(defun magit-fetch-branch (remote branch args)
  "Fetch a BRANCH from a REMOTE."
  (interactive
   (let ((remote (magit-read-remote-or-url "Fetch from remote or url")))
     (list remote
           (magit-read-remote-branch "Fetch branch" remote)
           (magit-fetch-arguments))))
  (magit-git-fetch remote (cons branch args)))

;;;###autoload
(defun magit-fetch-refspec (remote refspec args)
  "Fetch a REFSPEC from a REMOTE."
  (interactive
   (let ((remote (magit-read-remote-or-url "Fetch from remote or url")))
     (list remote
           (magit-read-refspec "Fetch using refspec" remote)
           (magit-fetch-arguments))))
  (magit-git-fetch remote (cons refspec args)))

253
;;;###autoload
254
(defun magit-fetch-all (args)
255
  "Fetch from all remotes."
256
  (interactive (list (magit-fetch-arguments)))
257
  (run-hooks 'magit-credential-hook)
258
  (magit-run-git-async "remote" "update" args))
259

260 261 262 263 264 265 266
;;;###autoload
(defun magit-fetch-all-prune ()
  "Fetch from all remotes, and prune.
Prune remote tracking branches for branches that have been
removed on the respective remote."
  (interactive)
  (run-hooks 'magit-credential-hook)
267
  (magit-run-git-async "remote" "update" "--prune"))
268 269 270 271 272 273

;;;###autoload
(defun magit-fetch-all-no-prune ()
  "Fetch from all remotes."
  (interactive)
  (run-hooks 'magit-credential-hook)
274
  (magit-run-git-async "remote" "update"))
275

276 277
;;; Pull

Jonas Bernoulli's avatar
Jonas Bernoulli committed
278
;;;###autoload (autoload 'magit-pull-popup "magit-remote" nil t)
279 280
(magit-define-popup magit-pull-popup
  "Popup console for pull commands."
281
  'magit-commands
282
  :man-page "git-pull"
283 284
  :variables '("Configure"
               (?r "branch.%s.rebase"
285
                   magit-cycle-branch*rebase
286 287
                   magit-pull-format-branch*rebase)
               (?C "variables..." magit-branch-config-popup))
288 289 290 291 292 293 294
  :actions '((lambda ()
               (--if-let (magit-get-current-branch)
                   (concat
                    (propertize "Pull into " 'face 'magit-popup-heading)
                    (propertize it           'face 'magit-branch-local)
                    (propertize " from"      'face 'magit-popup-heading))
                 (propertize "Pull from" 'face 'magit-popup-heading)))
295 296 297
             (?p magit-get-push-branch     magit-pull-from-pushremote)
             (?u magit-get-upstream-branch magit-pull-from-upstream)
             (?e "elsewhere"               magit-pull))
298 299
  :default-action 'magit-pull
  :max-action-columns 1)
300

301 302 303 304 305 306
;;;###autoload (autoload 'magit-pull-and-fetch-popup "magit-remote" nil t)
(magit-define-popup magit-pull-and-fetch-popup
  "Popup console for pull and fetch commands.

This popup is intended as a replacement for the separate popups
`magit-pull-popup' and `magit-fetch-popup'.  To use it, add this
307
to your init file:
308

309 310
  (with-eval-after-load \\='magit-remote
    (define-key magit-mode-map \"f\" \\='magit-pull-and-fetch-popup)
311 312 313 314 315 316 317 318 319
    (define-key magit-mode-map \"F\" nil))

The combined popup does not offer all commands and arguments
available from the individual popups.  Instead of the argument
`--prune' and the command `magit-fetch-all' it uses two commands
`magit-fetch-prune' and `magit-fetch-no-prune'.  And the commands
`magit-fetch-from-pushremote' and `magit-fetch-from-upstream' are
missing.  To add them use something like:

320 321 322 323 324 325 326
  (with-eval-after-load \\='magit-remote
    (magit-define-popup-action \\='magit-pull-and-fetch-popup ?U
      \\='magit-get-upstream-branch
      \\='magit-fetch-from-upstream-remote ?F)
    (magit-define-popup-action \\='magit-pull-and-fetch-popup ?P
      \\='magit-get-push-branch
      \\='magit-fetch-from-push-remote ?F))"
327 328
  'magit-commands
  :man-page "git-pull"
329
  :variables '("Configure"
330 331
               (?r "branch.%s.rebase"
                   magit-cycle-branch*rebase
332 333
                   magit-pull-format-branch*rebase)
               (?C "variables..." magit-branch-config-popup))
334 335 336 337 338 339 340 341 342 343 344 345 346 347
  :actions '((lambda ()
               (--if-let (magit-get-current-branch)
                   (concat
                    (propertize "Pull into " 'face 'magit-popup-heading)
                    (propertize it           'face 'magit-branch-local)
                    (propertize " from"      'face 'magit-popup-heading))
                 (propertize "Pull from" 'face 'magit-popup-heading)))
             (?p magit-get-push-branch     magit-pull-from-pushremote)
             (?u magit-get-upstream-branch magit-pull-from-upstream)
             (?e "elsewhere"               magit-pull)
             "Fetch from"
             (?f "remotes"           magit-fetch-all-no-prune)
             (?F "remotes and prune" magit-fetch-all-prune)
             "Fetch"
348
             (?o "another branch"    magit-fetch-branch)
349
             (?s "explicit refspec"  magit-fetch-refspec)
350 351 352 353
             (?m "submodules"        magit-submodule-fetch))
  :default-action 'magit-fetch
  :max-action-columns 1)

354 355 356 357 358 359
(defun magit-pull-format-branch*rebase ()
  (magit-popup-format-variable (format "branch.%s.rebase"
                                       (or (magit-get-current-branch) "<name>"))
                               '("true" "false")
                               "false" "pull.rebase"))

360
(defun magit-git-pull (source args)
361
  (run-hooks 'magit-credential-hook)
362 363 364
  (-let [(remote . branch)
         (magit-split-branch-name source)]
    (magit-run-git-with-editor "pull" args remote branch)))
365

366
;;;###autoload
367 368 369 370 371 372 373 374 375 376 377 378 379
(defun magit-pull-from-pushremote (args)
  "Pull from the push-remote of the current branch."
  (interactive (list (magit-pull-arguments)))
  (--if-let (magit-get-push-branch)
      (magit-git-pull it args)
    (--if-let (magit-get-current-branch)
        (user-error "No push-remote is configured for %s" it)
      (user-error "No branch is checked out"))))

;;;###autoload
(defun magit-pull-from-upstream (args)
  "Pull from the upstream of the current branch."
  (interactive (list (magit-pull-arguments)))
380
  (--if-let (magit-get-upstream-branch)
381 382 383
      (progn (run-hooks 'magit-credential-hook)
             (magit-run-git-with-editor
              "pull" args (car (magit-split-branch-name it))))
384
    (--if-let (magit-get-current-branch)
385 386
        (user-error "No upstream is configured for %s" it)
      (user-error "No branch is checked out"))))
387 388

;;;###autoload
389
(defun magit-pull (source args)
390
  "Pull from a branch read in the minibuffer."
391 392
  (interactive (list (magit-read-remote-branch "Pull" nil nil nil t)
                     (magit-pull-arguments)))
393
  (magit-git-pull source args))
394

395 396
;;; Push

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
(defcustom magit-push-current-set-remote-if-missing t
  "Whether to configure missing remotes before pushing.

When nil, then the command `magit-push-current-to-pushremote' and
`magit-push-current-to-upstream' do not appear in the push popup
if the push-remote resp. upstream is not configured.  If the user
invokes one of these commands anyway, then it raises an error.

When non-nil, then these commands always appear in the push
popup.  But if the required configuration is missing, then they
do appear in a way that indicates that this is the case.  If the
user invokes one of them, then it asks for the necessary
configuration, stores the configuration, and then uses it to push
a first time.

This option also affects whether the argument `--set-upstream' is
available in the popup.  If the value is t, then that argument is
414 415 416
redundant.  But note that changing the value of this option does
not take affect immediately, the argument will only be added or
removed after restarting Emacs."
417
  :package-version '(magit . "2.6.0")
418
  :group 'magit-commands
419 420 421
  :type '(choice (const :tag "don't set" nil)
                 (const :tag "set branch.<name>.pushRemote" t)
                 (const :tag "set remote.pushDefault" default)))
422

Jonas Bernoulli's avatar
Jonas Bernoulli committed
423
;;;###autoload (autoload 'magit-push-popup "magit-remote" nil t)
424 425
(magit-define-popup magit-push-popup
  "Popup console for push commands."
426
  'magit-commands
427
  :man-page "git-push"
428 429 430 431
  :switches `((?f "Force with lease" "--force-with-lease")
              (?F "Force"            "--force")
              (?h "Disable hooks"    "--no-verify")
              (?d "Dry run"          "--dry-run")
432 433
              ,@(and (not magit-push-current-set-remote-if-missing)
                     '((?u "Set upstream"  "--set-upstream"))))
434 435 436
  :actions '("Configure"
             (?C "variables..."      magit-branch-config-popup)
             (lambda ()
437 438 439 440
               (--when-let (magit-get-current-branch)
                 (concat (propertize "Push " 'face 'magit-popup-heading)
                         (propertize it      'face 'magit-branch-local)
                         (propertize " to"   'face 'magit-popup-heading))))
441 442 443 444 445
             (?p magit--push-current-to-pushremote-desc
                 magit-push-current-to-pushremote)
             (?u magit--push-current-to-upstream-desc
                 magit-push-current-to-upstream)
             (?e "elsewhere\n"       magit-push-current)
446
             "Push"
447 448
             (?o "another branch"    magit-push)
             (?T "a tag"             magit-push-tag)
449 450 451
             (?r "explicit refspecs" magit-push-refspecs)
             (?t "all tags"          magit-push-tags)
             (?m "matching branches" magit-push-matching))
452
  :max-action-columns 2)
453

454
(defun magit-git-push (branch target args)
455
  (run-hooks 'magit-credential-hook)
456 457
  (-let [(remote . target)
         (magit-split-branch-name target)]
458 459
    (magit-run-git-async "push" "-v" args remote
                         (format "%s:refs/heads/%s" branch target))))
460

461
;;;###autoload
462
(defun magit-push-current-to-pushremote (args &optional push-remote)
463
  "Push the current branch to `branch.<name>.pushRemote'.
464 465 466 467 468 469 470 471 472
If that variable is unset, then push to `remote.pushDefault'.

When `magit-push-current-set-remote-if-missing' is non-nil and
the push-remote is not configured, then read the push-remote from
the user, set it, and then push to it.  With a prefix argument
the push-remote can be changed before pushed to it."
  (interactive
   (list (magit-push-arguments)
         (and (magit--push-current-set-pushremote-p current-prefix-arg)
473 474 475 476 477
              (magit-read-remote
               (if (eq magit-push-current-set-remote-if-missing 'default)
                   "Set `remote.pushDefault' and push there"
                 (format "Set `branch.%s.pushRemote' and push there"
                         (magit-get-current-branch)))))))
478
  (--if-let (magit-get-current-branch)
479
      (progn (when push-remote
480 481 482 483 484 485
               (setf (magit-get
                      (if (eq magit-push-current-set-remote-if-missing 'default)
                          "remote.pushDefault"
                        (format "branch.%s.pushRemote"
                                (magit-get-current-branch))))
                     push-remote))
486 487 488 489 490
             (-if-let (remote (magit-get-push-remote it))
                 (if (member remote (magit-list-remotes))
                     (magit-git-push it (concat remote "/" it) args)
                   (user-error "Remote `%s' doesn't exist" remote))
               (user-error "No push-remote is configured for %s" it)))
491 492
    (user-error "No branch is checked out")))

493
(defun magit--push-current-set-pushremote-p (&optional change)
494 495 496 497
  (and (or change
           (and magit-push-current-set-remote-if-missing
                (not (magit-get-push-remote))))
       (magit-get-current-branch)))
498 499 500 501 502

(defun magit--push-current-to-pushremote-desc ()
  (--if-let (magit-get-push-branch)
      (concat (magit-branch-set-face it) "\n")
    (and (magit--push-current-set-pushremote-p)
503 504 505 506 507 508
         (concat
          (propertize (if (eq magit-push-current-set-remote-if-missing 'default)
                          "pushDefault"
                        "pushRemote")
                      'face 'bold)
          ", after setting that\n"))))
509

510
;;;###autoload
511 512 513 514 515 516 517 518 519 520
(defun magit-push-current-to-upstream (args &optional upstream)
  "Push the current branch to its upstream branch.

When `magit-push-current-set-remote-if-missing' is non-nil and
the upstream is not configured, then read the upstream from the
user, set it, and then push to it.  With a prefix argument the
upstream can be changed before pushed to it."
  (interactive
   (list (magit-push-arguments)
         (and (magit--push-current-set-upstream-p current-prefix-arg)
521
              (magit-read-upstream-branch))))
522
  (--if-let (magit-get-current-branch)
523 524
      (progn
        (when upstream
525
          (magit-set-branch*merge/remote it upstream))
526 527 528
        (-if-let (target (magit-get-upstream-branch it))
            (magit-git-push it target args)
          (user-error "No upstream is configured for %s" it)))
529
    (user-error "No branch is checked out")))
530

531
(defun magit--push-current-set-upstream-p (&optional change)
532 533 534 535
  (and (or change
           (and magit-push-current-set-remote-if-missing
                (not (magit-get-upstream-branch))))
       (magit-get-current-branch)))
536 537 538 539 540 541 542 543

(defun magit--push-current-to-upstream-desc ()
  (--if-let (magit-get-upstream-branch)
      (concat (magit-branch-set-face it) "\n")
    (and (magit--push-current-set-upstream-p)
         (concat (propertize "@{upstream}" 'face 'bold)
                 ", after setting that\n"))))

544
;;;###autoload
545
(defun magit-push-current (target args)
546 547
  "Push the current branch to a branch read in the minibuffer."
  (interactive
548 549 550
   (--if-let (magit-get-current-branch)
       (list (magit-read-remote-branch (format "Push %s to" it)
                                       nil nil it 'confirm)
551
             (magit-push-arguments))
552 553
     (user-error "No branch is checked out")))
  (magit-git-push (magit-get-current-branch) target args))
554

555
;;;###autoload
556 557 558 559 560 561 562
(defun magit-push (source target args)
  "Push an arbitrary branch or commit somewhere.
Both the source and the target are read in the minibuffer."
  (interactive
   (let ((source (magit-read-local-branch-or-commit "Push")))
     (list source
           (magit-read-remote-branch (format "Push %s to" source) nil
563
                                     (magit-get-upstream-branch source)
564 565 566
                                     source 'confirm)
           (magit-push-arguments))))
  (magit-git-push source target args))
567

568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
;;;###autoload
(defun magit-push-refspecs (remote refspecs args)
  "Push one or multiple REFSPECS to a REMOTE.
Both the REMOTE and the REFSPECS are read in the minibuffer.  To
use multiple REFSPECS, separate them with commas.  Completion is
only available for the part before the colon, or when no colon
is used."
  (interactive
   (list (magit-read-remote "Push to remote")
         (completing-read-multiple
          "Push refspec,s: "
          (cons "HEAD" (magit-list-local-branch-names)))
         (magit-push-arguments)))
  (run-hooks 'magit-credential-hook)
  (magit-run-git-async "push" "-v" args remote refspecs))

584
;;;###autoload
585 586
(defun magit-push-matching (remote &optional args)
  "Push all matching branches to another repository.
587
If multiple remotes exist, then read one from the user.
588
If just one exists, use that without requiring confirmation."
589 590
  (interactive (list (magit-read-remote "Push matching branches to" nil t)
                     (magit-push-arguments)))
591
  (run-hooks 'magit-credential-hook)
592
  (magit-run-git-async "push" "-v" args remote ":"))
593

594
;;;###autoload
595
(defun magit-push-tags (remote &optional args)
596 597 598 599
  "Push all tags to another repository.
If only one remote exists, then push to that.  Otherwise prompt
for a remote, offering the remote configured for the current
branch as default."
600
  (interactive (list (magit-read-remote "Push tags to remote" nil t)
601
                     (magit-push-arguments)))
602
  (run-hooks 'magit-credential-hook)
603
  (magit-run-git-async "push" remote "--tags" args))
604

605 606 607 608 609
;;;###autoload
(defun magit-push-tag (tag remote &optional args)
  "Push a tag to another repository."
  (interactive
   (let  ((tag (magit-read-tag "Push tag")))
610 611
     (list tag (magit-read-remote (format "Push %s to remote" tag) nil t)
           (magit-push-arguments))))
612
  (run-hooks 'magit-credential-hook)
613
  (magit-run-git-async "push" remote tag args))
614

615 616 617 618 619 620 621
;;;###autoload
(defun magit-push-implicitly (args)
  "Push somewhere without using an explicit refspec.

This command simply runs \"git push -v [ARGS]\".  ARGS are the
arguments specified in the popup buffer.  No explicit refspec
arguments are used.  Instead the behavior depends on at least
622
these Git variables: `push.default', `remote.pushDefault',
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
`branch.<branch>.pushRemote', `branch.<branch>.remote',
`branch.<branch>.merge', and `remote.<remote>.push'.

To add this command to the push popup add this to your init file:

  (with-eval-after-load \\='magit-remote
    (magit-define-popup-action \\='magit-push-popup ?P
      'magit-push-implicitly--desc
      'magit-push-implicitly ?p t))

The function `magit-push-implicitly--desc' attempts to predict
what this command will do, the value it returns is displayed in
the popup buffer."
  (interactive (list (magit-push-arguments)))
  (run-hooks 'magit-credential-hook)
638
  (magit-run-git-async "push" "-v" args))
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666

(defun magit-push-implicitly--desc ()
  (let ((default (magit-get "push.default")))
    (unless (equal default "nothing")
      (or (-when-let* ((remote (or (magit-get-remote)
                                   (magit-remote-p "origin")))
                       (refspec (magit-get "remote" remote "push")))
            (format "%s using %s"
                    (propertize remote  'face 'magit-branch-remote)
                    (propertize refspec 'face 'bold)))
          (--when-let (and (not (magit-get-push-branch))
                           (magit-get-upstream-branch))
            (format "%s aka %s\n"
                    (magit-branch-set-face it)
                    (propertize "@{upstream}" 'face 'bold)))
          (--when-let (magit-get-push-branch)
            (format "%s aka %s\n"
                    (magit-branch-set-face it)
                    (propertize "pushRemote" 'face 'bold)))
          (--when-let (magit-get-@{push}-branch)
            (format "%s aka %s\n"
                    (magit-branch-set-face it)
                    (propertize "@{push}" 'face 'bold)))
          (format "using %s (%s is %s)\n"
                  (propertize "git push"     'face 'bold)
                  (propertize "push.default" 'face 'bold)
                  (propertize default        'face 'bold))))))

667 668 669 670 671 672 673 674
;;;###autoload
(defun magit-push-to-remote (remote args)
  "Push to REMOTE without using an explicit refspec.
The REMOTE is read in the minibuffer.

This command simply runs \"git push -v [ARGS] REMOTE\".  ARGS
are the arguments specified in the popup buffer.  No refspec
arguments are used.  Instead the behavior depends on at least
675
these Git variables: `push.default', `remote.pushDefault',
676 677 678 679 680 681 682 683 684 685 686 687
`branch.<branch>.pushRemote', `branch.<branch>.remote',
`branch.<branch>.merge', and `remote.<remote>.push'.

To add this command to the push popup add this to your init file:

  (with-eval-after-load \\='magit-remote
    (magit-define-popup-action \\='magit-push-popup ?r
      'magit-push-to-remote--desc
      'magit-push-to-remote ?p t))"
  (interactive (list (magit-read-remote "Push to remote")
                     (magit-push-arguments)))
  (run-hooks 'magit-credential-hook)
688
  (magit-run-git-async "push" "-v" args remote))
689 690 691 692

(defun magit-push-to-remote--desc ()
  (format "using %s\n" (propertize "git push <remote>" 'face 'bold)))

693 694
;;; Email

Jonas Bernoulli's avatar
Jonas Bernoulli committed
695
;;;###autoload (autoload 'magit-patch-popup "magit-remote" nil t)
696 697
(magit-define-popup magit-patch-popup
  "Popup console for patch commands."
698
  'magit-commands
699
  :man-page "git-format-patch"
700 701
  :switches '("Switches for formatting patches"
              (?l "Add cover letter" "--cover-letter"))
702 703
  :options  '("Options for formatting patches"
              (?f "From"             "--from=")
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
              (?t "To"               "--to=")
              (?c "CC"               "--cc=")
              (?r "In reply to"      "--in-reply-to=")
              (?v "Reroll count"     "--reroll-count=")
              (?s "Thread style"     "--thread=")
              (?U "Context lines"    "-U")
              (?M "Detect renames"   "-M")
              (?C "Detect copies"    "-C")
              (?A "Diff algorithm"   "--diff-algorithm="
                  magit-diff-select-algorithm)
              (?o "Output directory" "--output-directory="))
  :actions  '((?p "Format patches"   magit-format-patch)
              (?r "Request pull"     magit-request-pull))
  :default-action 'magit-format-patch)

719
;;;###autoload
720
(defun magit-format-patch (range args)
721 722 723 724 725
  "Create patches for the commits in RANGE.
When a single commit is given for RANGE, create a patch for the
changes introduced by that commit (unlike 'git format-patch'
which creates patches for all commits that are reachable from
HEAD but not from the specified commit)."
726 727 728
  (interactive
   (list (-if-let (revs (magit-region-values 'commit))
             (concat (car (last revs)) "^.." (car revs))
729 730 731
           (let ((range (magit-read-range-or-commit "Format range or commit")))
             (if (string-match-p "\\.\\." range)
                 range
732 733
               (format "%s~..%s" range range))))
         (magit-patch-arguments)))
734 735
  (magit-call-git "format-patch" range args)
  (when (member "--cover-letter" args)
736 737 738 739 740 741 742 743
    (find-file
     (expand-file-name
      "0000-cover-letter.patch"
      (let ((topdir (magit-toplevel)))
        (or (--some (and (string-match "--output-directory=\\(.+\\)" it)
                         (expand-file-name (match-string 1 it) topdir))
                    args)
            topdir))))))
744 745 746 747 748 749 750 751 752 753 754

;;;###autoload
(defun magit-request-pull (url start end)
  "Request upstream to pull from you public repository.

URL is the url of your publically accessible repository.
START is a commit that already is in the upstream repository.
END is the last commit, usually a branch name, which upstream
is asked to pull.  START has to be reachable from that commit."
  (interactive
   (list (magit-get "remote" (magit-read-remote "Remote") "url")
755
         (magit-read-branch-or-commit "Start" (magit-get-upstream-branch))
756 757 758 759 760 761
         (magit-read-branch-or-commit "End")))
  (let ((dir default-directory))
    ;; mu4e changes default-directory
    (compose-mail)
    (setq default-directory dir))
  (message-goto-body)
762
  (magit-git-insert "request-pull" start url end)
763 764
  (set-buffer-modified-p nil))

765 766 767 768 769 770
;;; magit-remote.el ends soon
(provide 'magit-remote)
;; Local Variables:
;; indent-tabs-mode: nil
;; End:
;;; magit-remote.el ends here