(defun smart-period-or-smart-space ()
"double space adds a period!"
(interactive)
(if
(looking-back "[A-Za-z0-9] ")
(smart-period)
(smart-space)
))
(defun smart-space ()
"Insert space and then clean up whitespace."
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
;; (if (org-at-heading-p)
;; (insert-normal-space-in-org-heading)
(unless
(or
(let ((case-fold-search nil)
(looking-back "\\bi\.e[[:punct:][:punct:]]*[ ]*") ; don't add extra spaces to ie.
)
(looking-back "\\bvs.[ ]*") ; don't add extra spaces to vs.
(looking-back "\\be\.\g[[:punct:]]*[ ]*") ; don't add extra spaces to eg.
(looking-back "^[[:punct:]]*[ ]*") ; don't expand previous lines - brilliant!
(looking-back ">") ; don't expand days of the week inside timestamps
(looking-back "][\n\t ]*") ; don't expand past closing square brackets ]
))
(smart-expand))
(insert "\ ")
(just-one-space)
)
;; this is probably convuluted logic to invert the behavior of the SPC key when in org-heading
(defun insert-smart-space-in-org-heading ()
"Insert space and then clean up whitespace."
(interactive)
(unless
(or
(looking-back "\\bvs.[ ]*") ; don't add extra spaces to vs.
(looking-back "\\bi\.e[[:punct:][:punct:]]*[ ]*") ; don't add extra spaces to ie.
(looking-back "\\be\.\g[[:punct:][:punct:]]*[ ]*") ; don't add extra spaces to eg.
(looking-back "^[[:punct:][:punct:]]*[ ]*") ; don't expand previous lines---brilliant!
(looking-back ">") ; don't expand days of the week inside timestamps
(looking-back "][\n\t ]*") ; don't expand past closing square brackets ]
)
(smart-expand))
(insert "\ ")
(just-one-space))
(define-key org-mode-map (kbd "<SPC>") 'smart-space)
;; (define-key orgalist-mode-map (kbd "<SPC>") 'smart-period-or-smart-space)
(global-set-key (kbd "M-SPC") 'insert-space)
(define-key org-mode-map (kbd "<M-SPC>") 'insert-space)
;; (define-key orgalist-mode-map (kbd "<M-SPC>") 'insert-space)(defun my/fix-space ()
"Delete all spaces and tabs around point, leaving one space except at the beginning of a line and before a punctuation mark."
(interactive)
(just-one-space)
(when (and (or
(looking-back "^[[:space:]]+")
(looking-back "-[[:space:]]+")
(looking-at "[.,:;!?»)-]")
(looking-back"( ")
(looking-at " )")
)
(not (looking-back "^-[[:space:]]+"))
(not (looking-back " - "))
)
(delete-horizontal-space))). This.
(defun insert-space ()
(interactive)
(if (org-at-heading-p)
(insert-smart-space-in-org-heading)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(insert " ")
))
(defun insert-normal-space-in-org-heading ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(insert " ")
)
;; this is probably convuluted logic to invert the behavior of the SPC key when in org-heading
(defun insert-period ()
"Inserts a fuckin' period!"
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(insert ".")
)
(defun insert-comma ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(insert ",")
)
(defun insert-exclamation-point ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(insert "!")
)
(defun insert-colon ()
"Insert a goodamn colon!"
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(insert ":")
)
(defun insert-question-mark ()
"Insert a freaking question mark!!"
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(insert "?")
)
Kill-clause kills (cuts) a clause in the text and makes various fixes to punctuation and spacing.
(smart-expand): call expand-abbrev on any unexpanded words.- Check if the cursor is at a comma, semicolon, or colon and moves one character to the right if so.
- The function determines whether to kill the entire line or just a portion of it, based on specific conditions.
- The function makes several fixes to punctuation and spacing, such as:
- Removing extra spaces before punctuation marks
- Deleting incorrect combinations of punctuation marks and spaces
- Capitalizing the first letter of a sentence unless it’s an Org mode heading
- The function ensures the cursor is left at an appropriate position, either before or after punctuation, depending on the context.
(defun kill-clause ()
(interactive)
(smart-expand)
(when (or (looking-at ",")
(looking-at ";")
(looking-at ":"))
(org-delete-char 1))
(when (or (looking-back ",")
(looking-back ";")
(looking-back ":"))
(org-delete-backward-char 1))
(when (looking-back " ")
(left-char 1))
(if
(let ((sm (string-match "*+\s" (thing-at-point 'line)))) (and sm (= sm 0)))
(kill-line)
(let ((old-point (point))
(kill-punct (my/beginning-of-sentence-p)))
;; Stop at a period followed by a space, or the end of the line
(when (re-search-forward "--\\|[][,;:?!…\"”()}\\.]+\\|$" nil t)
(kill-region old-point
(if kill-punct
(match-end 0)
(match-beginning 0)))))
(my/fix-space)
(save-excursion
(when (my/beginning-of-sentence-p)
(capitalize-unless-org-heading)))
(cond
((looking-back "\\, \\, ")
(new-org-delete-backward-char 2)
(my/fix-space)
t)
((looking-back "!\\. ")
(new-org-delete-backward-char 2)
(my/fix-space)
t)
((looking-back ":: ")
(new-org-delete-backward-char 2)
(my/fix-space)
t))
(when
(looking-back "[[:punct:]]")
(progn
(forward-char 1)
(my/fix-space)
(backward-char 1)))
;; fix a bug that leaves this: " ?"
(when (looking-back " \\?")
(left-char 1)
(new-org-delete-backward-char 1)
(right-char 1))
;; fix a bug that leaves this: " , "
(when (looking-back " , ")
(left-char 2)
(my/fix-space)
(right-char 2))
;; fix a bug that leaves this: ":, "
(when (looking-back ":, ")
(left-char 1)
(delete-backward-char 1)
(right-char 1))
;; fix a bug that leaves this: ",."
(when (looking-back "\\,\\. ")
(left-char 2)
(delete-backward-char 1)
(right-char 2)
)
;; fix a bug that leaves this: ", . "
(when (looking-back "\\, \\. ")
(left-char 2)
(delete-backward-char 2)
(right-char 2)
)
;; fix a bug that leaves this: " ; "
(when
(looking-back " [[:punct:]] ")
(left-char 2)
(delete-backward-char 1)
(right-char 2)
)
(when
(and
(looking-back "----")
(looking-at "-"))
(delete-backward-char 4)
(delete-char 1)
(insert-space))
;; leave the cursor before the comma or period, not after it
(when
(looking-back "[[:punct:]] ")
(left-char 2))
(when
(looking-back "[[:punct:]]")
(left-char 1))
;; fix a bug that leaves this: ".,"
(when
(looking-at "\\.\\,")
(delete-forward-char 1)
)
;; works!!
;; fix a bug that leaves this: ":."
(when
(looking-at ":\\.")
(delete-forward-char 1)
)
;; works!!
;; a more general solution, haven't tested it yet:
;; (when
;; (looking-at "[[:punct:]]\\.")
;; (delete-forward-char 1) )
;; when on a punctuation mark with a space before it, delete the space
(when
(and
(looking-at "[[:punct:]]")
(looking-back " ")
)
(delete-backward-char 1))
)
(when
(or
(looking-at ":\\,")
(looking-at ";\\,")
(looking-at "\\,\\,")
(looking-at "\\.\\.")
(looking-at "\\,;")
(looking-at "\\,:")
(looking-at "\\?\\?")
)
(right-char 1)
(delete-char 1)
(left-char 1)
)
;; Add this near the end of the function, before the final right parenthesis
(when (looking-at ",")
(when (looking-back ", ")
(delete-backward-char 2)
(insert ", "))))
(defun kill-clause ()
"Kill a clause intelligently, fixing surrounding punctuation and spacing."
(interactive)
;; Expand abbreviations if appropriate
(when (smart-space-should-expand-p)
(smart-expand))
;; Remove trailing punctuation if present
(when (looking-at "[,;:]")
(delete-char 1))
(when (looking-back "[,;:]" (line-beginning-position))
(delete-char -1))
;; Adjust point position before killing
(when (looking-back " " (line-beginning-position))
(backward-char))
;; Determine region to kill
(let ((start (point))
(end (or (save-excursion
(re-search-forward "[.?!]\\s-+" nil t))
(line-end-position))))
(kill-region start end))
;; Clean up spaces and punctuation
(my/fix-space)
(when (looking-back "\\s-+" (line-beginning-position))
(delete-horizontal-space))
;; Capitalize next sentence if appropriate
(save-excursion
(when (looking-at "\\s-*\\w")
(capitalize-word 1)))
;; Additional punctuation cleanup
(clean-up-punctuation))
(defun clean-up-punctuation ()
"Clean up redundant or incorrect punctuation around point."
(interactive)
;; General cleanup for repeated punctuation
(let ((general-pattern "\\([[:punct:]]\\)\\1+"))
(save-excursion
(when (re-search-backward general-pattern (line-beginning-position) t)
(let ((match (match-string 0)))
(unless (smart-punctuation-exception-p match)
(replace-match "\\1"))))))
;; Specific patterns cleanup
(let ((specific-patterns
'(("[.,!?]\\s+[.,!?]" . "\\2")
("\\s-+\\([.,!?]\\)" . "\\1")
("\\([.,!?]\\)\\s-*$" . "\\1")
(":\\," . ":")
(";\\," . ";")
("\\.,\\s-*" . ".")
(":\\.\\s-*" . ":")
("\\([?!]\\)\\.\\s-*" . "\\1")
("\\([?!]\\)\\,\\s-*" . "\\1"))))
(dolist (pattern specific-patterns)
(save-excursion
(when (re-search-backward (car pattern) (line-beginning-position) t)
(replace-match (cdr pattern)))))))
(defvar *smart-punctuation-marks*
".,;:!?-")
(setq *smart-punctuation-exceptions*
(list "?!" ".." "..." "............................................." "---" ";;" "!!" "!!!" "??" "???" "! :" ". :" ") ; "))
(defvar smart-punctuation-exceptions
'("?!" ".." "..." "---" ";;" "!!" "!!!" "??" "???")
"List of punctuation sequences that should not be altered by smart punctuation functions.")
;; Configuration Variables
(defvar smart-punctuation-exceptions
'("??" "!!" "..." "---" "?!" ";;" "!!!" "???" "?!?" ".." "—")
"List of punctuation sequences that should not be altered by smart punctuation functions.")
(defvar smart-space-exception-patterns
'("\\b\\(i\\.e\\|e\\.g\\|vs\\.\\)[[:punct:]]*\\s-*"
"^\\s-*"
"[]>\\]\\)"
"\\s-*[[:punct:]]*https?://"
"\\s-*[@#]")
"List of regex patterns where `smart-expand` should not be called.")
(defvar smart-expand-abbrev-tables
'(global-abbrev-table text-mode-abbrev-table org-mode-abbrev-table)
"List of abbrev tables to use with `smart-expand`.")
(defun smart-punctuation-exception-p (sequence)
"Check if SEQUENCE is in `smart-punctuation-exceptions`."
(member sequence smart-punctuation-exceptions))
(defun smart-space-should-expand-p ()
"Check whether `smart-expand` should be called based on context."
(not (cl-some (lambda (pattern)
(save-excursion
(looking-back pattern (line-beginning-position))))
smart-space-exception-patterns)))
(defun smart-punctuation (new-punct &optional not-so-smart)
(smart-expand)
(save-restriction
(when (and (eql major-mode 'org-mode)
(org-at-heading-p))
(save-excursion
(org-beginning-of-line)
(let ((heading-text (fifth (org-heading-components))))
(when heading-text
(search-forward heading-text)
(narrow-to-region (match-beginning 0) (match-end 0))))))
(cl-flet ((go-back (regexp)
(re-search-backward regexp nil t)
(ignore-errors ; might signal `end-of-buffer'
(forward-char (length (match-string 0))))))
(if not-so-smart
(let ((old-point (point)))
(go-back "[^ \t]")
(insert new-punct)
(goto-char old-point)
(forward-char (length new-punct)))
(let ((old-point (point)))
(go-back (format "[^ \t%s]\\|\\`" *smart-punctuation-marks*))
(let ((was-after-space (and (< (point) old-point)
(find ? (buffer-substring (point) old-point)))))
(re-search-forward (format "\\([ \t]*\\)\\([%s]*\\)"
*smart-punctuation-marks*)
nil t)
(let* ((old-punct (match-string 2))
(was-after-punct (>= old-point (point))))
(replace-match "" nil t nil 1)
(replace-match (or (when (and was-after-punct
(not (string= old-punct "")))
(let ((potential-new-punct (concat old-punct new-punct)))
(find-if (lambda (exception)
(search potential-new-punct exception))
*smart-punctuation-exceptions*)))
new-punct)
nil t nil 2)
(if was-after-space
(my/fix-space)
(when (looking-at "[ \t]*\\<")
(save-excursion (my/fix-space))))))))))
(when (and (eql major-mode 'org-mode)
(org-at-heading-p))
))(defun smart-period ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(unless
(or
(looking-back "\\bvs.[ ]*") ; Don't add extra periods to vs.
(looking-back "\\bi\.e[[:punct:]]*[ ]*") ; don't add extra periods to ie.
(looking-back "\\be\.\g[[:punct:]]*[ ]*") ; don't add extra periods to eg.
)
(smart-punctuation "."))
(save-excursion
(unless
(or
(looking-at "[ ]*$")
(looking-at "\][[:punct:]]*[ ]*$")
(looking-at "[[:punct:]]*[ ]*$")
(looking-at "\"[[:punct:]]*[ ]*$")
(looking-at "\)[ ]*$")
(looking-at "\)")
) ; or
(capitalize-unless-org-heading)
) ; unless
) ; save excursion
;; if two periods or two commas in a row, delete the second one
(when
(or
(and
(looking-at "\\.")
(looking-back "\\.")
)
(and
(looking-at ",")
(looking-back ",")
))
(delete-char 1)
)
)
(define-key org-mode-map (kbd ".") 'smart-period)
(defun smart-comma ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(smart-punctuation ",")
(unless
(or
(looking-at "\]*[[:punct:]]*[ ]*$")
(looking-at "[[:punct:]]*[ ]*$")
(looking-at "[ ]*I\\b") ; never downcase the word "I"
(looking-at "[ ]*I\'") ; never downcase the word "I'
(looking-at "[[:punct:]]*[ ]*\"") ; beginning of a quote
)
(save-excursion (downcase-word 1)))
(when
;; if two periods or two commas in a row, delete the second one
(or
(and
(looking-at "\\.")
(looking-back "\\.")
)
(and
(looking-at ",")
(looking-back ",")
))
(delete-char 1)
)
)
(define-key org-mode-map (kbd ",") 'comma-or-smart-comma)
;; (define-key orgalist-mode-map (kbd ",") 'comma-or-smart-comma)(defun smart-question-mark ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(smart-punctuation "?")
(save-excursion
(unless
(or
(looking-at "[ ]*$")
(looking-at "\][[:punct:]]*[ ]*$")
(looking-at "[[:punct:]]*[ ]*$")
(looking-at "\"[[:punct:]]*[ ]*$")
(looking-at "\)[ ]*$")
(looking-at "\)")
) ; or
(capitalize-unless-org-heading)
) ; unless
) ; save excursion
) ; defun
;; works!!
(define-key org-mode-map (kbd "?") 'smart-question-mark)
;; (define-key orgalist-mode-map (kbd "?") 'smart-question-mark)(defun smart-exclamation-point ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(smart-punctuation "!")
(save-excursion
(unless (looking-at "[ ]*$")
(capitalize-unless-org-heading))
))
(define-key org-mode-map (kbd "!") 'smart-exclamation-point)
;; (define-key orgalist-mode-map (kbd "!") 'smart-exclamation-point)(defun smart-hyphen () (interactive) (smart-punctuation “-“))
(define-key org-mode-map (kbd “-“) ‘smart-hyphen) ;; (define-key orgalist-mode-map (kbd “-“) ‘smart-hyphen)
(defun smart-semicolon ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(smart-punctuation ";")
(unless
(or
(looking-at "[[:punct:]]*[ ]*$")
(looking-at "[ ]*I\\b") ; never downcase the word "I"
(looking-at "[ ]*I\'") ; never downcase the word "I'
(looking-at "[[:punct:]]*[ ]*\"") ; beginning of a quote
)
(save-excursion (downcase-word 1))))
(define-key org-mode-map (kbd ";") 'smart-semicolon)
;; (define-key orgalist-mode-map (kbd ";") 'smart-semicolon)(defun smart-colon ()
(interactive)
(cond (mark-active
(progn (delete-region (mark) (point)))))
(smart-punctuation ":")
(unless
(or
(looking-at "[[:punct:]]*[ ]*$")
(looking-at "[ ]*I\\b") ; never downcase the word "I"
(looking-at "[ ]*I\'") ; never downcase the word "I'
(looking-at "[[:punct:]]*[ ]*\"") ; beginning of a quote
)
;; (save-excursion (downcase-word 1))
))
(define-key org-mode-map (kbd ":") 'colon-or-smart-colon)
(define-key org-mode-map (kbd ",") 'comma-or-smart-comma)
;; (define-key orgalist-mode-map (kbd ":") 'smart-colon)(defun comma-or-smart-comma ()
(interactive)
(if
(or
(bolp)
(org-at-heading-p)
(looking-at " \"")
)
(insert ",")
(smart-comma))
)(defun line-starts-with-hash-p ()
(save-excursion
(beginning-of-line)
(looking-at-p "#")))
(defun colon-or-smart-colon ()
(interactive)
(if (or (bolp)
(org-at-heading-p)
(line-starts-with-hash-p))
(insert ":")
(smart-colon)))Rúdi: desired behavior is that when invoking backward-kill-word-correctly to delete words backwards, Emacs should leave a space after the word to the left of the point UNLESS point is at the beginning of the line or after “—”
I tried to implement this myself, below. My hack seems to work, but it seems slow… Is it possible to make it faster or no? maybe just than a look at the below and see if you think I implemented it in the best way.
(defun backward-kill-word-correctly ()
"Kill word."
(interactive)
(if (re-search-backward "\\>\\W*[[:punct:]]+\\W*\\=" nil t)
(kill-region (match-end 0) (match-beginning 0))
(backward-kill-word 1))
(my/fix-space)
;; I added this ↓↓↓ #######################
(when (and
(not (looking-back "---")) ; I added this
(not (looking-back "^"))) ; I added this
;; I added this ↑↑↑ #######################
(smart-space)
)
(my/fix-space
))Since backward-kill-word-correctly already calls my/fix-space, isn’t a call to smart-space redundant? What was the use case you were thinking of when you originally added it? Note that if you remove the whole (when ...) block, it apparently works as you intend it to work…
Good question. The answer is that there should never be a space after “—”
Example:
Alice was tired---tired as hell. ^
Say the point is the carat, and I invoke backward-kill-word-correctly 4 times.
Output if I remove the whole (when ...) block:
Alice was tired--- ^
Note the space after “—”
Desired output:
Alice was tired---^
No space. Does that make sense? Thanks!
(defun my/delete-backward ()
"When there is an active region, delete it and then fix up the whitespace"
(interactive)
(if (use-region-p)
(delete-region (region-beginning) (region-end))
(delete-backward-char 1))
(save-excursion
(when (or (looking-at "[[:space:]]")
(looking-back "[[:space:]]"))
(unless (looking-back "\\w ")
(my/fix-space)))))(defcustom capitalize-after-deleting-single-char nil
"Determines whether capitalization should occur after deleting a single character.")
(defun my/delete-backward-and-capitalize ()
"When there is an active region, delete it and then fix up the whitespace"
(interactive)
(when (looking-back "^[*]+ ")
(kill-line 0)
(insert " ") ; this line is super hacky I put it here because when I tried to use "unless", the rest of the function, and then this at the end, it didn't work; however, this does produce the behavior I desire
)
(let ((capitalize capitalize-after-deleting-single-char))
(if (use-region-p)
(progn
(delete-region (region-beginning) (region-end))
(setf capitalize t))
(new-org-delete-backward-char 1))
(save-excursion
(when (or (looking-at "[[:space:]]")
(looking-back "[[:space:]]"))
;; unless there's already exactly one space between words, since I need to be able to delete backward past spaces
(unless (and
(looking-back "\\w ")
(looking-at "\\w")
)
(my/fix-space))))
(when (and capitalize (my/beginning-of-sentence-p))
(save-excursion
(capitalize-unless-org-heading))))
(when
(or
(and
(looking-at "\\.")
(looking-back "\\.")
)
(and
(looking-at ",")
(looking-back ",")
))
(delete-char 1)
)
)(defun backward-kill-word-correctly-and-capitalize ()
"Backward kill word correctly. Then check to see if the point is at the beginning of the sentence. If yes, then kill-word-correctly and endless/capitalize to capitalize the first letter of the word that becomes the first word in the sentence. Otherwise simply kill-word-correctly."
(interactive)
(call-interactively 'backward-kill-word-correctly)
(let ((fix-capitalization (my/beginning-of-sentence-p)))
(when fix-capitalization
(save-excursion (capitalize-unless-org-heading)))))(defadvice capitalize-word (after capitalize-word-advice activate)
"After capitalizing the new first word in a sentence, downcase the next word which is no longer starting the sentence."
(unless
(or
(looking-at "[ ]*\"") ; if looking at a quote? Might not work
(looking-at "[[:punct:]]*[ ]*I\\b") ; never downcase the word "I"
(looking-at "[[:punct:]]*[ ]*I'") ; never downcase words like I'm, I'd
(looking-at "[[:punct:]]*[ ]*\"*I'") ; never downcase words like I'm, I'd
(looking-at "[ ]*I\'") ; never downcase the word "I'
(looking-at "[[:punct:]]*[ ]*\"I\\b") ; never downcase the word "I"
(looking-at "[[:punct:]]*[ ]*OK\\b") ; never downcase the word "OK"
;; (looking-at "\\") ; how do you search for a literal backslash?
(looking-at (sentence-end))
(looking-at "[[:punct:]]*[ ]*$") ; don't downcase past line break
(looking-at "[[:punct:]]*[ ]*\"$") ; don't downcase past quotation then line break
(looking-at "[[:punct:]]*[ ]*)$") ; don't downcase past a right paren then line break
(looking-at "[[:punct:]]*[ ]*\")$") ; don't downcase past a quotation then a right paren then a line break
(looking-at "[[:punct:]]*[ ]*http") ; never capitalize http
(looking-at "\"[[:punct:]]*[ ]*$") ; a quotation mark followed by "zero or more whitespace then end of line?"
(looking-at "\)[ ]*$") ; a right paren followed by "zero or more" whitespace, then end of line
(looking-at ")[ ]*$") ; a right paren followed by "zero or more" whitespace, then end of line
(looking-at ")$") ; a right paren followed by "zero or more" whitespace, then end of line
(looking-at "[ ]*-*[ ]*$") ; dashes at the end of a line
(looking-at (user-full-name))
)
(save-excursion
(downcase-word 1))))I tried to add exceptions for “line-end” and also for user-full name.
(defun capitalize-unless-org-heading ()
(interactive)
(when capitalist-mode
(unless
(or
(looking-at "[[:punct:]]*[\n\t ]*\\*")
(let ((case-fold-search nil))
(looking-at "[ ]*[\n\t ]*[[:punct:]]*[\n\t ]*[A-Z]")
(looking-at "[A-Z].*"))
(looking-at "[\n\t ]*[[:punct:]]*[\n\t ]*#\\+")
(looking-at "[\n\t ]*[[:punct:]]*[\n\t ]*\(")
(looking-at "[\n\t ]*[[:punct:]]*[\n\t ]*<")
(looking-at "[\n\t ]*[[:punct:]]*[\n\t ]*file:")
(looking-at "[\n\t ]*\\[fn")
(looking-at "[\n\t ]*)$")
(looking-at "[\n\t ]*\"$")
(looking-at "\"[\n\t ]*$")
(looking-at "[[:punct:]]*[ ]*http")
(looking-at "[[:punct:]]*[ ]*\")$"); don't capitalize past
(looking-at "[ ]*I\'")
(looking-at
(concat
"\\("
(reduce (lambda (a b) (concat a "\\|" b))
auto-capitalize-words)
"\\)")))
(capitalize-word 1))))(defun downcase-save-excursion ()
(interactive)
(unless
(or
(looking-at "[[:punct:]]*[ ]*$")
(looking-at "[ ]*I\\b") ; never downcase the word "I"
(looking-at "[[:punct:]]*[ ]*[[:punct:]]*I'") ; never downcase I'm I've etc.
(looking-at "[[:punct:]]*[ ]*$") ; zero or more whitespaces followed by zero or more punctuation followed by zero or more whitespaces followed by a line break
(looking-at "\"[[:punct:]]*[ ]*$") ; a quotation mark followed by "zero or more whitespace then end of line?"
(looking-at "\)[ ]*$") ; a quotation mark followed by "zero or more whitespace then end of line?"
(looking-at (sentence-end)) ; quotation mark followed by "zero or more whitespace then end of line?"
(looking-at (user-full-name))
)
(save-excursion
(downcase-word 1))
))Don’t expand past certain delimiters, e.g. line break, ), and ”
(defun smart-expand ()
(interactive)
(unless
(or
(looking-back "\)\n*")
(looking-back "[[:punct:]]*\)[ ]*[[:punct:]]*[\n\t ]*[[:punct:]]*>*")
(looking-back ":t[ ]*")
(looking-back "][\n\t ]*[[:punct:]]*[\n\t ]*") ; don't expand past closing square brackets ]
(looking-back ">[\n\t ]*[[:punct:]]*[\n\t ]*") ; don't expand past closing email addresses]
;; (looking-back "\\\w") ; for some reason this matches all words, not just ones that start with a backslash
)
(expand-abbrev)
)
)