My Personal Cheat-sheet on emacs

One can open emacs in gui mode or natively in terminal emacs in gui mode, is called an "emacs frame" Obviously you can open emacs on a macbook pro the usual way of opening a gui app:

• through spotlit
• through launcher
• through gui

But how to control opening emacs from a terminal command line:

• to open emacs while staying in the command line, use no window, -nw option

emacs -nw

If you have minimized your emacs window, recover it using mouse-click on appropriate app in apple's native doc (or C-z toggle)

you can also open -a emacs or just plain emacs from the terminal command line but will open emacs either in a separate GUI window, or in the command line, depending on these (as yet unknonw) settings in .emacs.d/init.el

If you placed the Emacs.app inside the root /Applications folder, then your path to the Emacs executable: /Applications/Emacs.app/Contents/MacOS/Emacs

If you placed the Emacs.app inside the root /Applications folder, then your path to the emacsclient executable is: /Applications/Emacs.app/Contents/MacOS/bin/emacsclient

You can run emacs --daemon so that emacs is running in the background when you boot up. AFter that run emacsclient filename & ??

test this

You could also add this to your .bash_profile file. i.e. emacs –daemon &

alias emacs='open -a /Applications/Emacs.app $1'

This may be inefficient.

A lot of very complex solutions to this problem are posted here. That's fair
because it seems non-trivial.

However, this solution works really well for me.

ec() {
   emacsclient -n $@ 2> /dev/null
   if [[ $? == 1 ]]; then
   open -a Emacs.app  -- $@
   fi
}
Usage
ec file [...]
Let's unpack what's happening:
pass all the ec arguments to emacsclient and don't (-n) wait for emacs before continuing.
If Emacs is already running, we're all done and you're editing.
swallow up the error message posted by emacsclient when there's no emacs running. (2> /dev/null)
Manually handle the exit code 1 ([[ $? == 1 ]])
open Emacs.app and pass file arguments to it (paths will be correctly opened.)
You're all done, and Emacs has opened your files.

           |
C-b <--------------> C-f
           |

(Or use left and right errors)

               |
back  M-b <---------> M-f  forward word
               |

          M-[
           ^
           |
M-a <--------------> M-e
           |                  
           V
          M-]	      

          C-p
           ^
           |
C-a <--------------> C-e
           |             
           V
          C-n

I typically use arrow keys for next and previous lines

For page at a time remember that others use C-v to paste contents of your clipboard, but emacs uses C-y to paste the contents of your clipboard.

That leaves C-v for page down, and M-v for page up.

 page up
   M-v
    ^
    |
    |
    V
   C-v
page down

  top of file
     M-<
      ^
      |
      |             
      V
     M->
bottom of file

• C-b back a character
• C-f forward a character
• C-a move cursor to beginning of line (a)
• C-e move cursor to end of line (e)
• M-b back a word
• M-f forward a word
• M-a beginning of sentence
• M-e end of sentence
• C-p previous line
• C-n next line
• M-[ start of paragraph
• M-] end of paragraph
• M-} end of paragraph
• M-{ start of paragraph
• M-v page up (^)
• C-v page down (v)
• M-< top of file (<)
• M-> bottom of file (>)
• M-x goto-line 451 (moves cursor to line 451)
• M-g M-g 233 goto line 233
• M-g g goto line #
• M-x goto-line 451 works too, but most likely it is set in init.el ; set a global key for goto-line (global-set-key (kbd "C-c j") 'goto-line)

  You can check if C-c j was already assigned to a command, and pick something else if you wish, - but check that one too.

This could be overwhelming, but still useful. C-h b does exactly that.

• delete key delete to the left
• C-d delete to right
• C-k delete to end of line
• C-u delete to start of line
• M-d delete word to right remember, my mac Option key is M-
• M-k delete sentence from cursor onwards
• C-S-backspace delete current line (can also C-a C-k to delete current line)
• C-S-backspace C-y C-y duplicates current line (see copying)

		  	    |
(char to left) delete <--------------> C-d (character to right)
			    |

                           |
(start of line)  C-u <------------> C-k (end of line)
                           |

                           |
(start of line)  C-u <------------> M-d (word to right)
                           |

                           |
(start of line)  C-u <------------> M-k (sentence to right)
                           |

You set a mark with C-space then can move your cursor up or down to wherever you want to "mark". Then:

• C-w delete (wipe) from mark to where the cursor is presently.
• M-w copy (wipe) from mark to where the cursor is presently.

• M-z" delete everthing to the next occurance of ~" that could be any character ) ] } ' … this is very similar to the vim "change inside" or ci" or ci) or ci] ci} … also "delete inside" di" di) di) di] di} Note that emacs is always in insert mode so the concept of ci vs di makes no sense to emacs. emacs is like ci… ALWAYS.
• M-SPC just-one-space will delete all whitespaces around cursor, leaving just one space. M-x just-one-space
• M-\ delete-horizontal-space # same as above, but does not leave 1 space.
• M-^ delete-indentation (joins current line with line above it and removes indents)
• M-x delete-whitespace-rectangle if you mark a region first, then this will delete all the excess whitespace in that region.
• C-M-s maps to Regexpl I-search: and interactive regex search and replace

• M-k delete sentence from cursor onwards
• M-w delete (wipe) the word? *this was different: C-h k M-w says it is "kill-ring-save"
• C-y to yank back (ie: paste a previously deleted word, sentence, line, mark) really what emacs does is "paste" back what was in the "kill ring" if you deleted three lines in a roll, emacs will keep all three in the kill ring.
• C-h v kill-ring to view your kill ring. yanking actually yanks it off the kill ring.

• M-7 do this next thing 7 times, so combining
• M-7-M-d delete 7 words to the right
• M-7-M-k delete 7 sentences
• M-7-C-d delete 7 characters to the right

Repeating a character or string of characters:

• C-u77- repeats whatever you type next, 77 times.

  ---

• C-u77. repeats whatever you type next, 77 times. ……………… …………………………………………………..

• M-w copies a selection into the buffer "kill-ring-save"
• C-y to yank back (ie: paste a previously deleted word, sentence, line, mark) really what emacs does is "paste" back what was in the "kill ring" if you deleted three lines in a roll, emacs will keep all three in the kill ring.
• C-S-backspace C-y C-y duplicates current line. C-S-backspace kills the current line, and C-y yanks it back. So second C-y yanks it back again hence duplicating the current line
• C-t to transpose the character to the one preceedin it See transpose

Remember that when in doubt: C-h k M-w tells you that M-w is "kill-ring-save"

• C-w to "wipe" the selection, and put it into the buffer
• C-y to yank back (ie: paste a previously deleted word, sentence, line, mark)

really what emacs does is "paste" back what was in the "kill ring" if you deleted three lines in a roll, emacs will keep all three in the kill ring.

M-3 C-k which will "cut" three lines, then move your cursor to where you want those three lines, and type C-y. This will "move" those three lines to the new location. Alternatively you could have done C-k C-k C-k instead of M-3 C-k

You can do the typical sequence of moving to the beginning of line, deleteing it then also deleting the newline, and yanking it back twice, i.e. C-a C-k C-k C-y C-y

But you can shorten that with the kill-whole-line command which is C-S-BACKSPACE and remember; on a macbook keyboard the BACKSPACE key is actually the DELETE key

So a shorter version is: C-S-DELETE C-y C-y C-S-DELETE C-y C-y C-S-DELETE C-y C-y

In Emacs, a major definition at the top level in the buffer, such as a function, is called a defun. The name comes from Lisp, define function, but in Emacs we use it for all languages.

Although defun is Lisp-speak, most modes support all the defun-like commands such as mark-defun or narrow-to-defun.

From the emacs manual: 26.2.2 Moving by Defuns These commands move point or set up the region based on top-level major definitions, also called defuns.

C-M-a Move to beginning of current or preceding defun (beginning-of-defun).

C-M-e Move to end of current or following defun (end-of-defun).

C-M-h Put region around whole current or following defun (mark-defun).

The commands to move to the beginning and end of the current defun are C-M-a (beginning-of-defun) and C-M-e (end-of-defun). If you repeat one of these commands, or use a positive numeric argument, each repetition moves to the next defun in the direction of motion.

C-M-a with a negative argument -n moves forward n times to the next beginning of a defun. This is not exactly the same place that C-M-e with argument n would move to; the end of this defun is not usually exactly the same place as the beginning of the following defun. (Whitespace, comments, and perhaps declarations can separate them.) Likewise, C-M-e with a negative argument moves back to an end of a defun, which is not quite the same as C-M-a with a positive argument.

To operate on the current defun, use C-M-h (mark-defun), which sets the mark at the end of the current defun and puts point at its beginning. See Commands to Mark Textual Objects. This is the easiest way to get ready to kill the defun in order to move it to a different place in the file. If the defun is directly preceded by comments (with no intervening blank lines), they are marked, too. If you use the command while point is between defuns, it uses the following defun. If you use the command while the mark is already active, it extends the end of the region to include one more defun. With a prefix argument, it marks that many defuns or extends the region by the appropriate number of defuns. With negative prefix argument it marks defuns in the opposite direction and also changes the direction of selecting for subsequent uses of mark-defun.

In C mode, C-M-h runs the function c-mark-function, which is almost the same as mark-defun; the difference is that it backs up over the argument declarations, function name and returned data type so that the entire C function is inside the region. This is an example of how major modes adjust the standard key bindings so that they do their standard jobs in a way better fitting a particular language. Other major modes may replace any or all of these key bindings for that purpose.

• C-t transpose 2 characters (transpose-chars)
• M-t transpose words (transpose-words)
• C-x C-t transpose lines (transpose-lines)
• M-x transpose-sentences
• M-x transpose-paragraphs
• M-x transpose-regions
• C-M-t transpose two balanced expressions (transpose-sexps)

For lines:

• if your cursor is in the middle of a line, that line is moved up
• if your cursor is at the end of a line, that line is moved up

• C-x C-q toggles buffer read-only mode in the current buffer
• M-x read-only-mode is an alternative if C-x C-q isn't working out.

• M-x overwrite-mode (is a toggle)
• C-l redraw the screen (in case it gets mucked up)
• tip: repeating the next command 55 times, uses M-55 command, e.g.

• M-l convert to lower case (downcase-word)
• M-u convert to upper case (upcase-word)
• M-c capitalize the following word (capitalize-word)
• C-c
• C-x C-l convert region to lower case (downcase-region)
• C-x C-u convert region to upper case (upcase-region)

M-l (downcase-word) converts the word after point to lower case, moving past it. Thus, repeating M-l converts successive words. M-u (upcase-word) converts to all capitals instead, while M-c (capitalize-word) puts the first letter of the word into upper case and the rest into lower case. All these commands convert several words at once if given an argument. They are especially convenient for converting a large amount of text from all upper case to mixed case, because you can move through the text using M-l, M-u or M-c on each word as appropriate, occasionally using M-f instead to skip a word.

A very useful technique is to use the iedit package, from Iedit on emacswiki.org Also available on github

C-; is a toggle for iedit for all the occurances of a string in the buffer. Typically a good way to change a variable name and have it change through-out the buffer. First select a string, then C-; (which is the default key-binding) And all matching strings will be highlighted. Make any editing changes, then finish with C-; again, or C-g while within an occurance.

There are three approaches to editing multiple lines at once, that I have tried.

1. rectangle editing
2. iedit mode
3. multiple cursor, mc mode

https://emacsrocks.com/e13.html The author has a youtube video showing how powerful this is. Worth watching it. Magnars multiple cursors git hub page is: https://github.com/magnars/multiple-cursors.el

If your problem is that the modifier keys are not mapped as you expected, you can directly set the variables mac-option-modifier, mac-command-modifier and mac-control-modifier (and their right- counterparts) to either 'meta or 'control in your ~/.emacs.d/init.el file.

E.g. (setq mac-command-modifier 'meta) will make the Command key act as a Meta key.

I personally like this setup:

(setq mac-control-modifier 'control) (setq mac-command-modifier 'meta) (setq
mac-right-option-modifier 'control)

Finally, you can set your CAPS lock key to be control key instead, and the fn key to be CAPS lock key if you wish. (I have done that to make emacs key bindings easier to use.) Go to sys-preferences, keyboard, modifier keys, CAPS-lock changed to Control and Function key changed to CAPS lock key. i.e. this change is done from the Mac OSX settings.

To get around not having CAPS LOCK, you can simply use M-u to uppercase all remaining characters from cursor, to the end of the word. — or next word if you cursor is on a space. M-u is mapped to M-x upcase-word while M-l is mapped to M-x downcase-word (think M-l for lower vs M-u for upper

You can remove the first n characters of a block of lines by running;

Move to one corner of the rectangle you want to delete, press C-SPC to set the mark. Move to the other corner of the rectangle and press

C-x r d (delete-rectangle). # I found that C-x r t did the same except that it left you still in the rectangular text mode that let you replace the deleted block with something if so desired.

Very similar to Rectangular editing

• M-x line-number-mode
• M-x column-number-mode«
• M-x Display-Fill-Column-Indicator mode

All three are toggles.

Now jump or goto a specific line with M-g g 366 to move to line 366 (you don't have to be in line-number or linum-mode mode.)

• M-x text-scale-adjust then + or -
• M-x t-s-ad +-
• C-x C-+ And you might not need to use the shift key for +, but just hit =
• C-x C-- (I find it easier to C-x C-+ +++---- as needed but start with +

Note, that after the first + or - is hit, you do NOT need to enter subsequent C-x C - - commands. Just continue with C - + or C– i.e. keep holding down the control key and hit +---+ (which is actually just ==---====)

In fact, you don't even have to hold the control key. just ----==–0== until you like the size, then any other key will fix that font size. Voila!

• C-x C-0 To restore the default (global) font text face height=

To increase font size: M-x text-scale-adjust then press + repeatedly To decrease font size: M-x text-scale-adjust then press - repeatedly

Alternatively M-x t-s-ad +++- or also C-x C-+

;; turn on highlighting current line (global-hl-line-mode 1) ===> alternatively you can just use M-x hi-line-mode. It is a toggle. This did not work for me actually. Neither did M-x global-hi-line-mode nor M-x hi-line-mode

Some notes from yang-mode give a good example of init.el configurations:

Version you are running by either running emacs –version or by running =M-x emacs-version from within emacs

• C-h for help
• C-h t for tutorial
• C-h m describe mode this one is key!! Learn to learn about every mode you are in. A lifetime of learning and expanding.
• C-h i another key feature that is useful to finding help. It shows all the help for all the packages your have installed

C-h k for documentation on the keystroke I am about to type for example C-h k C-x i gives me info on the "insert" command in a split mode And… to get back to one screen, use C-x 1 (see below on modes)

• C-h k C-x 1 will tell me about the key C-x 1 -> " get back to 1 window "
• C-h k C-s will tell me about the key C-s –> " search "
• C-h k M-% will tell me about the key M-% –> interactive queary-replace
• C-h f eval-last-sexp f is for function, –> eval-last-sexp which is

If you want to confirm a key binding, try checking keystroke help on the key sequence, so C-h k keysquence-I-want-checked

If you type C-x C-h which is in reverse, then emacs will display all the available key stroke combinations that start with C-x I assume that this also works for M-x C-h ? Well it id not work for me, but that is because I have an emacs package active that describes keys for me all the time, interactively. That package is a emacs LISP extension called "which-key".

Install that by listing the packages with M-x package-list-packages and pressing I beside which-key.

Another favourite of mine is C-h b to see what key bindings I have active now

What if you want to find if there is a key binding for M-x fill-region ? Or M-x set-fill-column ?

When some key sequence triggers an unexpected command, use view-lossage (bound to C-h l by default) to see what keystrokes Emacs has recently received.

Getting messed up in the commands?

• C-g keyboard quit * as in gong this keyboard mess *
• C-x u undo past editing chages. can do this repeatedly till all editing changes since last save are "undone"

Alternatively you can revert back to the last saved version with the command:

• C-x / is the same as C-x u both are undo.
• C-/ id undo
• C-g C-/ is redo

• M-x revert-buffer RETURN You might get: Buffer has been auto-saved recently. Revert from auto-save file (y or n)

  if you choose y, emacs will restore from the #filename# that it last saved (about up to 100 keystrokes ago) lf you choose n, emacs will restore from the file on the disk. (I think)

  if you had even more disasters, you can mv program.py~ program.py because when you edited program.py, emacs created a backup file called program.py~ Or If an Emacs session crashed recently, type M-x recover-session RET to recover the files you were editing.

This is useful in many situations, including mapping to Keyboard macros To change key bindings interactively, use the command define-key. Otherwise, you can use the init.el command ~(global-set-key /key/ /binding/ )

By the way, that is equivalent to: - (define-key (current-global-map) /key/ /binding/ )

When trying to set org-mode kbd macros set properly as per above link, I tried these following additons in init.el file. Only the _last_ one worked.

Keys can be bound to commands either interactively or in your .emacs file. To interactively bind keys for all modes, type

• M-x global-set-key RET key cmd RET
• M-x global-set-key RET key cmd RET

To bind a key just in the current major mode, type

• M-x local-set-key RET key cmd RET

Use the key C-h b to see key bindings, but also I like xxx and then cycle through all the bindings I have currently active. That is done through ivy, simply by hitting ??? I just did it not 5 min ago, and now can't remember.

From emacs.stackexchange.com : Modifier key s- is called "Super". (event-modifiers 's-Y) returns (super), which says that s-Y uses (only) the super modifier.

See the Emacs manual, node Modifier Keys. What physical keyboard key, if any, might correspond to this logical modifier key depends on your system and hardware. (event-convert-list '(super ?y)) returns 8388729, which is the internal representation of the event produced by key s-Y. (kbd "s-Y") returns [8388729], which is the internal representation of the key s-Y.

In my setup, and (describe-key [8388729]) returns the key-description string "s-Y is undefined". But presumably if you use org-roam that sexp will tell you what command s-Y is bound to in Org mode using org-roam.

I used keyboard macros to define the action, then keyboard mappings to set key strokes to call those actions in my init.el file. Here are the two sections:

#+BEGIN_EXAMPLE ;; setting Zintis org-mode keyboard macros (fset 'make-bold (kmacro-lambda-form [?\C-w ?* ?\C-y ?*] 0 "%d")) (fset 'make-hlight (kmacro-lambda-form [?\C-w ?~ ?\C-y ?~] 0 "%d")) (fset 'make-underline (kmacro-lambda-form [?\C-w ?_ ?\C-y ?_] 0 "%d")) (fset 'make-verbatim (kmacro-lambda-form [?\C-w ?= ?\C-y ?=] 0 "%d")) (fset 'make-italic (kmacro-lambda-form [?\C-w ?/ ?\C-y ?/] 0 "%d"))

;; This works (global-set-key (kbd "\C-c b") 'make-bold) (global-set-key (kbd "\C-c h") 'make-hlight) (global-set-key (kbd "\C-c u") 'make-underline) (global-set-key (kbd "\C-c v") 'make-verbatim) (global-set-key (kbd "\C-c i") 'make-italic) #+END_EXAMPLE

Setting regions is exactly the same as setting marks. See Setting Marks

Once region has been highlighed, you can do cool stuff with it, such as: Use "region editing" which all starts with C-x r

This works as you would expect, only when a region is active, the replacement is limited to regexp matches within in region only.

Part of gnu and melpa packages. I have mapped C-= to expand-region and C-- to contract-region

expand-region lets you type the following anywhere within the region and emacs will "select" the whole region. i.e. it will 'expand the region'.

M-x er or M-x expand-region

Best way to see how this works is using a larger .xml file. Put your cursor somewhere deep in a nested xml doc and repeatedly hit C-= followed by repeatedly hitting C-- You will see emacs repeatedly expand a selection out to eventually the whole file and C– reverses that back to the single character you were on. At any time you can C-w to wipe out the entire selection.

Usually C-= is smart enough to know that you can just repeatedly hit = and the region will continue to expand. Then too hitting - and = until you got just what you need will do the trick. i.e. no need to hold down the C key.

Well, you already have highlighted a block of lines so: C-x TAB arrows to indent interactively. M-M-M which is <esc> three times when done with indentation.

You can select a block of commands and uncomment or comment them like this:

Mark a bunch of lines, then

make them all coments, or if they are all comments, uncomment them. This is a toggle:

M-; with the active region (marked).

M-x comment-region also does the same thing.

You can comment out blocks using the M-; command, but to an arbitrary string to the front of every line, you need something more versatile.

That's where block editing, a.k.a. region editing, rectangle editing comes in:

• C-x r t Replace rectangle contents with string on each line

This is very similar to: M-x string-insert-rectangle hammer string hammer

See also rectangle editing.

C-x r M-w

Makes sense: C-x r to operate on the rectangular region, and M-w to copy it.

After the first comment line is entered, using M-j or C-M-j will add the next line of comments.

In auto-fill mode, you can just keep typing and emacs will auto-fill the comment lines. * nice *

• M-x auto-fill-mode just toggles it for this session.
• (add-hook 'text-mode-hook 'turn-on-auto-fill) turns it on for all text mode
• (setq-default auto-fill-function 'do-auto-fill) on all major

You can also auto-wrap text at 80 columns with with the command M-x (set-default fill-column 80) or in your .emacs.d/init.el file If you want to to make sure that lines don't split on your screen as you're typing things, you can set up visual line mode. C-c f also sets your fill column #. or M-x set-fill-column 80 at prompt

emacs.d/init.el

• (add-hook 'text-mode-hook 'turn-on-auto-fill)
• (add-hook 'text-mode-hook '(lambda() (set-fill-column 80)))

I would like it to happen in all modes, e.g. org-mode. I added the line (global-visual-line-mode t) to my .emacs file, in order for the word wrapping also to work in org-mode.

If you are continuously typing text without making mistakes or editing, then the end result would be the same in both cases.

auto-fill-mode isn't so helpful when editing existing text, though (especially so when editing text which has already been filled). It is just inserting line breaks when the current column exceeds the fill column, but if you are editing before the fill column, it does nothing; and it doesn't care about the preceding lines at all. You would probably need to invoke fill-paragraph manually from time to time.

refill-mode OTOH will automatically refill the current paragraph as you edit, and will still trigger when you are before the fill-column. This can be very useful, yet also be totally useless when you want to create lists with items on each new line. refill mode will keep putting them back as part of a paragraph. So good to know that you can toggle it on and off.

To set C-c q to the refill-mode toggle (it was unset before) use: (global-set-key (kbd "C-c q") 'refill-mode)

These three commands together will set up hard-wrapping lines

• set how wide to set your lines M-x set-fill-column
• Align lines to give a l\f based on what your set-fill-columns is set with:
  • M-x fill-paragraph ( or M-q )
  • M-x fill-region select region first then align highlighted block
  • M-x set-fill-column (use C-x f))
• If C-x f does not work check your keybinding of C-x f

• ? show available commands. magit-dispatch this is always available and opens a transient buffer that will automatically close once you hit the next command you want
• <tab> to expand sections OR to expand a file magit-section-toggle
• s on an untagged file, to stage it. magit-stage
• u on a stagge4d file to unstage it. magit-unstage q to quit this command display
• c commit magit-commit
• c c commit magit-commit-create (c is entered twice )
• d d diff (d is entered twice)
• b branch magit-branch
• b b again which is magit-checkout ( b is entered twice )
• s spin off a branch magit-branch-spinoff
• l log magit-log
• l log magit-log-current (l is entered twice)
• q quit this command (magit-log-bury-buffer)
• w magit-am
• w magit-am-apply-patches (w is entered twice)
• C-c C-c to confirm the edited commit.
• C-c C-k to cancel this commit.

So a typical, basic magit workflow is: M-x magit or C-x g

• ? remind yourself what commands are available
• move to any untracked or unstaged files and hit s
• s
• s
• s
• S to stage all remaining unstaged or untracked files
• TAB on any file you want to examine (diff)
• c c commit commit
• Add your commit message, then:
• C-c C-c

  ( or is C-c C-c followed by c c ??? No, it is c c then C-c C-c )

• $ bring up the details of the error message that just appeared.
• P push your commit o repository i.e. github

M-x magit-status (you can set C-x g to map to M-x magit-status by using: (global-set-key (kbd "C-x g") 'magit-status) in your .emacs-d/init.el file

• Refresh (g/G)
• global-magit-file-mode (C-c M-g)
• magit-dispatch (C-x M-g)

First a good idea to confirm that C-x g is not being used by anything useful C-h k C-x g See help magit status section above.

? will display the magit commands available. (must be in the magit-status buffer)

• M-n/p, j to move around the git status window (next/previous)
• M-1 or -2 or -3 or -4 , TAB, S-<tab> for visibility

D

C-c C-t (or M-x magit-diff-trace-definition) ?

Once in the diff buffer (D) see toggles such as -U for context lines and -t for hunk refinements which can show you the actual changes made to files between git commits.

git diff --word-diff (is the equivalent git cli command. ~ In a diff buffer, you can get the function history list as well… That is a list of historic changes to the function you are currently looking at say in python, or in .php or whatever program is being edited in magit mode.

L can toggle dates from absolute dates or days or hours ago.

shows who and when people committed people.

$ will show you what is happening with your git commands, at any given time

• to show dates when lines or sections were added or changed or deleted from a git file.

c c then edit the commit message with the following (emacs enforced) best practices

b brings up the branch popup. Can create a new branch, or open a branch, can check it out or not in the same command.

V

• VV (magin-revert-and-commit)
• Vv (magit-revert-no-commit)

Read the docs on this. What follows is just to make you aware that this feature exists, and is fairly useful:

Get your mouse onto a recent commit (pick one) and hit:

• x (and type Head) to revert to that version. ?
• x (and bring up the log to see what version you want to revert to.)

z z (magit-stash-both) Stashes index and working tree, untracked files included.

Once a change is stashed, you can hit on the stash (under git status buffer) at a latter time, to then incorporate the change into the branch at that time.

r i (magit-rebase-interactive)

Rebase allows you to resolve conflicts and rewrite history. ** very useful

magit does this very well.

Look at the log, choose a commit where you want to start the rebase. hit r i For instance c76309r, then you will see a list of commands.

Read them and use C-c C-c to execute what you want with the rebase. - any errors will pop up for you to resolve, or skip and continue forward.

C-c C-k to kill buffer out of this if you do not want to make any changes.

B B (magit-bisect-start) B s (magit-bisect-run) B b (magit-bisect-bad) B g (magit-bisect-good) B r (magit-bisect-reset)

This is good if you have a bug and want to know when the bug came into being.

Works good if you have been following proper git etiquette, hygene and standards, with proper messages left on commits, etc.

Read up on this.

You can use the following work-flow to edit text across multiple files.

1. M-x find-name-dired: you will be prompted for a root directory and a filename pattern.
2. Press t to "toggle mark" for all files found.
3. Press Q for "Query-Replace in Files...": you will be prompted for query/substitution regexps.
4. Proceed as with query-replace-regexp: SPACE to replace and move to next match, n to skip a match, etc.
5. Press C-x s to save buffers. (You can then press y, n or ! to save all at once)

I think this should query through what should be replaced or not, in each of the files that are "marked":

• in dired, or find-dired: (see dired.org for details)
• Mark the files you want. You can mark by regex by typing 【% m】.
• Type Q to call diredk-do-query-replace-regexp.
• Type your find regex and replace string. 〔☛ common elisp regex pattern〕
• For each occurrence, type y to replace, n to skip. Type 【Ctrl+g】 to abort the whole operation.
• Type ! to replace all occurrences in current file without asking, N to skip all possible replacement for rest of the current file. (N is emacs 23 only)

If you have marked a region of your file then M-r should do a regexp in that marked region.

As per the same workflow above, if you select the block of python code then:

That breaks down to this workflow:

• C-x( to start the macro
• C-w to wipe the selected python code.
• #+BEGIN_SRC python to mark start of the python code
• C-y to paste back the wipped block of python code
• #+END_SRC to add the trailing mark at the end of the python code
• C-x) to end recording the macro

You can save it permanently by editing your init.el file, and while there

1. M-x name-last-kbd-macro and give it a name. (C-x C-k n is mapping for this)
2. M-x insert-kbd-macro This will insert the lisp code for the named macro at the current cursor position
3. Copy and paste that code in your init.el file (if not already there)
4. M-x name Call the macro by name. Or, create a key mapping for M-x name
5. See Customize Key Bindings section.
   • (global-set-key (kbd "\C-c b") 'make-bold) in your init.el as well.

#+BEGIN_SRC python import json for i in paragraph: x = i.strings.json.load() #+END_SRC

The above notes show how you create macros, but to edit them permanently simply edit init.el and search for kmacro-lamba-form.

Keyboard macros are good when you want to assign a key mapping, e.g. C-C s to a macro called "wrap python" while in org mode. But when you want to have emacs automatically fill out typed words into a block of larger code, you use abbreviations. So, in that way I can type "s b l k " (without the extra spaces) in org mode and have that automagically fill out to the #+BEGIN_SRC block for python source code, while still in org mode.

I set up these abbreviations in org-mode: e b l k , s b l k , and now also

• scratch window, what is it?
• closing the open window
• closing the other window
• listing the windows

If you have two or three windows, and they are open to different buffers, you can copy text M-k or M-. mark and M-w or M-. and C-x w

And then yank it back in the other buffer:

• C-x o to move to the other window,
• then C-y to paste.

But you can also do that now with the window version of emacs, i.e. copy/cut in one window and C-y yank it back in another window. Cool…

OR C-x C-o to move the editing from one buffer to another…..

Deleting a windows means it isn't displayed anymore. It does nothing to the buffer(s)

• C-x 0 To delete the current window:
• C-x 1 To delete the other window, i.e. make the current window maximized (think "make this the one and only window" )
• C-x 2 Split window below ( horizontally )
• C-x 3 Split windows right ( vertically )
• C-x 3 C-x 1 C-x 2 example which split verticalyl, closed it, & split horizontally
• C-x ^ Makes the current window taller (increase window size)
• C-x } Make the current window wider (increase window size)
• =
• C-x 4 c is "clone-indirect-buffer-other-window" let's you have vertically split windows where each window is independent of the other. Good if you want to have an outline of a file in one split, and detailed view of the SAME file in the other window.

• C-x C-shift+ Making text font size bigger
• C-x C-- Making text font size smaller (control-minuskey)
• M-x text-scale-adjust also changes text font size
• C-x ^ Growing a window use:
• M-5 C-x ^ Growing a window 5 lines:

When in buffer list buffer, you can "kill" buffers with k That will mark buffers to be deleted with "D". Then once all buffers to be killed are so marked, you "execute" with x This behaviour mirrors dired mode with marking, then executing a command on the marked files.

M-x describe-key will let you enter any key combination, and if that key is bound to a command, will tell you the details. Use it in conjunction with M-x describe-key which will tell you what key binding you have (if any) for the subsequent key combination you press.

For example, you could type C-h k C-h v that will then tell you that the key C-h v is bound to counsel-describe-variable and will describe what that variable does.

M-x describe-bindings Is very useful to learn a new mode, or to refresh your memory on what bindings are active in the current mode.

M-x describe-variable shows you what the current variable is set to, and gives you some help text around that variable. For example: C-h v org-agenda-files See also LISP variables

M-x describe-mode Whatever mode you are in, you might have different key bindings, and other useful information. All that information is at your finger tips by using: C-h m. But you have to scroll down to see the key bindings. Elsewhere I have seen C-h ? as the "describe mode" To resolve this, try to run the "describe-key-binding" command or C-h k then press the key. Of course my loaded ?program? "which-key" shows you these every time, interactively. i.e. when you run a command with M-x fill-region for example, if there is a key mapped to this command it will show up right in the window. Conversely if You start typing C-x then all the options following C-x will be displayed. So you can continually be learning new functions and new key mappings.

For example in dired mode, you can see that Q is "dired-do-find-regexp-and-replace".

To actually search multiple files and replace strings across all of them M-x find-name-dired then enter root directory and regexp for files to select t to toggle mark for all files Q for Query-Replace in Files.. then enter query/substitution regexps press SPACE to replace, n to skip this occurance (same as in query-replace-regexp C-x s to save buffers. Then y, n, or ! to save all at once.

M-x describe-face displays the properties of <face> for the current frame. Not needed very often. Hardly at all, once your favourite fonts have been chosed, but occassionaly useful when you see something odd, or new.

To install an emacs package follow these steps: (for example elpy)

1. use pip to install "elpy", "jedi" and "rope" to install these 3 python modules into your library. Note, that this line is for python packages and NOT emacs packages. So ignore this for emacs.
2. Go to package mode of emacs M-x package-list-mode (I am guessing?)
3. Install elpy on emacs
4. Edit ~/.emacs file so that "elpy" starts with emacs
5. Edit ~/.emacs file to fix two bugs with "elpy"

• M-x package-list-package # see more about specialized commands in the specialized commands section.

from the package list can install directly as follows:

Or can install manually by M-x package-install [RET] ox-twbs [RET] if the package does not work, try refreshing the package list M-x package-refresh-contents [RET]

Or, edit your init.el file and add (without the ~ ) (use-package ox-twbs :ensure t)

the package list will likely be using Emacs key mappings. Here are some tips for getting around:

• C-v scrolls down one screen.
• M-v scrolls up one screen.
• C-s starts the incremental search function.
• C-s pressed repeatedly to move to the next match,
• RET to complete the search and stay where you are,
• i marks a package for installation.
• d marks a package for deletion.
• u un-marks a package.
• x executes the operations as marked (so mark things you want with i and then press x)
• q quits the package interface.

You can see a full list of available key mappings by asking Emacs for help with the current mode (“Package Menu Mode”). Press C-h followed by m, C-h m You can get help on a lot of things in Emacs by pressing C-h followed by some key. In fact, C-h m should have its own section.

For example C-h C-x g

Maybe only elpy has M-x elpy-config but worth looking for it as M-x elpy-config is really quite useful.

M-x pyvenv-activate could be useful if you are emacs-ing on a virtualenv framework. Try it…

Once in M-x package-list mode, you can mark files, m, i, etc, then: Type U to mark upgradable packages Type x to execute upgrade commands.

One can check the messages buffer for packages that need

Additional emacs packages are published online at melpa.org By default if you set up the following in your .emacs.d/init.el file, then package list will automatically list all 4,700 plus packages available on melpa.org

(require 'package) (add-to-list 'package-archives '(" smelpa"
. "https://melpa.org/packages/"))

Best practice is use your browser to browse and search for packages in melpa.org, and then read the package notes for instructions to download and install, then back in emacs package mode you can install the packages. check proper directory where the requirements.txt file is, if it exists.

typically the package will have documentation on melpa.org, and that typically points to a homepage that is typically on gitlab.com or github.com That will have instructions on how to change your .emacs.d/Init.el file or how to run the package manually.

This directory is where the standard emacs packages get stored. I believe other repo packages still get stored in this directory, but have not confirmed that conjecture. See emacs packages file for more details on packages.

Install First drop the file web-mode.el in a directory defined in your load-path. Then, add in your .emacs #+BEGIN_SRC emacs-lisp (require 'web-mode) (add-to-list 'auto-mode-alist '("\\.phtml\\'" . web-mode)) (add-to-list 'auto-mode-alist '("\\.tpl\\.php\\'" . web-mode)) (add-to-list 'auto-mode-alist '("\\.[agj]sp\\'" . web-mode)) (add-to-list 'auto-mode-alist '("\\.as[cp]x\\'" . web-mode)) (add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode)) (add-to-list 'auto-mode-alist '("\\.mustache\\'" . web-mode)) (add-to-list 'auto-mode-alist '("\\.djhtml\\'" . web-mode)) Using web-mode for editing plain HTML files can be done this way (add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode)) #+END_SRC

A specific engine can be forced with web-mode-engines-alist. #+BEGIN_SRC emacs-lisp (setq web-mode-engines-alist '(("php" . "\\.phtml\\'") ("blade" . "\\.blade\\.")) ) #+END_SRC

Using this association list is required as soon as the file extension is unknown (by web-mode) or is too general (e.g. *.html). In summary, you may have to set both auto-mode-alist and web-mode-engines-alist.

Since the version v10, you can also put a fragment like #+BEGIN_EXAMPLE -- engine:ENGINE_NAME -- in a comment at the beginning of your template (web-mode-enable-engine-detection must be set to t in your .emacs)

<?php * -- engine:php -- * ?> <span><?=$x?></span> #+END_EXAMPLE The recognized file extensions are listed in the Engine families paragraph.

web-mode.el can deal with many content types: html, xml, javascript, jsx, json, css. This was needed to edit *.js.erb files for example: js files that embed ruby blocks.

Sometimes, web-mode.el can not guess the content type with the file extension. e.g. you want to associate *.api files with web-mode.

The var web-mode-content-types-alist can be used to associate a file path with a content type

(add-to-list 'auto-mode-alist '("\\.api\\'" . web-mode)) (add-to-list
'auto-mode-alist '("/some/react/path/.*\\.js[x]?\\'" . web-mode))

(setq web-mode-content-types-alist '(("json" . "/some/path/.*\\.api\\'")
  ("xml" . "/other/path/.*\\.api\\'") ("jsx"
  . "/some/react/path/.*\\.js[x]?\\'")))

web-mode is a good way to enter html. Others are: emmet-mode (also available from MELPA) and js2-mode works well for javascript.

You have many template engines to work with, Look them up.

• jumping C-c C-n jump between opening & closing tags, or between control blocks such a <?php if (): ?> … <?php endif; ?>, <c:if> … </c:if>, or {% for %} … {% endfor %}, {{#SECTION}} … {{/SECTION}},
• dom navigation (parent, child, traversal, beginning/end
• code folding C-c C-f
• HTML tag auto closing <div></ –> <div>|</div>
• auto opening <div>hammer</div> –> <div>\n..|\n</div>
• auto expanding d/s/ –> <div><span>|</span></div>
• attribute auto quoting style= –> style="|"
• syntax highlighting
• snippet insertion C-c C-s (auto indented, aware of text selection)
• auto pairing (e.g. <?p … hp ?>, {% … %})
• comment / uncomment M-; according to type of block
• clever selection and expansion C-c C-m
• css colour fontification
• suspicious white-spaces detection C-c C-w
• understanding of comments and strings
• current HTML highlighting
• content and tag customized fontification
• current indentation column highlighting
• filling M-q compatibility

In an HTML document, a part is interpreted by the navigator e.g. a Javascript part of a CSS part) a block is processed (client-side or server-side) before being rendered by the navigator (eg. a PHP block, an Erb block a dustjs block etc)

It is a toggle. eblk

• M-x add-global-abbrev

To create a abbreviation for "iptables" put your curson on the word, then

• M-x add-global-abbrev and type tab when prompted.

eblk should expand to: #+BEGIN _ EXAMPLE #+END _ EXAMPLE.

#+BEGIN _ EXAMPLE without the extra spaces surrounding the underscore #+END _ EXAMPLE

without the extra spaces surrounding the underscore

1

sblk should expand to: #+BEGIN _ SRC #+END _ SRC

"sblk" 1

1 

(org-mode-abbrev-table) "eblk" 1 "

You can have the expansion also expand to emojis, or math symbols. Check out some I added to my~ /emacs.d/abbrev_devs file.

read-abbrev-file → Read abbrev definitions from file written with `write-abbrev-file'.

write-abbrev-file → Write all user-level abbrev definitions to a file of Lisp code.

M-x shell-script-mode when editing bash shell scripts But I found that turns on automagically when you are editing a .sh file. Probably a hook. Check your init.el file.

Opens up a bash shell in a buffer

Actually it opens up the shell that is specified by one of :

• explicit-shell-file-name emacs variable
• ESHELL environment variable
• shell-file-name emacs variable

If you change the default shell, you MUST create a new variable called explicit-<filenameofshell>-args where

(setq explicit-shell-file-name "/bin/tcsh") (setq shell-file-name "tcsh")
(setenv "SHELL" tcsh) (add-hook 'comint-output-filter-functions
'comint-strip-ctrl-m)

Rather than opening up a shell, you can simple run a single command and then capture the output in an emacs buffer. This is quite useful. M-x shell-command is usually keymapped to M-! The emacs buffer is named *Shell Command Output* and gets overwritten every time a new command is run.

stdout and stderror both get sent to the same *Shell Command Output* buffer. You can alter this to send stderror to a different buffer with a name of your choosing, by setting shell-command-default-error-buffer to some buffer name.

you can run the command in the background, just as you would using a shell, by appending & to the command, thus putting it to the background.

You can send a region of text to the shell command as stdin. The command is M-x shell-command-on-region which is typically mapped to the key M-| As usual the output (stdout) is overwrites the buffer *Shell Command Output* You can change this to replace the region with C-u . So for example C-u M-! ls -l puts a listing in the current buffer

• C-u M-! ls -l
• C-u M-! date
• C-u M-! curl ifconfig.me; echo " "

You might think sort would be a common use case, but emacs has its own sort command, so use that. UTF-8 encoding works nicely, but if you get garbled output read up on unicode and other coding systems in emacs.

in hard wrap, text is not split up in words as the line wraps. the wrap occurs on what ever character in the word got you to the end of the line.

in soft-wrap, words are preserved and carried over to the new line.

• m-x visual-line-mode turns on soft-wrap
• m-x auto-file-mode turns on hard-wrap

to change the font. i have liked andale mono 18 personally. (text)

You can see what themes you have available with M-x load-theme Then, if you want to create a new one, OR, edit an existing one, follow the instructions from gnu.org It worked for me.

The workflow is as follows, M-x customize-create-theme then pick the theme you want to customize, then pick the individual text type that you want to change, pick a colour, or bold, or other characteristic, to change. Once happy, save it to the same name you opened (if editing) or save to a new name (if creating a new theme). Then close C-x k this buffer, and load the new theme with M-x load-theme or M-x counsel-load-theme

After installing, emacs did NOT open in a new window, but in the terminal. To change this do the following:

Do NOT install the regular, plain Jane emacs using brew install emacs

Because what you will get is emacs built without GUI support.

So, I then did:

• brew uninstall emacs
• brew install --cask emacs (brew cask install emacs has been deprecated)

So, as of <2020-12-27 Sun> I have emacs version 27.1 running on my mac.

====== brew pin imagemagick@6 emacs

The init file contains one or more Lisp expressions. Each of these consists of a function name followed by arguments, all surrounded by parentheses. For example, (setq fill-column 80) calls the function setq to set the variable fill-column (see Filling) to 80.

www.gnu.org has documentation on init.el syntax. Read it.

The init file contains one or more Lisp expressions. Each of these consists of a function name followed by arguments, all surrounded by parentheses. For example, (setq fill-column 60) calls the function setq to set the variable fill-column (see Filling) to 60.

You may have to use setq-default and not just setq in the init.el file Confirm this please. <2022-03-03 Thu>

In init.el, if you want to set the variable x to 100, it would be (setq x 100) Or in an interactive emacs buffer, M-x set-variable v value That seems to contradict anther way which is M-: (setq v "value") remembering that M-: is bound to the commnd M-x eval-expression

Yet another way I have seen is: (set (make-local-variable 'foo) "value") But again, it was NOT documented if that should be M-: first or not. I assume yes.

I like to set the alt key as the emacs meta key, so I would use: (setq mac-command-key-is-meta yes)

I think you can do this in an init.el file, or in any buffer with the command: (setq-default fill-column 80) but you would use M-x eval-expression followed by (setq-default fill-column 80) followed by hammer. eval-expression has a default key-binding of M-: so it must be used quite often.

This is not exhaustive, just an introduction. It is ok to delete the Init.el file and start over. (maybe copy it to a safe place, and selective add back compoenents you want.)

If you are having errors with the init file, you can start emacs without any init file by using -Q

emacs -Q

To debug init.el, run emacs like this: emacs --debug-init

To reload an init file after already in emacs : M-x load-file or

M-x eval-buffer # reads .emacs.d/init.el again. or M-x load-file If you have problems (some packages don't like being loaded twice) simply restart emacs. Also, it is not a good idea to evaluate your init file more than once, as you can have hooks set multiple times which messes you up.

So, a better approach is to C-x C-e which executes code, but specifically executes the code for the section immediately before your cursor. As long as your cursor is on the last closed ) then it will execute just that section.

M-x eval-region Also works if you have highlighted a region and want just those lines evaluated. Nice when tweaking your init.el file

=M-x set-background-color gray10 =M-x set-foreground-color green

(if (display-graphic-p) (setq initial-frame-alist '( (tool-bar-lines . 0)
(width . 106) (height . 60) (background-color . "gray10") (foreground-color
. "green") (left . 50) (top . 50)))

should have (ivy-mode 1) in the :config section of (use-package ivy)

When you make a change to a variable, it will only be for that session. If you want to have that variable made the default, use: M-x customize-save-variable command.

To open a command log, you need to have this installed, and then use: M-x clm/toggle-command-log-buffer or using C-c o That opens the command log window for me, but it does nothing. I have to issue the command M-x global-command-log-mode then my commands were logged as expected.

The key sequence C-h l for help log? works for me as of <2023-05-11 Thu> This opened up a buffer showing the last keystrokes I made. Ivy showed this as view-lossage.

In ivy mode, whenever you have a list, hitting M-o will show you extra actions that can be done an any item within a a list that have to be defined for a particular function. For example often d can be hit to see the definition for that function. h will show you the help of that function.

So, workflow would be M-x then move to a function you are about to enter, but hit M-o then d to see the definition of that function.

While in the ivy minibuffer M-o w will copy the current string under the cursor to the kill ring (buffer) Remember M-w copy any highligt to the kill ring. So M-o w does the similar thing, but from the ivy minibuffer and not the main buffer. Once in the kill-ring you can paste it "yank it" back with C-y

You can even skip a step and run M-o i to copy from the minibuffer and immediately paste in the main buffer in one step.

toggle with M-x ivy-rich-mode Makes any ivy list show more helpful information

when the ivy window is open, hitting M-j will take the word that is currently under the cursor in the main window, and insert it into the ivy minibuffer. quite useful.

While in an ivy minibuffer showing a list of options, C-c C-o will produce a buffer from the items in the list. This buffer will be in the major mode, "ivy-occur".

Good for taking notes for yourself on what commands are you favourites, or read the docuementation on each of the modes.

Counsel in general counsels you on what commands are at your finger-tips. M-x counsel-M-x counsels you on what M-x modes are availalbe? Especially works will with ivy-rich mode.

This is known as the "Ivy version of 'execute-extended-command'.

With ivy installed, C-x C-b will list open buffers, but if you rather us M-x counsel-switch-buffer you can see each of the buffers as you arrow up and down (C-n and C-p) which is nicer. You may even want to remap your key binding for C-x C-b i.e. ("C-M-j" 'counsel-switch-buffer) Notice the single ' which is LISPs way of saying this isn't a string, but an object named counsel-switch-buffer

The bottom information line gives you details on what you have active at the current moment.

this really deservers a whole section by itself. Hence this section.

In directory ~/.emacs.d/settings

Not sure which takes precendence: See the section

Can be accomplished in several ways:

• M-x run-python
• C-c C-p which is M-x update this as currently is is M-x py-backward-statements
• C-c | executes the region marked
• C-c C-c executes the entire buffer (M-x py-execute-buffer)
• Don;t forget "describe mode" or C-c ? to see more python options or C-h m

By default it seems that my version selected is 2.7. To change this to version 3, do the following:

1. edit python.el in the directory:

I often get the default, python2.7, version when I run C-c C-c because I forget to set the python virtual environment. Remember this workflow!!!:

• M-x pyvenv-activate # NOT venv-activate Such a thing does not exist
• M-x pyvenv-activate
• M-x pyvenv-activate
• C-c C-c
• C-c C-c
• C-c C-c

I like that have this displayed in a buffer on the left when scripting in python: M-x lsp-treemacs-symbols

• M-x lsp-treemacs-symbols
• M-x lsp-treemacs-symbols
• M-x lsp-treemacs-symbols
• M-x lsp-treemacs-symbols

lsp is "Language Servet Protocol". The language server protocol was proposed by Microsoft as a way for different editors and development environments to share language analysis backends. These backends are called language servers Several options exist, including:

1. palantir
2. python-language-server

Either way, pip installs them as pyls, so a pip freeze | grep pyls will tell you what you have installed

Running emacs lsp-mode requires that you have a language server running. The most common language server to run is installed with pip install python-language-server, but a faster, more consise language server is palantir, but this section describes python-language-server

After installing it, if you run pyls and your terminal just sits on a new line then it appears that you have it installed properly. (just C-c to kill it)

The emacs lsp-mode and the palantir python-language-server works well to give you improved code intelligence when working on Python projects.

Activated for me with the sequence C-M l Brings advanced code editing features into emacs. Similar to Visual Studio or other IDEs. Available from https://emacs-lsp.github.io/lsp-mode/

It brings to life the idea of a separate language processing server to analyze and run AI for your coding. This language server protocol, or lsp is what lsp mode brings. Check out https://langserver.org/ for details on lsp itself.

From the lsp-mode link above, "Client for Language Server Protocol (v3.14). lsp-mode aims to provide IDE-like experience by providing optional integration with the most popular Emacs packages like company, flycheck and projectile."

For more info on what LSP is, check this blog, from which the above picture came: eclipe-foundation

Check out your lisp-mode.el file.

Apparently python-mode.el is depracated with emacs 24.1 and later Now emacs has a built-in python.el, so nothing to install here. But, you stillcall the mode python_mode within emacs, but you don't have to install python-mode from ELPY

You can let the language server rules automatically apply to a whole file at once.

M-x lsp-format-buffer and voila! according to the flycheck linter rules. So it immediately fixes all the complaints that the linter will have.

First you have to install it python3 -m pip --user install --user pytest ( You might need to install the dependencies that may be listed in a requirements.txt. If so, run ~python3 -m pip install --user -r requirements.txt Then you can from the command line, run pytest.

Within emacs, you can use projectile called M-x projectile-test-project It will be asking your for what tests you want to run, at the bottom with the prompt Test command: By default it will be pre-populated with the string: python -m unittest discover This needed some settings done as shown below.

Or, you can be more simple change the Test command to pytest and run that, which is a more modern and flexible option to the usual unittest.

But you will need to set these:

• set a directory-local variable for projectile-project-test-cmd with add-dir-local-variable
• set compilation-read-command to nil to skip asking every time you want to run the test (might be unsafe)
• g r inside the unit test buffer to rerun the tests or call recompile interactively.

The same link above is good for installation, for each language of interest.

For python, you will need to install latest version of ptvsd:

• python3 -m pip install ptvsd~ # makes sure version >= 4.2
• (require 'dap-python) in init.el, which adds the python specific config to dap-debug

After installing ptvsd, a template named "Python :: Run Configuration" will appear, which will execute the currently visited module. This will fall short whenever you need to specify arguments, environment variables or execute a setuptools based script.

In such case, define a template:

(dap-register-debug-template "My App" (list :type "python" :args "-i"5 :cwd
  nil :env '(("DEBUG" . "1")) :target-module (expand-file-name
  "~/src/myapp/.env/bin/myapp") :request "launch" :name "My App"))

After launching the dap debugger, try:

• dap-debug Select a template to execute
• dap-debug-list Run the most recent template
• dap-debug-recent Select a recent template to run
• dap-disconnect Disconnect from the debugging session (output buffer retained)
• ap-delete-session Delete current session (output buffer is deleted)
• dap-delete-all-sessions Clean up all debugging sessions.

(set elply-rpc-python-command "python3") or create a python3 virtual wrapper from terminal: mkvirtualenv test -p /user/bin/python3 # note: I use a different virtual environment: see the .org file on virtual env that I have b een maintaining (personal)

Then in emacs, activate the virtual environment using M-x pyenv-workon blah followed by M-x elpy-config

M-: (run-python "python3") or

• C-c C-p to run pyhon.

Can be accomplished in several ways:

• M-x run-python
• C-c C-p which is M-x update this
• C-c | executes the region marked
• C-c C-c executes the entire buffer
• Don;t forget "describe mode" or C-c ? to see more python options

• M-x highlight-indentation-mode is a toggle.
• C-c C-c evaluates the current python script (or region if something is selected) in an interactive python shell
• C-hammer evalutes the current statement (current line plus the following nested lines)
• C-c C-z toggle between script and interactive shell
• C-c C-d diplays document for the item under the cursor. Documentation will pop up in a separate windwo.s - press q to close

;; Fixing a key binding bug in elpy (define-key yas-minor-mode-map (kbd "C-c k") 'yas-expand) ;; Fixing another key binding bug in iedit mode (define-key global-map (kbd "C-c o" 'iedit-mode) ;; the k and o options can be changed to somehthing else if wanted. personal ;; preference. I actually found that my iedit-mode key was set as C-; with ;; the hide lines toggle C-' I checked before trying and they were as yet ;; undefined, so might as well use them - zp April2019

but how do I exit iedit-mode when I am done? Pay attention to the minibuffer and you will be told that it is C-; or M-x iedit-mode again. i.e. a toggle.

Note: there seems to be minor modes that, when active, re-map C-; to be comment text . When that happens, I have found that I must first activate iedit mode manually, using M-x iedit-mode after which the mapping is back to C-;.

See also how to restrict iedit to a region iedit limited to region basically by narrowing your buffer or by running iedit twice.

In a python program, but your cursor on a character and pres

C-u C-x =

That will tell you what the face under the cursor is.

In another emacs window,

M-x list-faces-display

Click on the face you want to change then:

• Select it
• Apply (or Apply and Save) if you know you will like the colour
• C-x k to kill this buffer (i.e. close it)
• C-x 1 to revert back to one window
• C-x b (to switch to the other buffer)
• C-x C-b to list buffers if you have more of them open

In the past it has been set as a boolean variable and not with YES/NO

defaults write com.apple.terminal FocusFollowsMouse -bool true defaults write com.apple.terminal FocusFollowsMouse -bool false

To match a special character in Unix, use C-x 8 i.e. type Ctrl+X 8 Enter and then the number, followed by Enter. (Ctrl+X 8 Enter can be followed by Unicode name as well).

The following commands have the same effect as checking the "Ignore built-in trackpad when mouse or wireless trackpad is present" option in the Accessibility panel of System Preferences:

$ defaults write com.apple.AppleMultitouchTrackpad USBMouseStopsTrackpad 1 $ defaults write com.apple.driver.AppleBluetoothMultitouch.trackpad USBMouseStopsTrackpad 1 To re-enable the trackpad:

$ defaults write com.apple.AppleMultitouchTrackpad USBMouseStopsTrackpad 0 $ defaults write com.apple.driver.AppleBluetoothMultitouch.trackpad USBMouseStopsTrackpad 0 shareimprove this answer

http://kitchingroup.cheme.cmu.edu/blog/2014/08/31/Using-Mac-gestures-in-Emacs/ (defvar my-previous-buffer t "can we switch?")

(defun my-previous-buffer () (interactive) (message "custom prev: my-previous-buffer*=%s" *my-previous-buffer) (when my-previous-buffer (previous-buffer) (setq my-previous-buffer nil) (run-at-time "1 sec" nil (lambda () (setq my-previous-buffer t)))))

(defvar my-next-buffer t "can we switch?")

(defun my-next-buffer () (interactive) (message "custom prev: my-next-buffer*=%s" *my-next-buffer) (when my-next-buffer (next-buffer) (setq my-next-buffer nil) (run-at-time "1 sec" nil (lambda () (setq my-next-buffer t)))))

(global-set-key [triple-wheel-right] 'my-previous-buffer) (global-set-key [triple-wheel-left] 'my-next-buffer)

(require 'package) (add-to-list 'package-archives ')"melpa ….

My favourite book ¹

Tetris: M-x tetris

Pong M-x pong

Psychotherapist: M-x doctor

Snake M-x snake

solitaire (not what you think) M-x solitair

M-x gomoku M-x 5x5 M-x dunnet (text based adventure game) M-x landmark

M-x bubbles (remove as many bubbles using least amount of moves)

M-x hanoi (towers of hanoi)

M-x life (runs Cponway's Game of Life cellular automation)

M-x morse-region (convert text in region to morse and back) M-x unmorse-region

M-x nato-region and M-x denato-region Mike-Dash-Xray Delta-Echo-November-Alfa-Tango-Oscar-Dash-Romeo-Echo-Golf-India-Oscar-November

M-x zone plays games with the display when emacs is idle

Useful to see to what to set your init.el default colours. You can use this to pick the colour you want to change, and then change it too.

Converting CRLF to just LF, and back, i.e. Windows to Unix and back:

A built-in package to emacs is prettify that lets you define symbols to be displayed in an emacs buffer in place of a specific string. For example, you can have emacs display a down arrow whenever it encounters the string #+BEGIN_EXAMPLE

While setq-default could be used to set a default value, what you should do is use the appropriate major mode hooks to setq the value to a sensible value for each of the modes you are interested in.

This applies to any function defined in init.el i.e. you can run any function by evaluating the list expression: M-x eval-expression (M-:) followed by (python-icons)

To set a variable defined with defcustom you can also use M-x set-variable. You will not have to type the parentheses and you will have name completion.