gergely/my-emacs-d
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Update packages

Browse Source
This commit is contained in:
Gergely Polonkai 2016-10-14 11:16:35 +02:00
parent 7817e10c26
commit bf8b81b09f
53 changed files with 1287 additions and 466 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
elpa/focus-20160131.1418/focus-pkg.el
View File

@ -1 +0,0 @@
(define-package "focus" "20160131.1418" "Dim the font color of text in surrounding sections" '((emacs "24") (cl-lib "0.5")) :url "http://github.com/larstvei/Focus")

4
elpa/focus-20160131.1418/focus-autoloads.el → elpa/focus-20161013.401/focus-autoloads.el
View File

@ -1,9 +1,9 @@
;;; focus-autoloads.el --- automatically extracted autoloads ;;; focus-autoloads.el --- automatically extracted autoloads
;; ;;
;;; Code: ;;; Code:
(add-to-list 'load-path (or (file-name-directory #$) (car load-path))) (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil "focus" "focus.el" (22500 1789 464040 629000)) ;;;### (autoloads nil "focus" "focus.el" (22528 41396 501073 373000))
;;; Generated autoloads from focus.el ;;; Generated autoloads from focus.el
(autoload 'focus-mode "focus" "\ (autoload 'focus-mode "focus" "\

2
elpa/focus-20161013.401/focus-pkg.el Normal file
View File

@ -0,0 +1,2 @@
;;; -*- no-byte-compile: t -*-
(define-package "focus" "20161013.401" "Dim the font color of text in surrounding sections" '((emacs "24") (cl-lib "0.5")) :url "http://github.com/larstvei/Focus")

4
elpa/focus-20160131.1418/focus.el → elpa/focus-20161013.401/focus.el
View File

@ -4,7 +4,7 @@
;; Author: Lars Tveito <larstvei@ifi.uio.no> ;; Author: Lars Tveito <larstvei@ifi.uio.no>
;; URL: http://github.com/larstvei/Focus ;; URL: http://github.com/larstvei/Focus
;; Package-Version: 20160131.1418 ;; Package-Version: 20161013.401
;; Created: 11th May 2015 ;; Created: 11th May 2015
;; Version: 0.1.0 ;; Version: 0.1.0
;; Package-Requires: ((emacs "24") (cl-lib "0.5")) ;; Package-Requires: ((emacs "24") (cl-lib "0.5"))
@ -219,7 +219,7 @@ if active."
(thing (focus-get-thing))) (thing (focus-get-thing)))
(forward-thing thing n) (forward-thing thing n)
(when (equal current-bounds (focus-bounds)) (when (equal current-bounds (focus-bounds))
(forward-thing thing (signum n))) (forward-thing thing (cl-signum n)))
(focus-goto-thing (focus-bounds)))) (focus-goto-thing (focus-bounds))))
(defun focus-prev-thing (&optional n) (defun focus-prev-thing (&optional n)

5
elpa/go-mode-20160913.944/go-mode-pkg.el
View File

@ -1,5 +0,0 @@
(define-package "go-mode" "20160913.944" "Major mode for the Go programming language" 'nil :url "https://github.com/dominikh/go-mode.el" :keywords
'("languages" "go"))
;; Local Variables:
;; no-byte-compile: t
;; End:

551
elpa/go-mode-20161013.1055/go-guru.el Normal file
View File

@ -0,0 +1,551 @@
;;; go-guru.el --- Integration of the Go 'guru' analysis tool into Emacs.
;; Copyright 2016 The Go Authors. All rights reserved.
;; Use of this source code is governed by a BSD-style
;; license that can be found in the LICENSE file.
;; Version: 0.1
;; Package-Requires: ((go-mode "1.3.1") (cl-lib "0.5"))
;; Keywords: tools
;;; Commentary:
;; To enable the Go guru in Emacs, use this command to download,
;; build, and install the tool in $GOROOT/bin:
;;
;; $ go get golang.org/x/tools/cmd/guru
;;
;; Verify that the tool is on your $PATH:
;;
;; $ guru -help
;; Go source code guru.
;; Usage: guru [flags] <mode> <position>
;; ...
;;
;; Then copy this file to a directory on your `load-path',
;; and add this to your ~/.emacs:
;;
;; (require 'go-guru)
;;
;; Inside a buffer of Go source code, select an expression of
;; interest, and type `C-c C-o d' (for "describe") or run one of the
;; other go-guru-xxx commands. If you use `menu-bar-mode', these
;; commands are available from the Guru menu.
;;
;; To enable identifier highlighting mode in a Go source buffer, use:
;;
;; (go-guru-hl-identifier-mode)
;;
;; To enable it automatically in all Go source buffers,
;; add this to your ~/.emacs:
;;
;; (add-hook 'go-mode-hook #'go-guru-hl-identifier-mode)
;;
;; See http://golang.org/s/using-guru for more information about guru.
;;; Code:
(require 'compile)
(require 'easymenu)
(require 'go-mode)
(require 'json)
(require 'simple)
(require 'cl-lib)
(defgroup go-guru nil
"Options specific to the Go guru."
:group 'go)
(defcustom go-guru-command "guru"
"The Go guru command."
:type 'string
:group 'go-guru)
(defcustom go-guru-scope ""
"The scope of the analysis. See `go-guru-set-scope'."
:type 'string
:group 'go-guru)
(defvar go-guru--scope-history
nil
"History of values supplied to `go-guru-set-scope'.")
(defcustom go-guru-build-tags ""
"Build tags passed to guru."
:type 'string
:group 'go-guru)
(defface go-guru-hl-identifier-face
'((t (:inherit highlight)))
"Face used for highlighting identifiers in `go-guru-hl-identifier'."
:group 'go-guru)
(defcustom go-guru-debug nil
"Print debug messages when running guru."
:type 'boolean
:group 'go-guru)
(defcustom go-guru-hl-identifier-idle-time 0.5
"How long to wait after user input before highlighting the current identifier."
:type 'float
:group 'go-guru)
(defvar go-guru--current-hl-identifier-idle-time
0
"The current delay for hl-identifier-mode.")
(defvar go-guru--hl-identifier-timer
nil
"The global timer used for highlighting identifiers.")
(defvar go-guru--last-enclosing
nil
"The remaining enclosing regions of the previous go-expand-region invocation.")
;; Extend go-mode-map.
(let ((m (define-prefix-command 'go-guru-map)))
(define-key m "d" #'go-guru-describe)
(define-key m "f" #'go-guru-freevars)
(define-key m "i" #'go-guru-implements)
(define-key m "c" #'go-guru-peers) ; c for channel
(define-key m "r" #'go-guru-referrers)
(define-key m "j" #'go-guru-definition) ; j for jump
(define-key m "p" #'go-guru-pointsto)
(define-key m "s" #'go-guru-callstack) ; s for stack
(define-key m "e" #'go-guru-whicherrs) ; e for error
(define-key m "<" #'go-guru-callers)
(define-key m ">" #'go-guru-callees)
(define-key m "x" #'go-guru-expand-region)) ;; x for expand
(define-key go-mode-map (kbd "C-c C-o") #'go-guru-map)
(easy-menu-define go-guru-mode-menu go-mode-map
"Menu for Go Guru."
'("Guru"
["Jump to Definition" go-guru-definition t]
["Show Referrers" go-guru-referrers t]
["Show Free Names" go-guru-freevars t]
["Describe Expression" go-guru-describe t]
["Show Implements" go-guru-implements t]
"---"
["Show Callers" go-guru-callers t]
["Show Callees" go-guru-callees t]
["Show Callstack" go-guru-callstack t]
"---"
["Show Points-To" go-guru-pointsto t]
["Show Which Errors" go-guru-whicherrs t]
["Show Channel Peers" go-guru-peers t]
"---"
["Set pointer analysis scope..." go-guru-set-scope t]))
;;;###autoload
(defun go-guru-set-scope ()
"Set the scope for the Go guru, prompting the user to edit the previous scope.
The scope restricts analysis to the specified packages.
Its value is a comma-separated list of patterns of these forms:
golang.org/x/tools/cmd/guru # a single package
golang.org/x/tools/... # all packages beneath dir
... # the entire workspace.
A pattern preceded by '-' is negative, so the scope
encoding/...,-encoding/xml
matches all encoding packages except encoding/xml."
(interactive)
(let ((scope (read-from-minibuffer "Go guru scope: "
go-guru-scope
nil
nil
'go-guru--scope-history)))
(if (string-equal "" scope)
(error "You must specify a non-empty scope for the Go guru"))
(setq go-guru-scope scope)))
(defun go-guru--set-scope-if-empty ()
(if (string-equal "" go-guru-scope)
(go-guru-set-scope)))
(defun go-guru--json (mode)
"Execute the Go guru in the specified MODE, passing it the
selected region of the current buffer, requesting JSON output.
Parse and return the resulting JSON object."
;; A "what" query works even in a buffer without a file name.
(let* ((filename (file-truename (or buffer-file-name "synthetic.go")))
(cmd (go-guru--command mode filename '("-json")))
(buf (current-buffer))
;; Use temporary buffers to avoid conflict with go-guru--start.
(json-buffer (generate-new-buffer "*go-guru-json-output*"))
(input-buffer (generate-new-buffer "*go-guru-json-input*")))
(unwind-protect
;; Run guru, feeding it the input buffer (modified files).
(with-current-buffer input-buffer
(go-guru--insert-modified-files)
(unless (buffer-file-name buf)
(go-guru--insert-modified-file filename buf))
(let ((exitcode (apply #'call-process-region
(append (list (point-min)
(point-max)
(car cmd) ; guru
nil ; delete
json-buffer ; output
nil) ; display
(cdr cmd))))) ; args
(with-current-buffer json-buffer
(unless (zerop exitcode)
;; Failed: use buffer contents (sans final \n) as an error.
(error "%s" (buffer-substring (point-min) (1- (point-max)))))
;; Success: parse JSON.
(goto-char (point-min))
(json-read))))
;; Clean up temporary buffers.
(kill-buffer json-buffer)
(kill-buffer input-buffer))))
(define-compilation-mode go-guru-output-mode "Go guru"
"Go guru output mode is a variant of `compilation-mode' for the
output of the Go guru tool."
(set (make-local-variable 'compilation-error-screen-columns) nil)
(set (make-local-variable 'compilation-filter-hook) #'go-guru--compilation-filter-hook)
(set (make-local-variable 'compilation-start-hook) #'go-guru--compilation-start-hook))
(defun go-guru--compilation-filter-hook ()
"Post-process a blob of input to the go-guru-output buffer."
;; For readability, truncate each "file:line:col:" prefix to a fixed width.
;; If the prefix is longer than 20, show "…/last/19chars.go".
;; This usually includes the last segment of the package name.
;; Hide the line and column numbers.
(let ((start compilation-filter-start)
(end (point)))
(goto-char start)
(unless (bolp)
;; TODO(adonovan): not quite right: the filter may be called
;; with chunks of output containing incomplete lines. Moving to
;; beginning-of-line may cause duplicate post-processing.
(beginning-of-line))
(setq start (point))
(while (< start end)
(let ((p (search-forward ": " end t)))
(if (null p)
(setq start end) ; break out of loop
(setq p (1- p)) ; exclude final space
(let* ((posn (buffer-substring-no-properties start p))
(flen (cl-search ":" posn)) ; length of filename
(filename (if (< flen 19)
(substring posn 0 flen)
(concat "…" (substring posn (- flen 19) flen)))))
(put-text-property start p 'display filename)
(forward-line 1)
(setq start (point))))))))
(defun go-guru--compilation-start-hook (proc)
"Erase default output header inserted by `compilation-mode'."
(with-current-buffer (process-buffer proc)
(let ((inhibit-read-only t))
(beginning-of-buffer)
(delete-region (point) (point-max)))))
(defun go-guru--start (mode)
"Start an asynchronous Go guru process for the specified query
MODE, passing it the selected region of the current buffer, and
feeding its standard input with the contents of all modified Go
buffers. Its output is handled by `go-guru-output-mode', a
variant of `compilation-mode'."
(or buffer-file-name
(error "Cannot use guru on a buffer without a file name"))
(let* ((filename (file-truename buffer-file-name))
(cmd (mapconcat #'shell-quote-argument (go-guru--command mode filename) " "))
(process-connection-type nil) ; use pipe (not pty) so EOF closes stdin
(procbuf (compilation-start cmd 'go-guru-output-mode)))
(with-current-buffer procbuf
(setq truncate-lines t)) ; the output is neater without line wrapping
(with-current-buffer (get-buffer-create "*go-guru-input*")
(erase-buffer)
(go-guru--insert-modified-files)
(process-send-region procbuf (point-min) (point-max))
(process-send-eof procbuf))
procbuf))
(defun go-guru--command (mode filename &optional flags)
"Return a command and argument list for a Go guru query of MODE, passing it
the selected region of the current buffer. FILENAME is the
effective name of the current buffer."
(let* ((posn (if (use-region-p)
(format "%s:#%d,#%d"
filename
(1- (go--position-bytes (region-beginning)))
(1- (go--position-bytes (region-end))))
(format "%s:#%d"
filename
(1- (go--position-bytes (point))))))
(cmd (append (list go-guru-command
"-modified"
"-scope" go-guru-scope
(format "-tags=%s" (mapconcat 'identity go-guru-build-tags ",")))
flags
(list mode
posn))))
;; Log the command to *Messages*, for debugging.
(when go-guru-debug
(message "go-guru--command: %s" cmd)
(message nil)) ; clear/shrink minibuffer
cmd))
(defun go-guru--insert-modified-files ()
"Insert the contents of each modified Go buffer into the
current buffer in the format specified by guru's -modified flag."
(mapc #'(lambda (b)
(and (buffer-modified-p b)
(buffer-file-name b)
(string= (file-name-extension (buffer-file-name b)) "go")
(go-guru--insert-modified-file (buffer-file-name b) b)))
(buffer-list)))
(defun go-guru--insert-modified-file (name buffer)
(insert (format "%s\n%d\n" name (go-guru--buffer-size-bytes buffer)))
(insert-buffer-substring buffer))
(defun go-guru--buffer-size-bytes (&optional buffer)
"Return the number of bytes in the current buffer.
If BUFFER, return the number of characters in that buffer instead."
(with-current-buffer (or buffer (current-buffer))
(string-bytes (buffer-substring (point-min)
(point-max)))))
(defun go-guru--goto-byte (offset)
"Go to the OFFSETth byte in the buffer."
(goto-char (byte-to-position offset)))
(defun go-guru--goto-byte-column (offset)
"Go to the OFFSETth byte in the current line."
(goto-char (byte-to-position (+ (position-bytes (point-at-bol)) (1- offset)))))
(defun go-guru--goto-pos (posn)
"Find the file containing the position POSN (of the form `file:line:col')
set the point to it, switching the current buffer."
(let ((file-line-pos (split-string posn ":")))
(find-file (car file-line-pos))
(goto-char (point-min))
(forward-line (1- (string-to-number (cadr file-line-pos))))
(go-guru--goto-byte-column (string-to-number (cl-caddr file-line-pos)))))
(defun go-guru--goto-pos-no-file (posn)
"Given `file:line:col', go to the line and column. The file
component will be ignored."
(let ((file-line-pos (split-string posn ":")))
(goto-char (point-min))
(forward-line (1- (string-to-number (cadr file-line-pos))))
(go-guru--goto-byte-column (string-to-number (cl-caddr file-line-pos)))))
;;;###autoload
(defun go-guru-callees ()
"Show possible callees of the function call at the current point."
(interactive)
(go-guru--set-scope-if-empty)
(go-guru--start "callees"))
;;;###autoload
(defun go-guru-callers ()
"Show the set of callers of the function containing the current point."
(interactive)
(go-guru--set-scope-if-empty)
(go-guru--start "callers"))
;;;###autoload
(defun go-guru-callstack ()
"Show an arbitrary path from a root of the call graph to the
function containing the current point."
(interactive)
(go-guru--set-scope-if-empty)
(go-guru--start "callstack"))
;;;###autoload
(defun go-guru-definition ()
"Jump to the definition of the selected identifier."
(interactive)
(or buffer-file-name
(error "Cannot use guru on a buffer without a file name"))
(let* ((res (go-guru--json "definition"))
(desc (cdr (assoc 'desc res))))
(push-mark)
(ring-insert find-tag-marker-ring (point-marker))
(go-guru--goto-pos (cdr (assoc 'objpos res)))
(message "%s" desc)))
;;;###autoload
(defun go-guru-describe ()
"Describe the selected syntax, its kind, type and methods."
(interactive)
(go-guru--start "describe"))
;;;###autoload
(defun go-guru-pointsto ()
"Show what the selected expression points to."
(interactive)
(go-guru--set-scope-if-empty)
(go-guru--start "pointsto"))
;;;###autoload
(defun go-guru-implements ()
"Describe the 'implements' relation for types in the package
containing the current point."
(interactive)
(go-guru--start "implements"))
;;;###autoload
(defun go-guru-freevars ()
"Enumerate the free variables of the current selection."
(interactive)
(go-guru--start "freevars"))
;;;###autoload
(defun go-guru-peers ()
"Enumerate the set of possible corresponding sends/receives for
this channel receive/send operation."
(interactive)
(go-guru--set-scope-if-empty)
(go-guru--start "peers"))
;;;###autoload
(defun go-guru-referrers ()
"Enumerate all references to the object denoted by the selected
identifier."
(interactive)
(go-guru--start "referrers"))
;;;###autoload
(defun go-guru-whicherrs ()
"Show globals, constants and types to which the selected
expression (of type 'error') may refer."
(interactive)
(go-guru--set-scope-if-empty)
(go-guru--start "whicherrs"))
(defun go-guru-what ()
"Run a 'what' query and return the parsed JSON response as an
association list."
(go-guru--json "what"))
(defun go-guru--hl-symbols (posn face id)
"Highlight the symbols at the positions POSN by creating
overlays with face FACE. The attribute 'go-guru-overlay on the
overlays will be set to ID."
(save-excursion
(mapc (lambda (pos)
(go-guru--goto-pos-no-file pos)
(let ((x (make-overlay (point) (+ (point) (length (current-word))))))
(overlay-put x 'go-guru-overlay id)
(overlay-put x 'face face)))
posn)))
;;;###autoload
(defun go-guru-unhighlight-identifiers ()
"Remove highlights from previously highlighted identifier."
(remove-overlays nil nil 'go-guru-overlay 'sameid))
;;;###autoload
(defun go-guru-hl-identifier ()
"Highlight all instances of the identifier under point. Removes
highlights from previously highlighted identifier."
(interactive)
(go-guru-unhighlight-identifiers)
(go-guru--hl-identifier))
(defun go-guru--hl-identifier ()
"Highlight all instances of the identifier under point."
(let ((posn (cdr (assoc 'sameids (go-guru-what)))))
(go-guru--hl-symbols posn 'go-guru-hl-identifier-face 'sameid)))
(defun go-guru--hl-identifiers-function ()
"Function run after an idle timeout, highlighting the
identifier at point, if necessary."
(when go-guru-hl-identifier-mode
(unless (go-guru--on-overlay-p 'sameid)
;; Ignore guru errors. Otherwise, we might end up with an error
;; every time the timer runs, e.g. because of a malformed
;; buffer.
(condition-case nil
(go-guru-hl-identifier)
(error nil)))
(unless (eq go-guru--current-hl-identifier-idle-time go-guru-hl-identifier-idle-time)
(go-guru--hl-set-timer))))
(defun go-guru--hl-set-timer ()
(if go-guru--hl-identifier-timer
(cancel-timer go-guru--hl-identifier-timer))
(setq go-guru--current-hl-identifier-idle-time go-guru-hl-identifier-idle-time)
(setq go-guru--hl-identifier-timer (run-with-idle-timer
go-guru-hl-identifier-idle-time
t
#'go-guru--hl-identifiers-function)))
;;;###autoload
(define-minor-mode go-guru-hl-identifier-mode
"Highlight instances of the identifier at point after a short
timeout."
:group 'go-guru
(if go-guru-hl-identifier-mode
(progn
(go-guru--hl-set-timer)
;; Unhighlight if point moves off identifier
(add-hook 'post-command-hook #'go-guru--hl-identifiers-post-command-hook nil t)
;; Unhighlight any time the buffer changes
(add-hook 'before-change-functions #'go-guru--hl-identifiers-before-change-function nil t))
(remove-hook 'post-command-hook #'go-guru--hl-identifiers-post-command-hook t)
(remove-hook 'before-change-functions #'go-guru--hl-identifiers-before-change-function t)
(go-guru-unhighlight-identifiers)))
(defun go-guru--on-overlay-p (id)
"Return whether point is on a guru overlay of type ID."
(cl-find-if (lambda (el) (eq (overlay-get el 'go-guru-overlay) id)) (overlays-at (point))))
(defun go-guru--hl-identifiers-post-command-hook ()
(if (and go-guru-hl-identifier-mode
(not (go-guru--on-overlay-p 'sameid)))
(go-guru-unhighlight-identifiers)))
(defun go-guru--hl-identifiers-before-change-function (_beg _end)
(go-guru-unhighlight-identifiers))
;; TODO(dominikh): a future feature may be to cycle through all uses
;; of an identifier.
(defun go-guru--enclosing ()
"Return a list of enclosing regions."
(cdr (assoc 'enclosing (go-guru-what))))
(defun go-guru--enclosing-unique ()
"Return a list of enclosing regions, with duplicates removed.
Two regions are considered equal if they have the same start and
end point."
(let ((enclosing (go-guru--enclosing)))
(cl-remove-duplicates enclosing
:from-end t
:test (lambda (a b)
(and (= (cdr (assoc 'start a))
(cdr (assoc 'start b)))
(= (cdr (assoc 'end a))
(cdr (assoc 'end b))))))))
(defun go-guru-expand-region ()
"Expand region to the next enclosing syntactic unit."
(interactive)
(let* ((enclosing (if (eq last-command #'go-guru-expand-region)
go-guru--last-enclosing
(go-guru--enclosing-unique)))
(block (if (> (length enclosing) 0) (elt enclosing 0))))
(when block
(go-guru--goto-byte (1+ (cdr (assoc 'start block))))
(set-mark (byte-to-position (1+ (cdr (assoc 'end block)))))
(setq go-guru--last-enclosing (cl-subseq enclosing 1))
(message "Region: %s" (cdr (assoc 'desc block)))
(setq deactivate-mark nil))))
(provide 'go-guru)
;; Local variables:
;; indent-tabs-mode: t
;; tab-width: 8
;; End
;;; go-guru.el ends here

106
elpa/go-mode-20160913.944/go-mode-autoloads.el → elpa/go-mode-20161013.1055/go-mode-autoloads.el
View File

@ -3,8 +3,106 @@
;;; Code: ;;; Code:
;;;### (autoloads nil "go-mode" "go-mode.el" (22490 24935 827407 ;;;### (autoloads nil "go-guru" "go-guru.el" (22528 41395 701074
;;;;;; 200000)) ;;;;;; 26000))
;;; Generated autoloads from go-guru.el
(autoload 'go-guru-set-scope "go-guru" "\
Set the scope for the Go guru, prompting the user to edit the previous scope.
The scope restricts analysis to the specified packages.
Its value is a comma-separated list of patterns of these forms:
golang.org/x/tools/cmd/guru # a single package
golang.org/x/tools/... # all packages beneath dir
... # the entire workspace.
A pattern preceded by '-' is negative, so the scope
encoding/...,-encoding/xml
matches all encoding packages except encoding/xml.
\(fn)" t nil)
(autoload 'go-guru-callees "go-guru" "\
Show possible callees of the function call at the current point.
\(fn)" t nil)
(autoload 'go-guru-callers "go-guru" "\
Show the set of callers of the function containing the current point.
\(fn)" t nil)
(autoload 'go-guru-callstack "go-guru" "\
Show an arbitrary path from a root of the call graph to the
function containing the current point.
\(fn)" t nil)
(autoload 'go-guru-definition "go-guru" "\
Jump to the definition of the selected identifier.
\(fn)" t nil)
(autoload 'go-guru-describe "go-guru" "\
Describe the selected syntax, its kind, type and methods.
\(fn)" t nil)
(autoload 'go-guru-pointsto "go-guru" "\
Show what the selected expression points to.
\(fn)" t nil)
(autoload 'go-guru-implements "go-guru" "\
Describe the 'implements' relation for types in the package
containing the current point.
\(fn)" t nil)
(autoload 'go-guru-freevars "go-guru" "\
Enumerate the free variables of the current selection.
\(fn)" t nil)
(autoload 'go-guru-peers "go-guru" "\
Enumerate the set of possible corresponding sends/receives for
this channel receive/send operation.
\(fn)" t nil)
(autoload 'go-guru-referrers "go-guru" "\
Enumerate all references to the object denoted by the selected
identifier.
\(fn)" t nil)
(autoload 'go-guru-whicherrs "go-guru" "\
Show globals, constants and types to which the selected
expression (of type 'error') may refer.
\(fn)" t nil)
(autoload 'go-guru-unhighlight-identifiers "go-guru" "\
Remove highlights from previously highlighted identifier.
\(fn)" nil nil)
(autoload 'go-guru-hl-identifier "go-guru" "\
Highlight all instances of the identifier under point. Removes
highlights from previously highlighted identifier.
\(fn)" t nil)
(autoload 'go-guru-hl-identifier-mode "go-guru" "\
Highlight instances of the identifier at point after a short
timeout.
\(fn &optional ARG)" t nil)
;;;***
;;;### (autoloads nil "go-mode" "go-mode.el" (22528 41395 693074
;;;;;; 32000))
;;; Generated autoloads from go-mode.el ;;; Generated autoloads from go-mode.el
(autoload 'go-mode "go-mode" "\ (autoload 'go-mode "go-mode" "\
@ -96,8 +194,8 @@ Tries to look for a URL at point.
;;;*** ;;;***
;;;### (autoloads nil nil ("go-mode-pkg.el") (22490 24935 844909 ;;;### (autoloads nil nil ("go-mode-pkg.el") (22528 41395 685074
;;;;;; 520000)) ;;;;;; 38000))
;;;*** ;;;***

5
elpa/go-mode-20161013.1055/go-mode-pkg.el Normal file
View File

@ -0,0 +1,5 @@
(define-package "go-mode" "20161013.1055" "Major mode for the Go programming language" 'nil :url "https://github.com/dominikh/go-mode.el" :keywords
'("languages" "go"))
;; Local Variables:
;; no-byte-compile: t
;; End:

0
elpa/go-mode-20160913.944/go-mode.el → elpa/go-mode-20161013.1055/go-mode.el
View File

0
elpa/js2-mode-20161009.341/js2-imenu-extras.el → elpa/js2-mode-20161013.1644/js2-imenu-extras.el
View File

10
elpa/js2-mode-20161009.341/js2-mode-autoloads.el → elpa/js2-mode-20161013.1644/js2-mode-autoloads.el
View File

@ -3,8 +3,8 @@
;;; Code: ;;; Code:
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (22523 ;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (22528
;;;;;; 21232 276321 957000)) ;;;;;; 31234 288278 643000))
;;; Generated autoloads from js2-imenu-extras.el ;;; Generated autoloads from js2-imenu-extras.el
(autoload 'js2-imenu-extras-setup "js2-imenu-extras" "\ (autoload 'js2-imenu-extras-setup "js2-imenu-extras" "\
@ -19,8 +19,8 @@ Toggle Imenu support for frameworks and structural patterns.
;;;*** ;;;***
;;;### (autoloads nil "js2-mode" "js2-mode.el" (22523 21232 296322 ;;;### (autoloads nil "js2-mode" "js2-mode.el" (22528 31234 308278
;;;;;; 105000)) ;;;;;; 621000))
;;; Generated autoloads from js2-mode.el ;;; Generated autoloads from js2-mode.el
(autoload 'js2-highlight-unused-variables-mode "js2-mode" "\ (autoload 'js2-highlight-unused-variables-mode "js2-mode" "\
@ -56,7 +56,7 @@ variables (`sgml-basic-offset' et al) locally, like so:
;;;*** ;;;***
;;;### (autoloads nil nil ("js2-mode-pkg.el" "js2-old-indent.el") ;;;### (autoloads nil nil ("js2-mode-pkg.el" "js2-old-indent.el")
;;;;;; (22523 21232 288322 46000)) ;;;;;; (22528 31234 300278 630000))
;;;*** ;;;***

2
elpa/js2-mode-20161009.341/js2-mode-pkg.el → elpa/js2-mode-20161013.1644/js2-mode-pkg.el
View File

@ -1,4 +1,4 @@
(define-package "js2-mode" "20161009.341" "Improved JavaScript editing mode" (define-package "js2-mode" "20161013.1644" "Improved JavaScript editing mode"
'((emacs "24.1") '((emacs "24.1")
(cl-lib "0.5")) (cl-lib "0.5"))
:url "https://github.com/mooz/js2-mode/" :keywords :url "https://github.com/mooz/js2-mode/" :keywords

73
elpa/js2-mode-20161009.341/js2-mode.el → elpa/js2-mode-20161013.1644/js2-mode.el
View File

@ -115,7 +115,7 @@
decodeURI decodeURIComponent encodeURI decodeURI decodeURIComponent encodeURI
encodeURIComponent escape eval isFinite isNaN encodeURIComponent escape eval isFinite isNaN
parseFloat parseInt undefined unescape)) parseFloat parseInt undefined unescape))
"Ecma-262 externs. Included in `js2-externs' by default.") "Ecma-262 externs. Never highlighted as undeclared variables.")
(defvar js2-browser-externs (defvar js2-browser-externs
(mapcar 'symbol-name (mapcar 'symbol-name
@ -789,28 +789,10 @@ Will only be used when we finish implementing the interpreter.")
(defcustom js2-global-externs nil (defcustom js2-global-externs nil
"A list of any extern names you'd like to consider always declared. "A list of any extern names you'd like to consider always declared.
This list is global and is used by all `js2-mode' files. This list is global and is used by all `js2-mode' files.
You can create buffer-local externs list using `js2-additional-externs'. You can create buffer-local externs list using `js2-additional-externs'."
There is also a buffer-local variable `js2-default-externs',
which is initialized by default to include the Ecma-262 externs
and the standard browser externs. The three lists are all
checked during highlighting."
:type 'list :type 'list
:group 'js2-mode) :group 'js2-mode)
(js2-deflocal js2-default-externs nil
"Default external declarations.
These are currently only used for highlighting undeclared variables,
which only worries about top-level (unqualified) references.
As js2-mode's processing improves, we will flesh out this list.
The initial value is set to `js2-ecma-262-externs', unless some
of the `js2-include-?-externs' variables are set to t, in which
case the browser, Rhino and/or Node.js externs are also included.
See `js2-additional-externs' for more information.")
(defcustom js2-include-browser-externs t (defcustom js2-include-browser-externs t
"Non-nil to include browser externs in the master externs list. "Non-nil to include browser externs in the master externs list.
If you work on JavaScript files that are not intended for browsers, If you work on JavaScript files that are not intended for browsers,
@ -834,7 +816,7 @@ See `js2-additional-externs' for more information about externs."
(js2-deflocal js2-additional-externs nil (js2-deflocal js2-additional-externs nil
"A buffer-local list of additional external declarations. "A buffer-local list of additional external declarations.
It is used to decide whether variables are considered undeclared It is used to decide whether variables are considered undeclared
for purposes of highlighting. for purposes of highlighting. See `js2-highlight-undeclared-vars'.
Each entry is a Lisp string. The string should be the fully qualified Each entry is a Lisp string. The string should be the fully qualified
name of an external entity. All externs should be added to this list, name of an external entity. All externs should be added to this list,
@ -1122,7 +1104,7 @@ another file, or you've got a potential bug."
(defcustom js2-include-jslint-globals t (defcustom js2-include-jslint-globals t
"Non-nil to include the identifiers from JSLint global "Non-nil to include the identifiers from JSLint global
declaration (see http://www.jslint.com/lint.html#global) in the declaration (see http://www.jslint.com/help.html#global) in the
buffer-local externs list. See `js2-additional-externs' for more buffer-local externs list. See `js2-additional-externs' for more
information." information."
:type 'boolean :type 'boolean
@ -7090,16 +7072,37 @@ later. NODE must be a name node."
(defun js2-highlight-undeclared-vars () (defun js2-highlight-undeclared-vars ()
"After entire parse is finished, look for undeclared variable references. "After entire parse is finished, look for undeclared variable references.
We have to wait until entire buffer is parsed, since JavaScript permits var We have to wait until entire buffer is parsed, since JavaScript permits var
decls to occur after they're used. declarations to occur after they're used.
If any undeclared var name is in `js2-externs' or `js2-additional-externs', Some identifiers may be assumed to be externally defined.
it is considered declared." These externs are not highlighted, even if there is no declaration
(let (name) for them in the source code (in the current file).
The list of externs consists of the following:
- `js2-ecma262-externs' for basic names from the ECMAScript language standard.
- Depending on the buffer-local variables `js2-include-*-externs'
the corresponding `js2-*-externs' to add names for certain environments
like the browser, Node or Rhino.
- Two customizable lists `js2-global-externs' and `js2-additional-externs',
the latter of which should be set per-buffer.
See especially `js2-additional-externs' for further details about externs."
(let ((default-externs
(append js2-ecma-262-externs
(if (and js2-include-browser-externs
(>= js2-language-version 200)) js2-harmony-externs)
(if js2-include-rhino-externs js2-rhino-externs)
(if js2-include-node-externs js2-node-externs)
(if (or js2-include-browser-externs js2-include-node-externs)
js2-typed-array-externs)
(if js2-include-browser-externs js2-browser-externs)))
name)
(dolist (entry js2-recorded-identifiers) (dolist (entry js2-recorded-identifiers)
(cl-destructuring-bind (name-node scope pos end) entry (cl-destructuring-bind (name-node scope pos end) entry
(setq name (js2-name-node-name name-node)) (setq name (js2-name-node-name name-node))
(unless (or (member name js2-global-externs) (unless (or (member name js2-global-externs)
(member name js2-default-externs) (member name default-externs)
(member name js2-additional-externs) (member name js2-additional-externs)
(js2-get-defining-scope scope name pos)) (js2-get-defining-scope scope name pos))
(js2-report-warning "msg.undeclared.variable" name pos (- end pos) (js2-report-warning "msg.undeclared.variable" name pos (- end pos)
@ -7259,19 +7262,6 @@ are ignored."
(remove-hook 'js2-post-parse-callbacks (remove-hook 'js2-post-parse-callbacks
#'js2-highlight-unused-variables t))) #'js2-highlight-unused-variables t)))
(defun js2-set-default-externs ()
"Set the value of `js2-default-externs' based on the various
`js2-include-?-externs' variables."
(setq js2-default-externs
(append js2-ecma-262-externs
(if js2-include-browser-externs js2-browser-externs)
(if (and js2-include-browser-externs
(>= js2-language-version 200)) js2-harmony-externs)
(if js2-include-rhino-externs js2-rhino-externs)
(if js2-include-node-externs js2-node-externs)
(if (or js2-include-browser-externs js2-include-node-externs)
js2-typed-array-externs))))
(defun js2-apply-jslint-globals () (defun js2-apply-jslint-globals ()
(setq js2-additional-externs (setq js2-additional-externs
(nconc (js2-get-jslint-globals) (nconc (js2-get-jslint-globals)
@ -11421,7 +11411,6 @@ highlighting features of `js2-mode'."
(set (make-local-variable 'max-lisp-eval-depth) (set (make-local-variable 'max-lisp-eval-depth)
(max max-lisp-eval-depth 3000)) (max max-lisp-eval-depth 3000))
(setq next-error-function #'js2-next-error) (setq next-error-function #'js2-next-error)
(js2-set-default-externs)
;; Experiment: make reparse-delay longer for longer files. ;; Experiment: make reparse-delay longer for longer files.
(if (cl-plusp js2-dynamic-idle-timer-adjust) (if (cl-plusp js2-dynamic-idle-timer-adjust)
(setq js2-idle-timer-delay (setq js2-idle-timer-delay
@ -11600,8 +11589,6 @@ Selecting an error will jump it to the corresponding source-buffer error.
js2-mode-buffer-dirty-p t js2-mode-buffer-dirty-p t
js2-mode-parsing nil) js2-mode-parsing nil)
(js2-set-default-externs)
(when js2-include-jslint-globals (when js2-include-jslint-globals
(add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t)) (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t))

0
elpa/js2-mode-20161009.341/js2-old-indent.el → elpa/js2-mode-20161013.1644/js2-old-indent.el
View File

177
elpa/magit-20161012.1035/magit.info
View File

@ -1,177 +0,0 @@
This is magit.info, produced by makeinfo version 5.2 from magit.texi.
Magit is an interface to the version control system Git, implemented as
an Emacs package. Magit aspires to be a complete Git porcelain. While
we cannot (yet) claim that Magit wraps and improves upon each and every
Git command, it is complete enough to allow even experienced Git users
to perform almost all of their daily version control tasks directly from
within Emacs. While many fine Git clients exist, only Magit and Git
itself deserve to be called porcelains.
Copyright (C) 2015-2016 Jonas Bernoulli <jonas@bernoul.li>
You can redistribute this document and/or modify it under the terms
of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option)
any later version.
This document 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.
INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Magit: (magit). Using Git from Emacs with Magit.
END-INFO-DIR-ENTRY

Indirect:
magit.info-1: 1222
magit.info-2: 321010

Tag Table:
(Indirect)
Node: Top1222
Node: Introduction6446
Node: Installation11169
Node: Updating from an older release11544
Node: Installing from an Elpa archive13139
Node: Installing from the Git repository14478
Node: Post-installation tasks17325
Node: Getting started18714
Node: Interface concepts24443
Node: Modes and Buffers24717
Node: Switching Buffers26462
Node: Naming Buffers31003
Node: Quitting Windows33838
Node: Automatic Refreshing of Magit Buffers35470
Node: Automatic Saving of File-Visiting Buffers38238
Node: Automatic Reverting of File-Visiting Buffers39423
Node: Risk of Reverting Automatically44419
Node: Sections46802
Node: Section movement47743
Node: Section visibility51670
Node: Section hooks55261
Node: Section types and values57542
Node: Section options58812
Node: Popup buffers and prefix commands59284
Node: Completion and confirmation60598
Node: Running Git63504
Node: Viewing Git output63740
Node: Running Git manually64740
Node: Git executable66866
Node: Global Git arguments68873
Node: Inspecting69680
Node: Status buffer70827
Node: Status sections73692
Node: Status header sections79571
Node: Status options82128
Node: Repository list82852
Node: Logging85010
Node: Refreshing logs87748
Node: Log Buffer89133
Node: Select from log92429
Node: Reflog93369
Node: Diffing93847
Node: Refreshing diffs96867
Node: Diff buffer99848
Node: Diff options102074
Node: Revision buffer105440
Node: Ediffing106395
Node: References buffer109985
Node: References sections114695
Node: Bisecting115570
Node: Visiting blobs117309
Node: Blaming117818
Node: Manipulating121248
Node: Repository setup121564
Node: Staging and unstaging122604
Node: Staging from file-visiting buffers126693
Node: Applying127861
Node: Committing129754
Node: Initiating a commit130337
Node: Editing commit messages133649
Node: Branching144045
Node: The two remotes144245
Node: The branch popup146789
Node: The branch config popup156025
Node: Merging161931
Node: Resolving conflicts164099
Ref: orgradiotarget1165184
Node: Rebasing169056
Node: Editing rebase sequences172697
Node: Information about in-progress rebase175727
Ref: Information about in-progress rebase-Footnote-1182563
Node: Cherry picking183149
Node: Reverting184755
Node: Resetting186118
Node: Stashing187630
Node: Transferring190804
Node: Remotes191042
Node: Fetching192328
Node: Pulling193694
Node: Pushing194540
Node: Creating and sending patches199284
Node: Applying patches199979
Node: Miscellaneous200977
Node: Tagging201280
Node: Notes202065
Node: Submodules204590
Node: Listing submodules204805
Node: Submodule popup206624
Node: Subtree207907
Node: Common commands209155
Node: Wip modes210900
Node: Minor mode for buffers visiting files217636
Node: Minor mode for buffers visiting blobs221110
Node: Customizing221915
Node: Per-repository configuration223587
Node: Essential settings225221
Node: Safety225545
Node: Performance227378
Node: Plumbing235340
Node: Calling Git236164
Node: Getting a value from Git237687
Node: Calling Git for effect240791
Node: Section plumbing247295
Node: Creating sections247523
Node: Section selection251422
Node: Matching sections253102
Node: Refreshing buffers258311
Node: Conventions261446
Node: Confirmation and completion261623
Node: Theming Faces262521
Node: FAQ270672
Node: Magit is slow272285
Node: I changed several thousand files at once and now Magit is unusable272486
Node: I am having problems committing273202
Node: Diffs are collapsed after un-/staging273648
Node: I don't understand how branching and pushing work275126
Node: I don't like the key binding in v24275501
Node: I cannot install the pre-requisites for Magit v2275840
Node: I am using an Emacs release older than v244276305
Node: I am using a Git release older than v194277918
Node: I am using MS Windows and cannot push with Magit278905
Node: I am using OS X and SOMETHING works in shell but not in Magit279509
Node: How to install the gitman info manual?280300
Node: How can I show Git's output?282841
Node: Diffs contain control sequences283628
Node: Expanding a file to show the diff causes it to disappear284633
Node: Point is wrong in the ‘COMMIT_EDITMSG’ buffer285168
Node: The mode-line information isn't always up-to-date286198
Node: Can Magit be used as ‘ediff-version-control-package’?287266
Node: How to show diffs for gpg-encrypted files?289310
Node: Emacs 245 hangs when loading Magit289907
Node: Symbol's value as function is void ‘--some’290482
Node: Where is the branch manager290816
Node: Keystroke Index291107
Node: Command Index321010
Node: Function Index351019
Node: Variable Index364913

End Tag Table

Local Variables:
coding: utf-8
End:

0
elpa/magit-20161012.1035/AUTHORS.md → elpa/magit-20161013.1332/AUTHORS.md
View File

0
elpa/magit-20161012.1035/COPYING → elpa/magit-20161013.1332/COPYING
View File

0
elpa/magit-20161012.1035/dir → elpa/magit-20161013.1332/dir
View File

4
elpa/magit-20161012.1035/git-rebase.el → elpa/magit-20161013.1332/git-rebase.el
View File

@ -419,7 +419,9 @@ running 'man git-rebase' at the command line) for details."
(setq save-place nil))) (setq save-place nil)))
(defun git-rebase-cancel-confirm (force) (defun git-rebase-cancel-confirm (force)
(or (not (buffer-modified-p)) force (magit-y-or-n-p "Abort this rebase? "))) (or (not (buffer-modified-p))
force
(magit-confirm 'abort-rebase "Abort this rebase")))
(defun git-rebase-autostash-save () (defun git-rebase-autostash-save ()
(--when-let (magit-file-line (magit-git-dir "rebase-merge/autostash")) (--when-let (magit-file-line (magit-git-dir "rebase-merge/autostash"))

0
elpa/magit-20161012.1035/magit-apply.el → elpa/magit-20161013.1332/magit-apply.el
View File

68
elpa/magit-20161012.1035/magit-autoloads.el → elpa/magit-20161013.1332/magit-autoloads.el
View File

@ -3,8 +3,8 @@
;;; Code: ;;; Code:
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil "git-rebase" "git-rebase.el" (22527 12701 974689 ;;;### (autoloads nil "git-rebase" "git-rebase.el" (22528 41393 93076
;;;;;; 557000)) ;;;;;; 154000))
;;; Generated autoloads from git-rebase.el ;;; Generated autoloads from git-rebase.el
(autoload 'git-rebase-mode "git-rebase" "\ (autoload 'git-rebase-mode "git-rebase" "\
@ -23,7 +23,7 @@ running 'man git-rebase' at the command line) for details.
;;;*** ;;;***
;;;### (autoloads nil "magit" "magit.el" (22527 12702 54689 632000)) ;;;### (autoloads nil "magit" "magit.el" (22528 41393 173076 88000))
;;; Generated autoloads from magit.el ;;; Generated autoloads from magit.el
(autoload 'magit-status "magit" "\ (autoload 'magit-status "magit" "\
@ -501,8 +501,8 @@ Git, and Emacs in the echo area.
;;;*** ;;;***
;;;### (autoloads nil "magit-apply" "magit-apply.el" (22527 12701 ;;;### (autoloads nil "magit-apply" "magit-apply.el" (22528 41393
;;;;;; 994689 575000)) ;;;;;; 113076 138000))
;;; Generated autoloads from magit-apply.el ;;; Generated autoloads from magit-apply.el
(autoload 'magit-stage-file "magit-apply" "\ (autoload 'magit-stage-file "magit-apply" "\
@ -538,8 +538,8 @@ Remove all changes from the staging area.
;;;*** ;;;***
;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (22527 ;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (22528
;;;;;; 12701 942689 527000)) ;;;;;; 41393 49076 189000))
;;; Generated autoloads from magit-autorevert.el ;;; Generated autoloads from magit-autorevert.el
(defvar magit-revert-buffers t) (defvar magit-revert-buffers t)
@ -568,8 +568,8 @@ See `auto-revert-mode' for more information on Auto-Revert mode.
;;;*** ;;;***
;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (22527 12701 ;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (22528 41393
;;;;;; 990689 572000)) ;;;;;; 109076 140000))
;;; Generated autoloads from magit-bisect.el ;;; Generated autoloads from magit-bisect.el
(autoload 'magit-bisect-popup "magit-bisect" nil t) (autoload 'magit-bisect-popup "magit-bisect" nil t)
@ -620,8 +620,8 @@ bisect run'.
;;;*** ;;;***
;;;### (autoloads nil "magit-blame" "magit-blame.el" (22527 12702 ;;;### (autoloads nil "magit-blame" "magit-blame.el" (22528 41393
;;;;;; 38689 617000)) ;;;;;; 161076 99000))
;;; Generated autoloads from magit-blame.el ;;; Generated autoloads from magit-blame.el
(autoload 'magit-blame-popup "magit-blame" nil t) (autoload 'magit-blame-popup "magit-blame" nil t)
@ -645,8 +645,8 @@ only arguments available from `magit-blame-popup' should be used.
;;;*** ;;;***
;;;### (autoloads nil "magit-commit" "magit-commit.el" (22527 12701 ;;;### (autoloads nil "magit-commit" "magit-commit.el" (22528 41393
;;;;;; 950689 534000)) ;;;;;; 57076 182000))
;;; Generated autoloads from magit-commit.el ;;; Generated autoloads from magit-commit.el
(autoload 'magit-commit "magit-commit" "\ (autoload 'magit-commit "magit-commit" "\
@ -728,8 +728,8 @@ Create a squash commit targeting COMMIT and instantly rebase.
;;;*** ;;;***
;;;### (autoloads nil "magit-diff" "magit-diff.el" (22527 12702 34689 ;;;### (autoloads nil "magit-diff" "magit-diff.el" (22528 41393 157076
;;;;;; 614000)) ;;;;;; 101000))
;;; Generated autoloads from magit-diff.el ;;; Generated autoloads from magit-diff.el
(autoload 'magit-diff-popup "magit-diff" "\ (autoload 'magit-diff-popup "magit-diff" "\
@ -813,8 +813,8 @@ for a revision.
;;;*** ;;;***
;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (22527 12702 ;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (22528 41393
;;;;;; 18689 598000)) ;;;;;; 145076 110000))
;;; Generated autoloads from magit-ediff.el ;;; Generated autoloads from magit-ediff.el
(autoload 'magit-ediff-popup "magit-ediff" nil t) (autoload 'magit-ediff-popup "magit-ediff" nil t)
@ -902,8 +902,8 @@ stash that were staged.
;;;*** ;;;***
;;;### (autoloads nil "magit-extras" "magit-extras.el" (22527 12701 ;;;### (autoloads nil "magit-extras" "magit-extras.el" (22528 41393
;;;;;; 954689 537000)) ;;;;;; 61076 179000))
;;; Generated autoloads from magit-extras.el ;;; Generated autoloads from magit-extras.el
(autoload 'magit-run-git-gui "magit-extras" "\ (autoload 'magit-run-git-gui "magit-extras" "\
@ -973,8 +973,8 @@ on a position in a file-visiting buffer.
;;;*** ;;;***
;;;### (autoloads nil "magit-log" "magit-log.el" (22527 12702 26689 ;;;### (autoloads nil "magit-log" "magit-log.el" (22528 41393 149076
;;;;;; 605000)) ;;;;;; 107000))
;;; Generated autoloads from magit-log.el ;;; Generated autoloads from magit-log.el
(autoload 'magit-log-buffer-file-popup "magit-log" "\ (autoload 'magit-log-buffer-file-popup "magit-log" "\
@ -1056,8 +1056,8 @@ Show commits in a branch that are not merged in the upstream branch.
;;;*** ;;;***
;;;### (autoloads nil "magit-remote" "magit-remote.el" (22527 12702 ;;;### (autoloads nil "magit-remote" "magit-remote.el" (22528 41393
;;;;;; 66689 643000)) ;;;;;; 189076 75000))
;;; Generated autoloads from magit-remote.el ;;; Generated autoloads from magit-remote.el
(autoload 'magit-clone "magit-remote" "\ (autoload 'magit-clone "magit-remote" "\
@ -1289,8 +1289,8 @@ is asked to pull. START has to be reachable from that commit.
;;;*** ;;;***
;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (22527 ;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (22528
;;;;;; 12702 58689 636000)) ;;;;;; 41393 177076 85000))
;;; Generated autoloads from magit-sequence.el ;;; Generated autoloads from magit-sequence.el
(autoload 'magit-sequencer-continue "magit-sequence" "\ (autoload 'magit-sequencer-continue "magit-sequence" "\
@ -1440,8 +1440,8 @@ Abort the current rebase operation, restoring the original branch.
;;;*** ;;;***
;;;### (autoloads nil "magit-stash" "magit-stash.el" (22527 12702 ;;;### (autoloads nil "magit-stash" "magit-stash.el" (22528 41393
;;;;;; 10689 590000)) ;;;;;; 133076 121000))
;;; Generated autoloads from magit-stash.el ;;; Generated autoloads from magit-stash.el
(autoload 'magit-stash-popup "magit-stash" nil t) (autoload 'magit-stash-popup "magit-stash" nil t)
@ -1540,8 +1540,8 @@ Show all diffs of a stash in a buffer.
;;;*** ;;;***
;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (22527 ;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (22528
;;;;;; 12702 78689 654000)) ;;;;;; 41393 213076 56000))
;;; Generated autoloads from magit-submodule.el ;;; Generated autoloads from magit-submodule.el
(autoload 'magit-submodule-popup "magit-submodule" nil t) (autoload 'magit-submodule-popup "magit-submodule" nil t)
@ -1631,8 +1631,8 @@ Display a list of the current repository's submodules.
;;;*** ;;;***
;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (22527 12701 ;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (22528 41393
;;;;;; 978689 560000)) ;;;;;; 101076 146000))
;;; Generated autoloads from magit-subtree.el ;;; Generated autoloads from magit-subtree.el
(autoload 'magit-subtree-popup "magit-subtree" nil t) (autoload 'magit-subtree-popup "magit-subtree" nil t)
@ -1668,8 +1668,8 @@ Extract the history of the subtree PREFIX.
;;;*** ;;;***
;;;### (autoloads nil "magit-wip" "magit-wip.el" (22527 12701 962689 ;;;### (autoloads nil "magit-wip" "magit-wip.el" (22528 41393 73076
;;;;;; 545000)) ;;;;;; 170000))
;;; Generated autoloads from magit-wip.el ;;; Generated autoloads from magit-wip.el
(defvar magit-wip-after-save-mode nil "\ (defvar magit-wip-after-save-mode nil "\
@ -1739,7 +1739,7 @@ command which is about to be called are committed.
;;;### (autoloads nil nil ("magit-core.el" "magit-git.el" "magit-mode.el" ;;;### (autoloads nil nil ("magit-core.el" "magit-git.el" "magit-mode.el"
;;;;;; "magit-pkg.el" "magit-process.el" "magit-section.el" "magit-utils.el") ;;;;;; "magit-pkg.el" "magit-process.el" "magit-section.el" "magit-utils.el")
;;;;;; (22527 12702 70689 646000)) ;;;;;; (22528 41393 197076 69000))
;;;*** ;;;***

0
elpa/magit-20161012.1035/magit-autorevert.el → elpa/magit-20161013.1332/magit-autorevert.el
View File

0
elpa/magit-20161012.1035/magit-bisect.el → elpa/magit-20161013.1332/magit-bisect.el
View File

0
elpa/magit-20161012.1035/magit-blame.el → elpa/magit-20161013.1332/magit-blame.el
View File

0
elpa/magit-20161012.1035/magit-commit.el → elpa/magit-20161013.1332/magit-commit.el
View File

0
elpa/magit-20161012.1035/magit-core.el → elpa/magit-20161013.1332/magit-core.el
View File

192
elpa/magit-20161012.1035/magit-diff.el → elpa/magit-20161013.1332/magit-diff.el
View File

@ -207,6 +207,20 @@ many spaces. Otherwise, highlight neither."
:group 'magit-diff :group 'magit-diff
:type 'boolean) :type 'boolean)
(defcustom magit-diff-visit-previous-blob t
"Whether `magit-diff-visit-file' may visit the previous blob.
When this is t and point is on a removed line in a diff for a
committed change, then `magit-diff-visit-file' visits the blob
from the last revision which still had that line.
Currently this is only supported for committed changes, for
staged and unstaged changes `magit-diff-visit-file' always
visits the file in the working tree."
:package-version '(magit . "2.9.0")
:group 'magit-diff
:type 'boolean)
;;;; File Diff ;;;; File Diff
(defcustom magit-diff-buffer-file-locked t (defcustom magit-diff-buffer-file-locked t
@ -498,6 +512,7 @@ and `:slant'."
:group 'magit-faces) :group 'magit-faces)
;;; Commands ;;; Commands
;;;; Diff popups
(defconst magit-diff-popup-common (defconst magit-diff-popup-common
'(:variable magit-diff-arguments '(:variable magit-diff-arguments
@ -663,6 +678,8 @@ buffer."
(?p "[p]atience" "patience") (?p "[p]atience" "patience")
(?h "[h]istogram" "histogram"))) (?h "[h]istogram" "histogram")))
;;;; Diff commands
;;;###autoload ;;;###autoload
(defun magit-diff-dwim (&optional args files) (defun magit-diff-dwim (&optional args files)
"Show changes for the thing at point." "Show changes for the thing at point."
@ -700,6 +717,17 @@ If no DWIM context is found, nil is returned."
(concat (car (last it)) ".." (car it)))) (concat (car (last it)) ".." (car it))))
(magit-buffer-refname (magit-buffer-refname
(cons 'commit magit-buffer-refname)) (cons 'commit magit-buffer-refname))
((derived-mode-p 'magit-stash-mode)
(cons 'commit
(magit-section-case
(commit (magit-section-value it))
(file (-> it
magit-section-parent
magit-section-value))
(hunk (-> it
magit-section-parent
magit-section-parent
magit-section-value)))))
((derived-mode-p 'magit-revision-mode) ((derived-mode-p 'magit-revision-mode)
(cons 'commit (car magit-refresh-args))) (cons 'commit (car magit-refresh-args)))
((derived-mode-p 'magit-diff-mode) ((derived-mode-p 'magit-diff-mode)
@ -894,6 +922,8 @@ for a revision."
(magit-section-cache-visibility child))))))) (magit-section-cache-visibility child)))))))
(magit-mode-setup #'magit-revision-mode rev nil args files))) (magit-mode-setup #'magit-revision-mode rev nil args files)))
;;;; Setting commands
(defun magit-diff-refresh (args files) (defun magit-diff-refresh (args files)
"Set the local diff arguments for the current buffer." "Set the local diff arguments for the current buffer."
(interactive (magit-diff-arguments t)) (interactive (magit-diff-arguments t))
@ -1018,6 +1048,8 @@ Customize variable `magit-diff-refine-hunk' to change the default mode."
(not magit-diff-refine-hunk))) (not magit-diff-refine-hunk)))
(magit-diff-update-hunk-refinement)) (magit-diff-update-hunk-refinement))
;;;; Visit commands
(defun magit-diff-visit-file (file &optional other-window force-worktree) (defun magit-diff-visit-file (file &optional other-window force-worktree)
"From a diff, visit the corresponding file at the appropriate position. "From a diff, visit the corresponding file at the appropriate position.
@ -1030,10 +1062,6 @@ parent of the commit which removed that line, i.e. the last
commit where that line still existed. Otherwise visit the blob commit where that line still existed. Otherwise visit the blob
for the commit whose changes are being shown. for the commit whose changes are being shown.
When the diff is about a range of commits, then, for the time
being, the point this function jumps to often is only an
approximation.
When the file or blob to be displayed is already being displayed When the file or blob to be displayed is already being displayed
in another window of the same frame, then just select that window in another window of the same frame, then just select that window
and adjust point. Otherwise, or with a prefix argument, display and adjust point. Otherwise, or with a prefix argument, display
@ -1044,66 +1072,42 @@ the buffer in another window."
current-prefix-arg)) current-prefix-arg))
(if (magit-file-accessible-directory-p file) (if (magit-file-accessible-directory-p file)
(magit-diff-visit-directory file other-window) (magit-diff-visit-directory file other-window)
(let ((current (magit-current-section)) (let* ((hunk (magit-diff-visit--hunk))
(rev (cond (force-worktree nil) (line (and hunk (magit-diff-hunk-line hunk)))
((derived-mode-p 'magit-revision-mode) (col (and hunk (magit-diff-hunk-column hunk)))
(car magit-refresh-args)) (rev (if (and magit-diff-visit-previous-blob
((derived-mode-p 'magit-stash-mode) (magit-section-match 'hunk)
(magit-section-case (save-excursion
(file (-> it (goto-char (line-beginning-position))
magit-section-parent (looking-at "-")))
magit-section-value)) (magit-diff-visit--range-beginning)
(hunk (-> it (magit-diff-visit--range-end)))
magit-section-parent (buf (if (and (not force-worktree)
magit-section-parent (stringp rev))
magit-section-value)))) (magit-find-file-noselect rev file)
((derived-mode-p 'magit-diff-mode) (or (get-file-buffer file)
(--when-let (car magit-refresh-args) (find-file-noselect file)))))
(and (string-match "\\.\\.\\([^.].*\\)?[ \t]*\\'" it) (magit-display-file-buffer buf)
(match-string 1 it)))) (with-current-buffer buf
))
(unmerged-p (magit-anything-unmerged-p file))
hunk line col buffer)
(pcase (magit-diff-scope)
((or `hunk `region)
(cond ((not rev))
((save-excursion (goto-char (line-beginning-position))
(looking-at "-"))
(setq rev (magit-rev-name (concat rev "~"))))
((magit-rev-head-p rev)
(setq rev nil)))
(setq hunk current))
((or `file `files)
(setq hunk (car (magit-section-children current))))
(`list
(setq hunk (car (magit-section-children
(car (magit-section-children current)))))))
(when (and rev (magit-rev-head-p rev))
(setq rev nil))
(when (and hunk
;; Currently the `hunk' type is also abused for file
;; mode changes. Luckily such sections have no value.
(magit-section-value hunk))
(setq line (magit-diff-hunk-line hunk)
col (magit-diff-hunk-column hunk)))
(setq buffer (if rev
(magit-find-file-noselect rev file)
(or (get-file-buffer file)
(find-file-noselect file))))
(magit-display-file-buffer buffer)
(with-current-buffer buffer
(when line (when line
(setq line
(cond ((eq rev 'staged)
(apply 'magit-diff-visit--offset file nil line))
((and force-worktree
(stringp rev))
(apply 'magit-diff-visit--offset file rev line))
(t
(apply '+ line))))
(let ((pos (save-restriction (let ((pos (save-restriction
(widen) (widen)
(goto-char (point-min)) (goto-char (point-min))
(forward-line (1- line)) (forward-line (1- line))
(when col (move-to-column col)
(move-to-column col))
(point)))) (point))))
(unless (<= (point-min) pos (point-max)) (unless (<= (point-min) pos (point-max))
(widen) (widen)
(goto-char pos)))) (goto-char pos))))
(when unmerged-p (when (magit-anything-unmerged-p file)
(smerge-start-session)) (smerge-start-session))
(run-hooks 'magit-diff-visit-file-hook))))) (run-hooks 'magit-diff-visit-file-hook)))))
@ -1145,6 +1149,77 @@ or `HEAD'."
current-prefix-arg)) current-prefix-arg))
(magit-diff-visit-file file other-window t)) (magit-diff-visit-file file other-window t))
(defun magit-diff-visit--range-end ()
(let ((rev (magit-diff--dwim)))
(if (symbolp rev)
rev
(setq rev (if (consp rev)
(cdr rev)
(car (magit-split-range rev))))
(if (magit-rev-head-p rev)
'unstaged
rev))))
(defun magit-diff-visit--range-beginning ()
(let ((rev (magit-diff--dwim)))
(cond ((consp rev)
(concat (cdr rev) "^"))
((stringp rev)
(cdr (magit-split-range rev)))
(t
rev))))
(defun magit-diff-visit--hunk ()
(-when-let (scope (magit-diff-scope))
(let ((section (magit-current-section)))
(cl-case scope
((file files)
(setq section (car (magit-section-children section))))
(list
(setq section (car (magit-section-children section)))
(when section
(setq section (car (magit-section-children section))))))
(and
;; Unmerged files appear in the list of staged changes
;; but unlike in the list of unstaged changes no diffs
;; are shown here. In that case `section' is nil.
section
;; Currently the `hunk' type is also abused for file
;; mode changes, which we are not interested in here.
;; Such sections have no value.
(magit-section-value section)
section))))
(defun magit-diff-visit--offset (file rev hunk-start line-offset)
(let ((offset 0))
(with-temp-buffer
(save-excursion
(magit-with-toplevel
(magit-git-insert "diff" rev "--" file)))
(catch 'found
(while (re-search-forward
"^@@ -\\([0-9]+\\),\\([0-9]+\\) \\+\\([0-9]+\\),\\([0-9]+\\) @@"
nil t)
(let* ((abeg (string-to-number (match-string 1)))
(alen (string-to-number (match-string 2)))
(bbeg (string-to-number (match-string 3)))
(blen (string-to-number (match-string 4)))
(aend (+ abeg alen))
(bend (+ bbeg blen))
(hend (+ hunk-start line-offset)))
(if (<= abeg hunk-start)
(if (or (>= aend hend)
(>= bend hend))
(let ((line 0))
(while (<= line alen)
(forward-line 1)
(cl-incf line)
(cond ((looking-at "^\\+") (cl-incf offset))
((looking-at "^-") (cl-decf offset)))))
(cl-incf offset (- blen alen)))
(throw 'found nil))))))
(+ hunk-start line-offset offset)))
(defun magit-diff-hunk-line (section) (defun magit-diff-hunk-line (section)
(let* ((value (magit-section-value section)) (let* ((value (magit-section-value section))
(prefix (- (length value) 2)) (prefix (- (length value) 2))
@ -1155,6 +1230,7 @@ or `HEAD'."
(prior (and (= (length value) 3) (prior (and (= (length value) 3)
(save-excursion (goto-char (line-beginning-position)) (save-excursion (goto-char (line-beginning-position))
(looking-at "-")))) (looking-at "-"))))
(offset 0)
(line (if prior (line (if prior
(cadr value) (cadr value)
(car (last value))))) (car (last value)))))
@ -1171,9 +1247,9 @@ or `HEAD'."
(unless (string-match-p (unless (string-match-p
(if prior "\\+" "-") (if prior "\\+" "-")
(buffer-substring (point) (+ (point) prefix))) (buffer-substring (point) (+ (point) prefix)))
(cl-incf line)) (cl-incf offset))
(forward-line))) (forward-line)))
line)) (list line offset)))
(defun magit-diff-hunk-column (section) (defun magit-diff-hunk-column (section)
(if (or (< (point) (magit-section-content section)) (if (or (< (point) (magit-section-content section))
@ -1192,6 +1268,8 @@ or `HEAD'."
'(display-buffer-same-window)))) '(display-buffer-same-window))))
(magit-status-internal directory)))) (magit-status-internal directory))))
;;;; Scroll commands
(defun magit-diff-show-or-scroll-up () (defun magit-diff-show-or-scroll-up ()
"Update the commit or diff buffer for the thing at point. "Update the commit or diff buffer for the thing at point.

16
elpa/magit-20161012.1035/magit-ediff.el → elpa/magit-20161013.1332/magit-ediff.el
View File

@ -242,16 +242,12 @@ range)."
'ediff-revision)))) 'ediff-revision))))
(defun magit-ediff-compare--read-revisions (&optional arg mbase) (defun magit-ediff-compare--read-revisions (&optional arg mbase)
(let ((input (or arg (magit-diff-read-range-or-commit "Compare range or commit" (let ((input (or arg (magit-diff-read-range-or-commit
nil mbase))) "Compare range or commit"
revA revB) nil mbase))))
(if (string-match magit-range-re input) (--if-let (magit-split-range input)
(progn (setq revA (or (match-string 1 input) "HEAD") (-cons-to-list it)
revB (or (match-string 3 input) "HEAD")) (list input nil))))
(when (string= (match-string 2 input) "...")
(setq revA (magit-git-string "merge-base" revA revB))))
(setq revA input))
(list revA revB)))
(defun magit-ediff-read-files (revA revB &optional fileB) (defun magit-ediff-read-files (revA revB &optional fileB)
"Read file in REVB, return it and the corresponding file in REVA. "Read file in REVB, return it and the corresponding file in REVA.

0
elpa/magit-20161012.1035/magit-extras.el → elpa/magit-20161013.1332/magit-extras.el
View File

12
elpa/magit-20161012.1035/magit-git.el → elpa/magit-20161013.1332/magit-git.el
View File

@ -482,7 +482,8 @@ returning the truename."
"Return t if `default-directory' is below a repository directory." "Return t if `default-directory' is below a repository directory."
;; This does not work if the gitdir is not located inside the ;; This does not work if the gitdir is not located inside the
;; working tree: (magit-rev-parse-p "--is-inside-git-dir"). ;; working tree: (magit-rev-parse-p "--is-inside-git-dir").
(file-in-directory-p default-directory (magit-git-dir))) (-when-let (gitdir (magit-git-dir))
(file-in-directory-p default-directory gitdir)))
(defun magit-inside-worktree-p () (defun magit-inside-worktree-p ()
"Return t if `default-directory' is below the work tree of a repository." "Return t if `default-directory' is below the work tree of a repository."
@ -1282,6 +1283,15 @@ Return a list of two integers: (A>B B>A)."
"\\(\\.\\.\\.?\\)" ; range marker "\\(\\.\\.\\.?\\)" ; range marker
"\\([^.][^ \t]*\\)?\\'")) ; revB "\\([^.][^ \t]*\\)?\\'")) ; revB
(defun magit-split-range (range)
(when (string-match magit-range-re range)
(let ((beg (or (match-string 1 range) "HEAD"))
(end (or (match-string 3 range) "HEAD")))
(cons (if (string-equal (match-string 2) "...")
(magit-git-string "merge-base" beg end)
beg)
end))))
;;; Completion ;;; Completion
(defvar magit-revision-history nil) (defvar magit-revision-history nil)

0
elpa/magit-20161012.1035/magit-log.el → elpa/magit-20161013.1332/magit-log.el
View File

7
elpa/magit-20161012.1035/magit-mode.el → elpa/magit-20161013.1332/magit-mode.el
View File

@ -460,8 +460,11 @@ Magit is documented in info node `(magit)'."
(add-hook 'post-command-hook #'magit-section-update-highlight t t) (add-hook 'post-command-hook #'magit-section-update-highlight t t)
(setq-local redisplay-highlight-region-function 'magit-highlight-region) (setq-local redisplay-highlight-region-function 'magit-highlight-region)
(setq-local redisplay-unhighlight-region-function 'magit-unhighlight-region) (setq-local redisplay-unhighlight-region-function 'magit-unhighlight-region)
(when (fboundp 'linum-mode) (when (bound-and-true-p global-linum-mode)
(linum-mode -1))) (linum-mode -1))
(when (and (fboundp 'nlinum-mode)
(bound-and-true-p global-nlinum-mode))
(nlinum-mode -1)))
(defvar-local magit-region-overlays nil) (defvar-local magit-region-overlays nil)

2
elpa/magit-20161012.1035/magit-pkg.el → elpa/magit-20161013.1332/magit-pkg.el
View File

@ -1,4 +1,4 @@
(define-package "magit" "20161012.1035" "A Git porcelain inside Emacs" (define-package "magit" "20161013.1332" "A Git porcelain inside Emacs"
'((emacs "24.4") '((emacs "24.4")
(async "20160711.223") (async "20160711.223")
(dash "20160820.501") (dash "20160820.501")

0
elpa/magit-20161012.1035/magit-process.el → elpa/magit-20161013.1332/magit-process.el
View File

0
elpa/magit-20161012.1035/magit-remote.el → elpa/magit-20161013.1332/magit-remote.el
View File

60
elpa/magit-20161012.1035/magit-section.el → elpa/magit-20161013.1332/magit-section.el
View File

@ -533,18 +533,23 @@ This command is intended for debugging purposes."
;;; Match ;;; Match
(defun magit-section-match (condition &optional section) (cl-defun magit-section-match
(condition &optional (section (magit-current-section)))
"Return t if SECTION matches CONDITION. "Return t if SECTION matches CONDITION.
SECTION defaults to the section at point.
Conditions can take the following forms: SECTION defaults to the section at point. If SECTION is not
specified and there also is no section at point, then return
nil.
CONDITION can take the following forms:
(CONDITION...) matches if any of the CONDITIONs matches. (CONDITION...) matches if any of the CONDITIONs matches.
[TYPE...] matches if the first TYPE matches the type [TYPE...] matches if the first TYPE matches the type
of the section at point, the second matches of the section, the second matches that of
that of its parent, and so on. its parent, and so on.
[* TYPE...] matches sections that match [TYPE...] and [* TYPE...] matches sections that match [TYPE...] and
also recursively all their child sections. also recursively all their child sections.
TYPE matches TYPE regardless of its parents. TYPE matches sections of TYPE regardless of the
types of the parent sections.
Each TYPE is a symbol. Note that it is not necessary to specify Each TYPE is a symbol. Note that it is not necessary to specify
all TYPEs up to the root section as printed by all TYPEs up to the root section as printed by
@ -552,41 +557,42 @@ all TYPEs up to the root section as printed by
precise." precise."
;; When recursing SECTION actually is a type list. Matching ;; When recursing SECTION actually is a type list. Matching
;; macros also pass such a list instead of a section struct. ;; macros also pass such a list instead of a section struct.
(let ((types (if (magit-section-p section) (and section
(mapcar 'car (magit-section-ident section)) (magit-section-match-1 condition
section))) (mapcar #'car (magit-section-ident section)))))
(when (or types section (magit-current-section))
(if (listp condition)
(--first (magit-section-match it types) condition)
(magit-section-match-1 (if (symbolp condition)
(list condition)
(append condition nil))
types)))))
(defun magit-section-match-1 (l1 l2) (defun magit-section-match-1 (condition type-list)
(if (listp condition)
(--first (magit-section-match-1 it type-list) condition)
(magit-section-match-2 (if (symbolp condition)
(list condition)
(append condition nil))
type-list)))
(defun magit-section-match-2 (l1 l2)
(or (null l1) (or (null l1)
(if (eq (car l1) '*) (if (eq (car l1) '*)
(or (magit-section-match-1 (cdr l1) l2) (or (magit-section-match-2 (cdr l1) l2)
(and l2 (and l2
(magit-section-match-1 l1 (cdr l2)))) (magit-section-match-2 l1 (cdr l2))))
(and l2 (and l2
(equal (car l1) (car l2)) (equal (car l1) (car l2))
(magit-section-match-1 (cdr l1) (cdr l2)))))) (magit-section-match-2 (cdr l1) (cdr l2))))))
(defmacro magit-section-when (condition &rest body) (defmacro magit-section-when (condition &rest body)
"If the section at point matches CONDITION evaluate BODY. "If the section at point matches CONDITION evaluate BODY.
If the section matches evaluate BODY forms sequentially and If the section matches, then evaluate BODY forms sequentially
return the value of the last one, or if there are no BODY forms with `it' bound to the section and return the value of the last
return the value of the section. If the section does not match form. If there are no BODY forms, then return the value of the
return nil. section. If the section does not match or if there is no section
at point then return nil.
See `magit-section-match' for the forms CONDITION can take." See `magit-section-match' for the forms CONDITION can take."
(declare (indent 1) (declare (indent 1)
(debug (sexp body))) (debug (sexp body)))
`(--when-let (magit-current-section) `(--when-let (magit-current-section)
(when (magit-section-match ',condition (when (magit-section-match ',condition it)
(mapcar 'car (magit-section-ident it)))
,@(or body '((magit-section-value it)))))) ,@(or body '((magit-section-value it))))))
(defmacro magit-section-case (&rest clauses) (defmacro magit-section-case (&rest clauses)
@ -610,7 +616,7 @@ at point."
(,ident (and it (mapcar 'car (magit-section-ident it))))) (,ident (and it (mapcar 'car (magit-section-ident it)))))
(cond ,@(mapcar (lambda (clause) (cond ,@(mapcar (lambda (clause)
`(,(or (eq (car clause) t) `(,(or (eq (car clause) t)
`(and it (magit-section-match `(and it (magit-section-match-1
',(car clause) ,ident))) ',(car clause) ,ident)))
,@(cdr clause))) ,@(cdr clause)))
clauses))))) clauses)))))

5
elpa/magit-20161012.1035/magit-sequence.el → elpa/magit-20161013.1332/magit-sequence.el
View File

@ -387,7 +387,7 @@ START has to be selected from a list of recent commits."
(setq commit (--if-let (magit-get-upstream-branch) (setq commit (--if-let (magit-get-upstream-branch)
(magit-git-string "merge-base" it "HEAD") (magit-git-string "merge-base" it "HEAD")
nil)) nil))
(when (magit-git-failure "merge-base" "--is-ancestor" commit "HEAD") (unless (magit-rev-ancestor-p commit "HEAD")
(user-error "%s isn't an ancestor of HEAD" commit)) (user-error "%s isn't an ancestor of HEAD" commit))
(if (magit-commit-parents commit) (if (magit-commit-parents commit)
(setq commit (concat commit "^")) (setq commit (concat commit "^"))
@ -483,7 +483,8 @@ edit. With a prefix argument the old message is reused as-is."
"Abort the current rebase operation, restoring the original branch." "Abort the current rebase operation, restoring the original branch."
(interactive) (interactive)
(if (magit-rebase-in-progress-p) (if (magit-rebase-in-progress-p)
(magit-run-git "rebase" "--abort") (when (magit-confirm 'abort-rebase "Abort this rebase")
(magit-run-git "rebase" "--abort"))
(user-error "No rebase in progress"))) (user-error "No rebase in progress")))
(defun magit-rebase-in-progress-p () (defun magit-rebase-in-progress-p ()

0
elpa/magit-20161012.1035/magit-stash.el → elpa/magit-20161013.1332/magit-stash.el
View File

0
elpa/magit-20161012.1035/magit-submodule.el → elpa/magit-20161013.1332/magit-submodule.el
View File

0
elpa/magit-20161012.1035/magit-subtree.el → elpa/magit-20161013.1332/magit-subtree.el
View File

61
elpa/magit-20161012.1035/magit-utils.el → elpa/magit-20161013.1332/magit-utils.el
View File

@ -90,6 +90,17 @@ these commands do:
magit-worktree-branch magit-worktree-branch
magit-tag)) magit-tag))
(defconst magit--confirm-actions
'((const reverse) (const discard)
(const rename) (const resurrect)
(const trash) (const delete)
(const abort-rebase)
(const abort-merge) (const merge-dirty)
(const drop-stashes) (const resect-bisect)
(const kill-process) (const delete-unmerged-branch)
(const stage-all-changes) (const unstage-all-changes)
(const safe-with-wip)))
(defcustom magit-no-confirm nil (defcustom magit-no-confirm nil
"A list of symbols for actions Magit should not confirm, or t. "A list of symbols for actions Magit should not confirm, or t.
@ -137,6 +148,10 @@ Sequences:
`reset-bisect' Aborting (known to Git as \"resetting\") a `reset-bisect' Aborting (known to Git as \"resetting\") a
bisect operation loses all information collected so far. bisect operation loses all information collected so far.
`abort-rebase' Aborting a rebase throws away all already
modified commits, but it's possible to restore those from the
reflog.
`abort-merge' Aborting a merge throws away all conflict `abort-merge' Aborting a merge throws away all conflict
resolutions which has already been carried out by the user. resolutions which has already been carried out by the user.
@ -182,24 +197,26 @@ Global settings:
:package-version '(magit . "2.1.0") :package-version '(magit . "2.1.0")
:group 'magit :group 'magit
:group 'magit-commands :group 'magit-commands
:type '(choice (const :tag "No confirmation needed" t) :type `(choice (const :tag "Always require confirmation" nil)
(set (const reverse) (const discard) (const :tag "Never require confirmation" t)
(const rename) (const resurrect) (set :tag "Require confirmation only for"
(const trash) (const delete) ,@magit--confirm-actions)))
(const abort-merge) (const merge-dirty)
(const drop-stashes) (const resect-bisect)
(const kill-process) (const delete-unmerged-branch)
(const stage-all-changes) (const unstage-all-changes)
(const safe-with-wip))))
(defcustom magit-slow-confirm nil (defcustom magit-slow-confirm '(drop-stashes)
"Whether to ask user \"y or n\" or \"yes or no\" questions. "Whether to ask user \"y or n\" or \"yes or no\" questions.
When this is nil (the default), then `y-or-n-p' is used when the
user has to confirm a potentially destructive action. When this When this is nil, then `y-or-n-p' is used when the user has to
is non-nil, then `yes-or-no-p' is used instead." confirm a potentially destructive action. When this is t, then
`yes-or-no-p' is used instead. If this is a list of symbols
identifying actions, then `yes-or-no-p' is used for those,
`y-or-no-p' for all others. The list of actions is the same as
for `magit-no-confirm' (which see)."
:package-version '(magit . "2.9.0") :package-version '(magit . "2.9.0")
:group 'magit-commands :group 'magit-commands
:type 'boolean) :type `(choice (const :tag "Always ask \"yes or no\" questions" t)
(const :tag "Always ask \"y or n\" questions" nil)
(set :tag "Ask yes or no questions only for"
,@magit--confirm-actions)))
(defcustom magit-no-message nil (defcustom magit-no-message nil
"A list of messages Magit should not display. "A list of messages Magit should not display.
@ -376,10 +393,12 @@ This is similar to `read-string', but
',(mapcar 'car clauses)) ',(mapcar 'car clauses))
,@(--map `(,(car it) ,@(cddr it)) clauses))) ,@(--map `(,(car it) ,@(cddr it)) clauses)))
(defun magit-y-or-n-p (prompt) (defun magit-y-or-n-p (prompt &optional action)
"Ask user a \"y or n\" or a \"yes or no\" question. "Ask user a \"y or n\" or a \"yes or no\" question using PROMPT.
Also see option `magit-slow-confirm'." Which kind of question is used depends on whether
(if magit-slow-confirm ACTION is a member of option `magit-slow-confirm'."
(if (or (eq magit-slow-confirm t)
(and action (member action magit-slow-confirm)))
(yes-or-no-p prompt) (yes-or-no-p prompt)
(y-or-n-p prompt))) (y-or-n-p prompt)))
@ -400,9 +419,9 @@ Also see option `magit-slow-confirm'."
unstage-all-changes)))))) unstage-all-changes))))))
(or (not sitems) items)) (or (not sitems) items))
((not sitems) ((not sitems)
(magit-y-or-n-p prompt)) (magit-y-or-n-p prompt action))
((= (length items) 1) ((= (length items) 1)
(and (magit-y-or-n-p prompt) items)) (and (magit-y-or-n-p prompt action) items))
((> (length items) 1) ((> (length items) 1)
(let ((buffer (get-buffer-create " *Magit Confirm*"))) (let ((buffer (get-buffer-create " *Magit Confirm*")))
(with-current-buffer buffer (with-current-buffer buffer
@ -411,7 +430,7 @@ Also see option `magit-slow-confirm'."
'((window-height . fit-window-to-buffer))) '((window-height . fit-window-to-buffer)))
(lambda (window _value) (lambda (window _value)
(with-selected-window window (with-selected-window window
(unwind-protect (and (magit-y-or-n-p prompt-n) items) (unwind-protect (and (magit-y-or-n-p prompt-n action) items)
(when (window-live-p window) (when (window-live-p window)
(quit-restore-window window 'kill))))) (quit-restore-window window 'kill)))))
(dolist (item items) (dolist (item items)

0
elpa/magit-20161012.1035/magit-wip.el → elpa/magit-20161013.1332/magit-wip.el
View File

33
elpa/magit-20161012.1035/magit.el → elpa/magit-20161013.1332/magit.el
View File

@ -1009,7 +1009,7 @@ reference, but it is not checked out."
(let ((ref (magit-section-value (magit-current-section)))) (let ((ref (magit-section-value (magit-current-section))))
(if current-prefix-arg (if current-prefix-arg
(magit-show-refs ref) (magit-show-refs ref)
(if (magit-section-when [branch remote]) (if (magit-section-match [branch remote])
(let ((start ref) (let ((start ref)
(arg "-b")) (arg "-b"))
(string-match "^[^/]+/\\(.+\\)" ref) (string-match "^[^/]+/\\(.+\\)" ref)
@ -2938,20 +2938,23 @@ Use the options `magit-repository-directories'
and `magit-repository-directories-depth' to and `magit-repository-directories-depth' to
control which repositories are displayed." control which repositories are displayed."
(interactive) (interactive)
(with-current-buffer (get-buffer-create "*Magit Repositories*") (if magit-repository-directories
(magit-repolist-mode) (with-current-buffer (get-buffer-create "*Magit Repositories*")
(setq tabulated-list-entries (magit-repolist-mode)
(mapcar (-lambda ((id . path)) (setq tabulated-list-entries
(let ((default-directory path)) (mapcar (-lambda ((id . path))
(list path (let ((default-directory path))
(vconcat (--map (or (funcall (nth 2 it) id) "") (list path
magit-repolist-columns))))) (vconcat (--map (or (funcall (nth 2 it) id) "")
(magit-list-repos-uniquify magit-repolist-columns)))))
(--map (cons (file-name-nondirectory (directory-file-name it)) (magit-list-repos-uniquify
it) (--map (cons (file-name-nondirectory (directory-file-name it))
(magit-list-repos))))) it)
(tabulated-list-print) (magit-list-repos)))))
(switch-to-buffer (current-buffer)))) (tabulated-list-print)
(switch-to-buffer (current-buffer)))
(message "You need to customize `magit-repository-directories' %s"
"before you can list repositories")))
(defvar magit-repolist-mode-map (defvar magit-repolist-mode-map
(let ((map (make-sparse-keymap))) (let ((map (make-sparse-keymap)))

177
elpa/magit-20161013.1332/magit.info Normal file
View File

@ -0,0 +1,177 @@
This is magit.info, produced by makeinfo version 5.2 from magit.texi.
Magit is an interface to the version control system Git, implemented as
an Emacs package. Magit aspires to be a complete Git porcelain. While
we cannot (yet) claim that Magit wraps and improves upon each and every
Git command, it is complete enough to allow even experienced Git users
to perform almost all of their daily version control tasks directly from
within Emacs. While many fine Git clients exist, only Magit and Git
itself deserve to be called porcelains.
Copyright (C) 2015-2016 Jonas Bernoulli <jonas@bernoul.li>
You can redistribute this document and/or modify it under the terms
of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option)
any later version.
This document 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.
INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Magit: (magit). Using Git from Emacs with Magit.
END-INFO-DIR-ENTRY

Indirect:
magit.info-1: 1222
magit.info-2: 321601

Tag Table:
(Indirect)
Node: Top1222
Node: Introduction6446
Node: Installation11169
Node: Updating from an older release11544
Node: Installing from an Elpa archive13139
Node: Installing from the Git repository14478
Node: Post-installation tasks17325
Node: Getting started18714
Node: Interface concepts24443
Node: Modes and Buffers24717
Node: Switching Buffers26462
Node: Naming Buffers31003
Node: Quitting Windows33838
Node: Automatic Refreshing of Magit Buffers35470
Node: Automatic Saving of File-Visiting Buffers38238
Node: Automatic Reverting of File-Visiting Buffers39423
Node: Risk of Reverting Automatically44419
Node: Sections46802
Node: Section movement47743
Node: Section visibility51670
Node: Section hooks55261
Node: Section types and values57542
Node: Section options58812
Node: Popup buffers and prefix commands59284
Node: Completion and confirmation60598
Node: Running Git63504
Node: Viewing Git output63740
Node: Running Git manually64740
Node: Git executable66866
Node: Global Git arguments68873
Node: Inspecting69680
Node: Status buffer70827
Node: Status sections73692
Node: Status header sections79571
Node: Status options82128
Node: Repository list82852
Node: Logging85010
Node: Refreshing logs87748
Node: Log Buffer89133
Node: Select from log92429
Node: Reflog93369
Node: Diffing93847
Node: Refreshing diffs96867
Node: Diff buffer99848
Node: Diff options102442
Node: Revision buffer105808
Node: Ediffing106763
Node: References buffer110353
Node: References sections115063
Node: Bisecting115938
Node: Visiting blobs117677
Node: Blaming118186
Node: Manipulating121616
Node: Repository setup121932
Node: Staging and unstaging122972
Node: Staging from file-visiting buffers127061
Node: Applying128229
Node: Committing130122
Node: Initiating a commit130705
Node: Editing commit messages134017
Node: Branching144413
Node: The two remotes144613
Node: The branch popup147157
Node: The branch config popup156393
Node: Merging162299
Node: Resolving conflicts164467
Ref: orgradiotarget1165552
Node: Rebasing169424
Node: Editing rebase sequences173065
Node: Information about in-progress rebase176095
Ref: Information about in-progress rebase-Footnote-1182931
Node: Cherry picking183517
Node: Reverting185123
Node: Resetting186486
Node: Stashing187998
Node: Transferring191172
Node: Remotes191410
Node: Fetching192696
Node: Pulling194062
Node: Pushing194908
Node: Creating and sending patches199652
Node: Applying patches200347
Node: Miscellaneous201345
Node: Tagging201648
Node: Notes202433
Node: Submodules204958
Node: Listing submodules205173
Node: Submodule popup206992
Node: Subtree208275
Node: Common commands209523
Node: Wip modes211268
Node: Minor mode for buffers visiting files218004
Node: Minor mode for buffers visiting blobs221478
Node: Customizing222283
Node: Per-repository configuration223955
Node: Essential settings225589
Node: Safety225913
Node: Performance227746
Node: Plumbing235708
Node: Calling Git236532
Node: Getting a value from Git238055
Node: Calling Git for effect241159
Node: Section plumbing247663
Node: Creating sections247891
Node: Section selection251790
Node: Matching sections253470
Node: Refreshing buffers258902
Node: Conventions262037
Node: Confirmation and completion262214
Node: Theming Faces263112
Node: FAQ271263
Node: Magit is slow272876
Node: I changed several thousand files at once and now Magit is unusable273077
Node: I am having problems committing273793
Node: Diffs are collapsed after un-/staging274239
Node: I don't understand how branching and pushing work275717
Node: I don't like the key binding in v24276092
Node: I cannot install the pre-requisites for Magit v2276431
Node: I am using an Emacs release older than v244276896
Node: I am using a Git release older than v194278509
Node: I am using MS Windows and cannot push with Magit279496
Node: I am using OS X and SOMETHING works in shell but not in Magit280100
Node: How to install the gitman info manual?280891
Node: How can I show Git's output?283432
Node: Diffs contain control sequences284219
Node: Expanding a file to show the diff causes it to disappear285224
Node: Point is wrong in the ‘COMMIT_EDITMSG’ buffer285759
Node: The mode-line information isn't always up-to-date286789
Node: Can Magit be used as ‘ediff-version-control-package’?287857
Node: How to show diffs for gpg-encrypted files?289901
Node: Emacs 245 hangs when loading Magit290498
Node: Symbol's value as function is void ‘--some’291073
Node: Where is the branch manager291407
Node: Keystroke Index291698
Node: Command Index321601
Node: Function Index351610
Node: Variable Index365504

End Tag Table

Local Variables:
coding: utf-8
End:

43
elpa/magit-20161012.1035/magit.info-1 → elpa/magit-20161013.1332/magit.info-1
View File

@ -2694,15 +2694,22 @@ File: magit.info, Node: Diff buffer, Next: Diff options, Prev: Refreshing dif
where that line still existed. Otherwise visit the blob for the where that line still existed. Otherwise visit the blob for the
commit whose changes are being shown. commit whose changes are being shown.
When the diff is about a range of commits, then, for the time
being, the point this function jumps to often is only an
approximation.
When the file or blob to be displayed is already being displayed in When the file or blob to be displayed is already being displayed in
another window of the same frame, then just select that window and another window of the same frame, then just select that window and
adjust point. Otherwise, or with a prefix argument, display the adjust point. Otherwise, or with a prefix argument, display the
buffer in another window. buffer in another window.
-- User Option: magit-diff-visit-previous-blob
This option controls whether ‘magit-diff-visit-file’ may visit the
previous blob. When this is ‘t’ and point is on a removed line in
a diff for a committed change, then ‘magit-diff-visit-file’ visits
the blob from the last revision which still had that line.
Currently this is only supported for committed changes, for staged
and unstaged changes ‘magit-diff-visit-file’ always visits the file
in the working tree.
‘C-<return>’ (‘magit-diff-visit-file-worktree’) ‘C-<return>’ (‘magit-diff-visit-file-worktree’)
From a diff, visit the corresponding file at the appropriate From a diff, visit the corresponding file at the appropriate
@ -6720,17 +6727,18 @@ File: magit.info, Node: Matching sections, Prev: Section selection, Up: Secti
-- Function: magit-section-match condition &optional section -- Function: magit-section-match condition &optional section
Return ‘t’ if SECTION matches CONDITION. SECTION defaults to the Return ‘t’ if SECTION matches CONDITION. SECTION defaults to the
section at point. section at point. If SECTION is not specified and there also is no
section at point, then return ‘nil’.
Conditions can take the following forms: CONDITION can take the following forms:
• ‘(CONDITION...)’ • ‘(CONDITION...)’
matches if any of the CONDITIONs matches. matches if any of the CONDITIONs matches.
• ‘[TYPE...]’ • ‘[TYPE...]’
matches if the first TYPE matches the type of the section at matches if the first TYPE matches the type of the section, the
point, the second matches that of its parent, and so on. second matches that of its parent, and so on.
• ‘[* TYPE...]’ • ‘[* TYPE...]’
@ -6739,7 +6747,8 @@ File: magit.info, Node: Matching sections, Prev: Section selection, Up: Secti
• ‘TYPE’ • ‘TYPE’
matches TYPE regardless of its parents. matches sections of TYPE regardless of the types of the parent
sections.
Each TYPE is a symbol. Note that it is not necessary to specify Each TYPE is a symbol. Note that it is not necessary to specify
all TYPEs up to the root section as printed by all TYPEs up to the root section as printed by
‘magit-describe-type’, unless of course you want to be that ‘magit-describe-type’, unless of course you want to be that
@ -6749,9 +6758,11 @@ File: magit.info, Node: Matching sections, Prev: Section selection, Up: Secti
If the section at point matches CONDITION evaluate BODY. If the section at point matches CONDITION evaluate BODY.
If the section matches evaluate BODY forms sequentially and return If the section matches, then evaluate BODY forms sequentially with
the value of the last one, or if there are no BODY forms return the ‘it’ bound to the section and return the value of the last form.
value of the section. If the section does not match return nil. If there are no BODY forms, then return the value of the section.
If the section does not match or if there is no section at point
then return nil.
See ‘magit-section-match’ for the forms CONDITION can take. See ‘magit-section-match’ for the forms CONDITION can take.
@ -7575,7 +7586,7 @@ Appendix B Keystroke Index
* c s: Initiating a commit. (line 54) * c s: Initiating a commit. (line 54)
* c S: Initiating a commit. (line 62) * c S: Initiating a commit. (line 62)
* c w: Initiating a commit. (line 32) * c w: Initiating a commit. (line 32)
* C-<return>: Diff buffer. (line 29) * C-<return>: Diff buffer. (line 36)
* C-<tab>: Section visibility. (line 13) * C-<tab>: Section visibility. (line 13)
* C-c C-a: Editing commit messages. * C-c C-a: Editing commit messages.
(line 128) (line 128)
@ -7656,7 +7667,7 @@ Appendix B Keystroke Index
* d w: Diffing. (line 43) * d w: Diffing. (line 43)
* D w: Refreshing diffs. (line 28) * D w: Refreshing diffs. (line 28)
* DEL: Log Buffer. (line 43) * DEL: Log Buffer. (line 43)
* DEL <1>: Diff buffer. (line 56) * DEL <1>: Diff buffer. (line 63)
* DEL <2>: Blaming. (line 44) * DEL <2>: Blaming. (line 44)
* DEL <3>: Editing rebase sequences. * DEL <3>: Editing rebase sequences.
(line 28) (line 28)
@ -7690,7 +7701,7 @@ Appendix B Keystroke Index
(line 22) (line 22)
* G: Automatic Refreshing of Magit Buffers. * G: Automatic Refreshing of Magit Buffers.
(line 31) (line 31)
* j: Diff buffer. (line 46) * j: Diff buffer. (line 53)
* k: Viewing Git output. (line 19) * k: Viewing Git output. (line 19)
* k <1>: Applying. (line 40) * k <1>: Applying. (line 40)
* k <2>: Editing rebase sequences. * k <2>: Editing rebase sequences.
@ -7838,7 +7849,7 @@ Appendix B Keystroke Index
(line 59) (line 59)
* S-<tab>: Section visibility. (line 22) * S-<tab>: Section visibility. (line 22)
* SPC: Log Buffer. (line 33) * SPC: Log Buffer. (line 33)
* SPC <1>: Diff buffer. (line 52) * SPC <1>: Diff buffer. (line 59)
* SPC <2>: Blaming. (line 34) * SPC <2>: Blaming. (line 34)
* SPC <3>: Editing rebase sequences. * SPC <3>: Editing rebase sequences.
(line 21) (line 21)

BIN
elpa/magit-20161012.1035/magit.info-2 → elpa/magit-20161013.1332/magit.info-2
View File

Binary file not shown.

4
elpa/magithub-20161011.2129/magithub-autoloads.el → elpa/magithub-20161013.2008/magithub-autoloads.el
View File

@ -4,8 +4,8 @@
(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
;;;### (autoloads nil nil ("magithub-cache.el" "magithub-ci.el" "magithub-core.el" ;;;### (autoloads nil nil ("magithub-cache.el" "magithub-ci.el" "magithub-core.el"
;;;;;; "magithub-issue.el" "magithub-pkg.el" "magithub.el") (22525 ;;;;;; "magithub-issue.el" "magithub-pkg.el" "magithub.el") (22528
;;;;;; 59330 912480 205000)) ;;;;;; 31239 328273 102000))
;;;*** ;;;***

0
elpa/magithub-20161011.2129/magithub-cache.el → elpa/magithub-20161013.2008/magithub-cache.el
View File

28
elpa/magithub-20161011.2129/magithub-ci.el → elpa/magithub-20161013.2008/magithub-ci.el
View File

@ -109,11 +109,11 @@ See also `magithub-repo-id'."
(defun magithub-ci-status--parse-2.2.8 (output) (defun magithub-ci-status--parse-2.2.8 (output)
"Backwards compatibility for old versions of hub. "Backwards compatibility for old versions of hub.
See `magithub-ci-status--parse'." See `magithub-ci-status--parse'."
(--when-let (cdr (s-match (rx bos (group (+ (any alpha space))) (-when-let (matches (cdr (s-match (rx bos (group (+ (any alpha space)))
(? ": " (group (+ (not (any " "))))) eos) (? ": " (group (+ (not (any " "))))) eos)
output)) output)))
(let ((status (list :status (intern (replace-regexp-in-string "\s" "-" (car it))) (let ((status (list :status (intern (replace-regexp-in-string "\s" "-" (car matches)))
:url (cadr it)))) :url (cadr matches))))
(magithub-ci-update-urls (list status)) (magithub-ci-update-urls (list status))
status))) status)))
@ -122,11 +122,11 @@ See `magithub-ci-status--parse'."
(let* ((current-commit (magit-rev-parse "HEAD")) (let* ((current-commit (magit-rev-parse "HEAD"))
(last-commit (or for-commit current-commit)) (last-commit (or for-commit current-commit))
(output (magithub--command-output "ci-status" `("-v" ,last-commit)))) (output (magithub--command-output "ci-status" `("-v" ,last-commit))))
(--if-let (if (magithub-hub-version-at-least "2.3") (-if-let (check (if (magithub-hub-version-at-least "2.3")
(car (magithub-ci-status--parse output)) (car (magithub-ci-status--parse output))
(magithub-ci-status--parse-2.2.8 (car output))) (magithub-ci-status--parse-2.2.8 (car output))))
(prog1 (or (plist-get it :status) 'no-status) (prog1 (or (plist-get check :status) 'no-status)
(if (not (or for-commit (plist-get it :status))) (if (not (or for-commit (plist-get check :status)))
(let ((last-commit (magithub-ci-status--last-commit))) (let ((last-commit (magithub-ci-status--last-commit)))
(unless (string-equal current-commit last-commit) (unless (string-equal current-commit last-commit)
(magithub-ci-status--internal last-commit)) (magithub-ci-status--internal last-commit))
@ -158,10 +158,10 @@ The first status will be an `overall' status."
(defun magithub-ci-status--parse-line (line) (defun magithub-ci-status--parse-line (line)
"Parse a single LINE of status into a status plist." "Parse a single LINE of status into a status plist."
(--if-let (cdr (s-match magithub-ci-status-regex line)) (-if-let (matches (cdr (s-match magithub-ci-status-regex line)))
(list :status (cdr (assoc (car it) magithub-ci-status-symbol-alist)) (list :status (cdr (assoc (car matches) magithub-ci-status-symbol-alist))
:url (car (cddr it)) :url (car (cddr matches))
:check (cadr it)) :check (cadr matches))
(if (string= line "no-status") (if (string= line "no-status")
'no-status 'no-status
(if (string= line "") 'no-output)))) (if (string= line "") 'no-output))))

4
elpa/magithub-20161011.2129/magithub-core.el → elpa/magithub-20161013.2008/magithub-core.el
View File

@ -29,8 +29,8 @@
(defun magithub-github-repository-p () (defun magithub-github-repository-p ()
"Non-nil if \"origin\" points to GitHub or a whitelisted domain." "Non-nil if \"origin\" points to GitHub or a whitelisted domain."
(--when-let (magit-get "remote" "origin" "url") (-when-let (origin (magit-get "remote" "origin" "url"))
(-some? (lambda (domain) (s-contains? domain it)) (-some? (lambda (domain) (s-contains? domain origin))
(cons "github.com" (magit-get-all "hub" "host"))))) (cons "github.com" (magit-get-all "hub" "host")))))
(defun magithub-repo-id () (defun magithub-repo-id ()

79
elpa/magithub-20161011.2129/magithub-issue.el → elpa/magithub-20161013.2008/magithub-issue.el
View File

@ -118,7 +118,7 @@ Returns a plist with the following properties:
"failed to parse issue" "failed to parse issue"
"There was an error parsing issues.")))) "There was an error parsing issues."))))
(defun magithub-issue-list--internal-2.2.8 () (defun magithub--issue-list--internal-2.2.8 ()
"Backwards compatibility for old versions of hub. "Backwards compatibility for old versions of hub.
See `magithub-issue-list--internal'." See `magithub-issue-list--internal'."
(magithub-issue--sort (magithub-issue--sort
@ -141,19 +141,19 @@ Returns a plist with the following properties:
:title (s-join "," (cddr ss)) :title (s-join "," (cddr ss))
:type (magithub-issue--url-type (cadr ss))))) :type (magithub-issue--url-type (cadr ss)))))
(defun magithub-issue-list--internal () (defun magithub--issue-list--internal ()
"Return a new list of issues for the current repository." "Return a new list of issues for the current repository."
(magithub-issue--sort (magithub-issue--sort
(mapcar #'magithub-issue--process-line (mapcar #'magithub-issue--process-line
(magithub--command-output "issue" '("--format=%I,%U,%t%n"))))) (magithub--command-output "issue" '("--format=%I,%U,%t%n")))))
(defun magithub-issue-list () (defun magithub--issue-list ()
"Return a list of issues for the current repository." "Return a list of issues for the current repository."
(magithub-cache (magithub-repo-id) :issues (magithub-cache (magithub-repo-id) :issues
'(with-temp-message "Retrieving issue list..." '(with-temp-message "Retrieving issue list..."
(if (magithub-hub-version-at-least "2.3") (if (magithub-hub-version-at-least "2.3")
(magithub-issue-list--internal) (magithub--issue-list--internal)
(magithub-issue-list--internal-2.2.8))))) (magithub--issue-list--internal-2.2.8)))))
(defun magithub-issue--insert (issue) (defun magithub-issue--insert (issue)
"Insert an `issue' as a Magit section into the buffer." "Insert an `issue' as a Magit section into the buffer."
@ -182,6 +182,7 @@ If `issue' is nil, open the repository's issues page."
(car (magithub--command-output "browse" '("--url-only" "--" "issues")))))) (car (magithub--command-output "browse" '("--url-only" "--" "issues"))))))
(defun magithub-issue-refresh () (defun magithub-issue-refresh ()
"Refresh issues for this repository."
(interactive) (interactive)
(magithub-cache-clear (magithub-repo-id) :issues) (magithub-cache-clear (magithub-repo-id) :issues)
(when (derived-mode-p 'magit-status-mode) (when (derived-mode-p 'magit-status-mode)
@ -208,26 +209,82 @@ If `issue' is nil, open the repository's issues page."
map) map)
"Keymap for `magithub-pull-request-list' sections.") "Keymap for `magithub-pull-request-list' sections.")
(defun magithub--issues-of-type (type)
"Filter `magithub--issue-list' for issues of type TYPE."
(-filter (lambda (i) (eq (plist-get i :type) type))
(magithub--issue-list)))
(defun magithub-issues ()
"Return a list of issue objects that are actually issues."
(magithub--issues-of-type 'issue))
(defun magithub-pull-requests ()
"Return a list of issue objects that are actually pull requests."
(magithub--issues-of-type 'pull-request))
(defun magithub-issue--insert-issue-section () (defun magithub-issue--insert-issue-section ()
"Insert GitHub issues if appropriate." "Insert GitHub issues if appropriate."
(when (magithub-usable-p) (when (magithub-usable-p)
(--when-let (-filter (lambda (i) (eq (plist-get i :type) 'issue)) (-when-let (issues (magithub-issues))
(magithub-issue-list))
(magit-insert-section (magithub-issue-list) (magit-insert-section (magithub-issue-list)
(magit-insert-heading "Issues:") (magit-insert-heading "Issues:")
(mapc #'magithub-issue--insert it) (mapc #'magithub-issue--insert issues)
(insert ?\n))))) (insert ?\n)))))
(defun magithub-issue--insert-pr-section () (defun magithub-issue--insert-pr-section ()
"Insert GitHub pull requests if appropriate." "Insert GitHub pull requests if appropriate."
(when (magithub-usable-p) (when (magithub-usable-p)
(--when-let (-filter (lambda (i) (eq (plist-get i :type) 'pull-request)) (-when-let (pull-requests (magithub-pull-requests))
(magithub-issue-list))
(magit-insert-section (magithub-pull-request-list) (magit-insert-section (magithub-pull-request-list)
(magit-insert-heading "Pull Requests:") (magit-insert-heading "Pull Requests:")
(mapc #'magithub-issue--insert it) (mapc #'magithub-issue--insert pull-requests)
(insert ?\n))))) (insert ?\n)))))
(defun magithub-repolist-column-issue (_id)
"Insert the number of open issues in this repository."
(number-to-string (length (magithub-issues))))
(defun magithub-repolist-column-pull-request (_id)
"Insert the number of open pull requests in this repository."
(number-to-string (length (magithub-pull-requests))))
(defun magithub-pull-request--format-pr-for-read (pr)
"Format pull request PR as string suitable for completion."
(format "%3d %s" (plist-get pr :number) (plist-get pr :title)))
(defun magithub-pull-request--completing-read-list ()
"Return an alist of PR-strings to full pull-request issue objects.
See `magithub-pull-request--format-pr-for-am'."
(-when-let (pr-list (magithub-pull-requests))
(-zip-pair
(mapcar #'magithub-pull-request--format-pr-for-read pr-list)
pr-list)))
(defun magithub-pull-request-at-point ()
"The pull request object at point (or nil)."
(when (derived-mode-p 'magit-status-mode)
(-when-let* ((s (magit-current-section))
(v (magit-section-value s)))
(and (listp v)
(eq (plist-get v :type) 'pull-request)
v))))
(defun magithub-pull-request--completing-read ()
"Complete over all open pull requests returning its issue object.
If point is on a pull-request object, that object is selected by
default."
(let ((prs (magithub-pull-request--completing-read-list)) current-pr)
(-when-let (tap (magithub-pull-request-at-point))
(when (and (listp tap) (eq (plist-get tap :type) 'pull-request))
(setq current-pr (magithub-pull-request--format-pr-for-read tap))))
(cdr (assoc (completing-read "Pull request: " prs nil t current-pr) prs))))
(defun magithub-pull-request-checkout (pull-request)
"Checkout PULL-REQUEST as a local branch."
(interactive (list (magithub-pull-request--completing-read)))
(magithub-with-hub
(magit-checkout (plist-get pull-request :url))))
;;; Hook into the status buffer ;;; Hook into the status buffer
(magithub--deftoggle magithub-toggle-issues (magithub--deftoggle magithub-toggle-issues
magit-status-sections-hook #'magithub-issue--insert-issue-section "issues") magit-status-sections-hook #'magithub-issue--insert-issue-section "issues")

3
elpa/magithub-20161011.2129/magithub-pkg.el → elpa/magithub-20161013.2008/magithub-pkg.el
View File

@ -1,9 +1,8 @@
(define-package "magithub" "20161011.2129" "Magit interfaces for GitHub" (define-package "magithub" "20161013.2008" "Magit interfaces for GitHub"
'((emacs "24.4") '((emacs "24.4")
(magit "2.8.0") (magit "2.8.0")
(git-commit "20160821.1338") (git-commit "20160821.1338")
(with-editor "20160828.1025") (with-editor "20160828.1025")
(cl-lib "1.0")
(s "20160711.525")) (s "20160711.525"))
:url "https://github.com/vermiculus/magithub" :keywords :url "https://github.com/vermiculus/magithub" :keywords
'("git" "tools" "vc")) '("git" "tools" "vc"))

15
elpa/magithub-20161011.2129/magithub.el → elpa/magithub-20161013.2008/magithub.el
View File

@ -5,7 +5,7 @@
;; Author: Sean Allred <code@seanallred.com> ;; Author: Sean Allred <code@seanallred.com>
;; Keywords: git, tools, vc ;; Keywords: git, tools, vc
;; Homepage: https://github.com/vermiculus/magithub ;; Homepage: https://github.com/vermiculus/magithub
;; Package-Requires: ((emacs "24.4") (magit "2.8.0") (git-commit "20160821.1338") (with-editor "20160828.1025") (cl-lib "1.0") (s "20160711.525")) ;; Package-Requires: ((emacs "24.4") (magit "2.8.0") (git-commit "20160821.1338") (with-editor "20160828.1025") (s "20160711.525"))
;; Package-Version: 0.1 ;; Package-Version: 0.1
;; This program is free software; you can redistribute it and/or modify ;; This program is free software; you can redistribute it and/or modify
@ -190,17 +190,16 @@ created by hub.
This function will return nil for matches to This function will return nil for matches to
`git-commit-filename-regexp'." `git-commit-filename-regexp'."
(let ((basename (file-name-base path))) (when (and path (magit-inside-gitdir-p))
(and path (let ((basename (file-name-base path)))
(s-suffix? "/.git/" (file-name-directory path)) (and (not (s-matches? git-commit-filename-regexp basename))
(not (s-matches? git-commit-filename-regexp basename)) (cdr (assoc basename magithub--file-types))))))
(cdr (assoc basename magithub--file-types)))))
(defun magithub-check-buffer () (defun magithub-check-buffer ()
"If this is a buffer created by hub, perform setup." "If this is a buffer created by hub, perform setup."
(--when-let (magithub--edit-file-type buffer-file-name) (-when-let (filetype (magithub--edit-file-type buffer-file-name))
(magithub-setup-edit-buffer) (magithub-setup-edit-buffer)
(when (eq it 'issue) (when (eq filetype 'issue)
(magithub-setup-new-issue-buffer)))) (magithub-setup-new-issue-buffer))))
(add-hook 'find-file-hook #'magithub-check-buffer) (add-hook 'find-file-hook #'magithub-check-buffer)