2 files changed, 45 insertions, 83 deletions

@@ -243,74 +243,13 @@ the deletion might narrow the column."
       (org-table-copy-down n)
     (acdw-org/return-dwim n)))
 
-(defun acdw-org/count-words (start end)
-  "Count words between START and END, respecting `org-mode' conventions."
-  (interactive (list nil nil))
-  (require 'cl-lib)
-  (require 'ox)
-  (message "Counting words...")
-  (cond ((not (called-interactively-p 'any))
-         (let ((words 0))
-           (save-excursion
-             (save-restriction
-               (narrow-to-region start end)
-               (goto-char (point-min))
-               (while (< (point) (point-max))
-                 (cond
-                  ;; Ignore comments
-                  ((or (org-at-comment-p)
-                       (org-in-commented-heading-p)) nil)
-                  ;; Ignore tables
-                  ((org-at-table-p) nil)
-                  ;; Ignore hyperlinks, but count the descriptions
-                  ((looking-at org-bracket-link-analytic-regexp)
-                   (when-let ((desc (match-string-no-properties 5)))
-                     (save-match-data
-                       (setq words (+ words
-                                      (length (remove ""
-                                                      (org-split-string
-                                                       desc "\\W")))))))
-                   (goto-char (match-end 0)))
-                  ;; Ignore source code blocks
-                  ((org-in-src-block-p) nil)
-                  ;; Ignore footnotes
-                  ((or (org-footnote-at-definition-p)
-                       (org-footnote-at-reference-p))
-                   nil)
-                  ;; else... check the context
-                  (t (let ((contexts (org-context)))
-                       (cond
-                        ;; Ignore tags, TODO keywords, etc.
-                        ((or (assoc :todo-keyword contexts)
-                             (assoc :priority contexts)
-                             (assoc :keyword contexts)
-                             (assoc :checkbox contexts))
-                         nil)
-                        ;; Ignore sections tagged :no-export
-                        ((assoc :tags contexts)
-                         (if (cl-intersection (org-get-tags-at)
-                                              org-export-exclude-tags
-                                              :test 'equal)
-                             (org-forward-same-level 1)
-                           nil))
-                        ;; else... count the word
-                        (t (setq words (1+ words)))))))
-                 (re-search-forward "\\w+\\W*")))
-             words)))
-        ((use-region-p)
-         (message "%d words in region"
-                  (acdw-org/count-words (region-beginning) (region-end))))
-        (t
-         (message "%d words in buffer"
-                  (acdw-org/count-words (point-min) (point-max))))))
-
 ;; This isn't the best code, but it'll do.
 (defun acdw-org/count-words-stupidly (start end &optional limit)
   "Count words between START and END, ignoring a lot.
 
 Since this function is, for some reason, pricy, the optional
 parameter LIMIT sets a word limit at which to stop counting.
-Once the function hits that number, it'll return \"-LIMIT\"
+Once the function hits that number, it'll return -LIMIT
 instead of the true count."
   (interactive (list nil nil))
   (cond ((not (called-interactively-p 'any))
@@ -334,13 +273,35 @@ instead of the true count."
                   ((or (looking-at org-drawer-regexp)
                        (looking-at org-clock-drawer-re))
                    (search-forward ":END:" nil :noerror))
+                  ;; Ignore tables
+                  ((org-at-table-p) (forward-line))
+                  ;; Ignore hyperlinks, but count the descriptions
+                  ((looking-at org-bracket-link-analytic-regexp)
+                   (when-let ((desc (match-string-no-properties 5)))
+                     (save-match-data
+                       (setq words (+ words
+                                      (length (remove ""
+                                                      (org-split-string
+                                                       desc "\\W")))))))
+                   (goto-char (match-end 0)))
+                  ;; Ignore source blocks
+                  ((org-in-src-block-p) (foreward-line))
                   ;; Count everything else
-                  (t (setq words (1+ words))
-                     (if (and limit
-                              (> words limit))
-                         (setq words limit
-                               continue nil))
-                     (forward-word-strictly))))))
+                  (t
+                   ;; ... unless it's in a few weird contexts
+                   (let ((contexts (org-context)))
+                     (cond ((or (assoc :todo-keyword contexts)
+                                (assoc :priority contexts)
+                                (assoc :keyword contexts)
+                                (assoc :checkbox contexts))
+                            (forward-word-strictly))
+                           
+                           (t (setq words (1+ words))
+                              (if (and limit
+                                       (> words limit))
+                                  (setq words (- limit)
+                                        continue nil))
+                              (forward-word-strictly)))))))))
            words))
         ((use-region-p)
          (message "%d words in region"
@@ -87,21 +87,6 @@ ARG).  When called with multiple arguments or a list, it returns
       (save-restriction
         (unfill-region (point-min) (point-max))))))
 
-(defun kill-ring-save-unfilled (start end &optional region)
-  "Unfill, kill, then re-fill the region defined by START and END positions.
-REGION is passed straight to `kill-ring-save'."
-  (interactive "*r")
-  (let ((sentence-end-double-space nil))
-    (unfill-region start end)
-    (kill-ring-save
-     ;; A quick hack to try and ameliorate the "Args out of range" error when
-     ;; `unfill-region' removes some newlines.  I'm not sure if this will work
-     ;; if calling from Lisp or other such nonsense.
-     (max start (point-min))
-     (min end (point-max))
-     region))
-  (fill-region start end))
-
 (defmacro when-unfocused (name &rest forms)
   "Define a function NAME, executing FORMS, that fires when Emacs
 is unfocused."
@@ -123,6 +108,22 @@ is unfocused."
               ,@body)
      (message "%s... Done." ,message)))
 
+(defmacro with-eval-after-loads (files &rest body)
+  "Execute BODY after FILES are loaded.
+This macro simplifies `with-eval-after-load' for multiple nested
+features."
+  (declare (indent 1) (debug (form def-body)))
+  (waterfall-list 'with-eval-after-load files body))
+
+(defun waterfall-list (car list rest)
+  "Cons CAR with each element in LIST in a waterfall fashion, end with REST.
+For use with the `with-eval-after-loads' function."
+  (cond ((atom list) `(,car ',list ,@rest))
+        ((= 1 (length list)) `(,car ',(car list) ,@rest))
+        (t
+         `(,car ',(car list)
+                ,(waterfall-list car (cdr list) rest)))))
+
 
 ;;; Comment-or-uncomment-sexp
 ;; from https://endlessparentheses.com/a-comment-or-uncomment-sexp-command.html