From eff14723378133469238a9e302677b84c3f7b63e Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Tue, 29 Jan 2013 13:57:22 -0700
Subject: Added GPL licensing information to lisp files

---
 lisp/ldg-regex.el | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 1c6b8f06..f2f83937 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -1,3 +1,24 @@
+;;; ldg-regex.el --- Helper code for use with the "ledger" command-line tool
+
+;; Copyright (C) 2003-2013 John Wiegley (johnw AT gnu DOT org)
+
+;; This file is not part of GNU Emacs.
+
+;; This is free software; you can redistribute it and/or modify it under
+;; the terms of the GNU General Public License as published by the Free
+;; Software Foundation; either version 2, or (at your option) any later
+;; version.
+;;
+;; This is distributed in the hope that it will be useful, but WITHOUT
+;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+;; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+;; for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+;; MA 02111-1307, USA.
+
 (require 'rx)
 
 (eval-when-compile
-- 
cgit v1.2.3


From 4d7c4929395421eb039f0d03afafaf55cffd686d Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Tue, 5 Feb 2013 12:33:42 -0700
Subject: Lisp code cleanup

Most of the files have been touched several times and the indentation structure
was wrong.  I ran all the files through the emacs indent region function to get back to
a baseline
---
 lisp/ldg-complete.el |  50 +++++++--------
 lisp/ldg-exec.el     |   4 +-
 lisp/ldg-fonts.el    |   2 +-
 lisp/ldg-mode.el     | 176 +++++++++++++++++++++++++--------------------------
 lisp/ldg-new.el      |   6 +-
 lisp/ldg-post.el     |  44 ++++++-------
 lisp/ldg-regex.el    | 130 ++++++++++++++++++-------------------
 lisp/ldg-register.el |  14 ++--
 lisp/ldg-report.el   | 106 +++++++++++++++----------------
 lisp/ldg-sort.el     |  14 ++--
 lisp/ldg-state.el    |  60 +++++++++---------
 lisp/ldg-test.el     |   8 +--
 lisp/ldg-texi.el     |  18 +++---
 13 files changed, 316 insertions(+), 316 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-complete.el b/lisp/ldg-complete.el
index 85546156..996df558 100644
--- a/lisp/ldg-complete.el
+++ b/lisp/ldg-complete.el
@@ -89,9 +89,9 @@
               (let ((entry (assoc (car elements) root)))
                 (if entry
                     (setq root (cdr entry))
-                  (setq entry (cons (car elements) (list t)))
-                  (nconc root (list entry))
-                  (setq root (cdr entry))))
+		    (setq entry (cons (car elements) (list t)))
+		    (nconc root (list entry))
+		    (setq root (cdr entry))))
               (setq elements (cdr elements)))))))))
 
 (defun ledger-accounts ()
@@ -106,18 +106,18 @@
             (setq prefix (concat prefix (and prefix ":")
                                  (car elements))
                   root (cdr entry))
-          (setq root nil elements nil)))
+	    (setq root nil elements nil)))
       (setq elements (cdr elements)))
     (and root
          (sort
           (mapcar (function
                    (lambda (x)
-                     (let ((term (if prefix
-                                     (concat prefix ":" (car x))
-                                   (car x))))
-                       (if (> (length (cdr x)) 1)
-                           (concat term ":")
-                         term))))
+		    (let ((term (if prefix
+				    (concat prefix ":" (car x))
+				    (car x))))
+		      (if (> (length (cdr x)) 1)
+			  (concat term ":")
+			  term))))
                   (cdr root))
           'string-lessp))))
 
@@ -129,21 +129,21 @@
                     (ledger-thing-at-point)) 'entry)
               (if (null current-prefix-arg)
                   (ledger-entries)  ; this completes against entry names
-                (progn
-                  (let ((text (buffer-substring (line-beginning-position)
-                                                (line-end-position))))
-                    (delete-region (line-beginning-position)
-                                   (line-end-position))
-                    (condition-case err
-                        (ledger-add-entry text t)
-                      ((error)
-                       (insert text))))
-                  (forward-line)
-                  (goto-char (line-end-position))
-                  (search-backward ";" (line-beginning-position) t)
-                  (skip-chars-backward " \t0123456789.,")
-                  (throw 'pcompleted t)))
-            (ledger-accounts)))))
+		  (progn
+		    (let ((text (buffer-substring (line-beginning-position)
+						  (line-end-position))))
+		      (delete-region (line-beginning-position)
+				     (line-end-position))
+		      (condition-case err
+			  (ledger-add-entry text t)
+			((error)
+			 (insert text))))
+		    (forward-line)
+		    (goto-char (line-end-position))
+		    (search-backward ";" (line-beginning-position) t)
+		    (skip-chars-backward " \t0123456789.,")
+		    (throw 'pcompleted t)))
+	      (ledger-accounts)))))
 
 (defun ledger-fully-complete-entry ()
   "Do appropriate completion for the thing at point"
diff --git a/lisp/ldg-exec.el b/lisp/ldg-exec.el
index f13cfa5a..e9cefd20 100644
--- a/lisp/ldg-exec.el
+++ b/lisp/ldg-exec.el
@@ -68,8 +68,8 @@
       (goto-char (point-min))
       (delete-horizontal-space)
       (setq version-strings (split-string
-			    (buffer-substring-no-properties (point)
-							       (+ (point) 12))))
+			     (buffer-substring-no-properties (point)
+							     (+ (point) 12))))
       (if (and (string-match (regexp-quote "Ledger") (car version-strings))
 	       (or (string= needed (car (cdr version-strings)))
 		   (string< needed (car (cdr version-strings)))))
diff --git a/lisp/ldg-fonts.el b/lisp/ldg-fonts.el
index 2b7717c6..6032e361 100644
--- a/lisp/ldg-fonts.el
+++ b/lisp/ldg-fonts.el
@@ -52,7 +52,7 @@
   :group 'ledger-faces)
 
 (defface ledger-font-comment-face
-  `((t :foreground "orange" ))
+    `((t :foreground "orange" ))
   "Face for Ledger comments"
   :group 'ledger-faces)
 
diff --git a/lisp/ldg-mode.el b/lisp/ldg-mode.el
index 4c55cdc0..226009c6 100644
--- a/lisp/ldg-mode.el
+++ b/lisp/ldg-mode.el
@@ -43,77 +43,77 @@ customizable to ease retro-entry.")
 
 ;;;###autoload
 (define-derived-mode ledger-mode text-mode "Ledger"
-  "A mode for editing ledger data files."
-  (ledger-check-version)
-  (ledger-post-setup)
-
-  (set (make-local-variable 'comment-start) " ; ")
-  (set (make-local-variable 'comment-end) "")
-  (set (make-local-variable 'indent-tabs-mode) nil)
-
-  (if (boundp 'font-lock-defaults)
-      (set (make-local-variable 'font-lock-defaults)
-           '(ledger-font-lock-keywords nil t)))
-
-  (set (make-local-variable 'pcomplete-parse-arguments-function)
-       'ledger-parse-arguments)
-  (set (make-local-variable 'pcomplete-command-completion-function)
-       'ledger-complete-at-point)
-  (set (make-local-variable 'pcomplete-termination-string) "")
-
-  (let ((map (current-local-map)))
-    (define-key map [(control ?c) (control ?a)] 'ledger-add-entry)
-    (define-key map [(control ?c) (control ?d)] 'ledger-delete-current-entry)
-    (define-key map [(control ?c) (control ?y)] 'ledger-set-year)
-    (define-key map [(control ?c) (control ?m)] 'ledger-set-month)
-    (define-key map [(control ?c) (control ?c)] 'ledger-toggle-current)
-    (define-key map [(control ?c) (control ?e)] 'ledger-toggle-current-entry)
-    (define-key map [(control ?c) (control ?r)] 'ledger-reconcile)
-    (define-key map [(control ?c) (control ?s)] 'ledger-sort-region)
-    (define-key map [(control ?c) (control ?t)] 'ledger-test-run)
-    (define-key map [(control ?c) (control ?v)] 'ledger-post-edit-amount)
-    (define-key map [(control ?c) (control ?f)] 'ledger-occur)
-    (define-key map [tab] 'pcomplete)
-    (define-key map [(control ?i)] 'pcomplete)
-    (define-key map [(control ?c) tab] 'ledger-fully-complete-entry)
-    (define-key map [(control ?c) (control ?i)] 'ledger-fully-complete-entry)
-    (define-key map [(control ?c) (control ?o) (control ?r)] 'ledger-report)
-    (define-key map [(control ?c) (control ?o) (control ?g)] 'ledger-report-goto)
-    (define-key map [(control ?c) (control ?o) (control ?a)] 'ledger-report-redo)
-    (define-key map [(control ?c) (control ?o) (control ?s)] 'ledger-report-save)
-    (define-key map [(control ?c) (control ?o) (control ?e)] 'ledger-report-edit)
-    (define-key map [(control ?c) (control ?o) (control ?k)] 'ledger-report-kill)
-
-    (define-key map [(meta ?p)] 'ledger-post-prev-xact)
-    (define-key map [(meta ?n)] 'ledger-post-next-xact)
-
-    (define-key map [menu-bar] (make-sparse-keymap "ldg-menu"))
-    (define-key map [menu-bar ldg-menu] (cons "Ledger" map))
-
-    (define-key map [report-kill] '(menu-item "Kill Report" ledger-report-kill :enable ledger-works))
-    (define-key map [report-edit] '(menu-item "Edit Report" ledger-report-edit :enable ledger-works))
-    (define-key map [report-save] '(menu-item "Save Report" ledger-report-save :enable ledger-works))
-    (define-key map [report-rrun] '(menu-item "Re-run Report" ledger-report-redo :enable ledger-works))
-    (define-key map [report-goto] '(menu-item "Goto Report" ledger-report-goto :enable ledger-works))
-    (define-key map [report-run] '(menu-item "Run Report" ledger-report :enable ledger-works))
-    (define-key map [sep5] '(menu-item "--"))
-    (define-key map [set-month] '(menu-item "Set Month" ledger-set-month :enable ledger-works))
-    (define-key map [set-year] '(menu-item "Set Year" ledger-set-year :enable ledger-works))
-    (define-key map [sep1] '("--"))
-    (define-key map [sort-buff] '(menu-item "Sort Buffer" ledger-sort-buffer))
-    (define-key map [sort-reg] '(menu-item "Sort Region" ledger-sort-region :enable mark-active))
-    (define-key map [sep2] '(menu-item "--"))
-    (define-key map [toggle-post] '(menu-item "Toggle Current Posting" ledger-toggle-current))
-    (define-key map [toggle-xact] '(menu-item "Toggle Current Transaction" ledger-toggle-current-entry))
-    (define-key map [sep4] '(menu-item "--"))
-    (define-key map [edit-amount] '(menu-item "Calc on Amount" ledger-post-edit-amount))
-    (define-key map [sep] '(menu-item "--"))
-    (define-key map [delete-xact] '(menu-item "Delete Entry" ledger-delete-current-entry))
-    (define-key map [add-xact] '(menu-item "Add Entry" ledger-add-entry :enable ledger-works))
-    (define-key map [sep3] '(menu-item "--"))
-    (define-key map [reconcile] '(menu-item "Reconcile Account" ledger-reconcile :enable ledger-works))
-    (define-key map [reconcile] '(menu-item "Hide Xacts" ledger-occur))
-    ))
+		     "A mode for editing ledger data files."
+		     (ledger-check-version)
+		     (ledger-post-setup)
+
+		     (set (make-local-variable 'comment-start) " ; ")
+		     (set (make-local-variable 'comment-end) "")
+		     (set (make-local-variable 'indent-tabs-mode) nil)
+
+		     (if (boundp 'font-lock-defaults)
+			 (set (make-local-variable 'font-lock-defaults)
+			      '(ledger-font-lock-keywords nil t)))
+
+		     (set (make-local-variable 'pcomplete-parse-arguments-function)
+			  'ledger-parse-arguments)
+		     (set (make-local-variable 'pcomplete-command-completion-function)
+			  'ledger-complete-at-point)
+		     (set (make-local-variable 'pcomplete-termination-string) "")
+
+		     (let ((map (current-local-map)))
+		       (define-key map [(control ?c) (control ?a)] 'ledger-add-entry)
+		       (define-key map [(control ?c) (control ?d)] 'ledger-delete-current-entry)
+		       (define-key map [(control ?c) (control ?y)] 'ledger-set-year)
+		       (define-key map [(control ?c) (control ?m)] 'ledger-set-month)
+		       (define-key map [(control ?c) (control ?c)] 'ledger-toggle-current)
+		       (define-key map [(control ?c) (control ?e)] 'ledger-toggle-current-entry)
+		       (define-key map [(control ?c) (control ?r)] 'ledger-reconcile)
+		       (define-key map [(control ?c) (control ?s)] 'ledger-sort-region)
+		       (define-key map [(control ?c) (control ?t)] 'ledger-test-run)
+		       (define-key map [(control ?c) (control ?v)] 'ledger-post-edit-amount)
+		       (define-key map [(control ?c) (control ?f)] 'ledger-occur)
+		       (define-key map [tab] 'pcomplete)
+		       (define-key map [(control ?i)] 'pcomplete)
+		       (define-key map [(control ?c) tab] 'ledger-fully-complete-entry)
+		       (define-key map [(control ?c) (control ?i)] 'ledger-fully-complete-entry)
+		       (define-key map [(control ?c) (control ?o) (control ?r)] 'ledger-report)
+		       (define-key map [(control ?c) (control ?o) (control ?g)] 'ledger-report-goto)
+		       (define-key map [(control ?c) (control ?o) (control ?a)] 'ledger-report-redo)
+		       (define-key map [(control ?c) (control ?o) (control ?s)] 'ledger-report-save)
+		       (define-key map [(control ?c) (control ?o) (control ?e)] 'ledger-report-edit)
+		       (define-key map [(control ?c) (control ?o) (control ?k)] 'ledger-report-kill)
+
+		       (define-key map [(meta ?p)] 'ledger-post-prev-xact)
+		       (define-key map [(meta ?n)] 'ledger-post-next-xact)
+
+		       (define-key map [menu-bar] (make-sparse-keymap "ldg-menu"))
+		       (define-key map [menu-bar ldg-menu] (cons "Ledger" map))
+
+		       (define-key map [report-kill] '(menu-item "Kill Report" ledger-report-kill :enable ledger-works))
+		       (define-key map [report-edit] '(menu-item "Edit Report" ledger-report-edit :enable ledger-works))
+		       (define-key map [report-save] '(menu-item "Save Report" ledger-report-save :enable ledger-works))
+		       (define-key map [report-rrun] '(menu-item "Re-run Report" ledger-report-redo :enable ledger-works))
+		       (define-key map [report-goto] '(menu-item "Goto Report" ledger-report-goto :enable ledger-works))
+		       (define-key map [report-run] '(menu-item "Run Report" ledger-report :enable ledger-works))
+		       (define-key map [sep5] '(menu-item "--"))
+		       (define-key map [set-month] '(menu-item "Set Month" ledger-set-month :enable ledger-works))
+		       (define-key map [set-year] '(menu-item "Set Year" ledger-set-year :enable ledger-works))
+		       (define-key map [sep1] '("--"))
+		       (define-key map [sort-buff] '(menu-item "Sort Buffer" ledger-sort-buffer))
+		       (define-key map [sort-reg] '(menu-item "Sort Region" ledger-sort-region :enable mark-active))
+		       (define-key map [sep2] '(menu-item "--"))
+		       (define-key map [toggle-post] '(menu-item "Toggle Current Posting" ledger-toggle-current))
+		       (define-key map [toggle-xact] '(menu-item "Toggle Current Transaction" ledger-toggle-current-entry))
+		       (define-key map [sep4] '(menu-item "--"))
+		       (define-key map [edit-amount] '(menu-item "Calc on Amount" ledger-post-edit-amount))
+		       (define-key map [sep] '(menu-item "--"))
+		       (define-key map [delete-xact] '(menu-item "Delete Entry" ledger-delete-current-entry))
+		       (define-key map [add-xact] '(menu-item "Add Entry" ledger-add-entry :enable ledger-works))
+		       (define-key map [sep3] '(menu-item "--"))
+		       (define-key map [reconcile] '(menu-item "Reconcile Account" ledger-reconcile :enable ledger-works))
+		       (define-key map [reconcile] '(menu-item "Hide Xacts" ledger-occur))
+		       ))
 
 (defun ledger-time-less-p (t1 t2)
   "Say whether time value T1 is less than time value T2."
@@ -133,8 +133,8 @@ Return the difference in the format of a time value."
     (ledger-iterate-entries
      (function
       (lambda (start date mark desc)
-        (if (ledger-time-less-p moment date)
-            (throw 'found t)))))))
+       (if (ledger-time-less-p moment date)
+	   (throw 'found t)))))))
 
 (defun ledger-iterate-entries (callback)
   (goto-char (point-min))
@@ -149,18 +149,18 @@ Return the difference in the format of a time value."
         (let ((found (match-string 2)))
           (if found
               (setq current-year (string-to-number found))
-            (let ((start (match-beginning 0))
-                  (year (match-string 3))
-                  (month (string-to-number (match-string 4)))
-                  (day (string-to-number (match-string 5)))
-                  (mark (match-string 6))
-                  (desc (match-string 7)))
-              (if (and year (> (length year) 0))
-                  (setq year (string-to-number year)))
-              (funcall callback start
-                       (encode-time 0 0 0 day month
-                                    (or year current-year))
-                       mark desc)))))
+	      (let ((start (match-beginning 0))
+		    (year (match-string 3))
+		    (month (string-to-number (match-string 4)))
+		    (day (string-to-number (match-string 5)))
+		    (mark (match-string 6))
+		    (desc (match-string 7)))
+		(if (and year (> (length year) 0))
+		    (setq year (string-to-number year)))
+		(funcall callback start
+			 (encode-time 0 0 0 day month
+				      (or year current-year))
+			 mark desc)))))
       (forward-line))))
 
 (defun ledger-set-year (newyear)
@@ -168,14 +168,14 @@ Return the difference in the format of a time value."
   (interactive "p")
   (if (= newyear 1)
       (setq ledger-year (read-string "Year: " (ledger-current-year)))
-    (setq ledger-year (number-to-string newyear))))
+      (setq ledger-year (number-to-string newyear))))
 
 (defun ledger-set-month (newmonth)
   "Set ledger's idea of the current month to the prefix argument."
   (interactive "p")
   (if (= newmonth 1)
       (setq ledger-month (read-string "Month: " (ledger-current-month)))
-    (setq ledger-month (format "%02d" newmonth))))
+      (setq ledger-month (format "%02d" newmonth))))
 
 (defun ledger-add-entry (entry-text &optional insert-at-point)
   (interactive (list
@@ -202,7 +202,7 @@ Return the difference in the format of a time value."
          (goto-char (point-min))
          (if (looking-at "Error: ")
              (error (buffer-string))
-           (buffer-string)))
+	     (buffer-string)))
        "\n"))))
 
 (defun ledger-current-entry-bounds ()
diff --git a/lisp/ldg-new.el b/lisp/ldg-new.el
index 1d7d5cac..3ee48897 100644
--- a/lisp/ldg-new.el
+++ b/lisp/ldg-new.el
@@ -47,9 +47,9 @@
 (require 'ldg-fonts)
 (require 'ldg-occur)
 
-;(autoload #'ledger-mode "ldg-mode" nil t)
-;(autoload #'ledger-fully-complete-entry "ldg-complete" nil t)
-;(autoload #'ledger-toggle-current "ldg-state" nil t)
+					;(autoload #'ledger-mode "ldg-mode" nil t)
+					;(autoload #'ledger-fully-complete-entry "ldg-complete" nil t)
+					;(autoload #'ledger-toggle-current "ldg-state" nil t)
 
 (autoload #'ledger-texi-update-test "ldg-texi" nil t)
 (autoload #'ledger-texi-update-examples "ldg-texi" nil t)
diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el
index dc033bf8..411911d9 100644
--- a/lisp/ldg-post.el
+++ b/lisp/ldg-post.el
@@ -66,16 +66,16 @@
 PROMPT is a string to prompt with.  CHOICES is a list of strings
 to choose from."
   (cond
-   (ledger-post-use-iswitchb
-    (let* ((iswitchb-use-virtual-buffers nil)
-           (iswitchb-make-buflist-hook
-            (lambda ()
-              (setq iswitchb-temp-buflist choices))))
-      (iswitchb-read-buffer prompt)))
-   (ledger-post-use-ido
-    (ido-completing-read prompt choices))
-   (t
-    (completing-read prompt choices))))
+    (ledger-post-use-iswitchb
+     (let* ((iswitchb-use-virtual-buffers nil)
+	    (iswitchb-make-buflist-hook
+	     (lambda ()
+	       (setq iswitchb-temp-buflist choices))))
+       (iswitchb-read-buffer prompt)))
+    (ledger-post-use-ido
+     (ido-completing-read prompt choices))
+    (t
+     (completing-read prompt choices))))
 
 (defvar ledger-post-current-list nil)
 
@@ -96,12 +96,12 @@ to choose from."
                        (match-end ledger-regex-post-line-group-account))
         (insert account)
         (cond
-         ((> existing-len account-len)
-          (insert (make-string (- existing-len account-len) ? )))
-         ((< existing-len account-len)
-          (dotimes (n (- account-len existing-len))
-            (if (looking-at "[ \t]\\( [ \t]\\|\t\\)")
-                (delete-char 1)))))))
+	  ((> existing-len account-len)
+	   (insert (make-string (- existing-len account-len) ? )))
+	  ((< existing-len account-len)
+	   (dotimes (n (- account-len existing-len))
+	     (if (looking-at "[ \t]\\( [ \t]\\|\t\\)")
+		 (delete-char 1)))))))
     (goto-char pos)))
 
 (defun ledger-next-amount (&optional end)
@@ -130,12 +130,12 @@ This is done so that the last digit falls in COLUMN, which defaults to 52."
           (setq adjust (- target-col col))
           (if (< col target-col)
               (insert (make-string (- target-col col) ? ))
-            (move-to-column target-col)
-            (if (looking-back "  ")
-                (delete-char (- col target-col))
-              (skip-chars-forward "^ \t")
-              (delete-horizontal-space)
-              (insert "  ")))
+	      (move-to-column target-col)
+	      (if (looking-back "  ")
+		  (delete-char (- col target-col))
+		  (skip-chars-forward "^ \t")
+		  (delete-horizontal-space)
+		  (insert "  ")))
           (forward-line))))))
 
 (defun ledger-post-align-amount ()
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index f2f83937..680063f7 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -27,10 +27,10 @@
 (defmacro ledger-define-regexp (name regex docs &rest args)
   "Simplify the creation of a Ledger regex and helper functions."
   (let ((defs
-          (list
-           `(defconst
-              ,(intern (concat "ledger-" (symbol-name name) "-regexp"))
-              ,(eval regex))))
+	 (list
+	  `(defconst
+	       ,(intern (concat "ledger-" (symbol-name name) "-regexp"))
+	     ,(eval regex))))
         (addend 0) last-group)
     (if (null args)
         (progn
@@ -38,82 +38,82 @@
            defs
            (list
             `(defconst
-               ,(intern
-                 (concat "ledger-regex-" (symbol-name name) "-group"))
+		 ,(intern
+		   (concat "ledger-regex-" (symbol-name name) "-group"))
                1)))
           (nconc
            defs
            (list
             `(defconst
-               ,(intern (concat "ledger-regex-" (symbol-name name)
-                                "-group--count"))
+		 ,(intern (concat "ledger-regex-" (symbol-name name)
+				  "-group--count"))
                1)))
           (nconc
            defs
            (list
             `(defmacro
-               ,(intern (concat "ledger-regex-" (symbol-name name)))
-               (&optional string)
+		 ,(intern (concat "ledger-regex-" (symbol-name name)))
+		 (&optional string)
                ,(format "Return the match string for the %s" name)
                (match-string
                 ,(intern (concat "ledger-regex-" (symbol-name name)
                                  "-group"))
                 string)))))
-      
-      (dolist (arg args)
-        (let (var grouping target)
-          (if (symbolp arg)
-              (setq var arg target arg)
-            (assert (listp arg))
-            (if (= 2 (length arg))
-                (setq var (car arg)
-                      target (cadr arg))
-              (setq var (car arg)
-                    grouping (cadr arg)
-                    target (caddr arg))))
-
-          (if (and last-group
-                   (not (eq last-group (or grouping target))))
-              (incf addend
-                    (symbol-value
-                     (intern-soft (concat "ledger-regex-"
-                                          (symbol-name last-group)
-                                          "-group--count")))))
-          (nconc
-           defs
-           (list
-            `(defconst
-               ,(intern (concat "ledger-regex-" (symbol-name name)
-                                "-group-" (symbol-name var)))
-               ,(+ addend
-                   (symbol-value
-                    (intern-soft
-                     (if grouping
-                         (concat "ledger-regex-" (symbol-name grouping)
-                                 "-group-" (symbol-name target))
-                       (concat "ledger-regex-" (symbol-name target)
-                               "-group"))))))))
-          (nconc
-           defs
-           (list
-            `(defmacro
-               ,(intern (concat "ledger-regex-" (symbol-name name)
-                                "-" (symbol-name var)))
-               (&optional string)
-               ,(format "Return the sub-group match for the %s %s."
-                        name var)
-               (match-string
-                ,(intern (concat "ledger-regex-" (symbol-name name)
-                                 "-group-" (symbol-name var)))
-                string))))
-
-          (setq last-group (or grouping target))))
-
-      (nconc defs
-             (list
-              `(defconst ,(intern (concat "ledger-regex-" (symbol-name name)
-                                          "-group--count"))
-                 ,(length args)))))
+	
+	(dolist (arg args)
+	  (let (var grouping target)
+	    (if (symbolp arg)
+		(setq var arg target arg)
+		(assert (listp arg))
+		(if (= 2 (length arg))
+		    (setq var (car arg)
+			  target (cadr arg))
+		    (setq var (car arg)
+			  grouping (cadr arg)
+			  target (caddr arg))))
+
+	    (if (and last-group
+		     (not (eq last-group (or grouping target))))
+		(incf addend
+		      (symbol-value
+		       (intern-soft (concat "ledger-regex-"
+					    (symbol-name last-group)
+					    "-group--count")))))
+	    (nconc
+	     defs
+	     (list
+	      `(defconst
+		   ,(intern (concat "ledger-regex-" (symbol-name name)
+				    "-group-" (symbol-name var)))
+		 ,(+ addend
+		     (symbol-value
+		      (intern-soft
+		       (if grouping
+			   (concat "ledger-regex-" (symbol-name grouping)
+				   "-group-" (symbol-name target))
+			   (concat "ledger-regex-" (symbol-name target)
+				   "-group"))))))))
+	    (nconc
+	     defs
+	     (list
+	      `(defmacro
+		   ,(intern (concat "ledger-regex-" (symbol-name name)
+				    "-" (symbol-name var)))
+		   (&optional string)
+		 ,(format "Return the sub-group match for the %s %s."
+			  name var)
+		 (match-string
+		  ,(intern (concat "ledger-regex-" (symbol-name name)
+				   "-group-" (symbol-name var)))
+		  string))))
+
+	    (setq last-group (or grouping target))))
+
+	(nconc defs
+	       (list
+		`(defconst ,(intern (concat "ledger-regex-" (symbol-name name)
+					    "-group--count"))
+		   ,(length args)))))
 
     (cons 'progn defs)))
 
diff --git a/lisp/ldg-register.el b/lisp/ldg-register.el
index 4c397049..adb37a1a 100644
--- a/lisp/ldg-register.el
+++ b/lisp/ldg-register.el
@@ -37,8 +37,8 @@
   :group 'ledger-register)
 
 (defface ledger-register-pending-face
-  '((((background light)) (:weight bold))
-    (((background dark)) (:weight bold)))
+    '((((background light)) (:weight bold))
+      (((background dark)) (:weight bold)))
   "Face used to highlight pending entries in a register report."
   :group 'ledger-register)
 
@@ -55,9 +55,9 @@
                       (save-excursion
                         (goto-line (nth 1 post))
                         (point-marker))
-                    (save-excursion
-                      (goto-line (nth 0 xact))
-                      (point-marker)))))))
+		      (save-excursion
+			(goto-line (nth 0 xact))
+			(point-marker)))))))
           (insert (format ledger-register-line-format
                           (format-time-string ledger-register-date-format
                                               (nth 2 post))
@@ -66,8 +66,8 @@
               (set-text-properties beg (1- (point))
                                    (list 'face 'ledger-register-pending-face
                                          'where where))
-            (set-text-properties beg (1- (point))
-                                 (list 'where where))))
+	      (set-text-properties beg (1- (point))
+				   (list 'where where))))
         (setq index (1+ index)))))
   (goto-char (point-min))
   )
diff --git a/lisp/ldg-report.el b/lisp/ldg-report.el
index 394c12e7..3b831825 100644
--- a/lisp/ldg-report.el
+++ b/lisp/ldg-report.el
@@ -39,7 +39,7 @@ the substitution.  See the documentation of the individual functions
 in that variable for more information on the behavior of each
 specifier."
   :type '(repeat (list (string :tag "Report Name")
-                       (string :tag "Command Line")))
+		  (string :tag "Command Line")))
   :group 'ledger)
 
 (defcustom ledger-report-format-specifiers
@@ -73,40 +73,40 @@ text that should replace the format specifier."
 (defvar ledger-report-mode-abbrev-table)
 
 (define-derived-mode ledger-report-mode text-mode "Ledger-Report"
-  "A mode for viewing ledger reports."
-  (let ((map (make-sparse-keymap)))
-    (define-key map [? ] 'scroll-up)
-    (define-key map [backspace] 'scroll-down)
-    (define-key map [?r] 'ledger-report-redo)
-    (define-key map [?s] 'ledger-report-save)
-    (define-key map [?k] 'ledger-report-kill)
-    (define-key map [?e] 'ledger-report-edit)
-    (define-key map [?q] 'ledger-report-quit)
-    (define-key map [(control ?c) (control ?l) (control ?r)]
-      'ledger-report-redo)
-    (define-key map [(control ?c) (control ?l) (control ?S)]
-      'ledger-report-save)
-    (define-key map [(control ?c) (control ?l) (control ?k)]
-      'ledger-report-kill)
-    (define-key map [(control ?c) (control ?l) (control ?e)]
-      'ledger-report-edit)
-    (define-key map [(control ?c) (control ?c)] 'ledger-report-visit-source)
-
-    
-    (define-key map [menu-bar] (make-sparse-keymap "ldg-rep"))
-    (define-key map [menu-bar ldg-rep] (cons "Reports" map))
-
-    (define-key map [menu-bar ldg-rep lrq] '("Quit" . ledger-report-quit))
-    (define-key map [menu-bar ldg-rep s2] '("--"))
-    (define-key map [menu-bar ldg-rep lrd] '("Scroll Down" . scroll-down))
-    (define-key map [menu-bar ldg-rep lru] '("Scroll Up" . scroll-up))
-    (define-key map [menu-bar ldg-rep s1] '("--"))
-    (define-key map [menu-bar ldg-rep lrk] '("Kill Report" . ledger-report-kill))
-    (define-key map [menu-bar ldg-rep lrr] '("Re-run Report" . ledger-report-redo))
-    (define-key map [menu-bar ldg-rep lre] '("Edit Report" . ledger-report-edit))
-    (define-key map [menu-bar ldg-rep lrs] '("Save Report" . ledger-report-save))
-
-    (use-local-map map)))
+		     "A mode for viewing ledger reports."
+		     (let ((map (make-sparse-keymap)))
+		       (define-key map [? ] 'scroll-up)
+		       (define-key map [backspace] 'scroll-down)
+		       (define-key map [?r] 'ledger-report-redo)
+		       (define-key map [?s] 'ledger-report-save)
+		       (define-key map [?k] 'ledger-report-kill)
+		       (define-key map [?e] 'ledger-report-edit)
+		       (define-key map [?q] 'ledger-report-quit)
+		       (define-key map [(control ?c) (control ?l) (control ?r)]
+			 'ledger-report-redo)
+		       (define-key map [(control ?c) (control ?l) (control ?S)]
+			 'ledger-report-save)
+		       (define-key map [(control ?c) (control ?l) (control ?k)]
+			 'ledger-report-kill)
+		       (define-key map [(control ?c) (control ?l) (control ?e)]
+			 'ledger-report-edit)
+		       (define-key map [(control ?c) (control ?c)] 'ledger-report-visit-source)
+
+		       
+		       (define-key map [menu-bar] (make-sparse-keymap "ldg-rep"))
+		       (define-key map [menu-bar ldg-rep] (cons "Reports" map))
+
+		       (define-key map [menu-bar ldg-rep lrq] '("Quit" . ledger-report-quit))
+		       (define-key map [menu-bar ldg-rep s2] '("--"))
+		       (define-key map [menu-bar ldg-rep lrd] '("Scroll Down" . scroll-down))
+		       (define-key map [menu-bar ldg-rep lru] '("Scroll Up" . scroll-up))
+		       (define-key map [menu-bar ldg-rep s1] '("--"))
+		       (define-key map [menu-bar ldg-rep lrk] '("Kill Report" . ledger-report-kill))
+		       (define-key map [menu-bar ldg-rep lrr] '("Re-run Report" . ledger-report-redo))
+		       (define-key map [menu-bar ldg-rep lre] '("Edit Report" . ledger-report-edit))
+		       (define-key map [menu-bar ldg-rep lrs] '("Save Report" . ledger-report-save))
+
+		       (use-local-map map)))
 
 (defun ledger-report-read-name ()
   "Read the name of a ledger report to use, with completion.
@@ -201,13 +201,13 @@ this variable would be set in a file local variable comment block at the
 end of a ledger file which is included in some other file."
   (if ledger-master-file
       (expand-file-name ledger-master-file)
-    (buffer-file-name)))
+      (buffer-file-name)))
 
 (defun ledger-read-string-with-default (prompt default)
   (let ((default-prompt (concat prompt
                                 (if default
                                     (concat " (" default "): ")
-                                  ": "))))
+				    ": "))))
     (read-string default-prompt nil nil default)))
 
 (defun ledger-report-payee-format-specifier ()
@@ -234,7 +234,7 @@ the default."
          (default
           (if (eq (ledger-context-line-type context) 'acct-transaction)
               (regexp-quote (ledger-context-field-value context 'account))
-            nil)))
+	      nil)))
     (ledger-read-string-with-default "Account" default)))
 
 (defun ledger-report-expand-format-specifiers (report-cmd)
@@ -248,9 +248,9 @@ the default."
                                   (with-current-buffer ledger-buf
                                     (shell-quote-argument (funcall f))))
                                 t t expanded-cmd))
-          (progn
-            (set-window-configuration ledger-original-window-cfg)
-            (error "Invalid ledger report format specifier '%s'" specifier)))))
+	    (progn
+	      (set-window-configuration ledger-original-window-cfg)
+	      (error "Invalid ledger report format specifier '%s'" specifier)))))
     expanded-cmd))
 
 (defun ledger-report-cmd (report-name edit)
@@ -280,12 +280,12 @@ the default."
     (shell-command
      (if register-report
          (concat cmd " --prepend-format='%(filename):%(beg_line):'")
-       cmd) t nil)
+	 cmd) t nil)
     (when register-report
       (goto-char data-pos)
       (while (re-search-forward "^\\([^:]+\\)?:\\([0-9]+\\)?:" nil t)
         (let ((file (match-string 1))
-               (line (string-to-number (match-string 2))))
+	      (line (string-to-number (match-string 2))))
           (delete-region (match-beginning 0) (match-end 0))
           (set-text-properties (line-beginning-position) (line-end-position)
                                (list 'ledger-source (cons file (save-window-excursion
@@ -307,14 +307,14 @@ the default."
       (widen)
       (if (markerp line-or-marker)
           (goto-char line-or-marker)
-        (goto-char (point-min))
-        (forward-line (1- line-or-marker))
-        (re-search-backward "^[0-9]+")
-        (beginning-of-line)
-        (let ((start-of-txn (point)))
-          (forward-paragraph)
-          (narrow-to-region start-of-txn (point))
-          (backward-paragraph))))))
+	  (goto-char (point-min))
+	  (forward-line (1- line-or-marker))
+	  (re-search-backward "^[0-9]+")
+	  (beginning-of-line)
+	  (let ((start-of-txn (point)))
+	    (forward-paragraph)
+	    (narrow-to-region start-of-txn (point))
+	    (backward-paragraph))))))
 
 (defun ledger-report-goto ()
   "Goto the ledger report buffer."
@@ -487,7 +487,7 @@ specified line, returns nil."
     (let ((left (forward-line offset)))
       (if (not (equal left 0))
           nil
-        (ledger-context-at-point)))))
+	  (ledger-context-at-point)))))
 
 (defun ledger-context-line-type (context-info)
   (nth 0 context-info))
@@ -525,6 +525,6 @@ specified line, returns nil."
     (let ((context-info (ledger-context-other-line i)))
       (if (eq (ledger-context-line-type context-info) 'entry)
           (ledger-context-field-value context-info 'payee)
-        nil))))
+	  nil))))
 
 (provide 'ldg-report)
diff --git a/lisp/ldg-sort.el b/lisp/ldg-sort.el
index 9cecefa4..86e3fa0a 100644
--- a/lisp/ldg-sort.el
+++ b/lisp/ldg-sort.el
@@ -23,11 +23,11 @@
 ;; the form YYYY/mm/dd.
 
 (defun ledger-next-record-function ()
-        (if (re-search-forward
-             (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
-                     "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)") nil t)
-            (goto-char (match-beginning 0))
-	    (goto-char (point-max))))
+  (if (re-search-forward
+       (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
+	       "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)") nil t)
+      (goto-char (match-beginning 0))
+      (goto-char (point-max))))
 
 (defun ledger-end-record-function ()
   (forward-paragraph))
@@ -42,7 +42,7 @@
 	(setq new-beg (point))
 	(goto-char end)
 	(ledger-next-record-function) ;make sure end of region is at the beginning of
-                                      ;next record after the region
+					;next record after the region
 	(setq new-end (point))
 	(narrow-to-region beg end)
 	(goto-char (point-min))
@@ -55,7 +55,7 @@
 
 (defun ledger-sort-buffer ()
   (interactive)
-    (ledger-sort-region (point-min) (point-max)))
+  (ledger-sort-region (point-min) (point-max)))
 
 
 (provide 'ldg-sort)
\ No newline at end of file
diff --git a/lisp/ldg-state.el b/lisp/ldg-state.el
index 03017b25..41c0d8f2 100644
--- a/lisp/ldg-state.el
+++ b/lisp/ldg-state.el
@@ -28,9 +28,9 @@
   (if (not (null state))
       (if (and style (eq style 'cleared))
           'cleared)
-    (if (and style (eq style 'pending))
-        'pending
-      'cleared)))
+      (if (and style (eq style 'pending))
+	  'pending
+	  'cleared)))
 
 (defun ledger-entry-state ()
   (save-excursion
@@ -106,23 +106,23 @@ dropped."
                     (progn
                       (insert "* ")
                       (setq inserted t)))
-              (if (and style (eq style 'pending))
-                  (progn
-                    (insert "! ")
-                    (setq inserted t))
-                (progn
-                  (insert "* ")
-                  (setq inserted t))))
+		(if (and style (eq style 'pending))
+		    (progn
+		      (insert "! ")
+		      (setq inserted t))
+		    (progn
+		      (insert "* ")
+		      (setq inserted t))))
             (if (and inserted
                      (re-search-forward "\\(\t\\| [ \t]\\)"
                                         (line-end-position) t))
                 (cond
-                 ((looking-at "\t")
-                  (delete-char 1))
-                 ((looking-at " [ \t]")
-                  (delete-char 2))
-                 ((looking-at " ")
-                  (delete-char 1))))
+		  ((looking-at "\t")
+		   (delete-char 1))
+		  ((looking-at " [ \t]")
+		   (delete-char 2))
+		  ((looking-at " ")
+		   (delete-char 1))))
             (setq clear inserted)))))
     ;; Clean up the entry so that it displays minimally
     (save-excursion
@@ -135,12 +135,12 @@ dropped."
           (skip-chars-forward " \t")
           (let ((cleared (if (member (char-after) '(?\* ?\!))
                              (char-after)
-                           ? )))
+			     ? )))
             (if first
                 (setq state cleared
                       first nil)
-              (if (/= state cleared)
-                  (setq hetero t))))
+		(if (/= state cleared)
+		    (setq hetero t))))
           (forward-line))
         (when (and (not hetero) (/= state ? ))
           (goto-char (car bounds))
@@ -162,12 +162,12 @@ dropped."
           (if (re-search-forward "\\(\t\\| [ \t]\\)"
                                  (line-end-position) t)
               (cond
-               ((looking-at "\t")
-                (delete-char 1))
-               ((looking-at " [ \t]")
-                (delete-char 2))
-               ((looking-at " ")
-                (delete-char 1)))))))
+		((looking-at "\t")
+		 (delete-char 1))
+		((looking-at " [ \t]")
+		 (delete-char 2))
+		((looking-at " ")
+		 (delete-char 1)))))))
     clear))
 
 (defun ledger-toggle-current (&optional style)
@@ -186,7 +186,7 @@ dropped."
             (forward-line)
             (goto-char (line-beginning-position))))
         (ledger-toggle-current-entry style))
-    (ledger-toggle-current-transaction style)))
+      (ledger-toggle-current-transaction style)))
 
 (defun ledger-toggle-current-entry (&optional style)
   (interactive)
@@ -201,10 +201,10 @@ dropped."
               (delete-char 1)
               (if (and style (eq style 'cleared))
                   (insert " *")))
-          (if (and style (eq style 'pending))
-              (insert " ! ")
-            (insert " * "))
-          (setq clear t))))
+	    (if (and style (eq style 'pending))
+		(insert " ! ")
+		(insert " * "))
+	    (setq clear t))))
     clear))
 
 (provide 'ldg-state)
diff --git a/lisp/ldg-test.el b/lisp/ldg-test.el
index 2036ea7b..7667a05e 100644
--- a/lisp/ldg-test.el
+++ b/lisp/ldg-test.el
@@ -67,9 +67,9 @@
         (ledger-mode)
         (if input
             (insert input)
-          (insert "2012-03-17 Payee\n")
-          (insert "    Expenses:Food                $20\n")
-          (insert "    Assets:Cash\n"))
+	    (insert "2012-03-17 Payee\n")
+	    (insert "    Expenses:Food                $20\n")
+	    (insert "    Assets:Cash\n"))
         (insert "\ntest reg\n")
         (if output
             (insert output))
@@ -90,7 +90,7 @@
         (let ((prev-directory default-directory))
           (cd ledger-source-directory)
           (unwind-protect
-              (async-shell-command (format "\"%s\" %s" command args))
+	       (async-shell-command (format "\"%s\" %s" command args))
             (cd prev-directory)))))))
 
 (provide 'ldg-test)
diff --git a/lisp/ldg-texi.el b/lisp/ldg-texi.el
index fefa7d2b..53e050ce 100644
--- a/lisp/ldg-texi.el
+++ b/lisp/ldg-texi.el
@@ -94,17 +94,17 @@
   (if (string-match "\\$LEDGER" command)
       (replace-match (format "%s -f \"%s\" %s" ledger-path
                              data-file ledger-normalization-args) t t command)
-    (concat (format "%s -f \"%s\" %s " ledger-path
-                    data-file ledger-normalization-args) command)))
+      (concat (format "%s -f \"%s\" %s " ledger-path
+		      data-file ledger-normalization-args) command)))
 
 (defun ledger-texi-invoke-command (command)
   (with-temp-buffer (shell-command command t (current-buffer))
-    (if (= (point-min) (point-max))
-        (progn
-          (push-mark nil t)
-          (message "Command '%s' yielded no result at %d" command (point))
-          (ding))
-      (buffer-string))))
+		    (if (= (point-min) (point-max))
+			(progn
+			  (push-mark nil t)
+			  (message "Command '%s' yielded no result at %d" command (point))
+			  (ding))
+			(buffer-string))))
 
 (defun ledger-texi-write-test-data (name input)
   (let ((path (expand-file-name name temporary-file-directory)))
@@ -149,7 +149,7 @@
 
         (let ((section-name (if (string= section "smex")
                                 "smallexample"
-                              "example"))
+				"example"))
               (output (ledger-texi-invoke-command
                        (ledger-texi-expand-command command data-file))))
           (insert "@" section-name ?\n output
-- 
cgit v1.2.3


From 1e3c795935dc5c938b78fc367ee19e1a259b0fb3 Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Wed, 27 Feb 2013 10:07:03 -0700
Subject: Update date regex to handles dashes and slashes

---
 lisp/ldg-commodities.el | 1 +
 lisp/ldg-regex.el       | 2 ++
 lisp/ldg-xact.el        | 4 ++--
 3 files changed, 5 insertions(+), 2 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-commodities.el b/lisp/ldg-commodities.el
index 612350b3..6f835221 100644
--- a/lisp/ldg-commodities.el
+++ b/lisp/ldg-commodities.el
@@ -36,6 +36,7 @@
 This only has effect interfacing to calc mode in edit amount"
   :type 'boolean
   :group 'ledger)
+
 (defun ledger-split-commodity-string (str)
   "Split a commoditized amount into two parts"
   (let (val
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 680063f7..e81394ef 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -24,6 +24,8 @@
 (eval-when-compile
   (require 'cl))
 
+(defvar ledger-date-regex "\\([0-9]+\\)[/-]\\([0-9]+\\)[/-]\\([0-9]+\\)")
+
 (defmacro ledger-define-regexp (name regex docs &rest args)
   "Simplify the creation of a Ledger regex and helper functions."
   (let ((defs
diff --git a/lisp/ldg-xact.el b/lisp/ldg-xact.el
index f5a38ef6..8db50df2 100644
--- a/lisp/ldg-xact.el
+++ b/lisp/ldg-xact.el
@@ -106,7 +106,7 @@ within the transaction."
 	 (extents (ledger-find-xact-extents (point)))
 	 (transaction (buffer-substring (car extents) (cadr extents)))
 	 encoded-date)
-    (if (string-match "\\([0-9]+\\)/\\([0-9]+\\)/\\([0-9]+\\)" date)
+    (if (string-match ledger-date-regex date)
 	(setq encoded-date
 	      (encode-time 0 0 0 (string-to-number (match-string 3 date))
 			   (string-to-number (match-string 2 date))
@@ -114,7 +114,7 @@ within the transaction."
     (ledger-find-slot encoded-date)
     (insert transaction "\n")
     (backward-paragraph)
-    (re-search-forward "\\([0-9]+\\)/\\([0-9]+\\)/\\([0-9]+\\)")
+    (re-search-forward ledger-date-regex)
     (replace-match date)
     (re-search-forward "[1-9][0-9]+\.[0-9]+")))
 
-- 
cgit v1.2.3


From 1eba7c6cdf4ac334a5b8580e4f18102db26b8c5f Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Wed, 6 Mar 2013 14:36:31 -0500
Subject: Code formatting cleanup.

---
 lisp/ldg-occur.el     | 4 +++-
 lisp/ldg-reconcile.el | 1 -
 lisp/ldg-regex.el     | 3 ++-
 3 files changed, 5 insertions(+), 3 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-occur.el b/lisp/ldg-occur.el
index 1561d6f8..f14aeeda 100644
--- a/lisp/ldg-occur.el
+++ b/lisp/ldg-occur.el
@@ -41,7 +41,9 @@
 (make-variable-buffer-local 'ledger-occur-use-face-unfolded)
 
 
-(defvar ledger-occur-mode nil) ;; name of the minor mode, shown in the mode-line
+(defvar ledger-occur-mode nil 
+"name of the minor mode, shown in the mode-line")
+
 (make-variable-buffer-local 'ledger-occur-mode)
 
 (or (assq 'ledger-occur-mode minor-mode-alist)
diff --git a/lisp/ldg-reconcile.el b/lisp/ldg-reconcile.el
index e45ab7c3..fd452004 100644
--- a/lisp/ldg-reconcile.el
+++ b/lisp/ldg-reconcile.el
@@ -443,6 +443,5 @@ POSTING is used in `ledger-clear-whole-transactions' is nil."
      (use-local-map map)))
 
 (provide 'ldg-reconcile)
-(provide 'ldg-reconcile)
 
 ;;; ldg-reconcile.el ends here
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index e81394ef..97fd6e2c 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -24,7 +24,8 @@
 (eval-when-compile
   (require 'cl))
 
-(defvar ledger-date-regex "\\([0-9]+\\)[/-]\\([0-9]+\\)[/-]\\([0-9]+\\)")
+(defvar ledger-date-regex 
+  "\\([0-9]+\\)[/-]\\([0-9]+\\)[/-]\\([0-9]+\\)")
 
 (defmacro ledger-define-regexp (name regex docs &rest args)
   "Simplify the creation of a Ledger regex and helper functions."
-- 
cgit v1.2.3


From 86d0fd87c49e20b0f5262e7ae48234986584b750 Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Tue, 2 Apr 2013 14:20:29 -0700
Subject: Fixes bug 904, failure to highly pending postings.  Adds two new
 faces for pending and cleared posting.

---
 doc/ledger-mode.texi |  5 +++++
 lisp/ldg-fonts.el    | 31 ++++++++++++++++++++++---------
 lisp/ldg-post.el     |  4 ++--
 lisp/ldg-regex.el    | 24 ++++++++++++++++++++++++
 4 files changed, 53 insertions(+), 11 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/doc/ledger-mode.texi b/doc/ledger-mode.texi
index 70a5d97a..34c38dae 100644
--- a/doc/ledger-mode.texi
+++ b/doc/ledger-mode.texi
@@ -672,6 +672,11 @@ Default face for pending (!) transactions
 Default face for other transactions
 @item ledger-font-posting-account-face
 Face for Ledger accounts
+@item ledger-font-posting-account-cleared-face
+Face for cleared Ledger accounts
+@item ledger-font-posting-account-pending-face
+Face for Ledger pending accounts
+
 @item ledger-font-posting-amount-face
 Face for Ledger amounts
 @item ledger-occur-narrowed-face
diff --git a/lisp/ldg-fonts.el b/lisp/ldg-fonts.el
index 3a7d1e0a..81196c10 100644
--- a/lisp/ldg-fonts.el
+++ b/lisp/ldg-fonts.el
@@ -26,6 +26,8 @@
 
 ;;; Code:
 
+(require 'ldg-regex)
+
 (defgroup ledger-faces nil "Ledger mode highlighting" :group 'ledger)
 (defface ledger-font-uncleared-face
     `((t :foreground "#dc322f" :weight bold ))
@@ -57,6 +59,16 @@
   "Face for Ledger accounts"
   :group 'ledger-faces)
 
+(defface ledger-font-posting-account-cleared-face
+    `((t :foreground "#657b83" ))
+  "Face for Ledger accounts"
+  :group 'ledger-faces)
+
+(defface ledger-font-posting-account-pending-face
+    `((t :foreground "#cb4b16" ))
+  "Face for Ledger accounts"
+  :group 'ledger-faces)
+
 (defface ledger-font-posting-amount-face
     `((t :foreground "yellow" ))
   "Face for Ledger amounts"
@@ -99,16 +111,17 @@
 
 
 (defvar ledger-font-lock-keywords
-  '(("^[0-9]+[-/.=][-/.=0-9]+\\s-\\!\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)" 2 'ledger-font-pending-face)
-    ("^[0-9]+[-/.=][-/.=0-9]+\\s-\\*\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)" 2 'ledger-font-cleared-face)
-    ("^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)" 2 'ledger-font-uncleared-face)
-    ("^\\s-+\\([*]\\s-*\\)?\\(\\([[(]\\)?[^*:
-        ]+?:\\([^]);
-        ]\\|\\s-\\)+?\\([])]\\)?\\)\\(    \\|  \\|$\\)"
+  `((,ledger-payee-pending-regex 2 'ledger-font-pending-face)
+    (,ledger-payee-cleared-regex 2 'ledger-font-cleared-face)
+    (,ledger-payee-uncleared-regex 2 'ledger-font-uncleared-face)
+    (,ledger-posting-account-cleared-regex
+      2 'ledger-font-posting-account-cleared-face) 
+    (,ledger-posting-account-pending-regex
+      2 'ledger-font-posting-account-pending-face) ; works
+    (,ledger-posting-account-all-regex
      2 'ledger-font-posting-account-face) ; works
-    ("\\(       \\|  \\|^\\)\\(;.*\\)" 2 'ledger-font-comment-face)  ; works
-    ("^\\([~=].+\\)" 1 ledger-font-other-face)
-    ("^\\([A-Za-z]+ .+\\)" 1 ledger-font-other-face))
+    (,ledger-comment-regex 2 'ledger-font-comment-face)  ; works
+    (,ledger-other-entries-regex 1 ledger-font-other-face))
   "Expressions to highlight in Ledger mode.")
 
 
diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el
index 554b8578..f29d8af8 100644
--- a/lisp/ldg-post.el
+++ b/lisp/ldg-post.el
@@ -136,14 +136,14 @@ point at beginning of the commodity."
            (match-end 3)) (point))))
 
 (defvar ledger-post-account-regex
-  "\\(^[ \t]+\\)\\(.+?\\)\\(  \\|\n\\)")  
+  "\\(^[ \t]+\\)\\([!*]?.+?\\)\\(  \\|$\\)")  
 
 (defun ledger-next-account (&optional end)
   "Move point to the beginning of the next account, or status marker (!*), as long as it is not past END.
 Return the column of the beginning of the account and leave point
 at beginning of account"
     (if (> end (point))
-	(when (re-search-forward ledger-post-account-regex (1+ end) t)  
+	(when (re-search-forward ledger-posting-account-all-regex (1+ end) t)  
 	  ;; the 1+ is to make sure we can catch the newline
 	  (goto-char (match-beginning 2))
 	  (current-column))))
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 97fd6e2c..7c92bf15 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -24,6 +24,30 @@
 (eval-when-compile
   (require 'cl))
 
+(defvar ledger-other-entries-regex
+  "^\\(\\([~=].+\\)\\|\\(^\\([A-Za-z]+ .+\\)\\)\\)")
+
+(defvar ledger-comment-regex
+  "\\(       \\|  \\|^\\)\\(;.*\\)")
+(defvar ledger-payee-pending-regex 
+  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\!\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
+
+(defvar ledger-payee-cleared-regex
+  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\*\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
+
+(defvar ledger-payee-uncleared-regex
+  "^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
+
+
+(defvar ledger-posting-account-all-regex
+  "\\(^[ \t]+\\)\\(.+?\\)\\(  \\|$\\)")  
+
+(defvar ledger-posting-account-cleared-regex
+  "\\(^[ \t]+\\)\\(\\*.+?\\)\\(  \\|$\\)")  
+
+(defvar ledger-posting-account-pending-regex
+  "\\(^[ \t]+\\)\\(!.+?\\)\\(  \\|$\\)")  
+
 (defvar ledger-date-regex 
   "\\([0-9]+\\)[/-]\\([0-9]+\\)[/-]\\([0-9]+\\)")
 
-- 
cgit v1.2.3


From 519e57ca1fac01ea057bea8263c6cb06a8ac4e7e Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Tue, 2 Apr 2013 23:13:23 -0700
Subject: Consolidated all major regexes into ldg-regex.  Only major exception
 are the regex in ledger context at point.

---
 lisp/ldg-commodities.el |  8 +++++---
 lisp/ldg-complete.el    |  5 ++---
 lisp/ldg-fonts.el       | 44 +++++++++++++++++++++++++++-----------------
 lisp/ldg-init.el        |  4 +++-
 lisp/ldg-mode.el        |  2 +-
 lisp/ldg-new.el         |  2 +-
 lisp/ldg-post.el        | 11 +----------
 lisp/ldg-reconcile.el   | 14 ++++++++++++--
 lisp/ldg-regex.el       | 35 ++++++++++++++++++++++++++++++++++-
 lisp/ldg-sort.el        |  5 ++---
 lisp/ldg-xact.el        |  4 ++--
 11 files changed, 90 insertions(+), 44 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-commodities.el b/lisp/ldg-commodities.el
index 8755166d..031bddeb 100644
--- a/lisp/ldg-commodities.el
+++ b/lisp/ldg-commodities.el
@@ -26,6 +26,8 @@
 
 ;;; Code:
 
+(require 'ldg-regex)
+
 (defcustom ledger-reconcile-default-commodity "$"
   "The default commodity for use in target calculations in ledger reconcile."
   :type 'string
@@ -36,13 +38,13 @@
 Returns a list with (value commodity)."
   (if (> (length str) 0) 
       (let ((number-regex (if (assoc "decimal-comma" ledger-environment-alist)
-			      "-?[1-9][0-9.]*[,]?[0-9]*"
-			      "-?[1-9][0-9,]*[.]?[0-9]*")))
+			      ledger-amount-decimal-comma-regex
+			      ledger-amount-decimal-period-regex)))
 	(with-temp-buffer
 	  (insert str)
 	  (goto-char (point-min))
 	  (cond 
-	    ((re-search-forward "\"\\(.*\\)\"" nil t) 
+	    ((re-search-forward "\"\\(.*\\)\"" nil t) ; look for quoted commodities
 	     (let ((com (delete-and-extract-region 
 			 (match-beginning 1)       
 			 (match-end 1))))
diff --git a/lisp/ldg-complete.el b/lisp/ldg-complete.el
index fe27e91d..3462c0bb 100644
--- a/lisp/ldg-complete.el
+++ b/lisp/ldg-complete.el
@@ -52,8 +52,7 @@
     (save-excursion
       (goto-char (point-min))
       (while (re-search-forward
-              (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
-                      "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)") nil t)  ;; matches first line
+              ledger-xact-payee-regex nil t)  ;; matches first line
         (unless (and (>= origin (match-beginning 0))
                      (< origin (match-end 0)))
           (setq payees-list (cons (match-string-no-properties 3)
@@ -70,7 +69,7 @@ Return tree structure"
     (save-excursion
       (goto-char (point-min))
       (while (re-search-forward
-              "^[ \t]+\\([*!]\\s-+\\)?[[(]?\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)" nil t)
+              ledger-complete-account-regex nil t)
         (unless (and (>= origin (match-beginning 0))
                      (< origin (match-end 0)))
           (setq account-elements
diff --git a/lisp/ldg-fonts.el b/lisp/ldg-fonts.el
index 81196c10..81b5b0bf 100644
--- a/lisp/ldg-fonts.el
+++ b/lisp/ldg-fonts.el
@@ -29,17 +29,17 @@
 (require 'ldg-regex)
 
 (defgroup ledger-faces nil "Ledger mode highlighting" :group 'ledger)
-(defface ledger-font-uncleared-face
+(defface ledger-font-payee-uncleared-face
     `((t :foreground "#dc322f" :weight bold ))
   "Default face for Ledger"
   :group 'ledger-faces)
 
-(defface ledger-font-cleared-face
+(defface ledger-font-payee-cleared-face
     `((t :foreground "#657b83" :weight normal ))
   "Default face for cleared (*) transactions"
   :group 'ledger-faces)
 
-(defface ledger-font-highlight-face
+(defface ledger-font-xact-highlight-face
     `((t :background "#eee8d5"))
   "Default face for transaction under point"
   :group 'ledger-faces)
@@ -50,7 +50,7 @@
   :group 'ledger-faces)
 
 (defface ledger-font-other-face
-    `((t :foreground "yellow" ))
+    `((t :foreground "#657b83" :weight bold))
   "Default face for other transactions"
   :group 'ledger-faces)
 
@@ -70,7 +70,7 @@
   :group 'ledger-faces)
 
 (defface ledger-font-posting-amount-face
-    `((t :foreground "yellow" ))
+    `((t :foreground "#cb4b16" ))
   "Face for Ledger amounts"
   :group 'ledger-faces)
 
@@ -111,20 +111,30 @@
 
 
 (defvar ledger-font-lock-keywords
-  `((,ledger-payee-pending-regex 2 'ledger-font-pending-face)
-    (,ledger-payee-cleared-regex 2 'ledger-font-cleared-face)
-    (,ledger-payee-uncleared-regex 2 'ledger-font-uncleared-face)
-    (,ledger-posting-account-cleared-regex
-      2 'ledger-font-posting-account-cleared-face) 
-    (,ledger-posting-account-pending-regex
-      2 'ledger-font-posting-account-pending-face) ; works
-    (,ledger-posting-account-all-regex
-     2 'ledger-font-posting-account-face) ; works
-    (,ledger-comment-regex 2 'ledger-font-comment-face)  ; works
-    (,ledger-other-entries-regex 1 ledger-font-other-face))
+  `( ;; (,ledger-other-entries-regex 1 
+     ;; 				  ledger-font-other-face)
+     (,ledger-comment-regex 2 
+			    'ledger-font-comment-face)
+     (,ledger-payee-pending-regex 2 
+				  'ledger-font-payee-pending-face) ; Works
+     (,ledger-payee-cleared-regex 2 
+ 				  'ledger-font-payee-cleared-face) ; Works
+     (,ledger-payee-uncleared-regex 2 
+ 				    'ledger-font-payee-uncleared-face) ; Works
+     (,ledger-posting-account-cleared-regex 2 
+ 					    'ledger-font-posting-account-cleared-face) ; Works
+     (,ledger-posting-account-pending-regex 2 
+ 					    'ledger-font-posting-account-pending-face) ; Works
+     (,ledger-posting-account-all-regex 2 
+ 					'ledger-font-posting-account-face)) ; Works
   "Expressions to highlight in Ledger mode.")
+    
 
-
+;; (defvar ledger-font-lock-keywords
+;;   `( (,ledger-other-entries-regex 1 
+;; 				  ledger-font-other-face))
+;;   "Expressions to highlight in Ledger mode.")
+    
 (provide 'ldg-fonts)
 
 ;;; ldg-fonts.el ends here
diff --git a/lisp/ldg-init.el b/lisp/ldg-init.el
index 8e657323..29839c9e 100644
--- a/lisp/ldg-init.el
+++ b/lisp/ldg-init.el
@@ -22,6 +22,8 @@
 ;;; Commentary:
 ;; Determine the ledger environment
 
+(require 'ldg-regex)
+
 (defcustom ledger-init-file-name "~/.ledgerrc"
   "Location of the ledger initialization file. nil if you don't have one"
   :group 'ledger-exec)
@@ -32,7 +34,7 @@
   (with-current-buffer file
     (setq ledger-environment-alist nil)
     (goto-char (point-min))
-    (while (re-search-forward "^--.+?\\($\\|[ ]\\)" nil t )
+    (while (re-search-forward ledger-init-string-regex nil t )
       (let ((matchb (match-beginning 0)) ;; save the match data, string-match stamp on it
 	    (matche (match-end 0)))
 	(end-of-line)
diff --git a/lisp/ldg-mode.el b/lisp/ldg-mode.el
index c9814918..df9dda87 100644
--- a/lisp/ldg-mode.el
+++ b/lisp/ldg-mode.el
@@ -238,7 +238,7 @@ correct chronological place in the buffer."
          exit-code)
     (unless insert-at-point
       (let ((date (car args)))
-        (if (string-match "\\([0-9]+\\)[-/]\\([0-9]+\\)[-/]\\([0-9]+\\)" date)
+        (if (string-match ledger-iso-date-regex date)
             (setq date
                   (encode-time 0 0 0 (string-to-number (match-string 3 date))
                                (string-to-number (match-string 2 date))
diff --git a/lisp/ldg-new.el b/lisp/ldg-new.el
index 8ff95cd3..05e18818 100644
--- a/lisp/ldg-new.el
+++ b/lisp/ldg-new.el
@@ -32,6 +32,7 @@
 
 ;;; Commentary:
 ;; Load up the ledger mode
+(require 'ldg-regex)
 (require 'esh-util)
 (require 'esh-arg)
 (require 'ldg-commodities)
@@ -43,7 +44,6 @@
 (require 'ldg-occur)
 (require 'ldg-post)
 (require 'ldg-reconcile)
-(require 'ldg-regex)
 (require 'ldg-report)
 (require 'ldg-sort)
 (require 'ldg-state)
diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el
index f29d8af8..767a263a 100644
--- a/lisp/ldg-post.el
+++ b/lisp/ldg-post.el
@@ -115,14 +115,7 @@ PROMPT is a string to prompt with.  CHOICES is a list of
 		 (delete-char 1)))))))
     (goto-char pos)))
 
-(defvar ledger-post-amount-regex
-  (concat "\\(  \\|\t\\| \t\\)[ \t]*-?"
-	  "\\([A-Z$€£_]+ *\\)?"
-	  "\\(-?[0-9,]+?\\)"
-	  "\\(.[0-9]+\\)?"
-	  "\\( *[[:word:]€£_\"]+\\)?"
-	  "\\([ \t]*[@={]@?[^\n;]+?\\)?"
-	  "\\([ \t]+;.+?\\|[ \t]*\\)?$"))
+
 
 (defsubst ledger-next-amount (&optional end)
   "Move point to the next amount, as long as it is not past END.
@@ -135,8 +128,6 @@ point at beginning of the commodity."
     (- (or (match-end 4)
            (match-end 3)) (point))))
 
-(defvar ledger-post-account-regex
-  "\\(^[ \t]+\\)\\([!*]?.+?\\)\\(  \\|$\\)")  
 
 (defun ledger-next-account (&optional end)
   "Move point to the beginning of the next account, or status marker (!*), as long as it is not past END.
diff --git a/lisp/ldg-reconcile.el b/lisp/ldg-reconcile.el
index bec6d175..ccf733b7 100644
--- a/lisp/ldg-reconcile.el
+++ b/lisp/ldg-reconcile.el
@@ -62,6 +62,16 @@ reconcile-finish will mark all pending posting cleared."
    :type 'boolean
    :group 'ledger-reconcile)
 
+(defcustom ledger-reconcile-default-date-format "%Y/%m/%d"
+  "Default date format for the reconcile buffer"
+  :type 'string
+  :group 'ledger-reconcile)
+
+(defcustom ledger-reconcile-target-prompt-string "Target amount for reconciliation "
+  "Default prompt for recon target prompt"
+  :type 'string
+  :group 'ledger-reconcile)
+
 
 (defun ledger-reconcile-get-cleared-or-pending-balance ()
   "Calculate the cleared or pending balance of the account."
@@ -299,7 +309,7 @@ POSTING is used in `ledger-clear-whole-transactions' is nil."
 		  (insert (format "%s %-4s %-30s %-30s %15s\n"
 				  (format-time-string (if date-format
 							  date-format
-							  "%Y/%m/%d") (nth 2 xact))
+							  ledger-reconcile-default-date-format) (nth 2 xact))
 				  (if (nth 3 xact)
 				      (nth 3 xact)
 				      "")
@@ -409,7 +419,7 @@ moved and recentered.  If they aren't strange things happen."
 (defun ledger-reconcile-change-target ()
   "Change the target amount for the reconciliation process."
   (interactive)
-  (setq ledger-target (ledger-read-commodity-string "Set reconciliation target")))
+  (setq ledger-target (ledger-read-commodity-string ledger-reconcile-target-prompt-string)))
 
 (define-derived-mode ledger-reconcile-mode text-mode "Reconcile"
    "A mode for reconciling ledger entries."
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 7c92bf15..24a3ae23 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -24,11 +24,23 @@
 (eval-when-compile
   (require 'cl))
 
+(defvar ledger-amount-decimal-comma-regex
+  "-?[1-9][0-9.]*[,]?[0-9]*")
+
+(defvar ledger-amount-decimal-period-regex
+  "-?[1-9][0-9.]*[.]?[0-9]*")
+
 (defvar ledger-other-entries-regex
-  "^\\(\\([~=].+\\)\\|\\(^\\([A-Za-z]+ .+\\)\\)\\)")
+  "\\(^[~=A-Za-z].+\\)+")
 
+;\\|^\\([A-Za-z] .+\\)\\)
+
+(defvar ledger-xact-payee-regex
+  (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
+                      "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)"))
 (defvar ledger-comment-regex
   "\\(       \\|  \\|^\\)\\(;.*\\)")
+
 (defvar ledger-payee-pending-regex 
   "^[0-9]+[-/.=][-/.=0-9]+\\s-\\!\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
 
@@ -38,19 +50,40 @@
 (defvar ledger-payee-uncleared-regex
   "^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
 
+(defvar ledger-iso-date-regex
+  "\\([12][0-9]\\{3\\}\\)[-/]\\([0-9]\\{2\\}\\)[-/]\\([0-9]\\{2\\}\\)")
+
+(defvar ledger-init-string-regex
+  "^--.+?\\($\\|[ ]\\)")
 
 (defvar ledger-posting-account-all-regex
   "\\(^[ \t]+\\)\\(.+?\\)\\(  \\|$\\)")  
 
+(defvar ledger-sort-next-record-regex
+  (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
+	  "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)"))
+
 (defvar ledger-posting-account-cleared-regex
   "\\(^[ \t]+\\)\\(\\*.+?\\)\\(  \\|$\\)")  
 
+(defvar ledger-complete-account-regex
+  "^[ \t]+\\([*!]\\s-+\\)?[[(]?\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)")
+
 (defvar ledger-posting-account-pending-regex
   "\\(^[ \t]+\\)\\(!.+?\\)\\(  \\|$\\)")  
 
 (defvar ledger-date-regex 
   "\\([0-9]+\\)[/-]\\([0-9]+\\)[/-]\\([0-9]+\\)")
 
+(defvar ledger-post-amount-regex
+  (concat "\\(  \\|\t\\| \t\\)[ \t]*-?"
+	  "\\([A-Z$€£_]+ *\\)?"
+	  "\\(-?[0-9,]+?\\)"
+	  "\\(.[0-9]+\\)?"
+	  "\\( *[[:word:]€£_\"]+\\)?"
+	  "\\([ \t]*[@={]@?[^\n;]+?\\)?"
+	  "\\([ \t]+;.+?\\|[ \t]*\\)?$"))
+
 (defmacro ledger-define-regexp (name regex docs &rest args)
   "Simplify the creation of a Ledger regex and helper functions."
   (let ((defs
diff --git a/lisp/ldg-sort.el b/lisp/ldg-sort.el
index 5119db5d..b106173b 100644
--- a/lisp/ldg-sort.el
+++ b/lisp/ldg-sort.el
@@ -28,9 +28,8 @@
 
 (defun ledger-next-record-function ()
   "Move point to next transaction."
-  (if (re-search-forward
-       (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
-	       "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)") nil t)
+  (if (re-search-forward ledger-sort-next-record-regex
+			 nil t)
       (goto-char (match-beginning 0))
       (goto-char (point-max))))
 
diff --git a/lisp/ldg-xact.el b/lisp/ldg-xact.el
index d6ccc2bf..66d3f46f 100644
--- a/lisp/ldg-xact.el
+++ b/lisp/ldg-xact.el
@@ -53,7 +53,7 @@ within the transaction."
 
 (defun ledger-highlight-xact-under-point ()
   "Move the highlight overlay to the current transaction."
-(if ledger-highlight-xact-under-point
+  (if ledger-highlight-xact-under-point
       (let ((exts (ledger-find-xact-extents (point)))
 	    (ovl highlight-overlay))
 	(if (not highlight-overlay)
@@ -63,7 +63,7 @@ within the transaction."
 				      (cadr exts)
 				      (current-buffer) t nil)))
 	    (move-overlay ovl (car exts) (cadr exts)))
-	(overlay-put ovl 'face 'ledger-font-highlight-face)
+	(overlay-put ovl 'face 'ledger-font-xact-highlight-face)
 	(overlay-put ovl 'priority 100))))
 
 (defun ledger-xact-payee ()
-- 
cgit v1.2.3


From 1a52899673f02b87b065c5b29755394581b485c9 Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Wed, 3 Apr 2013 16:30:36 -0700
Subject: Fix copy-at-point and more regex consolidation and cleanup

---
 lisp/ldg-complete.el |  6 ++--
 lisp/ldg-fonts.el    | 12 ++++----
 lisp/ldg-mode.el     | 53 +++++----------------------------
 lisp/ldg-post.el     |  4 +--
 lisp/ldg-regex.el    | 82 +++++++++++++++++++++++++---------------------------
 lisp/ldg-sort.el     |  4 +--
 lisp/ldg-xact.el     | 51 +++++++++++++++++++++++++++-----
 7 files changed, 103 insertions(+), 109 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-complete.el b/lisp/ldg-complete.el
index 3462c0bb..0be4f438 100644
--- a/lisp/ldg-complete.el
+++ b/lisp/ldg-complete.el
@@ -52,7 +52,7 @@
     (save-excursion
       (goto-char (point-min))
       (while (re-search-forward
-              ledger-xact-payee-regex nil t)  ;; matches first line
+              ledger-payee-any-status-regex nil t)  ;; matches first line
         (unless (and (>= origin (match-beginning 0))
                      (< origin (match-end 0)))
           (setq payees-list (cons (match-string-no-properties 3)
@@ -69,7 +69,7 @@ Return tree structure"
     (save-excursion
       (goto-char (point-min))
       (while (re-search-forward
-              ledger-complete-account-regex nil t)
+              ledger-account-any-status-regex nil t)
         (unless (and (>= origin (match-beginning 0))
                      (< origin (match-end 0)))
           (setq account-elements
@@ -153,7 +153,7 @@ Does not use ledger xact"
 	  (setq rest-of-name (match-string 3))
           ;; Start copying the postings
 	  (forward-line)
-          (while (looking-at ledger-post-account-regex)
+          (while (looking-at ledger-complete-account-regex)
             (setq xacts (cons (buffer-substring-no-properties
                                (line-beginning-position)
                                (line-end-position))
diff --git a/lisp/ldg-fonts.el b/lisp/ldg-fonts.el
index 81b5b0bf..d83e7f9b 100644
--- a/lisp/ldg-fonts.el
+++ b/lisp/ldg-fonts.el
@@ -121,12 +121,12 @@
  				  'ledger-font-payee-cleared-face) ; Works
      (,ledger-payee-uncleared-regex 2 
  				    'ledger-font-payee-uncleared-face) ; Works
-     (,ledger-posting-account-cleared-regex 2 
- 					    'ledger-font-posting-account-cleared-face) ; Works
-     (,ledger-posting-account-pending-regex 2 
- 					    'ledger-font-posting-account-pending-face) ; Works
-     (,ledger-posting-account-all-regex 2 
- 					'ledger-font-posting-account-face)) ; Works
+     (,ledger-account-cleared-regex 2 
+ 	      			    'ledger-font-posting-account-cleared-face) ; Works
+     (,ledger-account-pending-regex 2 
+ 	      			    'ledger-font-posting-account-pending-face) ; Works
+     (,ledger-account-any-status-regex 2 
+				       'ledger-font-posting-account-face)) ; Works
   "Expressions to highlight in Ledger mode.")
     
 
diff --git a/lisp/ldg-mode.el b/lisp/ldg-mode.el
index df9dda87..f1b434e9 100644
--- a/lisp/ldg-mode.el
+++ b/lisp/ldg-mode.el
@@ -101,7 +101,7 @@ Can be pcomplete, or align-posting"
       (define-key map [(control ?c) (control ?d)] 'ledger-delete-current-transaction)
       (define-key map [(control ?c) (control ?e)] 'ledger-toggle-current-transaction)
       (define-key map [(control ?c) (control ?f)] 'ledger-occur)
-      (define-key map [(control ?c) (control ?k)] 'ledger-copy-transaction)
+      (define-key map [(control ?c) (control ?k)] 'ledger-copy-transaction-at-point)
       (define-key map [(control ?c) (control ?m)] 'ledger-set-month)
       (define-key map [(control ?c) (control ?r)] 'ledger-reconcile)
       (define-key map [(control ?c) (control ?s)] 'ledger-sort-region)
@@ -144,7 +144,7 @@ Can be pcomplete, or align-posting"
       (define-key map [sort-reg] '(menu-item "Sort Region" ledger-sort-region :enable mark-active))
       (define-key map [align-reg] '(menu-item "Align Region" ledger-post-align-postings :enable mark-active))
       (define-key map [sep2] '(menu-item "--"))
-      (define-key map [copy-xact] '(menu-item "Copy Trans at Point" ledger-copy-transaction))
+      (define-key map [copy-xact] '(menu-item "Copy Trans at Point" ledger-copy-transaction-at-point))
       (define-key map [toggle-post] '(menu-item "Toggle Current Posting" ledger-toggle-current))
       (define-key map [toggle-xact] '(menu-item "Toggle Current Transaction" ledger-toggle-current-transaction))
       (define-key map [sep4] '(menu-item "--"))
@@ -172,43 +172,6 @@ Return the difference in the format of a time value."
     (list (- (car t1) (car t2) (if borrow 1 0))
           (- (+ (if borrow 65536 0) (cadr t1)) (cadr t2)))))
 
-(defun ledger-find-slot (moment)
-  "Find the right place in the buffer for a transaction at MOMENT.
-MOMENT is an encoded date"
-  (catch 'found
-    (ledger-iterate-transactions
-     (function
-      (lambda (start date mark desc)
-       (if (ledger-time-less-p moment date)
-	   (throw 'found t)))))))
-
-(defun ledger-iterate-transactions (callback)
-  "Iterate through each transaction call CALLBACK for each."
-  (goto-char (point-min))
-  (let* ((now (current-time))
-         (current-year (nth 5 (decode-time now))))
-    (while (not (eobp))
-      (when (looking-at
-             (concat "\\(Y\\s-+\\([0-9]+\\)\\|"
-                     "\\([0-9]\\{4\\}+\\)?[./-]?"
-                     "\\([0-9]+\\)[./-]\\([0-9]+\\)\\s-+"
-                     "\\(\\*\\s-+\\)?\\(.+\\)\\)"))
-        (let ((found (match-string 2)))
-          (if found
-              (setq current-year (string-to-number found))
-	      (let ((start (match-beginning 0))
-		    (year (match-string 3))
-		    (month (string-to-number (match-string 4)))
-		    (day (string-to-number (match-string 5)))
-		    (mark (match-string 6))
-		    (desc (match-string 7)))
-		(if (and year (> (length year) 0))
-		    (setq year (string-to-number year)))
-		(funcall callback start
-			 (encode-time 0 0 0 day month
-				      (or year current-year))
-			 mark desc)))))
-      (forward-line))))
 
 (defun ledger-set-year (newyear)
   "Set ledger's idea of the current year to the prefix argument NEWYEAR."
@@ -227,7 +190,7 @@ MOMENT is an encoded date"
 (defun ledger-add-transaction (transaction-text &optional insert-at-point)
   "Use ledger xact TRANSACTION-TEXT to add a transaction to the buffer.
 If INSERT-AT-POINT is non-nil insert the transaction
-there, otherwise call `ledger-find-slot' to insert it at the
+there, otherwise call `ledger-xact-find-slot' to insert it at the
 correct chronological place in the buffer."
   (interactive (list
 		(read-string "Transaction: " (concat ledger-year "/" ledger-month "/"))))
@@ -238,12 +201,12 @@ correct chronological place in the buffer."
          exit-code)
     (unless insert-at-point
       (let ((date (car args)))
-        (if (string-match ledger-iso-date-regex date)
+        (if (string-match ledger-iso-date-regexp date)
             (setq date
-                  (encode-time 0 0 0 (string-to-number (match-string 3 date))
-                               (string-to-number (match-string 2 date))
-                               (string-to-number (match-string 1 date)))))
-        (ledger-find-slot date)))
+                  (encode-time 0 0 0 (string-to-number (match-string 4 date))
+                               (string-to-number (match-string 3 date))
+                               (string-to-number (match-string 2 date)))))
+        (ledger-xact-find-slot date)))
     (if (> (length args) 1)
 	(save-excursion
 	  (insert
diff --git a/lisp/ldg-post.el b/lisp/ldg-post.el
index 767a263a..88387fd1 100644
--- a/lisp/ldg-post.el
+++ b/lisp/ldg-post.el
@@ -122,7 +122,7 @@ PROMPT is a string to prompt with.  CHOICES is a list of
 Return the width of the amount field as an integer and leave
 point at beginning of the commodity."
   ;;(beginning-of-line)
-  (when (re-search-forward ledger-post-amount-regex end t)
+  (when (re-search-forward ledger-amount-regex end t)
     (goto-char (match-beginning 0))
     (skip-syntax-forward " ")
     (- (or (match-end 4)
@@ -134,7 +134,7 @@ point at beginning of the commodity."
 Return the column of the beginning of the account and leave point
 at beginning of account"
     (if (> end (point))
-	(when (re-search-forward ledger-posting-account-all-regex (1+ end) t)  
+	(when (re-search-forward ledger-account-any-status-regex (1+ end) t)  
 	  ;; the 1+ is to make sure we can catch the newline
 	  (goto-char (match-beginning 2))
 	  (current-column))))
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 24a3ae23..95da77e2 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -24,58 +24,45 @@
 (eval-when-compile
   (require 'cl))
 
-(defvar ledger-amount-decimal-comma-regex
+(defconst ledger-amount-decimal-comma-regex
   "-?[1-9][0-9.]*[,]?[0-9]*")
 
-(defvar ledger-amount-decimal-period-regex
+(defconst ledger-amount-decimal-period-regex
   "-?[1-9][0-9.]*[.]?[0-9]*")
 
-(defvar ledger-other-entries-regex
+(defconst ledger-other-entries-regex
   "\\(^[~=A-Za-z].+\\)+")
 
 ;\\|^\\([A-Za-z] .+\\)\\)
 
-(defvar ledger-xact-payee-regex
-  (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
-                      "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)"))
-(defvar ledger-comment-regex
+(defconst ledger-comment-regex
   "\\(       \\|  \\|^\\)\\(;.*\\)")
 
-(defvar ledger-payee-pending-regex 
-  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\!\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
+(defconst ledger-payee-any-status-regex 
+  "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)")
 
-(defvar ledger-payee-cleared-regex
-  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\*\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
+(defconst ledger-payee-pending-regex 
+  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\!\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
 
-(defvar ledger-payee-uncleared-regex
-  "^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(\\(        ;\\|  ;\\|$\\)\\)")
+(defconst ledger-payee-cleared-regex
+  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\*\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
 
-(defvar ledger-iso-date-regex
-  "\\([12][0-9]\\{3\\}\\)[-/]\\([0-9]\\{2\\}\\)[-/]\\([0-9]\\{2\\}\\)")
+(defconst ledger-payee-uncleared-regex
+  "^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
 
-(defvar ledger-init-string-regex
+(defconst ledger-init-string-regex
   "^--.+?\\($\\|[ ]\\)")
 
-(defvar ledger-posting-account-all-regex
-  "\\(^[ \t]+\\)\\(.+?\\)\\(  \\|$\\)")  
+(defconst ledger-account-any-status-regex
+  "^[ \t]+\\([*!]\\s-+\\)?[[(]?\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)")  
 
-(defvar ledger-sort-next-record-regex
-  (concat "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+"
-	  "\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)"))
-
-(defvar ledger-posting-account-cleared-regex
-  "\\(^[ \t]+\\)\\(\\*.+?\\)\\(  \\|$\\)")  
-
-(defvar ledger-complete-account-regex
-  "^[ \t]+\\([*!]\\s-+\\)?[[(]?\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)")
-
-(defvar ledger-posting-account-pending-regex
+(defconst ledger-account-pending-regex
   "\\(^[ \t]+\\)\\(!.+?\\)\\(  \\|$\\)")  
 
-(defvar ledger-date-regex 
-  "\\([0-9]+\\)[/-]\\([0-9]+\\)[/-]\\([0-9]+\\)")
+(defconst ledger-account-cleared-regex
+  "\\(^[ \t]+\\)\\(\\*.+?\\)\\(  \\|$\\)")  
 
-(defvar ledger-post-amount-regex
+(defconst ledger-amount-regex
   (concat "\\(  \\|\t\\| \t\\)[ \t]*-?"
 	  "\\([A-Z$€£_]+ *\\)?"
 	  "\\(-?[0-9,]+?\\)"
@@ -84,6 +71,7 @@
 	  "\\([ \t]*[@={]@?[^\n;]+?\\)?"
 	  "\\([ \t]+;.+?\\|[ \t]*\\)?$"))
 
+
 (defmacro ledger-define-regexp (name regex docs &rest args)
   "Simplify the creation of a Ledger regex and helper functions."
   (let ((defs
@@ -179,23 +167,23 @@
 
 (put 'ledger-define-regexp 'lisp-indent-function 1)
 
-(ledger-define-regexp date
-  (let ((sep '(or ?- (any ?. ?/))))     ; can't do (any ?- ?. ?/) due to bug
+(ledger-define-regexp iso-date
+  ( let ((sep '(or ?-  ?/)))    
     (rx (group
-         (and (? (= 4 num)
-                 (eval sep))
-              (and num (? num))
+         (and (group (? (= 4 num)))
+	      (eval sep)
+              (group (and num (? num)))
               (eval sep)
-              (and num (? num))))))
+              (group (and num (? num)))))))
   "Match a single date, in its 'written' form.")
 
 (ledger-define-regexp full-date
   (macroexpand
-   `(rx (and (regexp ,ledger-date-regexp)
-             (? (and ?= (regexp ,ledger-date-regexp))))))
+   `(rx (and (regexp ,ledger-iso-date-regexp)
+             (? (and ?= (regexp ,ledger-iso-date-regexp))))))
   "Match a compound date, of the form ACTUAL=EFFECTIVE"
-  (actual date)
-  (effective date))
+  (actual iso-date)
+  (effective iso-date))
 
 (ledger-define-regexp state
   (rx (group (any ?! ?*)))
@@ -292,7 +280,7 @@
   (macroexpand
    `(rx (* (+ blank)
            (or (and ?\{ (regexp ,ledger-commoditized-amount-regexp) ?\})
-               (and ?\[ (regexp ,ledger-date-regexp) ?\])
+               (and ?\[ (regexp ,ledger-iso-date-regexp) ?\])
                (and ?\( (not (any ?\))) ?\))))))
   "")
 
@@ -328,4 +316,12 @@
   (amount full-amount)
   (note end-note))
 
+(defconst ledger-iterate-regex
+  (concat "\\(Y\\s-+\\([0-9]+\\)\\|"  ;; Catches a Y directive
+	  ledger-iso-date-regexp
+	  "\\([ *!]+\\)"  ;; mark
+	  "\\((.*)\\)"  ;; code
+	  "\\(.*\\)"   ;; desc
+	  "\\)"))
+
 (provide 'ldg-regex)
diff --git a/lisp/ldg-sort.el b/lisp/ldg-sort.el
index b106173b..f426a7ef 100644
--- a/lisp/ldg-sort.el
+++ b/lisp/ldg-sort.el
@@ -28,8 +28,8 @@
 
 (defun ledger-next-record-function ()
   "Move point to next transaction."
-  (if (re-search-forward ledger-sort-next-record-regex
-			 nil t)
+  (if (re-search-forward  ledger-payee-any-status-regex
+       			 nil t)
       (goto-char (match-beginning 0))
       (goto-char (point-max))))
 
diff --git a/lisp/ldg-xact.el b/lisp/ldg-xact.el
index 66d3f46f..31b9818f 100644
--- a/lisp/ldg-xact.el
+++ b/lisp/ldg-xact.el
@@ -76,6 +76,41 @@ within the transaction."
           (ledger-context-field-value context-info 'payee)
 	  nil))))
 
+(defun ledger-xact-find-slot (moment)
+  "Find the right place in the buffer for a transaction at MOMENT.
+MOMENT is an encoded date"
+  (catch 'found
+    (ledger-xact-iterate-transactions
+     (function
+      (lambda (start date mark desc)
+       (if (ledger-time-less-p moment date)
+	   (throw 'found t)))))))
+
+(defun ledger-xact-iterate-transactions (callback)
+  "Iterate through each transaction call CALLBACK for each."
+  (goto-char (point-min))
+  (let* ((now (current-time))
+         (current-year (nth 5 (decode-time now))))
+    (while (not (eobp))
+      (when (looking-at ledger-iterate-regex)
+        (let ((found-y-p (match-string 2)))  
+          (if found-y-p  
+              (setq current-year (string-to-number found-y-p)) ;; a Y directive was found
+	      (let ((start (match-beginning 0))
+		    (year (match-string 4))
+		    (month (string-to-number (match-string 5)))
+		    (day (string-to-number (match-string 6)))
+		    (mark (match-string 7))
+		    (code (match-string 8))
+		    (desc (match-string 9)))
+		(if (and year (> (length year) 0))
+		    (setq year (string-to-number year)))
+		(funcall callback start
+			 (encode-time 0 0 0 day month
+				      (or year current-year))
+			 mark desc)))))
+      (forward-line))))
+
 (defsubst ledger-goto-line (line-number)
   "Rapidly move point to line LINE-NUMBER."
   (goto-char (point-min)) 
@@ -106,17 +141,17 @@ within the transaction."
 	 (extents (ledger-find-xact-extents (point)))
 	 (transaction (buffer-substring-no-properties (car extents) (cadr extents)))
 	 encoded-date)
-    (if (string-match ledger-date-regex date)
+    (if (string-match ledger-iso-date-regexp date)
 	(setq encoded-date
-	      (encode-time 0 0 0 (string-to-number (match-string 3 date))
-			   (string-to-number (match-string 2 date))
-			   (string-to-number (match-string 1 date)))))
-    (ledger-find-slot encoded-date)
+	      (encode-time 0 0 0 (string-to-number (match-string 4 date))
+			   (string-to-number (match-string 3 date))
+			   (string-to-number (match-string 2 date)))))
+    (ledger-xact-find-slot encoded-date)
     (insert transaction "\n")
-    (backward-paragraph)
-    (re-search-forward ledger-date-regex)
+    (backward-paragraph 2)
+    (re-search-forward ledger-iso-date-regexp)
     (replace-match date)
-    (re-search-forward "[1-9][0-9]+\.[0-9]+")))
+    (ledger-next-amount)))
 
 (provide 'ldg-xact)
 
-- 
cgit v1.2.3


From 2e78e61be7ba6aa73c56c157405e45ed30990b31 Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Thu, 4 Apr 2013 12:35:20 -0700
Subject: Regex Cleanup

---
 lisp/ldg-reconcile.el | 3 +--
 lisp/ldg-regex.el     | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-reconcile.el b/lisp/ldg-reconcile.el
index ccf733b7..ff808485 100644
--- a/lisp/ldg-reconcile.el
+++ b/lisp/ldg-reconcile.el
@@ -227,8 +227,7 @@ Return the number of uncleared xacts found."
       (set-buffer-modified-p nil)
       (ledger-display-balance)
       (goto-char curpoint)
-      ;; (ledger-reconcile-visit t)
-      )))
+      (ledger-reconcile-visit t))))
 
 (defun ledger-reconcile-finish ()
   "Mark all pending posting or transactions as cleared.
diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 95da77e2..1b338012 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -54,7 +54,7 @@
   "^--.+?\\($\\|[ ]\\)")
 
 (defconst ledger-account-any-status-regex
-  "^[ \t]+\\([*!]\\s-+\\)?[[(]?\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)")  
+  "^[ \t]+\\([*!]\\s-+\\)?\\([[(]?.+?\\)\\(\t\\|\n\\| [ \t]\\)")  
 
 (defconst ledger-account-pending-regex
   "\\(^[ \t]+\\)\\(!.+?\\)\\(  \\|$\\)")  
-- 
cgit v1.2.3


From 98f8df5583f16792243aeadee9ed19bd8b3f7897 Mon Sep 17 00:00:00 2001
From: Craig Earls <enderw88@gmail.com>
Date: Sun, 7 Apr 2013 14:48:33 -0700
Subject: Regex consistency and cleanup.

---
 lisp/ldg-regex.el | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

(limited to 'lisp/ldg-regex.el')

diff --git a/lisp/ldg-regex.el b/lisp/ldg-regex.el
index 1b338012..226475df 100644
--- a/lisp/ldg-regex.el
+++ b/lisp/ldg-regex.el
@@ -24,6 +24,15 @@
 (eval-when-compile
   (require 'cl))
 
+(defconst ledger-amount-regex
+  (concat "\\(  \\|\t\\| \t\\)[ \t]*-?"
+	  "\\([A-Z$€£_]+ *\\)?"
+	  "\\(-?[0-9,]+?\\)"
+	  "\\(.[0-9]+\\)?"
+	  "\\( *[[:word:]€£_\"]+\\)?"
+	  "\\([ \t]*[@={]@?[^\n;]+?\\)?"
+	  "\\([ \t]+;.+?\\|[ \t]*\\)?$"))
+
 (defconst ledger-amount-decimal-comma-regex
   "-?[1-9][0-9.]*[,]?[0-9]*")
 
@@ -33,8 +42,6 @@
 (defconst ledger-other-entries-regex
   "\\(^[~=A-Za-z].+\\)+")
 
-;\\|^\\([A-Za-z] .+\\)\\)
-
 (defconst ledger-comment-regex
   "\\(       \\|  \\|^\\)\\(;.*\\)")
 
@@ -42,13 +49,13 @@
   "^[0-9/.=-]+\\(\\s-+\\*\\)?\\(\\s-+(.*?)\\)?\\s-+\\(.+?\\)\\(\t\\|\n\\| [ \t]\\)")
 
 (defconst ledger-payee-pending-regex 
-  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\!\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
+  "^[0-9]+[-/][-/.=0-9]+\\s-\\!\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
 
 (defconst ledger-payee-cleared-regex
-  "^[0-9]+[-/.=][-/.=0-9]+\\s-\\*\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
+  "^[0-9]+[-/][-/.=0-9]+\\s-\\*\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
 
 (defconst ledger-payee-uncleared-regex
-  "^[0-9]+[-/.=][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
+  "^[0-9]+[-/][-/.=0-9]+\\s-+\\(([^)]+)\\s-+\\)?\\([^*].+?\\)\\(;\\|$\\)")
 
 (defconst ledger-init-string-regex
   "^--.+?\\($\\|[ ]\\)")
@@ -62,14 +69,6 @@
 (defconst ledger-account-cleared-regex
   "\\(^[ \t]+\\)\\(\\*.+?\\)\\(  \\|$\\)")  
 
-(defconst ledger-amount-regex
-  (concat "\\(  \\|\t\\| \t\\)[ \t]*-?"
-	  "\\([A-Z$€£_]+ *\\)?"
-	  "\\(-?[0-9,]+?\\)"
-	  "\\(.[0-9]+\\)?"
-	  "\\( *[[:word:]€£_\"]+\\)?"
-	  "\\([ \t]*[@={]@?[^\n;]+?\\)?"
-	  "\\([ \t]+;.+?\\|[ \t]*\\)?$"))
 
 
 (defmacro ledger-define-regexp (name regex docs &rest args)
-- 
cgit v1.2.3