ledger-accounts-in-buffer: decide explicitly whether to include postings

The fact that ledger-accounts-in-buffer, even when called from Lisp, depends on
a user customization related to flymake, is kind of an ugly hack.  Here, we move
it to the completion function instead, which at least has a better excuse for
its behavior to depend on customizations.

Author: bcc32

ledger-complete.el

@@ -100,7 +100,7 @@ If nil, full account names are offered for completion."
     ;; to the list
     (sort (delete-dups payees-list) #'string-lessp)))
 
-(defun ledger-accounts-in-buffer ()
+(defun ledger-accounts-in-buffer (&optional include-postings)
   "Return an alist of accounts in the current buffer.
 The `car' of each element is the account name and the `cdr' is an
 alist where the key is a subdirective such as \"assert\" and the
@@ -114,7 +114,11 @@ account Assets:Checking
 Then one of the elements this function returns will be
 \(\"Assets:Checking\"
   (\"default\")
-  (\"assert\" . \"commodity == \"$\"\"))"
+  (\"assert\" . \"commodity == \"$\"\"))
+
+If INCLUDE-POSTINGS is non-nil, this alist will also include
+accounts seen in postings that aren't explicitly declared with
+\"account\" directives."
   (save-excursion
     (goto-char (point-min))
     (let (account-list
@@ -139,14 +143,8 @@ Then one of the elements this function returns will be
                 (push (cons d nil) data))))
           (push (cons account data) account-list)
           (puthash account t seen)))
-      ;; Next, gather all accounts declared in postings
-      (unless
-          ;; FIXME: People who have set `ledger-flymake-be-pedantic' to non-nil
-          ;; probably don't want accounts from postings, just those declared
-          ;; with directives.  But the name is a little misleading.  Should we
-          ;; make a ledger-mode-be-pedantic and use that instead?
-          (or (bound-and-true-p ledger-flymake-be-pedantic)
-              (bound-and-true-p flycheck-ledger-pedantic))
+      ;; Next, gather all accounts declared in postings, if requested
+      (when include-postings
         (goto-char (point-min))
         (while (re-search-forward ledger-account-name-or-directive-regex nil t)
           (let ((account (match-string-no-properties 1)))
@@ -155,16 +153,18 @@ Then one of the elements this function returns will be
               (push (cons account nil) account-list)))))
       (sort account-list (lambda (a b) (string-lessp (car a) (car b)))))))
 
-(defun ledger-accounts-list-in-buffer ()
+(defun ledger-accounts-list-in-buffer (&optional include-postings)
   "Return a list of all known account names in the current buffer as strings.
-Considers both accounts listed in postings and those declared
-with \"account\" directives."
-  (let ((accounts (ledger-accounts-in-buffer)))
+
+If INCLUDE-POSTINGS is non-nil, considers both accounts listed in
+postings and those declared with \"account\" directives.
+Otherwise, only considers the latter."
+  (let ((accounts (ledger-accounts-in-buffer include-postings)))
     (when ledger-accounts-exclude-function
       (setq accounts (cl-remove-if ledger-accounts-exclude-function accounts)))
     (mapcar #'car accounts)))
 
-(defun ledger-accounts-list ()
+(defun ledger-accounts-list (&optional include-postings)
   "Return a list of all known account names as strings.
 Looks in `ledger-accounts-file' if set, otherwise the current buffer."
   (if ledger-accounts-file
@@ -174,7 +174,7 @@ Looks in `ledger-accounts-file' if set, otherwise the current buffer."
           (ledger-accounts-list-in-buffer)))
     (ledger-accounts-list-in-buffer)))
 
-(defun ledger-find-accounts-in-buffer ()
+(defun ledger-find-accounts-in-buffer (&optional include-postings)
   (let ((account-tree (list t))
         (account-elements nil)
         (prefix ""))
@@ -183,7 +183,7 @@ Looks in `ledger-accounts-file' if set, otherwise the current buffer."
 
       (dolist (account
                (cl-remove-if-not (lambda (c) (string-prefix-p prefix c))
-                                 (ledger-accounts-list)))
+                                 (ledger-accounts-list include-postings)))
         (let ((root account-tree))
           (setq account-elements
                 (split-string
@@ -198,11 +198,11 @@ Looks in `ledger-accounts-file' if set, otherwise the current buffer."
             (setq account-elements (cdr account-elements))))))
     account-tree))
 
-(defun ledger-accounts-tree ()
+(defun ledger-accounts-tree (&optional include-postings)
   "Return a tree of all accounts in the buffer."
   (let* ((current (caar (ledger-parse-arguments)))
          (elements (and current (split-string current ":")))
-         (root (ledger-find-accounts-in-buffer))
+         (root (ledger-find-accounts-in-buffer include-postings))
          (prefix nil))
     (while (cdr elements)
       (let ((xact (assoc (car elements) root)))
@@ -305,9 +305,18 @@ Looks in `ledger-accounts-file' if set, otherwise the current buffer."
                                  (when (search-forward-regexp (rx (or eol (or ?\t (repeat 2 space)))) (line-end-position) t)
                                    (- (match-beginning 0) end)))
                  realign-after t
-                 collection (if ledger-complete-in-steps
-                                #'ledger-accounts-tree
-                              #'ledger-accounts-list))))
+                 collection
+                 ;; FIXME: People who have set `ledger-flymake-be-pedantic' or
+                 ;; `flycheck-ledger-pedantic' to non-nil probably don't want
+                 ;; accounts from postings, just those declared with directives.
+                 ;; But the name is a little misleading.  Should we make a
+                 ;; ledger-mode-be-pedantic and use that instead?
+                 (let ((include-postings
+                        (not (or (bound-and-true-p ledger-flymake-be-pedantic)
+                                 (bound-and-true-p flycheck-ledger-pedantic)))))
+                   (if ledger-complete-in-steps
+                       (lambda () (ledger-accounts-tree include-postings))
+                     (lambda () (ledger-accounts-list include-postings)))))))
     (when collection
       (let ((prefix (buffer-substring-no-properties start end)))
         (list start end