| commit | author | age | ||
| 5cb5f7 | 1 | ;ELC |
| C | 2 | ;;; Compiled |
| 3 | ;;; in Emacs version 26.1 | |
| 4 | ;;; with all optimizations. | |
| 5 | ||
| 6 | ;;; This file uses dynamic docstrings, first added in Emacs 19.29. | |
| 7 | ||
| 8 | ;;; This file does not contain utf-8 non-ASCII characters, | |
| 9 | ;;; and so can be loaded in Emacs versions earlier than 23. | |
| 10 | ||
| 11 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 12 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 13 | ||
| 14 | ||
| 15 | (byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\305\306\307\310\311\312\313\314&\210\315\316\317\320\321DD\322\323\324\313\306\325\326& \210\315\327\317\320\330DD\331\323\332\313\306\325\333\334\335& \210\315\336\317\320\337DD\340\323\341\313\306\325\333\334\342& \210\315\343\317\320\344DD\345\323\346\313\306\325\333\334\347& \210\315\350\317\320\351DD\352\323\353\313\306\325\333\334\354& \210\315\355\317\320\356DD\357\323\360\313\306\325\361& \210\315\362\317\320\363DD\364\323\365\313\306\325\366& \210\367\370\371\372\313\373%\210\367\374\375\376\313\373%\210\367\377\201@ \201A \313\373%\210\367\201B \201C \201D \313\373%\207" [require cl-lib dash eieio magit-utils custom-declare-group magit-section nil "Expandable sections." :link (info-link "(magit)Sections") :group magit custom-declare-variable magit-section-show-child-count funcall function #[0 "\300\207" [t] 1] "Whether to append the number of children to section headings.\nThis only applies to sections for which doing so makes sense." :package-version (magit . "2.1.0") :type boolean magit-section-movement-hook #[0 "\300\207" [(magit-hunk-set-window-start magit-log-maybe-update-revision-buffer magit-log-maybe-show-more-commits)] 1] "Hook run by `magit-section-goto'.\nThat function in turn is used by all section movement commands." (magit . "2.3.0") hook :options (magit-hunk-set-window-start magit-status-maybe-update-revision-buffer magit-status-maybe-update-blob-buffer magit-log-maybe-update-revision-buffer magit-log-maybe-update-blob-buffer magit-log-maybe-show-more-commits) magit-section-highlight-hook #[0 "\300\207" [(magit-diff-highlight magit-section-highlight magit-section-highlight-selection)] 1] "Functions used to highlight the current section.\nEach function is run with the current section as only argument\nuntil one of them returns non-nil." (magit . "2.1.0") (magit-diff-highlight magit-section-highlight magit-section-highlight-selection) magit-section-unhighlight-hook #[0 "\300\207" [(magit-diff-unhighlight)] 1] "Functions used to unhighlight the previously current section.\nEach function is run with the current section as only argument\nuntil one of them returns non-nil. Most sections are properly\nunhighlighted without requiring a specialized unhighlighter,\ndiff-related sections being the only exception." (magit . "2.1.0") (magit-diff-unhighlight) magit-section-set-visibility-hook #[0 "\300\207" [(magit-diff-expansion-threshold magit-section-cached-visibility)] 1] "Hook used to set the initial visibility of a section.\nStop at the first function that returns non-nil. The returned\nvalue should be `show', `hide' or nil. If no function returns\nnon-nil, determine the visibility as usual, i.e. use the\nhardcoded section specific default (see `magit-insert-section')." (magit . "2.4.0") (magit-diff-expansion-threshold magit-section-cached-visibility) magit-section-cache-visibility #[0 "\300\207" [t] 1] "Whether to cache visibility of sections.\n\nSections always retain their visibility state when they are being\nrecreated during a refresh. But if a section disappears and then\nlater reappears again, then this option controls whether this is\nthe case.\n\nIf t, then cache the visibility of all sections. If a list of\nsection types, then only do so for matching sections. If nil,\nthen don't do so for any sections." (magit . "2.12.0") (choice (const :tag "Don't cache visibility" nil) (const :tag "Cache visibility of all sections" t) (repeat :tag "Cache visibility for section types" symbol)) magit-section-initial-visibility-alist #[0 "\300\207" [((stashes . hide))] 1] "Alist controlling the initial visibility of sections.\n\nEach element maps a section type or lineage to the initial\nvisibility state for such sections. The state has to be one of\n`show' or `hide', or a function that returns one of these symbols.\nA function is called with the section as the only argument.\n\nUse the command `magit-describe-section' to determine a section's\nlineage or type. The vector in the output is the section lineage\nand the type is the first element of that vector. Wildcards can\nbe used, see `magit-section-match'.\n\nCurrently this option is only used to override hardcoded defaults,\nbut in the future it will also be used set the defaults.\n\nAn entry whose key is `magit-status-initial-section' specifies\nthe visibility of the section `magit-status-goto-initial-section'\njumps to. This does not only override defaults, but also other\nentries of this alist." (magit . "2.12.0") (alist :key-type (sexp :tag "Section type/lineage") :value-type (choice (const hide) (const show) function)) custom-declare-face magit-section-highlight ((((class color) (background light)) :background "grey95") (((class color) (background dark)) :background "grey20")) "Face for highlighting the current section." magit-faces magit-section-heading ((((class color) (background light)) :foreground "DarkGoldenrod4" :weight bold) (((class color) (background dark)) :foreground "LightGoldenrod2" :weight bold)) "Face for section headings." magit-section-secondary-heading ((t :weight bold)) "Face for section headings of some secondary headings." magit-section-heading-selection ((((class color) (background light)) :foreground "salmon4") (((class color) (background dark)) :foreground "LightSalmon3")) "Face for selected section headings."] 12) | |
| 16 | #@53 Internal variable used for `magit-explain-section'. | |
| 17 | (defvar magit--current-section-hook nil (#$ . 5791)) | |
| 18 | (defvar magit--section-type-alist '((file . magit-file-section) (hunk . magit-hunk-section) (module . magit-module-section))) | |
| 19 | (byte-code "\300\301\302\303!\"\210\300\304\305\303!\"\210\300\306\304\"\210\307\306\310\311#\210\312\303\313\304#\314\303\315\316\315$\207" [defalias magit-section-p eieio-make-class-predicate magit-section magit-section--eieio-childp eieio-make-child-predicate magit-section-child-p make-obsolete "use (cl-typep ... \\='magit-section) instead" "25.1" define-symbol-prop cl-deftype-satisfies eieio-defclass-internal nil ((keymap :initform nil :allocation :class) (type :initform nil :initarg :type) (value :initform nil :initarg :value) (start :initform nil :initarg :start) (content :initform nil) (end :initform nil) (hidden :initform nil) (washer :initform nil) (process :initform nil) (heading-highlight-face :initform nil) (inserter :initform (symbol-value 'magit--current-section-hook)) (parent :initform nil :initarg :parent) (children :initform nil))] 6) | |
| 20 | #@70 Create a new object of class type `magit-section'. | |
| 21 | ||
| 22 | (fn &rest SLOTS) | |
| 23 | (defalias 'magit-section #[128 "\300\301\302#\207" [apply make-instance magit-section] 5 (#$ . 6892)]) | |
| 24 | (byte-code "\300\301\302\303#\300\207" [function-put magit-section compiler-macro magit-section--anon-cmacro] 4) | |
| 25 | #@26 | |
| 26 | ||
| 27 | (fn WHOLE &rest SLOTS) | |
| 28 | (defalias 'magit-section--anon-cmacro #[385 "\211@;\204 \207\300\301\302@@#@\303@DABB\"\207" [macroexp--warn-and-return format "Obsolete name arg %S to constructor %S" identity] 7 (#$ . 7184)]) | |
| 29 | (byte-code "\300\301\302\303!\"\210\300\304\305\303!\"\210\300\306\304\"\210\307\306\310\311#\210\312\303\313\304#\314\303\315\316\317$\207" [defalias magit-file-section-p eieio-make-class-predicate magit-file-section magit-file-section--eieio-childp eieio-make-child-predicate magit-file-section-child-p make-obsolete "use (cl-typep ... \\='magit-file-section) instead" "25.1" define-symbol-prop cl-deftype-satisfies eieio-defclass-internal (magit-section) ((source :initform nil) (header :initform nil)) nil] 6) | |
| 30 | #@75 Create a new object of class type `magit-file-section'. | |
| 31 | ||
| 32 | (fn &rest SLOTS) | |
| 33 | (defalias 'magit-file-section #[128 "\300\301\302#\207" [apply make-instance magit-file-section] 5 (#$ . 7930)]) | |
| 34 | (byte-code "\300\301\302\303#\300\207" [function-put magit-file-section compiler-macro magit-file-section--anon-cmacro] 4) | |
| 35 | #@26 | |
| 36 | ||
| 37 | (fn WHOLE &rest SLOTS) | |
| 38 | (defalias 'magit-file-section--anon-cmacro #[385 "\211@;\204 \207\300\301\302@@#@\303@DABB\"\207" [macroexp--warn-and-return format "Obsolete name arg %S to constructor %S" identity] 7 (#$ . 8247)]) | |
| 39 | (byte-code "\300\301\302\303!\"\210\300\304\305\303!\"\210\300\306\304\"\210\307\306\310\311#\210\312\303\313\304#\314\303\315\316\317$\207" [defalias magit-hunk-section-p eieio-make-class-predicate magit-hunk-section magit-hunk-section--eieio-childp eieio-make-child-predicate magit-hunk-section-child-p make-obsolete "use (cl-typep ... \\='magit-hunk-section) instead" "25.1" define-symbol-prop cl-deftype-satisfies eieio-defclass-internal (magit-section) ((refined :initform nil)) nil] 6) | |
| 40 | #@75 Create a new object of class type `magit-hunk-section'. | |
| 41 | ||
| 42 | (fn &rest SLOTS) | |
| 43 | (defalias 'magit-hunk-section #[128 "\300\301\302#\207" [apply make-instance magit-hunk-section] 5 (#$ . 8976)]) | |
| 44 | (byte-code "\300\301\302\303#\300\207" [function-put magit-hunk-section compiler-macro magit-hunk-section--anon-cmacro] 4) | |
| 45 | #@26 | |
| 46 | ||
| 47 | (fn WHOLE &rest SLOTS) | |
| 48 | (defalias 'magit-hunk-section--anon-cmacro #[385 "\211@;\204 \207\300\301\302@@#@\303@DABB\"\207" [macroexp--warn-and-return format "Obsolete name arg %S to constructor %S" identity] 7 (#$ . 9293)]) | |
| 49 | (byte-code "\300\301\302\303!\"\210\300\304\305\303!\"\210\300\306\304\"\210\307\306\310\311#\210\312\303\313\304#\314\303\315\316\211$\207" [defalias magit-module-section-p eieio-make-class-predicate magit-module-section magit-module-section--eieio-childp eieio-make-child-predicate magit-module-section-child-p make-obsolete "use (cl-typep ... \\='magit-module-section) instead" "25.1" define-symbol-prop cl-deftype-satisfies eieio-defclass-internal (magit-file-section) nil] 6) | |
| 50 | #@77 Create a new object of class type `magit-module-section'. | |
| 51 | ||
| 52 | (fn &rest SLOTS) | |
| 53 | (defalias 'magit-module-section #[128 "\300\301\302#\207" [apply make-instance magit-module-section] 5 (#$ . 10011)]) | |
| 54 | (byte-code "\300\301\302\303#\300\207" [function-put magit-module-section compiler-macro magit-module-section--anon-cmacro] 4) | |
| 55 | #@26 | |
| 56 | ||
| 57 | (fn WHOLE &rest SLOTS) | |
| 58 | (defalias 'magit-module-section--anon-cmacro #[385 "\211@;\204 \207\300\301\302@@#@\303@DABB\"\207" [macroexp--warn-and-return format "Obsolete name arg %S to constructor %S" identity] 7 (#$ . 10339)]) | |
| 59 | #@186 The root section in the current buffer. | |
| 60 | All other sections are descendants of this section. The value | |
| 61 | of this variable is set by `magit-insert-section' and you should | |
| 62 | never modify it. | |
| 63 | (defvar magit-root-section nil (#$ . 10580)) | |
| 64 | (byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local magit-root-section put permanent-local t] 4) | |
| 65 | #@30 Return the section at point. | |
| 66 | (defalias 'magit-current-section #[0 "\301`\302\"\206 \207" [magit-root-section get-text-property magit-section] 3 (#$ . 10937)]) | |
| 67 | #@107 Return an unique identifier for SECTION. | |
| 68 | The return value has the form ((TYPE . VALUE)...). | |
| 69 | ||
| 70 | (fn SECTION) | |
| 71 | (defalias 'magit-section-ident #[257 "\211\301\302\"\301\302\"\303>\204 \301\304\"\202G \305\301\304\"\306\307\310#)\266\203\203/ \301\304\"\202G \311\301\304\"\306\307\310#)\266\203\203F \312\202G \313B\301\314\"\205U \315\301\314\"!B\207" [inhibit-changing-match-data slot-value type (unpulled unpushed) value "@{upstream}" nil t string-match "\\`\\.\\." "..@{push}" "@{push}.." parent magit-section-ident] 10 (#$ . 11105)]) | |
| 72 | #@129 Return the section identified by IDENT. | |
| 73 | IDENT has to be a list as returned by `magit-section-ident'. | |
| 74 | ||
| 75 | (fn IDENT &optional ROOT) | |
| 76 | (defalias 'magit-get-section #[513 "\301!\262\211\206\n \211A\262\242@\302\303\"=\205t \203s \304\302\305\"\306\307\203_ \203_ @\2038 \304\262\202S @@\302\303\"=\203S @A\302\310\"\232\203S \211\262\210\211T\262A\262\202$ \266\211\262\211\262\203s \211A\262\210\202 \211\207" [magit-root-section reverse eieio-oref type nil children t 0 value] 12 (#$ . 11662)]) | |
| 77 | #@87 Return the lineage of SECTION. | |
| 78 | The return value has the form (TYPE...). | |
| 79 | ||
| 80 | (fn SECTION) | |
| 81 | (defalias 'magit-section-lineage #[257 "\300\301\"\300\302\"\211\205 \303!\262B\207" [eieio-oref type parent magit-section-lineage] 5 (#$ . 12186)]) | |
| 82 | #@24 For internal use only. | |
| 83 | (defvar magit-insert-section--current nil (#$ . 12432)) | |
| 84 | #@24 For internal use only. | |
| 85 | (defvar magit-insert-section--parent nil (#$ . 12517)) | |
| 86 | #@24 For internal use only. | |
| 87 | (defvar magit-insert-section--oldroot nil (#$ . 12601)) | |
| 88 | #@52 Move to the beginning of the next visible section. | |
| 89 | (defalias 'magit-section-forward #[0 "m\203 \300\301!\207\302 \303\304\"\203W \303\305\"?\205) \303\306\"`TU?\205) \303\307\"@\203E \211\204E \310\311\"@\211\262\204) \303\304\"\262\202) \211\203O \312!\202R \300\301!\262\202Z \312\313!\207" [user-error "No next section" magit-current-section eieio-oref parent hidden end children magit-section-siblings next magit-section-goto 1] 5 (#$ . 12686) nil]) | |
| 90 | #@232 Move to the beginning of the current or the previous visible section. | |
| 91 | When point is at the beginning of a section then move to the | |
| 92 | beginning of the previous visible section. Otherwise move to | |
| 93 | the beginning of the current section. | |
| 94 | (defalias 'magit-section-backward #[0 "o\203 \300\301!\207\302 \303`\304\305\"SU\203( \304\306\"\211\262\203( \307\310!@!\202\234 \304\311\"\203> `\304\312\"U\204> \307!\202\234 \313\314\"@\211\203a \304\315\"\204g \304\306\"\211\262\203g \310!@\262\202G \304\311\"\262\211\203q \307!\202\232 \304\311\"\203~ \300\301!\202\232 \316`S\317\"\204\214 \307\320!\202\232 \321`S\317\"b\210\320y\210\307\302 !\262\207" [user-error "No previous section" magit-current-section nil eieio-oref end children magit-section-goto last parent start magit-section-siblings prev hidden get-text-property invisible -1 previous-single-property-change] 6 (#$ . 13159) nil]) | |
| 95 | #@46 Move to the beginning of the parent section. | |
| 96 | (defalias 'magit-section-up #[0 "\300\301 \302\"\211\203 \303!\202 \304\305!\207" [eieio-oref magit-current-section parent magit-section-goto user-error "No parent section"] 3 (#$ . 14068) nil]) | |
| 97 | #@114 Move to the beginning of the next sibling section. | |
| 98 | If there is no next sibling section, then move to the parent. | |
| 99 | (defalias 'magit-section-forward-sibling #[0 "\300 \301\302\"\203 \303\304\"@\211\203 \305!\202 \306 \262\202\" \305\307!\207" [magit-current-section eieio-oref parent magit-section-siblings next magit-section-goto magit-section-forward 1] 4 (#$ . 14318) nil]) | |
| 100 | #@122 Move to the beginning of the previous sibling section. | |
| 101 | If there is no previous sibling section, then move to the parent. | |
| 102 | (defalias 'magit-section-backward-sibling #[0 "\300 \301\302\"\203 \303\304\"@\211\203 \305!\202 \306 \262\202\" \305\307!\207" [magit-current-section eieio-oref parent magit-section-siblings prev magit-section-goto magit-section-backward -1] 4 (#$ . 14706) nil]) | |
| 103 | #@12 | |
| 104 | ||
| 105 | (fn ARG) | |
| 106 | (defalias 'magit-section-goto #[257 "\211\250\203 \211y\210\300 \262\202 \301\302\"b\210\303\304\"\207" [magit-current-section eieio-oref start run-hook-with-args magit-section-movement-hook] 4 (#$ . 15104)]) | |
| 107 | #@59 Ensure the beginning of SECTION is visible. | |
| 108 | ||
| 109 | (fn SECTION) | |
| 110 | (defalias 'magit-section-set-window-start #[257 "\300\301\302\"!?\205 \303\304 \301\305\"\"\207" [pos-visible-in-window-p eieio-oref end set-window-start selected-window start] 6 (#$ . 15335)]) | |
| 111 | #@133 When SECTION is a `hunk', ensure that its beginning is visible. | |
| 112 | It the SECTION has a different type, then do nothing. | |
| 113 | ||
| 114 | (fn SECTION) | |
| 115 | (defalias 'magit-hunk-set-window-start #[257 "\300!\205 \301!\207" [magit-hunk-section-p magit-section-set-window-start] 3 (#$ . 15597)]) | |
| 116 | #@187 Define an interactive function to go some section. | |
| 117 | Together TYPE and VALUE identify the section. | |
| 118 | HEADING is the displayed heading of the section. | |
| 119 | ||
| 120 | (fn NAME HEADING TYPE &optional VALUE) | |
| 121 | (defalias 'magit-define-section-jumper '(macro . #[1027 "\300\301\302\303\"\304\305\306\307\211\310 D\nE\311BBD\312\313\302\314 \"DF\257\207" [defun (&optional expand) format "Jump to the section \"%s\".\nWith a prefix argument also expand it." (interactive "P") --if-let magit-get-section cons quote ((magit-section-ident magit-root-section)) (progn (goto-char (oref it start)) (when expand (with-local-quit (magit-section-show it)) (recenter 0))) message "Section \"%s\" wasn't found"] 16 (#$ . 15877)])) | |
| 122 | (byte-code "\300\301\302\303#\300\207" [function-put magit-define-section-jumper lisp-indent-function defun] 4) | |
| 123 | #@53 Show the body of the current section. | |
| 124 | ||
| 125 | (fn SECTION) | |
| 126 | (defalias 'magit-section-show #[257 "\302\303\304#\210\305\306\"\211\203Q \302\306\304#\210\307\305\310\"\212\211\2034 \211\305\311\"W\2034 !\210\202K \305\311\"b\210\302\310\312 #\210 \210\302\311\312 #\210+\266\313 \210\210\305\310\"\211\203d \314\305\311\"\315\307$\210\210\316!\210\305\317\"\211\205\214 \211@\305\303\"\203\201 \320!\210\202\205 \321!\210A\266\202\202m \207" [magit-insert-section--parent inhibit-read-only eieio-oset hidden nil eieio-oref washer t content end point-marker magit-section-update-highlight remove-overlays invisible magit-section-maybe-cache-visibility children magit-section-hide magit-section-show] 9 (#$ . 16695) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 127 | #@53 Hide the body of the current section. | |
| 128 | ||
| 129 | (fn SECTION) | |
| 130 | (defalias 'magit-section-hide #[257 "\211=\203\n \301\302!\207\303\304\305#\210\306\307\"\211\2034 \306\310\"\311\312\305$\210\313\"\314\315\305#\210\314\312\305#\266\210\316!\207" [magit-root-section user-error "Cannot hide root section" eieio-oset hidden t eieio-oref content end remove-overlays invisible make-overlay overlay-put evaporate magit-section-maybe-cache-visibility] 8 (#$ . 17485) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 131 | #@69 Toggle visibility of the body of the current section. | |
| 132 | ||
| 133 | (fn SECTION) | |
| 134 | (defalias 'magit-section-toggle #[257 "\211=\203\n \301\302!\207\303\304\"b\210\303\305\"\203 \306!\207\307!\207" [magit-root-section user-error "Cannot hide root section" eieio-oref start hidden magit-section-show magit-section-hide] 4 (#$ . 18004) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 135 | #@79 Toggle visibility of bodies of children of the current section. | |
| 136 | ||
| 137 | (fn SECTION) | |
| 138 | (defalias 'magit-section-toggle-children #[257 "\300\301\"b\210\300\302\"\303\304\305\306\2035 \2035 @\203# \304\262\202) \300\307\"\262\210\211T\262A\262\202 \266\211\262!\211\203O \211@\310\307#\210A\266\202\202< \266\311!\207" [eieio-oref start children ---truthy\? nil t 0 hidden eieio-oset magit-section-show] 11 (#$ . 18387) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 139 | #@168 Recursively show the bodies of children of the current section. | |
| 140 | With a prefix argument show children that deep and hide deeper | |
| 141 | children. | |
| 142 | ||
| 143 | (fn SECTION &optional DEPTH) | |
| 144 | (defalias 'magit-section-show-children #[513 "\300\"\210\301!\207" [magit-section-show-children-1 magit-section-show] 5 (#$ . 18878) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 145 | #@32 | |
| 146 | ||
| 147 | (fn SECTION &optional DEPTH) | |
| 148 | (defalias 'magit-section-show-children-1 #[513 "\300\301\"\211\2055 \211@\302\303\304#\210\203* \305V\203# \306S\"\210\202. \307!\210\202. \306!\210A\266\202\202 \207" [eieio-oref children eieio-oset hidden nil 0 magit-section-show-children-1 magit-section-hide] 8 (#$ . 19240)]) | |
| 149 | #@79 Recursively hide the bodies of children of the current section. | |
| 150 | ||
| 151 | (fn SECTION) | |
| 152 | (defalias 'magit-section-hide-children #[257 "\300\301\302\303\"\"\207" [mapc magit-section-hide eieio-oref children] 6 (#$ . 19567) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 153 | #@147 Recursively show headings of children of the current section. | |
| 154 | Only show the headings, previously shown text-only bodies are | |
| 155 | hidden. | |
| 156 | ||
| 157 | (fn SECTION) | |
| 158 | (defalias 'magit-section-show-headings #[257 "\300!\210\301!\207" [magit-section-show-headings-1 magit-section-show] 3 (#$ . 19839) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 159 | #@16 | |
| 160 | ||
| 161 | (fn SECTION) | |
| 162 | (defalias 'magit-section-show-headings-1 #[257 "\300\301\"\211\205) \211@\302\303\304#\210\300\301\"\204 \300\305\"\204\" \306!\210A\266\202\202 \207" [eieio-oref children eieio-oset hidden nil content magit-section-show-headings-1] 7 (#$ . 20178)]) | |
| 163 | #@69 Cycle visibility of current section and its children. | |
| 164 | ||
| 165 | (fn SECTION) | |
| 166 | (defalias 'magit-section-cycle #[257 "\300\301\"b\210\300\302\"\203 \303!\210\304!\207\300\305\"\306\307\310\311\203D \203D @\2032 \307\262\2028 \300\302\"\262\210\211T\262A\262\202 \266\211\262!\203\207 \306\307\310\311\203x \203x @\203f \307\262\202l \300\305\"\262\210\211T\262A\262\202R \266\211\262!\203\207 \312!\202\227 \313\314\"\203\224 \315!\202\227 \316!\207" [eieio-oref start hidden magit-section-show magit-section-hide-children children ---truthy\? nil t 0 magit-section-show-headings -any-p magit-section-hidden-body magit-section-show-children magit-section-hide] 11 (#$ . 20457) (byte-code "\300 C\207" [magit-current-section] 1)]) | |
| 167 | #@57 Cycle visibility of all sections in the current buffer. | |
| 168 | (defalias 'magit-section-cycle-global #[0 "\301\302\"\303\304\305\306\203/ \203/ @\203 \304\262\202# \301\307\"\262\210\211T\262A\262\202 \266\211\262!\203r \303\304\305\306\203c \203c @\203Q \304\262\202W \301\302\"\262\210\211T\262A\262\202= \266\211\262!\203r \310!\202\203 \311\312\"\203 \313!\202\203 \314\315\"\207" [magit-root-section eieio-oref children ---truthy\? nil t 0 hidden magit-section-show-headings -any-p magit-section-hidden-body magit-section-show-children mapc magit-section-hide] 10 (#$ . 21218) nil]) | |
| 169 | #@66 Cycle visibility of diff-related sections in the current buffer. | |
| 170 | (defalias 'magit-section-cycle-diffs #[0 "\301\302!\203 \303\304\305\306\307\310!\307\311!D\"\"\202# \301\312!\205# \313\314\315\316\"\"\211\205 \317\320\321\322\203R \203R @\203@ \320\262\202F \315\323\"\262\210\211T\262A\262\202, \266\211\262!\203v \211\211\205q \211@\324!\210\325!\210A\266\202\202\\ \262\202 \303\304\305\326\"\"\317\320\321\322\203\250 \203\250 @\203\226 \320\262\202\234 \315\323\"\262\210\211T\262A\262\202\202 \266\211\262!\203\354 \317\320\321\322\203\334 \203\334 @\203\312 \320\262\202\320 \315\316\"\262\210\211T\262A\262\202\266 \266\211\262!\203\354 \327\330\"\202\376 \331\332\"\203\372 \327\333\"\202\376 \327\334\"\262\207" [magit-root-section derived-mode-p magit-status-mode apply append mapcar #[257 "\211\205 \300\301\"\203 \302!\210\300\303\"\207" [eieio-oref hidden magit-section-show children] 4 "\n\n(fn IT)"] magit-get-section ((staged) (status)) ((unstaged) (status)) magit-diff-mode -filter magit-file-section-p eieio-oref children ---truthy\? nil t 0 hidden magit-section-show magit-section-hide-children #[257 "\300\301\"\207" [eieio-oref children] 4 "\n\n(fn IT)"] mapc magit-section-show-headings -any-p magit-section-hidden-body magit-section-show-children magit-section-hide] 11 (#$ . 21839) nil]) | |
| 171 | #@31 | |
| 172 | ||
| 173 | (fn SECTION &optional PRED) | |
| 174 | (defalias 'magit-section-hidden-body #[513 "\300\301\"\211\203 \206 \302\303\"\202 \300\304\"\205 \300\305\"\207" [eieio-oref children -any-p magit-section-hidden-body content hidden] 6 (#$ . 23218)]) | |
| 175 | #@176 Return t if the SECTION's body is invisible. | |
| 176 | When the body of an ancestor of SECTION is collapsed then | |
| 177 | SECTION's body (and heading) obviously cannot be visible. | |
| 178 | ||
| 179 | (fn SECTION) | |
| 180 | (defalias 'magit-section-invisible-p #[257 "\300\301\"\206 \300\302\"\211\205 \303!\262\207" [eieio-oref hidden parent magit-section-invisible-p] 4 (#$ . 23465)]) | |
| 181 | #@143 Show surrounding sections up to LEVEL. | |
| 182 | If LEVEL is negative, show up to the absolute value. | |
| 183 | Sections at higher levels are hidden. | |
| 184 | ||
| 185 | (fn LEVEL) | |
| 186 | (defalias 'magit-section-show-level #[257 "\211\301W\203+ \302 [\262\303!GSV\203% \304\305\"\262\304\306\"b\210\202\f \307S\"\207\302 \303!GS\211W\203D \307\310\311#\"\210\202a \211U\203Q \312!\210\202a \304\305\"\262\211S\211\262\262\2022 \313!\207" [magit-root-section 0 magit-current-section magit-section-ident eieio-oref parent start magit-section-show-children - 1 magit-section-hide magit-section-goto] 9 (#$ . 23816)]) | |
| 187 | #@43 Show surrounding sections on first level. | |
| 188 | (defalias 'magit-section-show-level-1 #[0 "\300\301!\207" [magit-section-show-level 1] 2 (#$ . 24412) nil]) | |
| 189 | #@35 Show all sections on first level. | |
| 190 | (defalias 'magit-section-show-level-1-all #[0 "\300\301!\207" [magit-section-show-level -1] 2 (#$ . 24568) nil]) | |
| 191 | #@47 Show surrounding sections up to second level. | |
| 192 | (defalias 'magit-section-show-level-2 #[0 "\300\301!\207" [magit-section-show-level 2] 2 (#$ . 24721) nil]) | |
| 193 | #@39 Show all sections up to second level. | |
| 194 | (defalias 'magit-section-show-level-2-all #[0 "\300\301!\207" [magit-section-show-level -2] 2 (#$ . 24881) nil]) | |
| 195 | #@46 Show surrounding sections up to third level. | |
| 196 | (defalias 'magit-section-show-level-3 #[0 "\300\301!\207" [magit-section-show-level 3] 2 (#$ . 25038) nil]) | |
| 197 | #@38 Show all sections up to third level. | |
| 198 | (defalias 'magit-section-show-level-3-all #[0 "\300\301!\207" [magit-section-show-level -3] 2 (#$ . 25197) nil]) | |
| 199 | #@47 Show surrounding sections up to fourth level. | |
| 200 | (defalias 'magit-section-show-level-4 #[0 "\300\301!\207" [magit-section-show-level 4] 2 (#$ . 25353) nil]) | |
| 201 | #@39 Show all sections up to fourth level. | |
| 202 | (defalias 'magit-section-show-level-4-all #[0 "\300\301!\207" [magit-section-show-level -4] 2 (#$ . 25513) nil]) | |
| 203 | #@215 Show information about the section at point. | |
| 204 | With a prefix argument show the section identity instead of the | |
| 205 | section lineage. This command is intended for debugging purposes. | |
| 206 | ||
| 207 | (fn SECTION &optional MESSAGE IDENT) | |
| 208 | (defalias 'magit-describe-section-briefly #[769 "\300\301\302!\303\304\"\211;\203 \305!\202( \306!\203' \307\310!\203' \310!\202( \211\262\2035 \311!\202< \312\313\314 !\"\303\315\"\211\205H \316!\262\303 \317\"\211\205V \316!\262&\203e \320\321\"\202f \211\207" [format "#<%s %S %S %s-%s>" eieio-object-class eieio-oref value substring-no-properties eieio-object-p fboundp cl-prin1-to-string magit-section-ident apply vector magit-section-lineage start marker-position end message "%s"] 12 (#$ . 25671) (byte-code "\300 \301D\207" [magit-current-section t] 2)]) | |
| 209 | (cl-generic-define-method 'cl-print-object nil '((section magit-section) stream) nil #[514 "\300\301!\"\207" [princ magit-describe-section-briefly] 5 "Print `magit-describe-section' result of SECTION.\n\n(fn SECTION STREAM)"]) | |
| 210 | #@84 Show information about the section at point. | |
| 211 | ||
| 212 | (fn SECTION &optional INTERACTIVE-P) | |
| 213 | (defalias 'magit-describe-section #[513 "C\211\242\211\203 \305\306\"\204 \305\307\"\262\202 \211\203' \305\306\"\203' \240\210\210\305\242\306\"\310:\2038@\211:\2030\211@A\211:\203'\211@A\211\204A\211\311\312 \242D\"\210\313\211\223\210\314 B\315\nB\316 \317 \320!\211 \313\211r\fq\210\321\322\323\242!\324\325\n!\313\326\327\330C&\324\325\n!\313\326\331\330C&$c\210\211\203\330 \211@\211@A\211@A\321\332\324\325!\313\326\327\330 C&\324\325!\313\326\331\330 C&#c\266A\266\202\202\241 \210\333c\210\321\334\324\325 !\313\326\327\330 C&\"c\210\335!)\262rq\210\336\313\"\262)\337\340!\203\340\"\202\211)\266\204*\266\203\262\202\"\341\342\323\n\242!\"\266\202\202+!\266\202\2023!\262\202;\211!\266\202\207" [help-window-point-marker temp-buffer-window-setup-hook temp-buffer-window-show-hook help-window-old-frame standard-output eieio-oref inserter parent #[257 "\300\301\302\242!\"\207" [message #1="%s, inserter unknown" magit-describe-section-briefly] 5 "\n\n(fn SECTION)"] help-setup-xref magit-describe-section nil help-mode-setup help-mode-finish selected-frame help-buffer temp-buffer-window-setup format-message "%s\n is inserted by `%s'\n from `%s'" magit-describe-section-briefly make-text-button symbol-name :type help-function help-args help-variable ",\n called by `%s'\n from `%s'" ".\n\n" "`%s' is " describe-function-1 temp-buffer-window-show functionp help-window-setup message #1#] 36 (#$ . 26705) (byte-code "\300 \301D\207" [magit-current-section t] 2)]) | |
| 214 | #@1435 Return t if SECTION matches CONDITION. | |
| 215 | ||
| 216 | SECTION defaults to the section at point. If SECTION is not | |
| 217 | specified and there also is no section at point, then return | |
| 218 | nil. | |
| 219 | ||
| 220 | CONDITION can take the following forms: | |
| 221 | (CONDITION...) matches if any of the CONDITIONs matches. | |
| 222 | [CLASS...] matches if the section's class is the same | |
| 223 | as the first CLASS or a subclass of that; | |
| 224 | the section's parent class matches the | |
| 225 | second CLASS; and so on. | |
| 226 | [* CLASS...] matches sections that match [CLASS...] and | |
| 227 | also recursively all their child sections. | |
| 228 | CLASS matches if the section's class is the same | |
| 229 | as CLASS or a subclass of that; regardless | |
| 230 | of the classes of the parent sections. | |
| 231 | ||
| 232 | Each CLASS should be a class symbol, identifying a class that | |
| 233 | derives from `magit-section'. For backward compatibility CLASS | |
| 234 | can also be a "type symbol". A section matches such a symbol | |
| 235 | if the value of its `type' slot is `eq'. If a type symbol has | |
| 236 | an entry in `magit--section-type-alist', then a section also | |
| 237 | matches that type if its class is a subclass of the class that | |
| 238 | corresponds to the type as per that alist. | |
| 239 | ||
| 240 | Note that it is not necessary to specify the complete section | |
| 241 | lineage as printed by `magit-describe-section-briefly', unless | |
| 242 | of course you want to be that precise. | |
| 243 | ||
| 244 | (fn CONDITION &optional (SECTION (magit-current-section))) | |
| 245 | (defalias 'magit-section-match #[385 "\211\203 \211A\262\242\202 \300 \203 \301\302\303\304G\\D\"\210\211\205% \305\"\207" [magit-current-section signal wrong-number-of-arguments magit-section-match 2 magit-section-match-1] 8 (#$ . 28360)]) | |
| 246 | #@26 | |
| 247 | ||
| 248 | (fn CONDITION SECTION) | |
| 249 | (defalias 'magit-section-match-1 #[514 "\204 \300\301!\210\211\205U <\203D \302\303\304\203@ \203@ @\203) \302\262\2024 \305\"\2034 \211\262\210\211T\262A\262\202 \266\211\207\3069\203O C\202S \307\310\"\"\207" [cl--assertion-failed condition nil t 0 magit-section-match-1 magit-section-match-2 cl-coerce list] 10 (#$ . 30050)]) | |
| 250 | #@26 | |
| 251 | ||
| 252 | (fn CONDITION SECTION) | |
| 253 | (defalias 'magit-section-match-2 #[514 "@\301=\203 \302A\"\206^ \303\304\"\211\205 \302\"\207@\305!\203+ \306\"\202B \211\236A\211\203: \306\"\202@ \303\307\"=\262\262\205^ A\211\262?\206^ \303\304\"\211\205\\ \302\"\262\207" [magit--section-type-alist * magit-section-match-2 eieio-oref parent class-p cl-typep type] 7 (#$ . 30432)]) | |
| 254 | #@353 If the section at point matches CONDITION, then return its value. | |
| 255 | ||
| 256 | If optional SECTION is non-nil then test whether that matches | |
| 257 | instead. If there is no section at point and SECTION is nil, | |
| 258 | then return nil. If the section does not match, then return | |
| 259 | nil. | |
| 260 | ||
| 261 | See `magit-section-match' for the forms CONDITION can take. | |
| 262 | ||
| 263 | (fn CONDITION &optional SECTION) | |
| 264 | (defalias 'magit-section-value-if #[513 "\211\206 \300 \211\205 \301\"\205 \302\303\"\207" [magit-current-section magit-section-match eieio-oref value] 6 (#$ . 30824)]) | |
| 265 | #@431 If the section at point matches CONDITION, evaluate BODY. | |
| 266 | ||
| 267 | If the section matches, then evaluate BODY forms sequentially | |
| 268 | with `it' bound to the section and return the value of the last | |
| 269 | form. If there are no BODY forms, then return the value of the | |
| 270 | section. If the section does not match or if there is no section | |
| 271 | at point, then return nil. | |
| 272 | ||
| 273 | See `magit-section-match' for the forms CONDITION can take. | |
| 274 | ||
| 275 | (fn CONDITION &rest BODY) | |
| 276 | (defalias 'magit-section-when '(macro . #[385 "\300\301\302\303\304D\305BB\206 \306BBE\207" [--when-let (magit-current-section) when magit-section-match quote (it) ((oref it value))] 8 (#$ . 31358)])) | |
| 277 | (byte-code "\300\301\302\303#\210\304\301\305\306#\307\301\310\311#\207" [make-obsolete magit-section-when "instead use `magit-section-match' or `magit-section-value-if'." "Magit 2.90.0" function-put lisp-indent-function 1 put edebug-form-spec (sexp body)] 5) | |
| 278 | #@626 Choose among clauses on the type of the section at point. | |
| 279 | ||
| 280 | Each clause looks like (CONDITION BODY...). The type of the | |
| 281 | section is compared against each CONDITION; the BODY forms of the | |
| 282 | first match are evaluated sequentially and the value of the last | |
| 283 | form is returned. Inside BODY the symbol `it' is bound to the | |
| 284 | section at point. If no clause succeeds or if there is no | |
| 285 | section at point, return nil. | |
| 286 | ||
| 287 | See `magit-section-match' for the forms CONDITION can take. | |
| 288 | Additionally a CONDITION of t is allowed in the final clause, and | |
| 289 | matches if no other CONDITION match, even if there is no section | |
| 290 | at point. | |
| 291 | ||
| 292 | (fn &rest CLAUSES) | |
| 293 | (defalias 'magit-section-case '(macro . #[128 "\300\301\302\303\304\"BE\207" [let* ((it (magit-current-section))) cond mapcar #[257 "\211@\300=\206 \301\302\303\304@D\305BBEAB\207" [t and it magit-section-match-1 quote (it)] 6 "\n\n(fn CLAUSE)"]] 7 (#$ . 32260)])) | |
| 294 | (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-section-case lisp-indent-function 0 put edebug-form-spec (&rest (sexp body))] 5) | |
| 295 | #@90 Return the value associated with SECTION's type or lineage in ALIST. | |
| 296 | ||
| 297 | (fn SECTION ALIST) | |
| 298 | (defalias 'magit-section-match-assoc #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [-some make-byte-code 257 "\211@A\211\301\300\"\205 \266\202\207" vconcat vector [magit-section-match-1] 8 "\n\n(fn ARG0)"] 9 (#$ . 33313)]) | |
| 299 | #@155 Hook run after `magit-insert-section's BODY. | |
| 300 | Avoid using this hook and only ever do so if you know | |
| 301 | what you are doing and are sure there is no other way. | |
| 302 | (defvar magit-insert-section-hook nil (#$ . 33650)) | |
| 303 | #@1663 Insert a section at point. | |
| 304 | ||
| 305 | TYPE is the section type, a symbol. Many commands that act on | |
| 306 | the current section behave differently depending on that type. | |
| 307 | Also if a variable `magit-TYPE-section-map' exists, then use | |
| 308 | that as the text-property `keymap' of all text belonging to the | |
| 309 | section (but this may be overwritten in subsections). TYPE can | |
| 310 | also have the form `(eval FORM)' in which case FORM is evaluated | |
| 311 | at runtime. | |
| 312 | ||
| 313 | Optional VALUE is the value of the section, usually a string | |
| 314 | that is required when acting on the section. | |
| 315 | ||
| 316 | When optional HIDE is non-nil collapse the section body by | |
| 317 | default, i.e. when first creating the section, but not when | |
| 318 | refreshing the buffer. Else expand it by default. This can be | |
| 319 | overwritten using `magit-section-set-visibility-hook'. When a | |
| 320 | section is recreated during a refresh, then the visibility of | |
| 321 | predecessor is inherited and HIDE is ignored (but the hook is | |
| 322 | still honored). | |
| 323 | ||
| 324 | BODY is any number of forms that actually insert the section's | |
| 325 | heading and body. Optional NAME, if specified, has to be a | |
| 326 | symbol, which is then bound to the struct of the section being | |
| 327 | inserted. | |
| 328 | ||
| 329 | Before BODY is evaluated the `start' of the section object is set | |
| 330 | to the value of `point' and after BODY was evaluated its `end' is | |
| 331 | set to the new value of `point'; BODY is responsible for moving | |
| 332 | `point' forward. | |
| 333 | ||
| 334 | If it turns out inside BODY that the section is empty, then | |
| 335 | `magit-cancel-section' can be used to abort and remove all traces | |
| 336 | of the partially inserted section. This can happen when creating | |
| 337 | a section by washing Git's output and Git didn't actually output | |
| 338 | anything this time around. | |
| 339 | ||
| 340 | (fn [NAME] (TYPE &optional VALUE HIDE) &rest BODY) | |
| 341 | (defalias 'magit-insert-section '(macro . #[128 "\300\301!@9\205 \211A\262\242\300\302!\303@@\211\242\304=\203$ \211A@\202' \305D\262D\306\307\310D\311\312\313\f\314BBD\315BBF\316\307\310\nD\311\317\320 \321BBD\322\323\324BBBE F\325 @A@\326BBBBBBDD\327\330\331\332\333\334 EDC\335\331\336\337\340\341\342D\343BBEDC\344\331\332\345\346BBDC\347\350\351\352\332\306\332EEE\353BB\354@8FFFF\355\356D\357D\340\311\340\360\357\361\362\352\362EEEEDE\363\364\365 \203\332 \355\n\nDC ABBC\202\335 A\366\367 D\370\371 \372BB\373BB\303\374\327\375BBD\376\377\201@ BBD\201A \201B \201C \201D \371\201E BBEDD\201F \201B \201C \201G \371\201H BBEDD\201I BBBB\201J \201K \371\201L BBD\201M \201N \355\201O \360\201P \201Q \201R \201S \201T \257\201U BBB\201V BBBEEE\307\201W \201X BB\355\201Y \201Z DE\327\371\201[ BB\201\\ \201] \371\211\201^ BB\201_ BB\201` DEFF\257\"BBFF\207" [cl-gensym "type" "section" let* eval quote funcall if class-p or cdr assq (magit--section-type-alist) ('magit-section) :type car rassq (magit--section-type-alist) error "BUG: No entry for %s in %s" ('magit--section-type-alist) :value (:start (point-marker) :parent magit-insert-section--parent) oset hidden if-let value run-hook-with-args-until-success 'magit-section-set-visibility-hook (eq value 'hide) incarnation and magit-insert-section--oldroot magit-get-section magit-section-ident (magit-insert-section--oldroot) (oref incarnation hidden) magit-section-match-assoc (magit-section-initial-visibility-alist) progn when (functionp value) setq ((eq value 'hide)) 2 let magit-insert-section--current magit-insert-section--parent unless prog1 magit-root-section catch 'cancel-section append (run-hooks 'magit-insert-section-hook) magit-insert-child-count set-marker-insertion-type oref (start) (t) end (end (point-marker)) class-map oref-default (keymap) magit-map intern format "magit-%s-section-map" (type) forge-map "forge-%s-section-map" (type) ((map (or (and class-map (symbol-value class-map)) (and (boundp magit-map) (symbol-value magit-map)) (and (boundp forge-map) (symbol-value forge-map))))) save-excursion goto-char (start) while (< (point) end) ((next (or (next-single-property-change (point) 'magit-section) end))) (get-text-property (point) 'magit-section) put-text-property (point) next 'magit-section ((when map (put-text-property (point) next 'keymap map))) ((goto-char next)) eq (magit-root-section) ((magit-section-cache-visibility nil)) magit-section-show (parent) children nconc (parent) (children) list] 31 (#$ . 33864)])) | |
| 342 | (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-insert-section lisp-indent-function defun put edebug-form-spec ([&optional symbolp] (&or [("eval" symbolp) &optional form form] [symbolp &optional form form]) body)] 5) | |
| 343 | (defalias 'magit-cancel-section #[0 "\205 \301\302\"\204 \303c\207\301\304\"`|\210\305\306\307\305\"\207" [magit-insert-section--current eieio-oref parent "(empty)\n" start nil throw cancel-section] 3]) | |
| 344 | #@1331 Insert the heading for the section currently being inserted. | |
| 345 | ||
| 346 | This function should only be used inside `magit-insert-section'. | |
| 347 | ||
| 348 | When called without any arguments, then just set the `content' | |
| 349 | slot of the object representing the section being inserted to | |
| 350 | a marker at `point'. The section should only contain a single | |
| 351 | line when this function is used like this. | |
| 352 | ||
| 353 | When called with arguments ARGS, which have to be strings, or | |
| 354 | nil, then insert those strings at point. The section should not | |
| 355 | contain any text before this happens and afterwards it should | |
| 356 | again only contain a single line. If the `face' property is set | |
| 357 | anywhere inside any of these strings, then insert all of them | |
| 358 | unchanged. Otherwise use the `magit-section-heading' face for | |
| 359 | all inserted text. | |
| 360 | ||
| 361 | The `content' property of the section struct is the end of the | |
| 362 | heading (which lasts from `start' to `content') and the beginning | |
| 363 | of the the body (which lasts from `content' to `end'). If the | |
| 364 | value of `content' is nil, then the section has no heading and | |
| 365 | its body cannot be collapsed. If a section does have a heading, | |
| 366 | then its height must be exactly one line, including a trailing | |
| 367 | newline character. This isn't enforced, you are responsible for | |
| 368 | getting it right. The only exception is that this function does | |
| 369 | insert a newline character if necessary. | |
| 370 | ||
| 371 | (fn &rest ARGS) | |
| 372 | (defalias 'magit-insert-heading #[128 "\211\203 \301\302\"\303\304G\305\306%\203 \211\202 \307\305\310#c\266n\204& \311c\210\312 \210\313\314\315 #\207" [magit-insert-section--current apply concat text-property-not-all 0 face nil propertize magit-section-heading 10 magit-maybe-make-margin-overlay eieio-oset content point-marker] 8 (#$ . 38566)]) | |
| 373 | (byte-code "\300\301\302\303#\300\207" [function-put magit-insert-heading lisp-indent-function defun] 4) | |
| 374 | #@13 | |
| 375 | ||
| 376 | (fn HOOK) | |
| 377 | (defalias 'magit-insert-headers #[257 "\301C\302\303\304\305\306!\307\"\310$<\203 \202 CB\311!\210\211\242\205\201 \312c\210\211\242A\205\201 \211\242\237\240\210\211\242\211\242A\240\210\242\313\314\"\315\316C#\210\315\316\242#\210\315\317\313\242@\320\"#\210\315\321\313\322\242!@\321\"#\210\242\211\205} \211@\315\314#\210A\266\202\202i \262\266\202)\207" [magit-insert-section-hook nil make-byte-code 0 "\300 \300\242B\240\207" vconcat vector [magit-insert-section--current] 3 magit-run-section-hook "\n" eieio-oref parent eieio-oset children content start end last] 10 (#$ . 40364)]) | |
| 378 | #@379 Modify SECTION's heading to contain number of child sections. | |
| 379 | ||
| 380 | If `magit-section-show-child-count' is non-nil and the SECTION | |
| 381 | has children and its heading ends with ":", then replace that | |
| 382 | with " (N)", where N is the number of child sections. | |
| 383 | ||
| 384 | This function is called by `magit-insert-section' after that has | |
| 385 | evaluated its BODY. Admittedly that's a bit of a hack. | |
| 386 | ||
| 387 | (fn SECTION) | |
| 388 | (defalias 'magit-insert-child-count #[257 "\301\211\205> \302\303\"G\211\262\205> \211\304V\205> \302\305\"\211\262\205> S\206' `Sf\306=\205> \212\307Zb\210\310\311\"c\210\312\313!)\207" [magit-section-show-child-count nil eieio-oref children 0 content 58 2 format " (%s)" delete-char 1] 6 (#$ . 40999)]) | |
| 389 | (defvar magit-section-highlight-overlays nil nil) | |
| 390 | (make-variable-buffer-local 'magit-section-highlight-overlays) | |
| 391 | (defvar magit-section-highlighted-section nil nil) | |
| 392 | (make-variable-buffer-local 'magit-section-highlighted-section) | |
| 393 | (defvar magit-section-highlighted-sections nil nil) | |
| 394 | (make-variable-buffer-local 'magit-section-highlighted-sections) | |
| 395 | (defvar magit-section-unhighlight-sections nil nil) | |
| 396 | (make-variable-buffer-local 'magit-section-unhighlight-sections) | |
| 397 | #@75 When the region is a valid section-selection, highlight them all. | |
| 398 | ||
| 399 | (fn _) | |
| 400 | (defalias 'magit-section-update-region #[257 "\300 \207" [magit-region-sections] 2 (#$ . 42158)]) | |
| 401 | (defalias 'magit-section-update-highlight #[0 "\306 \211=?\205` \307\310\311 \312\313 \"\210\310\f\310=\204) \314\315#\210 \211\203= \211@\314\316#\210A\266\202\202* \210\317\310!\210=\204R \320\321\"?\205Q *\266\322\323\"\205` \310\211\207" [magit-section-highlighted-section deactivate-mark inhibit-read-only magit-section-highlight-overlays magit-section-highlighted-sections magit-section-unhighlight-sections magit-current-section t nil magit-region-sections mapc delete-overlay run-hook-with-args-until-success magit-section-highlight-hook magit-section-unhighlight-hook restore-buffer-modified-p eieio-oref hidden version< "25.1" magit-root-section emacs-version] 10]) | |
| 402 | #@255 Highlight SECTION and if non-nil all sections in SELECTION. | |
| 403 | This function works for any section but produces undesirable | |
| 404 | effects for diff related sections, which by default are | |
| 405 | highlighted using `magit-diff-highlight'. Return t. | |
| 406 | ||
| 407 | (fn SECTION SELECTION) | |
| 408 | (defalias 'magit-section-highlight #[514 "\300\301\"\211\203/ \206 C\211\203. \211@\302\300\303\"\300\304\"\206$ \300\305\"#\210A\266\202\202 \210\210\211\203L \302\300@\303\"\300\306!@\305\"\307#\210\310\311\"\210\202X \302\300\303\"\300\305\"\307#\210\312\207" [eieio-oref heading-highlight-face magit-section-make-overlay start content end last magit-section-highlight magit-section-highlight-selection nil t] 10 (#$ . 43038)]) | |
| 409 | #@547 Highlight the section-selection region. | |
| 410 | If SELECTION is non-nil, then it is a list of sections selected by | |
| 411 | the region. The headings of these sections are then highlighted. | |
| 412 | ||
| 413 | This is a fallback for people who don't want to highlight the | |
| 414 | current section and therefore removed `magit-section-highlight' | |
| 415 | from `magit-section-highlight-hook'. | |
| 416 | ||
| 417 | This function is necessary to ensure that a representation of | |
| 418 | such a region is visible. If neither of these functions were | |
| 419 | part of the hook variable, then such a region would be | |
| 420 | invisible. | |
| 421 | ||
| 422 | (fn _ SELECTION) | |
| 423 | (defalias 'magit-section-highlight-selection #[514 "\211\205. \301=?\205. \211\211\203, \211@\302\303\304\"\303\305\"\206\" \303\306\"\307#\210A\266\202\202\f \210\310\207" [this-command mouse-drag-region magit-section-make-overlay eieio-oref start content end magit-section-heading-selection t] 9 (#$ . 43745)]) | |
| 424 | #@23 | |
| 425 | ||
| 426 | (fn START END FACE) | |
| 427 | (defalias 'magit-section-make-overlay #[771 "\203 \211\302>\203 \303\304!D\262\305\306\307$\310\311#\210\310\312\307#\210\211 B\211\207" [magit-keep-region-overlay magit-section-highlight-overlays (magit-section-heading-selection magit-diff-file-heading-selection magit-diff-hunk-heading-selection) :foreground face-foreground make-overlay nil t overlay-put face evaporate] 8 (#$ . 44615)]) | |
| 428 | #@30 | |
| 429 | ||
| 430 | (fn SECTION LINE CHAR ARG) | |
| 431 | (defalias 'magit-section-goto-successor #[1028 "\301!\302!\211\2039 \303\304\"\211b\210=?\2054 \3051% y\210u0\202) \210\202* \210\306 =?\2054 \211b\262\202\343 \307!\203\303 \302\301\303\310\"!!\211\205\276 \303\311\"\312\313\"\211G8\204u \211\206g \314!@\211\205p \315!\210\316\262\202\274 \211\203} \315!\210;\203\226 \317\303\320\"\316#\203\226 \321\224b\202\274 \303\314!@\320\"b\210\322y\210\323\324!\203\256 \322y\210\202\242 \323\325!\203\272 \322y\210\202\256 \326y\266\203\262\206\343 \327!\211\203\337 \303\330\"\331=\203\330 e\202\340 \303\304\"\202\340 e\262b\262\207" [magit-root-section magit-section-ident magit-get-section eieio-oref start (error) magit-current-section magit-hunk-section-p parent children magit-section-siblings prev last magit-section-goto t re-search-forward end 0 -1 looking-at "^ " "^[-+]" nil magit-section-goto-successor-1 type button] 15 (#$ . 45045)]) | |
| 432 | #@16 | |
| 433 | ||
| 434 | (fn SECTION) | |
| 435 | (defalias 'magit-section-goto-successor-1 #[257 "\300\301\"\211\302\267\202 \303\202 \304\202 \305\202 \306\202 \307\262\211\205' \310C\311B!\262\206g \312\313\"@\211\205: \310\314!!\262\206g \312\315\"@\211\205M \310\314!!\262\206g \300\316\"\211\205e \310\314!!\206e \317!\262\207" [eieio-oref type #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (staged 10 unstaged 14 unpushed 18 unpulled 22)) unstaged staged unpulled unpushed nil magit-get-section ((status)) magit-section-siblings next magit-section-ident prev parent magit-section-goto-successor-1] 5 (#$ . 46011)]) | |
| 436 | (defvar magit-section-visibility-cache nil nil) | |
| 437 | (byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local magit-section-visibility-cache put permanent-local t] 4) | |
| 438 | #@61 Set SECTION's visibility to the cached value. | |
| 439 | ||
| 440 | (fn SECTION) | |
| 441 | (defalias 'magit-section-cached-visibility #[257 "\301\302!\"A\207" [magit-section-visibility-cache assoc magit-section-ident] 4 (#$ . 46843)]) | |
| 442 | #@58 | |
| 443 | ||
| 444 | (fn &optional (SECTION magit-insert-section--current)) | |
| 445 | (defalias 'magit-section-cache-visibility #[128 "\211\203 \211A\262\242\202 \203 \302\303\304GTD\"\210\305!\306 \"\307\310\"\203- \311\202. \312\2038 \241\202? B B\211\266\203\207" [magit-insert-section--current magit-section-visibility-cache signal wrong-number-of-arguments magit-section-cache-visibility magit-section-ident assoc eieio-oref hidden hide show] 7 (#$ . 47055)]) | |
| 446 | #@58 | |
| 447 | ||
| 448 | (fn &optional (SECTION magit-insert-section--current)) | |
| 449 | (defalias 'magit-section-maybe-cache-visibility #[128 "\211\203 \211A\262\242\202 \203 \302\303\304GTD\"\210 \305=\204* \306\307\" >\205- \301!\207" [magit-insert-section--current magit-section-cache-visibility signal wrong-number-of-arguments magit-section-maybe-cache-visibility t eieio-oref type] 6 (#$ . 47514)]) | |
| 450 | (defalias 'magit-preserve-section-visibility-cache #[0 "\302\303\304\"\205 \305\301B \"\207" [major-mode magit-section-visibility-cache derived-mode-p magit-status-mode magit-refs-mode magit-repository-local-set] 3]) | |
| 451 | #@13 | |
| 452 | ||
| 453 | (fn MODE) | |
| 454 | (defalias 'magit-restore-section-visibility-cache #[257 "\301\300B!\211\207" [magit-section-visibility-cache magit-repository-local-get] 4 (#$ . 48123)]) | |
| 455 | #@53 | |
| 456 | ||
| 457 | (fn SECTION &optional (SELECTION nil SSELECTION)) | |
| 458 | (defalias 'magit-section-selected-p #[385 "\211\205 \301\211A\262\242\203 \302\303\304\305G\\D\"\210=?\205H \306 =\206H \2031 \2026 \307 \211\262>\206H \310\311\"\211\205F \304\"\262\207" [magit-root-section t signal wrong-number-of-arguments magit-section-selected-p 2 magit-current-section magit-region-sections eieio-oref parent] 9 (#$ . 48297)]) | |
| 459 | #@16 | |
| 460 | ||
| 461 | (fn SECTION) | |
| 462 | (defalias 'magit-section-parent-value #[257 "\300\301\"\211\205\f \300\302\"\207" [eieio-oref parent value] 5 (#$ . 48723)]) | |
| 463 | #@299 Return a list of the sibling sections of SECTION. | |
| 464 | ||
| 465 | If optional DIRECTION is `prev', then return siblings that come | |
| 466 | before SECTION. If it is `next', then return siblings that come | |
| 467 | after SECTION. For all other values, return all siblings | |
| 468 | excluding SECTION itself. | |
| 469 | ||
| 470 | (fn SECTION &optional DIRECTION) | |
| 471 | (defalias 'magit-section-siblings #[513 "\300\301\"\211\205( \300\302\"\303\267\202\" \304!\235A\202& \235A\202& \305\"\262\207" [eieio-oref parent children #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (prev 18 next 27)) reverse remq] 7 (#$ . 48872)]) | |
| 472 | #@183 Return a list of the values of the selected sections. | |
| 473 | ||
| 474 | Return the values that themselves would be returned by | |
| 475 | `magit-region-sections' (which see). | |
| 476 | ||
| 477 | (fn &optional CONDITION MULTIPLE) | |
| 478 | (defalias 'magit-region-values #[512 "\300\301\302\"\"\207" [mapcar #[257 "\300\301\"\207" [eieio-oref value] 4 "\n\n(fn IT)"] magit-region-sections] 7 (#$ . 49479)]) | |
| 479 | #@1183 Return a list of the selected sections. | |
| 480 | ||
| 481 | When the region is active and constitutes a valid section | |
| 482 | selection, then return a list of all selected sections. This is | |
| 483 | the case when the region begins in the heading of a section and | |
| 484 | ends in the heading of the same section or in that of a sibling | |
| 485 | section. If optional MULTIPLE is non-nil, then the region cannot | |
| 486 | begin and end in the same section. | |
| 487 | ||
| 488 | When the selection is not valid, then return nil. In this case, | |
| 489 | most commands that can act on the selected sections will instead | |
| 490 | act on the section at point. | |
| 491 | ||
| 492 | When the region looks like it would in any other buffer then | |
| 493 | the selection is invalid. When the selection is valid then the | |
| 494 | region uses the `magit-section-highlight' face. This does not | |
| 495 | apply to diffs where things get a bit more complicated, but even | |
| 496 | here if the region looks like it usually does, then that's not | |
| 497 | a valid selection as far as this function is concerned. | |
| 498 | ||
| 499 | If optional CONDITION is non-nil, then the selection not only | |
| 500 | has to be valid; all selected sections additionally have to match | |
| 501 | CONDITION, or nil is returned. See `magit-section-match' for the | |
| 502 | forms CONDITION can take. | |
| 503 | ||
| 504 | (fn &optional CONDITION MULTIPLE) | |
| 505 | (defalias 'magit-region-sections #[512 "\301 \205\242 \302 \303 \304\305\"\304\305\"\211\205\240 \211=?\205\240 \205# \211=?\205\240 \306\307\"B\310>\205\236 \311\"\205\236 \311\"\205\236 \203_ @B\262\211A\262\242=\203D \310\262\202D \211\237\262\203\235 \312\312\313\203\223 \203\223 @\204\200 \310\262\202\207 \314 \"\262\210\211T\262A\262\202l \266\315!\262\205\236 \211\266\202\266\204\207" [magit-root-section region-active-p region-beginning region-end get-text-property magit-section magit-section-siblings next nil magit-section-position-in-heading-p t 0 magit-section-match ---truthy\?] 16 (#$ . 49839)]) | |
| 506 | #@156 Return t if POSITION is inside the heading of SECTION. | |
| 507 | POSITION defaults to point and SECTION defaults to the | |
| 508 | current section. | |
| 509 | ||
| 510 | (fn &optional SECTION POS) | |
| 511 | (defalias 'magit-section-position-in-heading-p #[512 "\204 \300 \262\211\204 `\262\205- \211\301\302\"Y\205- \211\301\303\"\206( \301\304\"W\205- \305\207" [magit-current-section eieio-oref start content end t] 6 (#$ . 51683)]) | |
| 512 | #@138 Return t if the region is active and inside SECTION's body. | |
| 513 | If optional SECTION is nil, use the current section. | |
| 514 | ||
| 515 | (fn &optional SECTION) | |
| 516 | (defalias 'magit-section-internal-region-p #[256 "\300 \205: \211\204 \301 \211\262\205: \302\303 \304\"\211\302\305 \304\"=\205# \211=\262\205: \306\303 \"\2065 \306\305 \"?\205: \307\207" [region-active-p magit-current-section get-text-property region-beginning magit-section region-end magit-section-position-in-heading-p t] 6 (#$ . 52082)]) | |
| 517 | #@271 Move to the beginning of the current or the previous visible section. | |
| 518 | Same as `magit-section-backward' but for non-interactive use. | |
| 519 | Suppress `magit-section-movement-hook', and return a boolean to | |
| 520 | indicate whether a section was found, instead of raising an error | |
| 521 | if not. | |
| 522 | (defalias 'magit-section--backward-protected #[0 "\3011 \302\303 \210)\3040\207\210\302\207" [magit-section-movement-hook (user-error) nil magit-section-backward t] 1 (#$ . 52577)]) | |
| 523 | #@139 Move to the first previous section satisfying PREDICATE. | |
| 524 | PREDICATE does not take any parameter and should not move | |
| 525 | point. | |
| 526 | ||
| 527 | (fn PREDICATE) | |
| 528 | (defalias 'magit-section--backward-find #[257 "\300\301 \211\262\203 \203 \211\207" [nil magit-section--backward-protected] 4 (#$ . 53038)]) | |
| 529 | #@131 Repeatedly call FUNCTION until it returns nil or eob is reached. | |
| 530 | FUNCTION has to move point forward or return nil. | |
| 531 | ||
| 532 | (fn FUNCTION) | |
| 533 | (defalias 'magit-wash-sequence #[257 "m?\205 \211 \205 \202 \207" [] 2 (#$ . 53329)]) | |
| 534 | #@1364 Add to the value of section hook HOOK the function FUNCTION. | |
| 535 | ||
| 536 | Add FUNCTION at the beginning of the hook list unless optional | |
| 537 | APPEND is non-nil, in which case FUNCTION is added at the end. | |
| 538 | If FUNCTION already is a member, then move it to the new location. | |
| 539 | ||
| 540 | If optional AT is non-nil and a member of the hook list, then | |
| 541 | add FUNCTION next to that instead. Add before or after AT, or | |
| 542 | replace AT with FUNCTION depending on APPEND. If APPEND is the | |
| 543 | symbol `replace', then replace AT with FUNCTION. For any other | |
| 544 | non-nil value place FUNCTION right after AT. If nil, then place | |
| 545 | FUNCTION right before AT. If FUNCTION already is a member of the | |
| 546 | list but AT is not, then leave FUNCTION where ever it already is. | |
| 547 | ||
| 548 | If optional LOCAL is non-nil, then modify the hook's buffer-local | |
| 549 | value rather than its global value. This makes the hook local by | |
| 550 | copying the default value. That copy is then modified. | |
| 551 | ||
| 552 | HOOK should be a symbol. If HOOK is void, it is first set to nil. | |
| 553 | HOOK's value must not be a single hook function. FUNCTION should | |
| 554 | be a function that takes no arguments and inserts one or multiple | |
| 555 | sections at point, moving point forward. FUNCTION may choose not | |
| 556 | to insert its section(s), when doing so would not make sense. It | |
| 557 | should not be abused for other side-effects. To remove FUNCTION | |
| 558 | again use `remove-hook'. | |
| 559 | ||
| 560 | (fn HOOK FUNCTION &optional AT APPEND LOCAL) | |
| 561 | (defalias 'magit-add-section-hook #[1282 "\300!\204\f \301\302\"\210\303!\204 \304\305\"\210\211\2039 \306!\203& J\202< \307!\2040 \310!\210\311\312!!\202< \312!\203 \235\211\262\203\205 \313\"\262\314=\203\\ \240\210\202\205 \203m \211AB\241\266\202\205 @\211AB\241\266\240\210\202\205 \313\"\262\235\204\235 \203\230 \315C\"\202\233 B\262\314=\203\251 \313\"\262\203\263 L\202\270 \304\"\207" [boundp error "Cannot add function to undefined hook variable %s" default-boundp set-default nil local-variable-p local-variable-if-set-p make-local-variable copy-sequence default-value delq replace append] 11 (#$ . 53556)]) | |
| 562 | #@74 Run HOOK with ARGS, warning about invalid entries. | |
| 563 | ||
| 564 | (fn HOOK &rest ARGS) | |
| 565 | (defalias 'magit-run-section-hook #[385 "J\211<\204 \211C\262\301\302\"\211\203) \303\304\305\306\307##\210\310\311!\210\312\313N@!\262\210\211\211\205D \211@DB\314\"\210)A\266\202\202+ \262\207" [magit--current-section-hook -remove functionp message "`%s' contains entries that are no longer valid.\n%s\nUsing standard value instead. Please re-configure hook variable." mapconcat #[257 "\300\301\"\207" [format " `%s'"] 4 "\n\n(fn SYM)"] "\n" sit-for 5 eval standard-value apply] 11 (#$ . 55604)]) | |
| 566 | (provide 'magit-section) | |
