[elpa] externals/org 26e6881: element: Integrate some syntax constants

[ELPA Syncer]

branch: externals/org
commit 26e68816bdae78c24a26274fe3e79df8998f3488
Author: Nicolas Goaziou <mail@nicolasgoaziou.fr>
Commit: Nicolas Goaziou <mail@nicolasgoaziou.fr>

    element: Integrate some syntax constants
    
    * lisp/org-element.el (org-element-archive-tag):
    (org-element-clock-line-re):
    (org-element-comment-string):
    (org-element-closed-keyword):
    (org-element-deadline-keyword):
    (org-element-scheduled-keyword):
    (org-element-planning-keywords-re):
    (org-element-planning-line-re):
    (org-element-drawer-re):
    (org-element-dynamic-block-open-re):
    (org-element-headline-re): New constants.
    (org-element-drawer-parser):
    (org-element-dynamic-block-parser):
    (org-element--footnote-separator):
    (org-element--get-node-properties):
    (org-element--get-time-properties):
    (org-element-headline-parser):
    (org-element-headline-interpreter):
    (org-element-inlinetask-parser):
    (org-element--list-struct):
    (org-element-paragraph-parser):
    (org-element-planning-parser):
    (org-element-planning-interpreter):
    (org-element--current-element):
    (org-element--cache-for-removal):
    (org-element-cache-map):
    (org-element-context): Use new constants so as to not use org.el's.
    * testing/lisp/test-org-element.el 
(test-org-element/headline-comment-keyword):
    (test-org-element/headline-archive-tag):
    * testing/lisp/test-ox.el (test-org-export/handle-options): Fix tests.
---
 lisp/org-element.el              | 147 ++++++++++++++++++++++++++-------------
 testing/lisp/test-org-element.el |  37 ++++------
 testing/lisp/test-ox.el          |  23 +++---
 3 files changed, 121 insertions(+), 86 deletions(-)

diff --git a/lisp/org-element.el b/lisp/org-element.el
index 6e228d4..8102387 100644
--- a/lisp/org-element.el
+++ b/lisp/org-element.el
@@ -82,25 +82,14 @@
 (declare-function outline-next-heading "outline" ())
 (declare-function outline-previous-heading "outline" ())
 
-(defvar org-archive-tag)
-(defvar org-clock-line-re)
-(defvar org-closed-string)
-(defvar org-comment-string)
 (defvar org-complex-heading-regexp)
-(defvar org-dblock-start-re)
-(defvar org-deadline-string)
 (defvar org-done-keywords)
-(defvar org-drawer-regexp)
 (defvar org-edit-src-content-indentation)
-(defvar org-keyword-time-not-clock-regexp)
 (defvar org-match-substring-regexp)
 (defvar org-odd-levels-only)
-(defvar org-outline-regexp-bol)
-(defvar org-planning-line-re)
 (defvar org-property-drawer-re)
 (defvar org-property-format)
 (defvar org-property-re)
-(defvar org-scheduled-string)
 (defvar org-src-preserve-indentation)
 (defvar org-tags-column)
 (defvar org-time-stamp-formats)
@@ -117,6 +106,9 @@
 ;; `org-element-update-syntax' builds proper syntax regexps according
 ;; to current setup.
 
+(defconst org-element-archive-tag "ARCHIVE"
+  "Tag marking a substree as archived.")
+
 (defconst org-element-citation-key-re
   (rx "@" (group (one-or-more (any word "-.:?!`'/*@+|(){}<>&_^$#%~"))))
   "Regexp matching a citation key.
@@ -130,6 +122,56 @@ Key is located in match group 1.")
   "Regexp matching a citation prefix.
 Style, if any, is located in match group 1.")
 
+(defconst org-element-clock-line-re
+  (rx line-start (0+ (or ?\t ?\s)) "CLOCK:")
+  "Regexp matching a clock line.")
+
+(defconst org-element-comment-string "COMMENT"
+  "String marker for commented headlines.")
+
+(defconst org-element-closed-keyword "CLOSED:"
+  "Keyword used to close TODO entries.")
+
+(defconst org-element-deadline-keyword "DEADLINE:"
+  "Keyword used to mark deadline entries.")
+
+(defconst org-element-scheduled-keyword "SCHEDULED:"
+  "Keyword used to mark scheduled entries.")
+
+(defconst org-element-planning-keywords-re
+  (regexp-opt (list org-element-closed-keyword
+                    org-element-deadline-keyword
+                    org-element-scheduled-keyword))
+  "Regexp matching any planning line keyword.")
+
+(defconst org-element-planning-line-re
+  (rx-to-string
+   `(seq line-start (0+ (any ?\s ?\t))
+         (group (regexp ,org-element-planning-keywords-re))))
+  "Regexp matching a planning line.")
+
+(defconst org-element-drawer-re
+  (rx line-start (0+ (any ?\s ?\t))
+      ":" (group (1+ (any ?- ?_ word))) ":"
+      (0+ (any ?\s ?\t)) line-end)
+  "Regexp matching opening or closing line of a drawer.
+Drawer's name is located in match group 1.")
+
+(defconst org-element-dynamic-block-open-re
+  (rx line-start (0+ (any ?\s ?\t))
+      "#+BEGIN:" (0+ (any ?\s ?\t))
+      (group (1+ word))
+      (opt
+       (1+ (any ?\s ?\t))
+       (group (1+ nonl))))
+  "Regexp matching the opening line of a dynamic block.
+Dynamic block's name is located in match group 1.
+Parameters are in match group 2.")
+
+(defconst org-element-headline-re
+  (rx line-start (1+ "*") " ")
+  "Regexp matching a headline.")
+
 (defvar org-element-paragraph-separate nil
   "Regexp to separate paragraphs in an Org buffer.
 In the case of lines starting with \"#\" and \":\", this regexp
@@ -789,8 +831,10 @@ Assume point is at beginning of drawer."
        (org-element-paragraph-parser limit affiliated)
       (save-excursion
        (let* ((drawer-end-line (match-beginning 0))
-              (name (progn (looking-at org-drawer-regexp)
-                           (match-string-no-properties 1)))
+              (name
+                (progn
+                  (looking-at org-element-drawer-re)
+                 (match-string-no-properties 1)))
               (begin (car affiliated))
               (post-affiliated (point))
               ;; Empty drawers have no contents.
@@ -845,9 +889,10 @@ Assume point is at beginning of dynamic block."
        (org-element-paragraph-parser limit affiliated)
       (let ((block-end-line (match-beginning 0)))
        (save-excursion
-         (let* ((name (progn (looking-at org-dblock-start-re)
-                             (match-string-no-properties 1)))
-                (arguments (match-string-no-properties 3))
+         (let* ((name (progn
+                         (looking-at org-element-dynamic-block-open-re)
+                        (match-string-no-properties 1)))
+                (arguments (match-string-no-properties 2))
                 (begin (car affiliated))
                 (post-affiliated (point))
                 ;; Empty blocks have no contents.
@@ -885,7 +930,7 @@ CONTENTS is the contents of the element."
 ;;;; Footnote Definition
 
 (defconst org-element--footnote-separator
-  (concat org-outline-regexp-bol "\\|"
+  (concat org-element-headline-re "\\|"
          org-footnote-definition-re "\\|"
          "^\\([ \t]*\n\\)\\{2,\\}")
   "Regexp used as a footnote definition separator.")
@@ -982,7 +1027,7 @@ parse properties for property drawer at point."
   (save-excursion
     (unless at-point-p?
       (forward-line)
-      (when (looking-at-p org-planning-line-re) (forward-line)))
+      (when (looking-at-p org-element-planning-line-re) (forward-line)))
     (when (looking-at org-property-drawer-re)
       (forward-line)
       (let ((end (match-end 0)) properties)
@@ -1010,16 +1055,16 @@ parse properties for property drawer at point."
   "Return time properties associated to headline at point.
 Return value is a plist."
   (save-excursion
-    (when (progn (forward-line) (looking-at org-planning-line-re))
-      (let ((end (line-end-position)) plist)
-       (while (re-search-forward org-keyword-time-not-clock-regexp end t)
-         (goto-char (match-end 1))
+    (when (progn (forward-line) (looking-at org-element-planning-line-re))
+      (let ((end (line-end-position))
+            plist)
+       (while (re-search-forward org-element-planning-keywords-re end t)
          (skip-chars-forward " \t")
-         (let ((keyword (match-string 1))
+         (let ((keyword (match-string 0))
                (time (org-element-timestamp-parser)))
-           (cond ((equal keyword org-scheduled-string)
+           (cond ((equal keyword org-element-scheduled-keyword)
                   (setq plist (plist-put plist :scheduled time)))
-                 ((equal keyword org-deadline-string)
+                 ((equal keyword org-element-deadline-keyword)
                   (setq plist (plist-put plist :deadline time)))
                  (t (setq plist (plist-put plist :closed time))))))
        plist))))
@@ -1058,7 +1103,8 @@ Assume point is at beginning of the headline."
                          (progn (goto-char (match-end 0))
                                 (aref (match-string 0) 2))))
           (commentedp
-           (and (let (case-fold-search) (looking-at org-comment-string))
+           (and (let ((case-fold-search nil))
+                   (looking-at org-element-comment-string))
                 (goto-char (match-end 0))))
           (title-start (prog1 (point)
                           (unless (or todo priority commentedp)
@@ -1073,7 +1119,7 @@ Assume point is at beginning of the headline."
           (title-end (point))
           (raw-value (org-trim
                       (buffer-substring-no-properties title-start title-end)))
-          (archivedp (member org-archive-tag tags))
+          (archivedp (member org-element-archive-tag tags))
           (footnote-section-p (and org-footnote-section
                                    (string= org-footnote-section raw-value)))
           (standard-props (org-element--get-node-properties))
@@ -1099,7 +1145,7 @@ Assume point is at beginning of the headline."
                                     (line-beginning-position 2))))
            (robust-begin (and contents-begin
                               (progn (goto-char contents-begin)
-                                     (when (looking-at-p org-planning-line-re)
+                                     (when (looking-at-p 
org-element-planning-line-re)
                                        (forward-line))
                                      (when (looking-at org-property-drawer-re)
                                        (goto-char (match-end 0)))
@@ -1173,7 +1219,7 @@ CONTENTS is the contents of the element."
          (concat (make-string (if org-odd-levels-only (1- (* level 2)) level)
                               ?*)
                  (and todo (concat " " todo))
-                 (and commentedp (concat " " org-comment-string))
+                 (and commentedp (concat " " org-element-comment-string))
                  (and priority (format " [#%c]" priority))
                  " "
                  (if (and org-footnote-section
@@ -1321,7 +1367,7 @@ Assume point is at beginning of the inline task."
                       (buffer-substring-no-properties title-start title-end)))
           (task-end (save-excursion
                       (end-of-line)
-                      (and (re-search-forward org-outline-regexp-bol limit t)
+                      (and (re-search-forward org-element-headline-re limit t)
                            (looking-at-p "[ \t]*END[ \t]*$")
                            (line-beginning-position))))
           (standard-props (and task-end (org-element--get-node-properties)))
@@ -1616,7 +1662,7 @@ CONTENTS is the contents of the element."
                   (re-search-forward
                    (format "^[ \t]*#\\+END%s[ \t]*$" (match-string 1))
                    limit t)))
-            ((and (looking-at org-drawer-regexp)
+            ((and (looking-at org-element-drawer-re)
                   (re-search-forward "^[ \t]*:END:[ \t]*$" limit t))))
            (forward-line))))))))
 
@@ -2506,7 +2552,7 @@ Assume point is at the beginning of the paragraph."
                       ((not (and (re-search-forward
                                   org-element-paragraph-separate limit 'move)
                                  (progn (beginning-of-line) t))))
-                      ((looking-at org-drawer-regexp)
+                      ((looking-at org-element-drawer-re)
                        (save-excursion
                          (re-search-forward "^[ \t]*:END:[ \t]*$" limit t)))
                       ((looking-at "[ \t]*#\\+BEGIN_\\(\\S-+\\)")
@@ -2571,14 +2617,14 @@ containing `:closed', `:deadline', `:scheduled', 
`:begin',
           (end (point))
           closed deadline scheduled)
       (goto-char begin)
-      (while (re-search-forward org-keyword-time-not-clock-regexp end t)
-       (goto-char (match-end 1))
+      (while (re-search-forward org-element-planning-keywords-re end t)
        (skip-chars-forward " \t" end)
-       (let ((keyword (match-string 1))
+       (let ((keyword (match-string 0))
              (time (org-element-timestamp-parser)))
-         (cond ((equal keyword org-closed-string) (setq closed time))
-               ((equal keyword org-deadline-string) (setq deadline time))
-               (t (setq scheduled time)))))
+         (cond
+           ((equal keyword org-element-closed-keyword) (setq closed time))
+          ((equal keyword org-element-deadline-keyword) (setq deadline time))
+          (t (setq scheduled time)))))
       (list 'planning
            (list :closed closed
                  :deadline deadline
@@ -2595,15 +2641,15 @@ containing `:closed', `:deadline', `:scheduled', 
`:begin',
    (delq nil
         (list (let ((deadline (org-element-property :deadline planning)))
                 (when deadline
-                  (concat org-deadline-string " "
+                  (concat org-element-deadline-keyword " "
                           (org-element-timestamp-interpreter deadline nil))))
               (let ((scheduled (org-element-property :scheduled planning)))
                 (when scheduled
-                  (concat org-scheduled-string " "
+                  (concat org-element-scheduled-keyword " "
                           (org-element-timestamp-interpreter scheduled nil))))
               (let ((closed (org-element-property :closed planning)))
                 (when closed
-                  (concat org-closed-string " "
+                  (concat org-element-closed-keyword " "
                           (org-element-timestamp-interpreter closed nil))))))
    " "))
 
@@ -4117,7 +4163,7 @@ element it has to parse."
                        (org-element--cache-find (point) t)))
          (element (progn (while (and element
                                      (not (and (eq (point) 
(org-element-property :begin element))
-                                             (eq mode (org-element-property 
:mode element)))))
+                                               (eq mode (org-element-property 
:mode element)))))
                            (setq element (org-element-property :parent 
element)))
                          element))
          (old-element element)
@@ -4163,7 +4209,7 @@ element it has to parse."
             ;; Planning.
             ((and (eq mode 'planning)
                  (eq ?* (char-after (line-beginning-position 0)))
-                 (looking-at org-planning-line-re))
+                 (looking-at org-element-planning-line-re))
             (org-element-planning-parser limit))
             ;; Property drawer.
             ((and (pcase mode
@@ -4179,7 +4225,8 @@ element it has to parse."
             ;; a footnote definition: next item is always a paragraph.
             ((not (bolp)) (org-element-paragraph-parser limit (list (point))))
             ;; Clock.
-            ((looking-at org-clock-line-re) (org-element-clock-parser limit))
+            ((looking-at org-element-clock-line-re)
+             (org-element-clock-parser limit))
             ;; Inlinetask.
             ((looking-at "^\\*+ ")
             (org-element-inlinetask-parser limit raw-secondary-p))
@@ -4196,7 +4243,7 @@ element it has to parse."
                  ((looking-at org-element--latex-begin-environment)
                   (org-element-latex-environment-parser limit affiliated))
                  ;; Drawer.
-                 ((looking-at org-drawer-regexp)
+                 ((looking-at org-element-drawer-re)
                   (org-element-drawer-parser limit affiliated))
                  ;; Fixed Width
                  ((looking-at "[ \t]*:\\( \\|$\\)")
@@ -4259,7 +4306,7 @@ element it has to parse."
                         ;; Start with a full rule.
                         (and
                          (looking-at rule-regexp)
-                         (< next limit)        ;no room for a table.el table
+                         (< next limit) ;no room for a table.el table
                          (save-excursion
                            (end-of-line)
                            (cond
@@ -6595,7 +6642,7 @@ known element in cache (it may start after END)."
                              (org-with-point-at (org-element-property 
:contents-begin up)
                                (unless
                                    (save-match-data
-                                     (when (looking-at-p org-planning-line-re)
+                                     (when (looking-at-p 
org-element-planning-line-re)
                                        (forward-line))
                                      (when (looking-at org-property-drawer-re)
                                        (< beg (match-end 0))))
@@ -7198,13 +7245,13 @@ of FUNC.  Changes to elements made in FUNC will also 
alter the cache."
                                                     restrict-elements)))
                                      (cons
                                       (org-with-limited-levels
-                                       org-outline-regexp-bol)
+                                       org-element-headline-re)
                                       'match-beg))
                                     (`headline+inlinetask
                                      (cons
                                       (if (eq '(inlinetask) restrict-elements)
                                           (org-inlinetask-outline-regexp)
-                                        org-outline-regexp-bol)
+                                        org-element-headline-re)
                                       'match-beg))
                                     ;; TODO: May add other commonly
                                     ;; searched elements as needed.
@@ -7596,7 +7643,7 @@ Providing it allows for quicker computation."
           (let ((end (match-end 4)))
             (if (not end) (throw 'objects-forbidden element)
               (goto-char (match-beginning 4))
-              (when (looking-at org-comment-string)
+              (when (looking-at org-element-comment-string)
                 (goto-char (match-end 0)))
               (if (>= (point) end) (throw 'objects-forbidden element)
                 (narrow-to-region (point) end))))))
diff --git a/testing/lisp/test-org-element.el b/testing/lisp/test-org-element.el
index 560ba59..47e841a 100644
--- a/testing/lisp/test-org-element.el
+++ b/testing/lisp/test-org-element.el
@@ -1199,32 +1199,27 @@ Some other text
   "Test COMMENT keyword recognition."
   ;; Reference test.
   (org-test-with-temp-text "* Headline"
-    (let ((org-comment-string "COMMENT"))
-      (should-not (org-element-property :commentedp (org-element-at-point)))))
+    (should-not (org-element-property :commentedp (org-element-at-point))))
   ;; Standard position.
   (org-test-with-temp-text "* COMMENT Headline"
-    (let ((org-comment-string "COMMENT")
-         (headline (org-element-at-point)))
+    (let ((headline (org-element-at-point)))
       (should (org-element-property :commentedp headline))
       (should (equal (org-element-property :raw-value headline) "Headline"))))
   ;; Case sensitivity.
-  (org-test-with-temp-text "* COMMENT Headline"
-    (let* ((org-comment-string "Comment")
-          (headline (org-element-at-point)))
+  (org-test-with-temp-text "* Comment Headline"
+    (let ((headline (org-element-at-point)))
       (should-not (org-element-property :commentedp headline))
       (should (equal (org-element-property :raw-value headline)
-                    "COMMENT Headline"))))
+                    "Comment Headline"))))
   ;; With another keyword.
   (org-test-with-temp-text "* TODO COMMENT Headline"
-    (let* ((org-comment-string "COMMENT")
-          (org-todo-keywords '((sequence "TODO" "DONE")))
+    (let* ((org-todo-keywords '((sequence "TODO" "DONE")))
           (headline (org-element-at-point)))
       (should (org-element-property :commentedp headline))
       (should (equal (org-element-property :raw-value headline) "Headline"))))
   ;; With the keyword only.
   (org-test-with-temp-text "* COMMENT"
-    (let* ((org-comment-string "COMMENT")
-          (headline (org-element-at-point)))
+    (let* ((headline (org-element-at-point)))
       (should (org-element-property :commentedp headline))
       (should (equal (org-element-property :raw-value headline) "")))))
 
@@ -1233,23 +1228,19 @@ Some other text
   ;; Reference test.
   (should-not
    (org-test-with-temp-text "* Headline"
-     (let ((org-archive-tag "ARCHIVE"))
-       (org-element-property :archivedp (org-element-at-point)))))
+     (org-element-property :archivedp (org-element-at-point))))
   ;; Single tag.
   (org-test-with-temp-text "* Headline :ARCHIVE:"
-    (let ((org-archive-tag "ARCHIVE"))
-      (let ((headline (org-element-at-point)))
-       (should (org-element-property :archivedp headline)))))
+    (let ((headline (org-element-at-point)))
+      (should (org-element-property :archivedp headline))))
   ;; Multiple tags.
   (org-test-with-temp-text "* Headline :test:ARCHIVE:"
-    (let ((org-archive-tag "ARCHIVE"))
-      (let ((headline (org-element-at-point)))
-       (should (org-element-property :archivedp headline)))))
+    (let ((headline (org-element-at-point)))
+      (should (org-element-property :archivedp headline))))
   ;; Tag is case-sensitive.
   (should-not
-   (org-test-with-temp-text "* Headline :ARCHIVE:"
-     (let ((org-archive-tag "Archive"))
-       (org-element-property :archivedp (org-element-at-point))))))
+   (org-test-with-temp-text "* Headline :Archive:"
+     (org-element-property :archivedp (org-element-at-point)))))
 
 (ert-deftest test-org-element/headline-properties ()
   "Test properties from property drawer."
diff --git a/testing/lisp/test-ox.el b/testing/lisp/test-ox.el
index 5455804..25e02b2 100644
--- a/testing/lisp/test-ox.el
+++ b/testing/lisp/test-ox.el
@@ -536,24 +536,21 @@ Paragraph"
    (equal ""
          (let (org-export-filter-body-functions
                org-export-filter-final-output-functions)
-           (org-test-with-temp-text "* Head1 :archive:"
-             (let ((org-archive-tag "archive"))
-               (org-export-as (org-test-default-backend)
-                              nil nil nil '(:with-archived-trees nil)))))))
+           (org-test-with-temp-text "* Head1 :ARCHIVE:"
+             (org-export-as (org-test-default-backend)
+                            nil nil nil '(:with-archived-trees nil))))))
   (should
    (string-match
-    "\\* Head1[ \t]+:archive:"
+    "\\* Head1[ \t]+:ARCHIVE:"
     (org-test-with-temp-text "* Head1 :archive:\nbody\n** Sub-head 2"
-      (let ((org-archive-tag "archive"))
-       (org-export-as (org-test-default-backend) nil nil nil
-                      '(:with-archived-trees headline))))))
+      (org-export-as (org-test-default-backend) nil nil nil
+                    '(:with-archived-trees headline)))))
   (should
    (string-match
-    "\\`\\* Head1[ \t]+:archive:\n\\'"
-    (org-test-with-temp-text "* Head1 :archive:"
-      (let ((org-archive-tag "archive"))
-       (org-export-as (org-test-default-backend)
-                      nil nil nil '(:with-archived-trees t))))))
+    "\\`\\* Head1[ \t]+:ARCHIVE:\n\\'"
+    (org-test-with-temp-text "* Head1 :ARCHIVE:"
+      (org-export-as (org-test-default-backend)
+                    nil nil nil '(:with-archived-trees t)))))
   ;; Broken links.  Depending on `org-export-with-broken-links', raise
   ;; an error, ignore link or mark is as broken in output.
   (should-error