emacs-evil / evil-magit Goto Github PK

View Code? Open in Web Editor NEW

275.0 275.0 16.0 224 KB

Black magic or evil keys for magit

Home Page: https://github.com/justbur/evil-magit

License: GNU General Public License v3.0

Emacs Lisp 98.98% Makefile 1.02%

evil-magit's People

Contributors

Stargazers

Watchers

Forkers

mkomitee eipplusone robbyoconnor vinay-jayaram bixuanzju michaelstergianis edkolev br3athein danielrichtmann duianto bmag jappeace bling luiznux analyticd korallin

evil-magit's Issues

with-editor bindings

i've filed a request for better evil mode bindings in with-editor buffers here: magit/magit#2561

perhaps this makes better sense in this project instead? feedback welcome. :)

void-function override-state in magit-status with evil-magit

I'm not entirely sure if it belongs here or at bind-map so just dumping whole debug error traceback.

Debugger entered--Lisp error: (void-function override-state)
  (override-state . motion)
  (keymap #^[nil nil keymap 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap (97 . magit-add-change-log-entry-other-window)) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] #^^[1 0 #^^[2 0 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap (97 . magit-add-change-log-entry-other-window)) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil ...] (override-state . motion) (menu-bar keymap (Magit menu-item "Magit" (keymap "Magit" (Refresh menu-item "Refresh" magit-refresh) (Refresh\ all menu-item "Refresh all" magit-refresh-all) (nil menu-item "---") (Stage menu-item "Stage" magit-stage) (Stage\ modified menu-item "Stage modified" magit-stage-modified) (Unstage menu-item "Unstage" magit-unstage) (Reset\ index menu-item "Reset index" magit-reset-index) (Commit menu-item "Commit" magit-commit-popup) (Add\ log\ entry menu-item "Add log entry" magit-commit-add-log) (Tag menu-item "Tag" magit-tag) (nil-10 menu-item "---") (Diff\ working\ tree menu-item "Diff working tree" magit-diff-working-tree) (Diff menu-item "Diff" magit-diff) (Log menu-item "Log" (keymap "Log" (Log menu-item "Log" magit-log) (Reflog menu-item "Reflog" magit-reflog) (Extended\.\.\. menu-item "Extended..." magit-log-popup))) (nil-14 menu-item "---") (Cherry\ pick menu-item "Cherry pick" magit-cherry-pick) (Revert\ commit menu-item "Revert commit" magit-revert-popup) (nil-17 menu-item "---") (Ignore menu-item "Ignore" magit-gitignore) (Ignore\ locally menu-item "Ignore locally" magit-gitignore-locally) (Discard menu-item "Discard" magit-discard) (Reset\ head menu-item "Reset head" magit-reset-head) (Stash menu-item "Stash" magit-stash) (Snapshot menu-item "Snapshot" magit-snapshot) (nil-24 menu-item "---") (Branch\.\.\. menu-item "Branch..." magit-checkout) (Merge menu-item "Merge" magit-merge) (Ediff\ resolve menu-item "Ediff resolve" magit-ediff-resolve) (Rebase\.\.\. menu-item "Rebase..." magit-rebase-popup) (nil-29 menu-item "---") (Push menu-item "Push" magit-push) (Pull menu-item "Pull" magit-pull) (Remote\ update menu-item "Remote update" magit-fetch-all) (Submodule menu-item "Submodule" (keymap "Submodule" (Submodule\ update menu-item "Submodule update" magit-submodule-update) (Submodule\ update\ and\ init menu-item "Submodule update and init" magit-submodule-setup) (Submodule\ init menu-item "Submodule init" magit-submodule-init) (Submodule\ sync menu-item "Submodule sync" magit-submodule-sync))) (nil-34 menu-item "---") (Extensions menu-item "Extensions" (keymap "Extensions" (GitHub\ Pull\ Requests menu-item "GitHub Pull Requests" (keymap "GitHub Pull Requests" ... ... ... ...) :visible magit-gh-pulls-mode))) (nil-36 menu-item "---") (Display\ Git\ output menu-item "Display Git output" magit-process-buffer) (Quit\ Magit menu-item "Quit Magit" magit-mode-bury-buffer)))) (M-return . magit-dired-jump) (C-return . magit-visit-thing) (backtab . magit-section-cycle-global) (s-tab . magit-section-cycle-global) (M-tab . magit-section-cycle-diffs) (C-tab . magit-section-cycle) (remap keymap (evil-next-line . evil-next-visual-line) (evil-previous-line . evil-previous-visual-line) (self-insert-command . undefined)))
  (keymapp (keymap #^[nil nil keymap 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap (97 . magit-add-change-log-entry-other-window)) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] #^^[1 0 #^^[2 0 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap ...) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil ...] (override-state . motion) (menu-bar keymap (Magit menu-item "Magit" (keymap "Magit" (Refresh menu-item "Refresh" magit-refresh) (Refresh\ all menu-item "Refresh all" magit-refresh-all) (nil menu-item "---") (Stage menu-item "Stage" magit-stage) (Stage\ modified menu-item "Stage modified" magit-stage-modified) (Unstage menu-item "Unstage" magit-unstage) (Reset\ index menu-item "Reset index" magit-reset-index) (Commit menu-item "Commit" magit-commit-popup) (Add\ log\ entry menu-item "Add log entry" magit-commit-add-log) (Tag menu-item "Tag" magit-tag) (nil-10 menu-item "---") (Diff\ working\ tree menu-item "Diff working tree" magit-diff-working-tree) (Diff menu-item "Diff" magit-diff) (Log menu-item "Log" (keymap "Log" (Log menu-item "Log" magit-log) (Reflog menu-item "Reflog" magit-reflog) (Extended\.\.\. menu-item "Extended..." magit-log-popup))) (nil-14 menu-item "---") (Cherry\ pick menu-item "Cherry pick" magit-cherry-pick) (Revert\ commit menu-item "Revert commit" magit-revert-popup) (nil-17 menu-item "---") (Ignore menu-item "Ignore" magit-gitignore) (Ignore\ locally menu-item "Ignore locally" magit-gitignore-locally) (Discard menu-item "Discard" magit-discard) (Reset\ head menu-item "Reset head" magit-reset-head) (Stash menu-item "Stash" magit-stash) (Snapshot menu-item "Snapshot" magit-snapshot) (nil-24 menu-item "---") (Branch\.\.\. menu-item "Branch..." magit-checkout) (Merge menu-item "Merge" magit-merge) (Ediff\ resolve menu-item "Ediff resolve" magit-ediff-resolve) (Rebase\.\.\. menu-item "Rebase..." magit-rebase-popup) (nil-29 menu-item "---") (Push menu-item "Push" magit-push) (Pull menu-item "Pull" magit-pull) (Remote\ update menu-item "Remote update" magit-fetch-all) (Submodule menu-item "Submodule" (keymap "Submodule" (Submodule\ update menu-item "Submodule update" magit-submodule-update) (Submodule\ update\ and\ init menu-item "Submodule update and init" magit-submodule-setup) (Submodule\ init menu-item "Submodule init" magit-submodule-init) (Submodule\ sync menu-item "Submodule sync" magit-submodule-sync))) (nil-34 menu-item "---") (Extensions menu-item "Extensions" (keymap "Extensions" (GitHub\ Pull\ Requests menu-item "GitHub Pull Requests" ... :visible magit-gh-pulls-mode))) (nil-36 menu-item "---") (Display\ Git\ output menu-item "Display Git output" magit-process-buffer) (Quit\ Magit menu-item "Quit Magit" magit-mode-bury-buffer)))) (M-return . magit-dired-jump) (C-return . magit-visit-thing) (backtab . magit-section-cycle-global) (s-tab . magit-section-cycle-global) (M-tab . magit-section-cycle-diffs) (C-tab . magit-section-cycle) (remap keymap (evil-next-line . evil-next-visual-line) (evil-previous-line . evil-previous-visual-line) (self-insert-command . undefined))))
  eval((keymapp (keymap #^[nil nil keymap 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap (97 . magit-add-change-log-entry-other-window)) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] #^^[1 0 #^^[2 0 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap ...) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil ...] (override-state . motion) (menu-bar keymap (Magit menu-item "Magit" (keymap "Magit" (Refresh menu-item "Refresh" magit-refresh) (Refresh\ all menu-item "Refresh all" magit-refresh-all) (nil menu-item "---") (Stage menu-item "Stage" magit-stage) (Stage\ modified menu-item "Stage modified" magit-stage-modified) (Unstage menu-item "Unstage" magit-unstage) (Reset\ index menu-item "Reset index" magit-reset-index) (Commit menu-item "Commit" magit-commit-popup) (Add\ log\ entry menu-item "Add log entry" magit-commit-add-log) (Tag menu-item "Tag" magit-tag) (nil-10 menu-item "---") (Diff\ working\ tree menu-item "Diff working tree" magit-diff-working-tree) (Diff menu-item "Diff" magit-diff) (Log menu-item "Log" (keymap "Log" (Log menu-item "Log" magit-log) (Reflog menu-item "Reflog" magit-reflog) (Extended\.\.\. menu-item "Extended..." magit-log-popup))) (nil-14 menu-item "---") (Cherry\ pick menu-item "Cherry pick" magit-cherry-pick) (Revert\ commit menu-item "Revert commit" magit-revert-popup) (nil-17 menu-item "---") (Ignore menu-item "Ignore" magit-gitignore) (Ignore\ locally menu-item "Ignore locally" magit-gitignore-locally) (Discard menu-item "Discard" magit-discard) (Reset\ head menu-item "Reset head" magit-reset-head) (Stash menu-item "Stash" magit-stash) (Snapshot menu-item "Snapshot" magit-snapshot) (nil-24 menu-item "---") (Branch\.\.\. menu-item "Branch..." magit-checkout) (Merge menu-item "Merge" magit-merge) (Ediff\ resolve menu-item "Ediff resolve" magit-ediff-resolve) (Rebase\.\.\. menu-item "Rebase..." magit-rebase-popup) (nil-29 menu-item "---") (Push menu-item "Push" magit-push) (Pull menu-item "Pull" magit-pull) (Remote\ update menu-item "Remote update" magit-fetch-all) (Submodule menu-item "Submodule" (keymap "Submodule" (Submodule\ update menu-item "Submodule update" magit-submodule-update) (Submodule\ update\ and\ init menu-item "Submodule update and init" magit-submodule-setup) (Submodule\ init menu-item "Submodule init" magit-submodule-init) (Submodule\ sync menu-item "Submodule sync" magit-submodule-sync))) (nil-34 menu-item "---") (Extensions menu-item "Extensions" (keymap "Extensions" (GitHub\ Pull\ Requests menu-item "GitHub Pull Requests" ... :visible magit-gh-pulls-mode))) (nil-36 menu-item "---") (Display\ Git\ output menu-item "Display Git output" magit-process-buffer) (Quit\ Magit menu-item "Quit Magit" magit-mode-bury-buffer)))) (M-return . magit-dired-jump) (C-return . magit-visit-thing) (backtab . magit-section-cycle-global) (s-tab . magit-section-cycle-global) (M-tab . magit-section-cycle-diffs) (C-tab . magit-section-cycle) (remap keymap (evil-next-line . evil-next-visual-line) (evil-previous-line . evil-previous-visual-line) (self-insert-command . undefined)))))
  evil-delay((keymapp (keymap #^[nil nil keymap 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap (97 . magit-add-change-log-entry-other-window)) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] #^^[1 0 #^^[2 0 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap ...) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil ...] (override-state . motion) (menu-bar keymap (Magit menu-item "Magit" (keymap "Magit" (Refresh menu-item "Refresh" magit-refresh) (Refresh\ all menu-item "Refresh all" magit-refresh-all) (nil menu-item "---") (Stage menu-item "Stage" magit-stage) (Stage\ modified menu-item "Stage modified" magit-stage-modified) (Unstage menu-item "Unstage" magit-unstage) (Reset\ index menu-item "Reset index" magit-reset-index) (Commit menu-item "Commit" magit-commit-popup) (Add\ log\ entry menu-item "Add log entry" magit-commit-add-log) (Tag menu-item "Tag" magit-tag) (nil-10 menu-item "---") (Diff\ working\ tree menu-item "Diff working tree" magit-diff-working-tree) (Diff menu-item "Diff" magit-diff) (Log menu-item "Log" (keymap "Log" (Log menu-item "Log" magit-log) (Reflog menu-item "Reflog" magit-reflog) (Extended\.\.\. menu-item "Extended..." magit-log-popup))) (nil-14 menu-item "---") (Cherry\ pick menu-item "Cherry pick" magit-cherry-pick) (Revert\ commit menu-item "Revert commit" magit-revert-popup) (nil-17 menu-item "---") (Ignore menu-item "Ignore" magit-gitignore) (Ignore\ locally menu-item "Ignore locally" magit-gitignore-locally) (Discard menu-item "Discard" magit-discard) (Reset\ head menu-item "Reset head" magit-reset-head) (Stash menu-item "Stash" magit-stash) (Snapshot menu-item "Snapshot" magit-snapshot) (nil-24 menu-item "---") (Branch\.\.\. menu-item "Branch..." magit-checkout) (Merge menu-item "Merge" magit-merge) (Ediff\ resolve menu-item "Ediff resolve" magit-ediff-resolve) (Rebase\.\.\. menu-item "Rebase..." magit-rebase-popup) (nil-29 menu-item "---") (Push menu-item "Push" magit-push) (Pull menu-item "Pull" magit-pull) (Remote\ update menu-item "Remote update" magit-fetch-all) (Submodule menu-item "Submodule" (keymap "Submodule" (Submodule\ update menu-item "Submodule update" magit-submodule-update) (Submodule\ update\ and\ init menu-item "Submodule update and init" magit-submodule-setup) (Submodule\ init menu-item "Submodule init" magit-submodule-init) (Submodule\ sync menu-item "Submodule sync" magit-submodule-sync))) (nil-34 menu-item "---") (Extensions menu-item "Extensions" (keymap "Extensions" (GitHub\ Pull\ Requests menu-item "GitHub Pull Requests" ... :visible magit-gh-pulls-mode))) (nil-36 menu-item "---") (Display\ Git\ output menu-item "Display Git output" magit-process-buffer) (Quit\ Magit menu-item "Quit Magit" magit-mode-bury-buffer)))) (M-return . magit-dired-jump) (C-return . magit-visit-thing) (backtab . magit-section-cycle-global) (s-tab . magit-section-cycle-global) (M-tab . magit-section-cycle-diffs) (C-tab . magit-section-cycle) (remap keymap (evil-next-line . evil-next-visual-line) (evil-previous-line . evil-previous-visual-line) (self-insert-command . undefined)))) (let* ((state motion) (keymap (keymap #^[nil nil keymap 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap ...) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] #^^[1 0 #^^[2 0 
#^^[3 0 nil nil nil ... nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value ... nil nil ... nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil ...] (override-state . motion) (menu-bar keymap (Magit menu-item "Magit" (keymap "Magit" (Refresh menu-item "Refresh" magit-refresh) (Refresh\ all menu-item "Refresh all" magit-refresh-all) (nil menu-item "---") (Stage menu-item "Stage" magit-stage) (Stage\ modified menu-item "Stage modified" magit-stage-modified) (Unstage menu-item "Unstage" magit-unstage) (Reset\ index menu-item "Reset index" magit-reset-index) (Commit menu-item "Commit" magit-commit-popup) (Add\ log\ entry menu-item "Add log entry" magit-commit-add-log) (Tag menu-item "Tag" magit-tag) (nil-10 menu-item "---") (Diff\ working\ tree menu-item "Diff working tree" magit-diff-working-tree) (Diff menu-item "Diff" magit-diff) (Log menu-item "Log" ...) (nil-14 menu-item "---") (Cherry\ pick menu-item "Cherry pick" magit-cherry-pick) (Revert\ commit menu-item "Revert commit" magit-revert-popup) (nil-17 menu-item "---") (Ignore menu-item "Ignore" magit-gitignore) (Ignore\ locally menu-item "Ignore locally" magit-gitignore-locally) (Discard menu-item "Discard" magit-discard) (Reset\ head menu-item "Reset head" magit-reset-head) (Stash menu-item "Stash" magit-stash) (Snapshot menu-item "Snapshot" magit-snapshot) (nil-24 menu-item "---") (Branch\.\.\. menu-item "Branch..." magit-checkout) (Merge menu-item "Merge" magit-merge) (Ediff\ resolve menu-item "Ediff resolve" magit-ediff-resolve) (Rebase\.\.\. menu-item "Rebase..." magit-rebase-popup) (nil-29 menu-item "---") (Push menu-item "Push" magit-push) (Pull menu-item "Pull" magit-pull) (Remote\ update menu-item "Remote update" magit-fetch-all) (Submodule menu-item "Submodule" ...) (nil-34 menu-item "---") (Extensions menu-item "Extensions" ...) (nil-36 menu-item "---") (Display\ Git\ output menu-item "Display Git output" magit-process-buffer) (Quit\ Magit menu-item "Quit Magit" magit-mode-bury-buffer)))) (M-return . magit-dired-jump) (C-return . magit-visit-thing) (backtab . magit-section-cycle-global) (s-tab . magit-section-cycle-global) (M-tab . magit-section-cycle-diffs) (C-tab . magit-section-cycle) (remap keymap (evil-next-line . evil-next-visual-line) (evil-previous-line . evil-previous-visual-line) (self-insert-command . undefined)))) (key "g") (def nil) (bindings (list)) aux) (if state (setq aux (evil-get-auxiliary-keymap keymap state t)) (setq aux keymap)) (while key (define-key aux key def) (setq key (pop bindings) def (pop bindings))) (evil-set-keymap-prompt aux (keymap-prompt aux))) after-load-functions t nil "evil-define-key-in-keymap")
  (evil-define-key motion (keymap #^[nil nil keymap 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap (97 . magit-add-change-log-entry-other-window)) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] #^^[1 0 #^^[2 0 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap ...) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil ...] (override-state . motion) (menu-bar keymap (Magit menu-item "Magit" (keymap "Magit" (Refresh menu-item "Refresh" magit-refresh) (Refresh\ all menu-item "Refresh all" magit-refresh-all) (nil menu-item "---") (Stage menu-item "Stage" magit-stage) (Stage\ modified menu-item "Stage modified" magit-stage-modified) (Unstage menu-item "Unstage" magit-unstage) (Reset\ index menu-item "Reset index" magit-reset-index) (Commit menu-item "Commit" magit-commit-popup) (Add\ log\ entry menu-item "Add log entry" magit-commit-add-log) (Tag menu-item "Tag" magit-tag) (nil-10 menu-item "---") (Diff\ working\ tree menu-item "Diff working tree" magit-diff-working-tree) (Diff menu-item "Diff" magit-diff) (Log menu-item "Log" (keymap "Log" (Log menu-item "Log" magit-log) (Reflog menu-item "Reflog" magit-reflog) (Extended\.\.\. menu-item "Extended..." magit-log-popup))) (nil-14 menu-item "---") (Cherry\ pick menu-item "Cherry pick" magit-cherry-pick) (Revert\ commit menu-item "Revert commit" magit-revert-popup) (nil-17 menu-item "---") (Ignore menu-item "Ignore" magit-gitignore) (Ignore\ locally menu-item "Ignore locally" magit-gitignore-locally) (Discard menu-item "Discard" magit-discard) (Reset\ head menu-item "Reset head" magit-reset-head) (Stash menu-item "Stash" magit-stash) (Snapshot menu-item "Snapshot" magit-snapshot) (nil-24 menu-item "---") (Branch\.\.\. menu-item "Branch..." magit-checkout) (Merge menu-item "Merge" magit-merge) (Ediff\ resolve menu-item "Ediff resolve" magit-ediff-resolve) (Rebase\.\.\. menu-item "Rebase..." magit-rebase-popup) (nil-29 menu-item "---") (Push menu-item "Push" magit-push) (Pull menu-item "Pull" magit-pull) (Remote\ update menu-item "Remote update" magit-fetch-all) (Submodule menu-item "Submodule" (keymap "Submodule" (Submodule\ update menu-item "Submodule update" magit-submodule-update) (Submodule\ update\ and\ init menu-item "Submodule update and init" magit-submodule-setup) (Submodule\ init menu-item "Submodule init" magit-submodule-init) (Submodule\ sync menu-item "Submodule sync" magit-submodule-sync))) (nil-34 menu-item "---") (Extensions menu-item "Extensions" (keymap "Extensions" (GitHub\ Pull\ Requests menu-item "GitHub Pull Requests" ... :visible magit-gh-pulls-mode))) (nil-36 menu-item "---") (Display\ Git\ output menu-item "Display Git output" magit-process-buffer) (Quit\ Magit menu-item "Quit Magit" magit-mode-bury-buffer)))) (M-return . magit-dired-jump) (C-return . magit-visit-thing) (backtab . magit-section-cycle-global) (s-tab . magit-section-cycle-global) (M-tab . magit-section-cycle-diffs) (C-tab . magit-section-cycle) (remap keymap (evil-next-line . evil-next-visual-line) (evil-previous-line . evil-previous-visual-line) (self-insert-command . undefined))) "g" nil)
  eval((evil-define-key motion (keymap #^[nil nil keymap 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap (97 . magit-add-change-log-entry-other-window)) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] #^^[1 0 #^^[2 0 
#^^[3 0 nil nil nil (keymap (5 . magit-dispatch-popup) (3 . magit-dispatch-popup)) nil nil nil nil nil magit-section-toggle nil nil nil magit-visit-thing nil nil nil nil nil nil nil nil nil magit-copy-section-value (keymap (52 keymap ...) (97 . magit-add-change-log-entry)) nil nil (keymap (119 . magit-copy-buffer-revision) (52 . magit-section-show-level-4-all) (51 . magit-section-show-level-3-all) (50 . magit-section-show-level-2-all) (49 . magit-section-show-level-1-all) (112 . magit-section-backward-sibling) (110 . magit-section-forward-sibling)) nil nil nil nil magit-diff-show-or-scroll-up magit-run-popup nil spacemacs/load-gh-pulls-mode magit-process-buffer magit-gitflow-popup nil nil nil nil nil magit-diff-more-context nil magit-diff-less-context nil nil ...] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil ...] (override-state . motion) (menu-bar keymap (Magit menu-item "Magit" (keymap "Magit" (Refresh menu-item "Refresh" magit-refresh) (Refresh\ all menu-item "Refresh all" magit-refresh-all) (nil menu-item "---") (Stage menu-item "Stage" magit-stage) (Stage\ modified menu-item "Stage modified" magit-stage-modified) (Unstage menu-item "Unstage" magit-unstage) (Reset\ index menu-item "Reset index" magit-reset-index) (Commit menu-item "Commit" magit-commit-popup) (Add\ log\ entry menu-item "Add log entry" magit-commit-add-log) (Tag menu-item "Tag" magit-tag) (nil-10 menu-item "---") (Diff\ working\ tree menu-item "Diff working tree" magit-diff-working-tree) (Diff menu-item "Diff" magit-diff) (Log menu-item "Log" (keymap "Log" (Log menu-item "Log" magit-log) (Reflog menu-item "Reflog" magit-reflog) (Extended\.\.\. menu-item "Extended..." magit-log-popup))) (nil-14 menu-item "---") (Cherry\ pick menu-item "Cherry pick" magit-cherry-pick) (Revert\ commit menu-item "Revert commit" magit-revert-popup) (nil-17 menu-item "---") (Ignore menu-item "Ignore" magit-gitignore) (Ignore\ locally menu-item "Ignore locally" magit-gitignore-locally) (Discard menu-item "Discard" magit-discard) (Reset\ head menu-item "Reset head" magit-reset-head) (Stash menu-item "Stash" magit-stash) (Snapshot menu-item "Snapshot" magit-snapshot) (nil-24 menu-item "---") (Branch\.\.\. menu-item "Branch..." magit-checkout) (Merge menu-item "Merge" magit-merge) (Ediff\ resolve menu-item "Ediff resolve" magit-ediff-resolve) (Rebase\.\.\. menu-item "Rebase..." magit-rebase-popup) (nil-29 menu-item "---") (Push menu-item "Push" magit-push) (Pull menu-item "Pull" magit-pull) (Remote\ update menu-item "Remote update" magit-fetch-all) (Submodule menu-item "Submodule" (keymap "Submodule" (Submodule\ update menu-item "Submodule update" magit-submodule-update) (Submodule\ update\ and\ init menu-item "Submodule update and init" magit-submodule-setup) (Submodule\ init menu-item "Submodule init" magit-submodule-init) (Submodule\ sync menu-item "Submodule sync" magit-submodule-sync))) (nil-34 menu-item "---") (Extensions menu-item "Extensions" (keymap "Extensions" (GitHub\ Pull\ Requests menu-item "GitHub Pull Requests" ... :visible magit-gh-pulls-mode))) (nil-36 menu-item "---") (Display\ Git\ output menu-item "Display Git output" magit-process-buffer) (Quit\ Magit menu-item "Quit Magit" magit-mode-bury-buffer)))) (M-return . magit-dired-jump) (C-return . magit-visit-thing) (backtab . magit-section-cycle-global) (s-tab . magit-section-cycle-global) (M-tab . magit-section-cycle-diffs) (C-tab . magit-section-cycle) (remap keymap (evil-next-line . evil-next-visual-line) (evil-previous-line . evil-previous-visual-line) (self-insert-command . undefined))) "g" nil))
  byte-code("�\303�\211�\203$\n@�\304\305   @   A@J\306 8\307   8\257�!\210\nA\211�\204�*\310\311\312\"\210\313\314\315\"\207" [evil-magit-mode-map-bindings binding --dolist-tail-- nil eval evil-define-key 2 3 add-hook magit-blame-mode-hook evil-normalize-keymaps eval-after-load git-rebase #[nil "\305� \"\210\306\307!\210\n\310�\211�\203-\f@\211�@\203&\311\312\313\314\315\310\316\317\300\"&�\210\fA\211�\204�*\320\321\322\"\210\323\324\325\"\210\326\324\321\315#\207" [git-rebase-mode-map evil-magit-state evil-magit-rebase-commands-w-descriptions cmd --dolist-tail-- evil-make-overriding-map (lambda (def-tmp-var) (defvar evil-magit-rebase-commands-w-descriptions def-tmp-var)) (("p" git-rebase-pick "pick = use commit") ("r" git-rebase-reword "reword = use commit, but edit the commit message") ("e" git-rebase-edit "edit = use commit, but stop for amending") ("s" git-rebase-squash "squash = use commit, but meld into previous commit") ("f" git-rebase-fixup "fixup = like \"squash\", but discard this commit's log message") ("x" git-rebase-exec "exec = run command (the rest of the line) using shell") ("d" git-rebase-kill-line "drop = remove commit" "k") ("u" git-rebase-undo "undo last change") (nil with-editor-finish "tell Git to make it happen") (nil with-editor-cancel "tell Git that you changed your mind, i.e. abort") ("k" evil-previous-visual-line "move point to previous line" "p") ("j" evil-next-visual-line "move point to next line" "n") ("M-k" git-rebase-move-line-up "move the commit at point up" "\360") ("M-j" git-rebase-move-line-down "move the commit at point down" "\356") (nil git-rebase-show-commit "show the commit at point in another buffer")) nil evil-delay (and (boundp (quote git-rebase-mode-map)) (keymapp git-rebase-mode-map)) (let* ((state evil-magit-state) (keymap git-rebase-mode-map) (key (kbd (car cmd))) (def (nth 1 cmd)) (bindings (list)) aux) (if state (setq aux (evil-get-auxiliary-keymap keymap state t)) (setq aux keymap)) (while key (define-key aux key def) (setq key (pop bindings) def (pop bindings))) (evil-set-keymap-prompt aux (keymap-prompt aux))) after-load-functions t format "evil-define-key-in-%s" defalias evil-magit-add-rebase-messages #[nil "eb\210\306\307\310�\"\311  �\"���\212\312 �\313\216\314\315!\210eb\210��\205t\316\317\320\306#\205t��\320��\211��\205s��@��\307\321��@\203U��A@\322\n��@\"=\203U��@\202b\323�\324\325\307\326��A@\"!#\327��8#c\210��A\211��\2044\320*.�\207" [evil-magit-state git-rebase-mode-map aux-map state-regexp inhibit-read-only save-match-data-internal t format "<%s-state> " evil-get-auxiliary-keymap match-data ((byte-code "\301�\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) flush-lines "^#.+ = " re-search-forward "^# Commands:\n" nil "# %-8s %s\n" lookup-key replace-regexp-in-string "" substitute-command-keys "\\[%s]" 2 git-rebase-show-instructions evil-magit-rebase-commands-w-descriptions cmd --dolist-tail--] 10 "Remove evil-state annotations and reformat git-rebase buffer."] remove-hook git-rebase-mode-hook git-rebase-mode-show-keybindings add-hook] 10]] 8)
  require(evil-magit)
  (lambda nil (require (quote evil-magit)) (evil-delay (quote (and (boundp (quote magit-mode-map)) (keymapp magit-mode-map))) (quote (let* ((state (quote motion)) (keymap magit-mode-map) (key (kbd dotspacemacs-leader-key)) (def spacemacs-default-map) (bindings (list)) aux) (if state (setq aux (evil-get-auxiliary-keymap keymap state t)) (setq aux keymap)) (while key (define-key aux key def) (setq key (pop bindings) def (pop bindings))) (evil-set-keymap-prompt aux (keymap-prompt aux)))) (quote after-load-functions) t nil (format "evil-define-key-in-%s" (quote magit-mode-map))))()
  eval-after-load-helper("/Users/nixmaniack/.emacs.d/elpa/magit-20151208.1407/magit.elc")
  run-hook-with-args(eval-after-load-helper "/Users/nixmaniack/.emacs.d/elpa/magit-20151208.1407/magit.elc")
  do-after-load-evaluation("/Users/nixmaniack/.emacs.d/elpa/magit-20151208.1407/magit.elc")
  autoload-do-load((autoload "magit" "Show the status of the current Git repository in a buffer.\nWith a prefix argument prompt for a repository to be shown.\nWith two prefix arguments prompt for an arbitrary directory.\nIf that directory isn't the root of an existing repository\nthen offer to initialize it as a new repository.\n\n(fn &optional DIRECTORY)" t nil) magit-status)
  command-execute(magit-status)

Support registers for "yank" commands?

It would be great to implement a version of the Magit "yank" functions that can be combined with evil registers. For example, I often want to copy the commit hash from Magit and paste it into a GitHub issue, Slack channel, etc. It would be really awesome to be able to do this with the keys "+ys (yank to system clipboard).

I think this would require wrapping the magit-yank-* in evil-define-command with register support, but I don't know evil's internals well enough to do it myself.

In the meantime, in case it's useful for others, I wrote the following helper function for copying the top of my kill ring to the system clipboard:

(setq select-enable-clipboard t)

(defun ans/kill-ring-to-clipboard ()
  "Copy current kill ring to system clipboard"
  (interactive)
  (gui-select-text (current-kill 0)))

Evil binding rationale

A rationale for Evil bindings was started with https://github.com/jojojames/evil-collection:
we are trying to enforce as much consistency as possible across the various Emacs modes.

@justbur: You are probably in a good position to give insightful feedback regarding the aforementioned rationale. Your opinion and/or contribution is very welcome!

Doesn't take any effect

This package isn't having any effect on my keybindings. Is it something wrong in my config?

(use-package magit
  :commands
  (magit-blame-mode
   magit-commit
   magit-diff
   magit-log
   magit-status)
  :init
  (with-eval-after-load 'evil-leader
    (evil-leader/set-key
      (kbd "gb") #'magit-blame
      (kbd "gc") #'magit-commit
      (kbd "gd") #'magit-diff
      (kbd "gl") #'magit-log
      (kbd "gr") #'magit-reflog
      (kbd "gs") #'magit-status))
  (with-eval-after-load 'which-key
    (which-key-declare-prefixes
      "<SPC>g" "Git"))
  :config
  (add-hook 'magit-diff-mode-hook (lambda () (setq cursor-type nil)))
  (add-hook 'magit-log-mode-hook (lambda () (setq cursor-type nil)))
  (add-hook 'magit-log-select-mode-hook (lambda () (setq cursor-type nil)))
  (add-hook 'magit-refs-mode-hook (lambda () (setq cursor-type nil)))
  (add-hook 'magit-revision-mode-hook (lambda () (setq cursor-type nil)))
  (add-hook 'magit-status-mode-hook #'hl-line-mode)
  (add-hook 'magit-status-mode-hook (lambda () (setq cursor-type nil)))
  (add-hook 'with-editor-mode-hook 'evil-insert-state)
  (bind-keys
   :map magit-status-mode-map
   ("<C-tab>"   . nil)
   ("<backtab>" . magit-section-cycle))
  (set-face-background 'magit-diff-added-highlight "SeaGreen4")
  (set-face-background 'magit-diff-removed-highlight "IndianRed4")
  (setq magit-completing-read-function 'magit-ido-completing-read)
  (setq magit-push-always-verify nil)
  (use-package magit-gh-pulls
    :config
    (add-hook 'magit-mode-hook #'turn-on-magit-gh-pulls)))

(require 'evil-magit)

Support for GPG signing

It seems like currently there is no built in support for GPG signing commits in the commit screen (SPC - g - s, S - y, c).

This would be a great feature to add

Getting 'Error callling diff" errors with latest magit

Apart from the spelling error in "callling", this seems to break everything.
package versions:
magit-20180409.1612
evil-magit-20180313.931

evil-magit breaks evil-want-C-u-scroll

I set evil-want-C-u-scroll to true so that I can scroll up exactly like in vim, installing evil-magit breaks it and I couldn't scroll back with C-u any more.

evil version: 1.2.12
evil-magit version: 20161130.847

Previously set keys are re-bound

In my evil configuration, I've set C-b to nil in evil-motion-state-map, because I like to use C-b as a prefix key. This is reset by evil-magit however, and attempting to re-bind to nil after loading evil-magit doesn't seem to do anything.

[feature request] support for magic-todos

There is this new package magit-todos.

It binds jT which should be gT in the evil world.

Moving to parent section

Hi,

I just came across an inconsistency in the mapping of the keys (at least IMO):

While evil-magit binds gk and gj to move to the the next/previous sibling in the status window, there are no bindings for gh and gl.

Looking at, e.g., the evil bindings for org-mode, gh and gl get bound to move to the parent/child of the current heading.

IMO gl doesn't make a lot of sense here but I think that gh might come in handy, so perhaps it should be bound, too.

Out of the current functionality in magit, the candidate for this is probably magit-section-up, which is what I currently bind in my config.

Let me know what you think. I can PR if you want me to.

'c' just opens popup

I'm new to Emacs and I'm having trouble figuring out how to commit. When I press 'c' it just opens a popup with switches and options.

Let's implement it

Were it all began: magit/magit#1968.

That discussion contains some suggestions which seem reasonable to a layman like me. Please create a branch and import your configuration. When that is ready create a commit on the master which describes your configuration in README.md. Then rebase your work on top of that and ask for push permissions. Finally push that one descriptive commit to master (and only that) and your implementation to the branch YOUR_GITHUB_USERNAME.

Evil-style chunk folding

It would be intuitive if the Vim folding keybinding worked for magit chunks. Eg:

zr Opened all chunks
za Toggled a chunk
zc Closed all chunk
zc Closed a fold
zo Opened a chunk
zO Opened a chunk recursively

Obviously, this would come at the cost of changing the keymap binding for stash operations, but that isn't very semantically named in the first place, so I personally don't see that as a huge deal.

magit-blame C-e not like C-y

Hello everyone,
I just found a little problem with magit-blame mode.

When you press C-y you effectively scrollup.
But, when you C-e, you scrolldown but you are blocked by the git user on top of the screen.

Maybe I have to configurate something ?
Ty very much. I expect I'd be clear.

evil-magit gets me stuck in insert mode on other buffers

when entering a magit window while using evil-magit, everything works fine, but when I go back to editing I find myself stuck in insert mode, the key seems unresponsive, this only happens when I have the evil-magit package installed.

 ;; BEFORE
 j [evil-next-line]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [evil-force-normal-state]
 ESC [ 2 0 ~ [magit-status]
 q [magit-mode-bury-buffer]

 ;; AFTER (no single ESC detected)
 ESC ESC o [nil]
 ESC o o [facemenu-set-face]
 ESC ESC ESC [keyboard-escape-quit]
 ESC ESC k [nil]
 j [evil-next-line]
 k [evil-previous-line]
 o [evil-open-below]
 ESC ESC ESC [keyboard-escape-quit]
 ESC ESC ESC [keyboard-escape-quit]
 ESC ESC ESC [keyboard-escape-quit]
 ESC [ 1 1 ~ l [view-lossage]

view-lossage included for more clarity

could you advise?

h and l are incorrectly bound if evil-magit is loaded lazily

If I use :after magit in the evil-magit use-package decl. to defer loading, h and l keys move cursor regardless of the value of evil-magit-want-horizontal-movement. I found that I have to not defer evil-magit at all in order to fix this issue.

;; This setting causes h/l to move cursor in magit buffers
(use-package magit
  :config
  (setq magit-popup-show-common-commands nil))

(use-package evil-magit
  :after magit
  :init
  (add-hook 'magit-mode-hook 'turn-off-evil-snipe-override-mode)
  (setq evil-magit-want-horizontal-movement nil))

Inconsistent keybindings after adding forge support

Forge won't load until user call forge-dispatch when using use-package to install forge. So the keybindings are F for pulling and p for push.
The problem is

there's no way to load forge by keypresses
keybindings change after load forge to F for forge-dispatch, P for pulling, which is inconsistent

Initial state of magit-popup

I have to put

(general-define-key
 :states 'emacs
 :keymaps 'magit-popup-mode-map
 "j"	 'forward-button
 "k"	 'backward-button)

in my config since magit-popup uses emacs-state by default (contrary to magit-status), can this be changed to normal state? In the past I tried to manually change it to normal state using evil-initial-state resulting in breakage of magit-popup.

magit-gh-pulls no longer works

Since 4a375ea -- it has stopped working completely with the following message shown:

jit-lock-fontify-now: Wrong type argument: number-or-marker-p, nil

`o` for revert?

Whats the rationale for using o for revert? o is not really mnemonic for revert and because it is normally used for submodules, it forces us to rebind submodules to > as well. I propose that o be set back to submodules, and use something else for revert like <, which is more evocative of revert than > is for submodules (imho at least).

Map 'evil-yank' to 'y'?

It would be convenient to be able to yank selections from the magit buffers, like diffs and logs. Would this be possible?

Add bindings for magit-diff-show-or-scroll-{up,down}

These commands are really convenient when skimming through a list of commits. Magit binds these to SPC and DEL.

Maybe M-{j,k} would be suitable keybindings?

Missing license file

The GPL3 license file is missing.
https://www.gnu.org/licenses/gpl-3.0.en.html

All file buffers are starting in evil-motion-state

This started happening after a recent package update, and I believe it's because Magit has now globally enabled magit-file-mode which I see is included in evil-magit-default-to-evil-magit-state-modes. Not sure if other people are seeing this issue, so let me know if you need any debug info.

Conflicts with magit-gh-pulls

evil-search-word-backward conflicts with the # prefix that magit-gh-pulls uses. I have no idea why evil binds # to this command, I don't think thats what vim does. Can anyone replicate this to be sure?

Add binding for magit-reset-popup

It was recently introduced.

Can't require evil-magit since Magit switched from magit-popup to Transient

Magit has moved from magit-popup to Transient in magit/magit#3728. As part of it the popup commands were renamed to remove the -popup suffix, resulting in the following error when trying to (require 'evil-magit):

Debugger entered--Lisp error: (void-variable magit-dispatch-popup)
  (copy-sequence magit-dispatch-popup)
  (defvar evil-magit-dispatch-popup-backup (copy-sequence magit-dispatch-popup))
  #<subr require>(evil-magit)
  apply(#<subr require> evil-magit)
  require(evil-magit)
  eval((require 'evil-magit) nil)
  eval-expression((require 'evil-magit) nil nil 127)
  funcall-interactively(eval-expression (require 'evil-magit) nil nil 127)
  call-interactively(eval-expression nil nil)
  command-execute(eval-expression)

I assume there's more to fix than just renaming functions, though :(

evil-magit disables M-x.

To reproduce:

start emacs -q
load packages (el-get in my case)
activate evil-mode
run evil-magit-init
run magit-status
M-x will now be undefined

The binding can still be partially reintroduced by readding it to all of magit's mode-maps,
but that 1) should not be necessary in the first place, and 2) not even sufficient. In magit's
status buffer there is a single line which separates the Untracked Files and Unstaged Changes
sections. I've been unable to readd an M-x binding to that line no matter what I tried.
global-set-key, (evil)-define-key on any and all keymaps I could get my hands on did nothing
for that specific case.

Here's the exact list of keymaps I tried:

(list
 evil-normal-state-map
 evil-visual-state-map
 evil-insert-state-map
 evil-motion-state-map
 magit-mode-map
 magit-status-mode-map
 magit-log-mode-map
 magit-diff-mode-map
 magit-branch-section-map
 magit-untracked-section-map
 magit-file-section-map
 magit-status-mode-map
 magit-hunk-section-map
 magit-stash-section-map
 magit-stashes-section-map
 magit-staged-section-map
 magit-unstaged-section-map))

I'm running the newest evil-magit pulled directly from github yesterday.
My magit version is 2.4.1-2-g7a4a760.

Region Staging doesn't work

To reproduce: go into visual selection either with v or V in the magit-status buffer, inside a chunk... then try to move either up or down with j or k...the selection will dissapear.

Request for binding magit-stgit-popup

can you please introduce binding for magit-stgit-popup ?

Support evil-search-module set to evil-search

Currently, / is bound to evil-search-forward. However, that should be evil-ex-search-forward when evil-search-module is set to evil-search, for consistency with evil's own settings.

request magit-repolist-mode support

Currently this mode (via magit-list-repositories) doesn't work very well with evil, a few important bindings such as RET are hidden by evil. For now I have it in the 'evil-emacs-state-modes list, but it would be nice if it was supported in evil-magit.

Commit message window cannot be finished from a key binding

I have staged the files, pressed c, commit message with a diff window have opened, I have wrote a commit message, saved the buffer. After that whatever I do I cannot finish the commit. The only way to finally commit it was was typing with-editor-finish. What is a binding to finish the commit? If there is no one, please, advise, I was thinking to bind q as a finishing binding, how can I make such binding?

Support for forge

Now that forge's been released, it might be a good idea to consider what binding would be appropriate. I'm not sure if evil-magit is the best place for such a binding to be defined though, evil-collection also seems like an option.

Looking at here, ' is the default binding, which is now used for Submodules by evil-magit.

Symbol's value as variable is void: binding

Bugus commit: d45808c

After updating to the above mentioned commit, I can not start emacs anymore. Even --debug-init does not help.

As this hits all melpa users, and it is unknown so far, why you are not affected by this, I suggest reverting melpa to a previous state.

The error message from emacs is given in the title of this issue report.

If you can't reproduce this with your .emacs.d, you can do:

git clone https://github.com/cohomology/.emacs.d .emacs.d
cd .emacs.d
git submodule update --init --recursive
cd third-party/evil-magit
git pull

(After the version from melpa doesn't seem to work anymore, I stopped using evil-magit from melpa and took an old version as a git submodule in my .emacs.d).

Best regards,
Kilian.

Option to easily scroll horizontally

If you have vertical split with magit and the changes you see don't fit in the window(commit window alongside changes) it becomes difficult to scroll horizontally without vim like bindings. We have to use arrow keys to scroll.

Any options/suggestions?

'=' not bound to magit-diff-less-context

I'm running magit-20160410.222 with evil-magit-20160324.1838 and noticed that = is bound to magit-log-toggle-commit-limit and isn't working correctly. Using = on a diff gives me this error: Wrong type argument: consp, nil.

+ is bound to magit-diff-more-context and works fine.

evil-visual-char Request

When using (setq evil-magit-want-horizontal-movement t), sometimes (most of the time), I'd like to be able to select the text I want to yank with v, but both v and V go to evil-visual-line.

If there are no downfalls, could we get a setting to get the old 'v' functionality?

Thanks!

magit compatibility: Error the keymap magit-blame-mode-map is not bound

The mode map was renamed to magit-blame-read-only-mode-map in magit/magit@6d7127d.

MagitPopup without evil bindings

As above, MagitPopup (or magit-popup-mode) doesn't have evil bindings yet. However, this works instead so far:

(evil-set-initial-state 'magit-popup-mode 'normal)

Thanks!

C-w

When evil-want-C-w-delete is set to nil, Evil uses C-w for window switching keys (like Vim obviously). There is another evil setting, evil-want-C-w-in-emacs-state, that adds the C-w window switching even to emacs-state. Evil-magit should probably respect one of these settings and remap magit-copy-selection-value to something else so that people have a way to switch out of the Magit windows.

Initialisation warning

I have both magit and evil installed.

After adding (require 'evil-magit) into my emacs init file, I get the following warning:

Warning (initialization): An error occurred while loading ‘/home/karan/.emacs.d/init.el’:

Symbol's function definition is void: transient-suffix-put

To ensure normal operation, you should investigate and remove the
cause of the error in your initialization file. Start Emacs with
the ‘--debug-init’ option to view a complete error backtrace.

After running Emacs with --debug-init, I get the following backtrace:

Debugger entered--Lisp error: (void-function transient-suffix-put)
transient-suffix-put(magit-branch "x" :key "X")
evil-magit-change-popup-key(magit-branch "x" "X" magit-branch-reset)
apply(evil-magit-change-popup-key (magit-branch "x" "X" magit-branch-reset))
evil-magit-adjust-popups()
evil-magit-init()
require(evil-magit)
eval-buffer(#<buffer load-875345> nil "/home/karan/.emacs.d/config.el.el" nil t) ; Reading at buffer position 2245
load-with-code-conversion("/home/karan/.emacs.d/config.el.el" "/home/karan/.emacs.d/config.el.el" nil nil)
load("/home/karan/.emacs.d/config.el.el" nil nil t)
load-file("/home/karan/.emacs.d/config.el.el")
org-babel-load-file("/home/karan/.emacs.d/config.el.org")
eval-buffer(#<buffer load> nil "/home/karan/.emacs.d/init.el" nil t) ; Reading at buffer position 848
load-with-code-conversion("/home/karan/.emacs.d/init.el" "/home/karan/.emacs.d/init.el" t t)
load("/home/karan/.emacs.d/init" t t)
#f(compiled-function () #<bytecode 0x1df201>)()
command-line()
normal-top-level()

My config is here (I've commented out the evil magit line): https://github.com/knjk04/.emacs.d/blob/master/config.el.org

Any idea why?

magit-blame somehow nullifies evil-state

after entering magit-blame state, (evil-state-property evil-state :name) returns nil. All evil bindings vanish. I've tried

(add-hook 'magit-blame-mode-hook #'evil-normal-state)
(add-hook 'magit-blame-read-only-mode-hook #'evil-normal-state)

and

(evil-set-initial-state 'magit-blame-mode 'normal)

neither works

Support for magit-wip-mode

Magit has magit-wip-mode, a global minor mode that is not enabled by default. When enabled, it presents the X w keybinding in magit-status. I would like to request this binding be made available. Thank you.

For more information: https://magit.vc/manual/magit/Wip-Modes.html

magit-gh-pulls help text needs to be overriden

There needs to be a way to override the helpdesk displayed in the magit-status buffer. Since # g is overriden, users will get confused when it doesn't work. My emacs lisp chops aren't great but will take a stab at this.

Deferring evil-magit with use-package doesn't seem to work in strange cases

Keybinds don't seem to work if I defer ag for some reason..

Evil is not deferred.
(evil-mode 1)

;; Leaving it like this works.
(use-package ag
  :ensure t
  :config
  (add-to-list 'ag-arguments "-U") ;; ignore .ignore files by default
  (setq ag-highlight-search t)
  (setq ag-reuse-buffers t))

But this causes binds to break

(use-package ag
  :ensure t
  :commands (ag ag-project)
  :config
  (add-to-list 'ag-arguments "-U") ;; ignore .ignore files by default
  (setq ag-highlight-search t)
  (setq ag-reuse-buffers t))

;; C-h k r in git-status
r runs the command dired-do-redisplay, which is an interactive
autoloaded compiled Lisp function in ‘dired-aux.el’.

It is bound to r, <normal-state> r.

(dired-do-redisplay &optional ARG TEST-FOR-SUBDIR)

But then, it doesn't seem like AG is a problem (something it does side-effects and makes everything work though).

I comment out the entire ag use-package snippet, and it still fails. (evil-magit commands aren't bound)

(defmacro after-evil (&rest body)
  `(eval-after-load "evil"
     (lambda ()
       ,@body)))

(use-package magit
  :ensure t
  :commands (magit-toplevel magit-status magit-blame magit-log)
  :config
  (after-evil
   (evil-define-key 'normal magit-log-mode-map
     (kbd "`") 'magit-process-buffer
     (kbd "~") 'magit-diff-default-context
     (kbd "0") 'evil-digit-argument-or-evil-beginning-of-line
     (kbd "$") 'evil-end-of-line)
   (evil-define-key 'normal magit-status-mode-map
     (kbd "q") 'quit-window
     (kbd "`") 'magit-process-buffer
     (kbd "~") 'magit-diff-default-context
     (kbd "0") 'evil-digit-argument-or-evil-beginning-of-line
     (kbd "$") 'evil-end-of-line
     (kbd "Q") 'delete-window)
   (evil-define-key 'normal magit-repolist-mode-map
     (kbd "q") 'quit-window
     (kbd "Q") 'delete-window
     (kbd "RET") 'magit-repolist-status
     (kbd "gr") 'magit-list-repositories))

  (setq magit-repository-directories '("~/Developer"
                                       "~/Code"
                                       "~/.emacs.d"
                                       "~/.vim"
                                       "~/.dotfiles"
                                       "~/.zsh"))
  (setq magit-refresh-status-buffer nil)
  (setq magit-completing-read-function 'ivy-completing-read)
  (setq vc-handled-backends (delq 'Git vc-handled-backends))

  (defadvice magit-show-commit (around dont-select-commit-window activate)
    "magit-show-commit selects the window it opens unless magit-display-buffer-noselect is set.
Setting magit-display-buffer-noselect changes the selection logic for other parts of magit though.
Instead, advise magit-show-commit by setting magit-show-commit to t
before calling magit-show-commit and set it back to nil afterwards."
    (setq magit-display-buffer-noselect t)
    (setq ad-return-value ad-do-it)
    (setq magit-display-buffer-noselect nil))

  ;; https://github.com/magit/magit/issues/2541 (tweaked)
  ;; single window or special magit modes -> open in other window
  (setq magit-display-buffer-function
        (lambda (buffer)
          (display-buffer
           buffer
           (cond
            ((eq (count-windows) 1)
             nil)
            ((and (derived-mode-p 'magit-mode)
                  (eq (with-current-buffer buffer major-mode)
                      'magit-status-mode))
             nil)
            ((memq (with-current-buffer buffer major-mode)
                   '(magit-process-mode
                     magit-revision-mode
                     magit-diff-mode
                     magit-stash-mode))
             nil)
            (t
             '(display-buffer-same-window))))))

  ;; Add rebase argument to pull
  ;; https://github.com/magit/magit/issues/2597
  (magit-define-popup-switch 'magit-pull-popup ?R "Rebase" "--rebase"))

Tried various things,

;; This does not work if ag is deferred or commented out.
(use-package evil-magit
  :ensure t
  :after magit
  :init
  (setq evil-magit-want-horizontal-movement t))

;; This does work but it also auto-loads magit and evil..
(use-package evil-magit
  :ensure t
  :init
  (setq evil-magit-want-horizontal-movement t))

;; This doesn't seem to work.
(use-package magit
  :commands (random commands to defer magit)
  :config
  (after-evil
   (use-package evil-magit
     :ensure t
     :init
     (setq evil-magit-want-horizontal-movement t))))

I'm heaving ag in for now but it's definitely a little messy. Thanks for any help.

ESC should close the Magit popup window

Hitting ESC to close or get out of everything is a Vim habit I find hard to get rid of. Currently ESC does not close the Magit popup, but acts as a prefix key instead. It would be nice if simply hitting ESC closed the popup window.

git-rebase-mode: meaningfully disable most keybindings

I only want to keep the binding for [return] (show commit at point) and remove all the rest as I find the non-textual editing interface too simple and limiting. I've managed to hack together something along the lines of

(add-hook 'git-rebase-mode-hook 'l/git-rebase-keymap)

; git-rebase.el is provided by Magit.
(defun l/git-rebase-keymap ()
	"My keys for git-rebase mode."
	(interactive)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "p" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "r" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "e" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "s" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "f" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "x" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "d" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "u" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "h" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "j" nil)
	(evil-magit-define-key evil-magit-state 'git-rebase-mode-map "k" nil)

	(define-key git-rebase-mode-map "p" nil)
	(define-key git-rebase-mode-map "r" nil)
	(define-key git-rebase-mode-map "e" nil)
	(define-key git-rebase-mode-map "s" nil)
	(define-key git-rebase-mode-map "f" nil)
	(define-key git-rebase-mode-map "x" nil)
	(define-key git-rebase-mode-map "d" nil)
	(define-key git-rebase-mode-map "u" nil)
	(define-key git-rebase-mode-map "h" nil)
	(define-key git-rebase-mode-map "j" nil)
	(define-key git-rebase-mode-map "k" nil)
)

(with-eval-after-load "git-rebase"
	`(progn
		(l/git-rebase-keymap)
	)
)

which seems to successfully unbind the various keys like p and r, but I find myself stuck with one major problem: when I go into insert mode after (toggle-read-only nil), I can't type anything in because all of my insert keys are unbound! E.g., if I press a I get a is undefined.

Help?

with evil-magit-want-horizontal-movement C-l to Change Log not obvious

Hey,

I found it within the code but when evil-magit-want-horizontal-movement is enabled then both =Logging= and =Change Logs= show as L.

Not a big deal but worth noting. :-)

Best regards,
benny

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.