From 479c21336fb0ba79a17372fab2bc1b342f1f56c7 Mon Sep 17 00:00:00 2001 From: Nicolas Goaziou Date: Thu, 4 Apr 2013 19:23:07 +0200 Subject: [PATCH] Remove special behaviour for TARGET keyword * lisp/org.el (org-store-link, org-link-search, org-options-keywords): Remove reference to TARGET keyword. * lisp/ox.el (org-export-resolve-fuzzy-link, org-export-get-ordinal): Do not use TARGET as a destination for links anymore. * testing/lisp/test-ox.el: Update tests. * testing/lisp/test-org.el: Update tests. Its specifications were not useful enough to keep maintaining this feature. --- lisp/org.el | 12 +----- lisp/ox.el | 90 +++++++++++++++++++--------------------- testing/lisp/test-org.el | 50 ++++++++++------------ testing/lisp/test-ox.el | 90 +++++++++++++++++----------------------- 4 files changed, 105 insertions(+), 137 deletions(-) diff --git a/lisp/org.el b/lisp/org.el index 1c15afd54..669d22360 100644 --- a/lisp/org.el +++ b/lisp/org.el @@ -9456,7 +9456,7 @@ active region." (et (org-element-type ee)) (ev (plist-get (cadr ee) :value)) (ek (plist-get (cadr ee) :key)) - (eok (and (stringp ek) (string-match "name\\|target" ek)))) + (eok (and (stringp ek) (string-match "name" ek)))) (setq txt (cond ((org-at-heading-p) nil) ((and (eq et 'keyword) eok) ev) @@ -10630,14 +10630,6 @@ visibility around point, thus ignoring pos (match-beginning 0)))) ;; There is an exact target for this (goto-char pos)) - ((save-excursion - (goto-char (point-min)) - (and - (re-search-forward - (format "^[ \t]*#\\+TARGET: %s" (regexp-quote s0)) nil t) - (setq type 'dedicated pos (match-beginning 0)))) - ;; Found an invisible target. - (goto-char pos)) ((save-excursion (goto-char (point-min)) (and @@ -11871,7 +11863,7 @@ keywords relative to each registered export back-end." "DESCRIPTION:" "DRAWERS:" "EMAIL:" "EXCLUDE_TAGS:" "FILETAGS:" "INCLUDE:" "INDEX:" "KEYWORDS:" "LANGUAGE:" "MACRO:" "OPTIONS:" "PROPERTY:" "PRIORITIES:" "SELECT_TAGS:" "SEQ_TODO:" "SETUPFILE:" "STARTUP:" "TAGS:" - "TITLE:" "TODO:" "TYP_TODO:" "SELECT_TAGS:" "EXCLUDE_TAGS:" "TARGET:")) + "TITLE:" "TODO:" "TYP_TODO:" "SELECT_TAGS:" "EXCLUDE_TAGS:")) (defcustom org-structure-template-alist '(("s" "#+BEGIN_SRC ?\n\n#+END_SRC" diff --git a/lisp/ox.el b/lisp/ox.el index ac76e501f..32b2ac93e 100644 --- a/lisp/ox.el +++ b/lisp/ox.el @@ -3808,8 +3808,7 @@ INFO is a plist holding contextual information. Return value can be an object, an element, or nil: -- If LINK path matches a target object (i.e. <>) or - element (i.e. \"#+TARGET: path\"), return it. +- If LINK path matches a target object (i.e. <>) return it. - If LINK path exactly matches the name affiliated keyword \(i.e. #+NAME: path) of an element, return that element. @@ -3831,14 +3830,12 @@ significant." (if match-title-p (substring raw-path 1) raw-path)))) (cond ;; First try to find a matching "<>" unless user specified - ;; he was looking for a headline (path starts with a * + ;; he was looking for a headline (path starts with a "*" ;; character). ((and (not match-title-p) - (org-element-map (plist-get info :parse-tree) '(keyword target) + (org-element-map (plist-get info :parse-tree) 'target (lambda (blob) - (and (or (eq (org-element-type blob) 'target) - (equal (org-element-property :key blob) "TARGET")) - (equal (org-split-string (org-element-property :value blob)) + (and (equal (org-split-string (org-element-property :value blob)) path) blob)) info t))) @@ -3851,10 +3848,10 @@ significant." (let ((name (org-element-property :name el))) (when (and name (equal (org-split-string name) path)) el))) info 'first-match))) - ;; Last case: link either points to a headline or to - ;; nothingness. Try to find the source, with priority given to - ;; headlines with the closest common ancestor. If such candidate - ;; is found, return it, otherwise return nil. + ;; Last case: link either points to a headline or to nothingness. + ;; Try to find the source, with priority given to headlines with + ;; the closest common ancestor. If such candidate is found, + ;; return it, otherwise return nil. (t (let ((find-headline (function @@ -3946,43 +3943,40 @@ a target, return the same value as if ELEMENT was the closest table, item or headline containing the target. In any other case, return the sequence number of ELEMENT among elements or objects of the same type." - ;; A target keyword, representing an invisible target, never has - ;; a sequence number. - (unless (eq (org-element-type element) 'keyword) - ;; Ordinal of a target object refer to the ordinal of the closest - ;; table, item, or headline containing the object. - (when (eq (org-element-type element) 'target) - (setq element - (loop for parent in (org-export-get-genealogy element) - when - (memq - (org-element-type parent) - '(footnote-definition footnote-reference headline item - table)) - return parent))) - (case (org-element-type element) - ;; Special case 1: A headline returns its number as a list. - (headline (org-export-get-headline-number element info)) - ;; Special case 2: An item returns its number as a list. - (item (let ((struct (org-element-property :structure element))) - (org-list-get-item-number - (org-element-property :begin element) - struct - (org-list-prevs-alist struct) - (org-list-parents-alist struct)))) - ((footnote-definition footnote-reference) - (org-export-get-footnote-number element info)) - (otherwise - (let ((counter 0)) - ;; Increment counter until ELEMENT is found again. - (org-element-map (plist-get info :parse-tree) - (or types (org-element-type element)) - (lambda (el) - (cond - ((eq element el) (1+ counter)) - ((not predicate) (incf counter) nil) - ((funcall predicate el info) (incf counter) nil))) - info 'first-match)))))) + ;; Ordinal of a target object refer to the ordinal of the closest + ;; table, item, or headline containing the object. + (when (eq (org-element-type element) 'target) + (setq element + (loop for parent in (org-export-get-genealogy element) + when + (memq + (org-element-type parent) + '(footnote-definition footnote-reference headline item + table)) + return parent))) + (case (org-element-type element) + ;; Special case 1: A headline returns its number as a list. + (headline (org-export-get-headline-number element info)) + ;; Special case 2: An item returns its number as a list. + (item (let ((struct (org-element-property :structure element))) + (org-list-get-item-number + (org-element-property :begin element) + struct + (org-list-prevs-alist struct) + (org-list-parents-alist struct)))) + ((footnote-definition footnote-reference) + (org-export-get-footnote-number element info)) + (otherwise + (let ((counter 0)) + ;; Increment counter until ELEMENT is found again. + (org-element-map (plist-get info :parse-tree) + (or types (org-element-type element)) + (lambda (el) + (cond + ((eq element el) (1+ counter)) + ((not predicate) (incf counter) nil) + ((funcall predicate el info) (incf counter) nil))) + info 'first-match))))) ;;;; For Src-Blocks diff --git a/testing/lisp/test-org.el b/testing/lisp/test-org.el index 9d060c48e..36f92d9c6 100644 --- a/testing/lisp/test-org.el +++ b/testing/lisp/test-org.el @@ -295,38 +295,34 @@ ;;;; Fuzzy Links ;; Fuzzy links [[text]] encompass links to a target (<>), to -;; a target keyword (aka an invisible target: #+TARGET: text), to ;; a named element (#+name: text) and to headlines (* Text). (ert-deftest test-org/fuzzy-links () "Test fuzzy links specifications." ;; 1. Fuzzy link goes in priority to a matching target. - (org-test-with-temp-text - "#+TARGET: Test\n#+NAME: Test\n|a|b|\n<>\n* Test\n[[Test]]" - (goto-line 6) - (org-open-at-point) - (should (looking-at "<>"))) - ;; 2. Fuzzy link should then go to a matching target keyword. - (org-test-with-temp-text - "#+NAME: Test\n|a|b|\n#+TARGET: Test\n* Test\n[[Test]]" - (goto-line 5) - (org-open-at-point) - (should (looking-at "#\\+TARGET: Test"))) - ;; 3. Then fuzzy link points to an element with a given name. - (org-test-with-temp-text "Test\n#+NAME: Test\n|a|b|\n* Test\n[[Test]]" - (goto-line 5) - (org-open-at-point) - (should (looking-at "#\\+NAME: Test"))) - ;; 4. A target still lead to a matching headline otherwise. - (org-test-with-temp-text "* Head1\n* Head2\n*Head3\n[[Head2]]" - (goto-line 4) - (org-open-at-point) - (should (looking-at "\\* Head2"))) - ;; 5. With a leading star in link, enforce heading match. - (org-test-with-temp-text "#+TARGET: Test\n* Test\n<>\n[[*Test]]" - (goto-line 4) - (org-open-at-point) - (should (looking-at "\\* Test")))) + (should + (org-test-with-temp-text "#+NAME: Test\n|a|b|\n<>\n* Test\n[[Test]]" + (goto-line 5) + (org-open-at-point) + (looking-at "<>"))) + ;; 2. Then fuzzy link points to an element with a given name. + (should + (org-test-with-temp-text "Test\n#+NAME: Test\n|a|b|\n* Test\n[[Test]]" + (goto-line 5) + (org-open-at-point) + (looking-at "#\\+NAME: Test"))) + ;; 3. A target still lead to a matching headline otherwise. + (should + (org-test-with-temp-text "* Head1\n* Head2\n*Head3\n[[Head2]]" + (goto-line 4) + (org-open-at-point) + (looking-at "\\* Head2"))) + ;; 4. With a leading star in link, enforce heading match. + (should + (org-test-with-temp-text "* Test\n<>\n[[*Test]]" + (goto-line 3) + (org-open-at-point) + (looking-at "\\* Test")))) ;;;; Link Escaping diff --git a/testing/lisp/test-ox.el b/testing/lisp/test-ox.el index 1acc4e1a8..d02384566 100644 --- a/testing/lisp/test-ox.el +++ b/testing/lisp/test-ox.el @@ -1348,15 +1348,7 @@ Paragraph[fn:1]" (ert-deftest test-org-export/fuzzy-link () "Test fuzzy links specifications." - ;; 1. Links to invisible (keyword) targets should be ignored. - (org-test-with-parsed-data - "Paragraph.\n#+TARGET: Test\n[[Test]]" - (should-not - (org-element-map tree 'link - (lambda (link) - (org-export-get-ordinal - (org-export-resolve-fuzzy-link link info) info)) info))) - ;; 2. Link to an headline should return headline's number. + ;; Link to an headline should return headline's number. (org-test-with-parsed-data "Paragraph.\n* Head1\n* Head2\n* Head3\n[[Head2]]" (should @@ -1366,7 +1358,7 @@ Paragraph[fn:1]" (lambda (link) (org-export-get-ordinal (org-export-resolve-fuzzy-link link info) info)) info t)))) - ;; 3. Link to a target in an item should return item's number. + ;; Link to a target in an item should return item's number. (org-test-with-parsed-data "- Item1\n - Item11\n - <>Item12\n- Item2\n\n\n[[test]]" (should @@ -1376,8 +1368,7 @@ Paragraph[fn:1]" (lambda (link) (org-export-get-ordinal (org-export-resolve-fuzzy-link link info) info)) info t)))) - ;; 4. Link to a target in a footnote should return footnote's - ;; number. + ;; Link to a target in a footnote should return footnote's number. (org-test-with-parsed-data " Paragraph[1][2][fn:lbl3:C<>][[test]][[target]]\n[1] A\n\n[2] <>B" (should @@ -1386,8 +1377,8 @@ Paragraph[1][2][fn:lbl3:C<>][[test]][[target]]\n[1] A\n\n[2] <>B" (lambda (link) (org-export-get-ordinal (org-export-resolve-fuzzy-link link info) info)) info)))) - ;; 5. Link to a named element should return sequence number of that - ;; element. + ;; Link to a named element should return sequence number of that + ;; element. (org-test-with-parsed-data "#+NAME: tbl1\n|1|2|\n#+NAME: tbl2\n|3|4|\n#+NAME: tbl3\n|5|6|\n[[tbl2]]" (should @@ -1396,8 +1387,8 @@ Paragraph[1][2][fn:lbl3:C<>][[test]][[target]]\n[1] A\n\n[2] <>B" (lambda (link) (org-export-get-ordinal (org-export-resolve-fuzzy-link link info) info)) info t)))) - ;; 6. Link to a target not within an item, a table, a footnote - ;; reference or definition should return section number. + ;; Link to a target not within an item, a table, a footnote + ;; reference or definition should return section number. (org-test-with-parsed-data "* Head1\n* Head2\nParagraph<>\n* Head3\n[[target]]" (should @@ -1406,13 +1397,13 @@ Paragraph[1][2][fn:lbl3:C<>][[test]][[target]]\n[1] A\n\n[2] <>B" (lambda (link) (org-export-get-ordinal (org-export-resolve-fuzzy-link link info) info)) info t)))) - ;; 7. Space are not significant when matching a fuzzy link. + ;; Space are not significant when matching a fuzzy link. (should (org-test-with-parsed-data "* Head 1\n[[Head\n 1]]" (org-element-map tree 'link (lambda (link) (org-export-resolve-fuzzy-link link info)) info t))) - ;; 8. Statistics cookies are ignored for headline match. + ;; Statistics cookies are ignored for headline match. (should (org-test-with-parsed-data "* Head [0/0]\n[[Head]]" (org-element-map tree 'link @@ -1491,55 +1482,50 @@ Another text. (ref:text) (ert-deftest test-org-export/resolve-fuzzy-link () "Test `org-export-resolve-fuzzy-link' specifications." - ;; 1. Match target objects. - (org-test-with-parsed-data "<> [[target]]" - (should + ;; Match target objects. + (should + (org-test-with-parsed-data "<> [[target]]" (org-export-resolve-fuzzy-link (org-element-map tree 'link 'identity info t) info))) - ;; 2. Match target elements. - (org-test-with-parsed-data "#+TARGET: target\n[[target]]" - (should + ;; Match named elements. + (should + (org-test-with-parsed-data "#+NAME: target\nParagraph\n\n[[target]]" (org-export-resolve-fuzzy-link (org-element-map tree 'link 'identity info t) info))) - ;; 3. Match named elements. - (org-test-with-parsed-data "#+NAME: target\nParagraph\n\n[[target]]" - (should + ;; Match exact headline's name. + (should + (org-test-with-parsed-data "* My headline\n[[My headline]]" (org-export-resolve-fuzzy-link (org-element-map tree 'link 'identity info t) info))) - ;; 4. Match exact headline's name. - (org-test-with-parsed-data "* My headline\n[[My headline]]" - (should - (org-export-resolve-fuzzy-link - (org-element-map tree 'link 'identity info t) info))) - ;; 5. Targets objects have priority over named elements and headline - ;; titles. - (org-test-with-parsed-data - "* target\n#+NAME: target\n<>\n\n[[target]]" - (should - (eq 'target + ;; Targets objects have priority over named elements and headline + ;; titles. + (should + (eq 'target + (org-test-with-parsed-data + "* target\n#+NAME: target\n<>\n\n[[target]]" (org-element-type (org-export-resolve-fuzzy-link (org-element-map tree 'link 'identity info t) info))))) - ;; 6. Named elements have priority over headline titles. - (org-test-with-parsed-data - "* target\n#+NAME: target\nParagraph\n\n[[target]]" - (should - (eq 'paragraph + ;; Named elements have priority over headline titles. + (should + (eq 'paragraph + (org-test-with-parsed-data + "* target\n#+NAME: target\nParagraph\n\n[[target]]" (org-element-type (org-export-resolve-fuzzy-link (org-element-map tree 'link 'identity info t) info))))) - ;; 7. If link's path starts with a "*", only match headline titles, - ;; though. - (org-test-with-parsed-data - "* target\n#+NAME: target\n<>\n\n[[*target]]" - (should - (eq 'headline + ;; If link's path starts with a "*", only match headline titles, + ;; though. + (should + (eq 'headline + (org-test-with-parsed-data + "* target\n#+NAME: target\n<>\n\n[[*target]]" (org-element-type (org-export-resolve-fuzzy-link (org-element-map tree 'link 'identity info t) info))))) - ;; 8. Return nil if no match. - (org-test-with-parsed-data "[[target]]" - (should-not + ;; Return nil if no match. + (should-not + (org-test-with-parsed-data "[[target]]" (org-export-resolve-fuzzy-link (org-element-map tree 'link 'identity info t) info))))