Merge branch 'maint'
authorNicolas Goaziou <n.goaziou@gmail.com>
Tue, 25 Feb 2014 19:54:48 +0000 (25 20:54 +0100)
committerNicolas Goaziou <n.goaziou@gmail.com>
Tue, 25 Feb 2014 19:54:48 +0000 (25 20:54 +0100)
Conflicts:
lisp/org-element.el

1  2 
lisp/org-element.el
testing/lisp/test-org-element.el

@@@ -5766,88 -4891,54 +5766,98 @@@ Providing it allows for quicker computa
           (if (and (>= origin (point)) (< origin (line-end-position)))
               (narrow-to-region (point) (line-end-position))
             (throw 'objects-forbidden element))))
-       ;; All other locations cannot contain objects: bail out.
+       ;; At a planning line, if point is at a timestamp, return it,
+       ;; otherwise, return element.
+       ((eq type 'planning)
+        (dolist (p '(:closed :deadline :scheduled))
+          (let ((timestamp (org-element-property p element)))
+            (when (and timestamp
+                       (<= (org-element-property :begin timestamp) origin)
+                       (> (org-element-property :end timestamp) origin))
+              (throw 'objects-forbidden timestamp))))
++       ;; All other locations cannot contain objects: bail out.
+        (throw 'objects-forbidden element))
        (t (throw 'objects-forbidden element)))
         (goto-char (point-min))
 -       (let ((restriction (org-element-restriction type))
 -             (parent element)
 -             (candidates 'initial))
 -         (catch 'exit
 -           (while (setq candidates
 -                      (org-element--get-next-object-candidates
 -                       restriction candidates))
 -             (let ((closest-cand (rassq (apply 'min (mapcar 'cdr candidates))
 -                                        candidates)))
 -               ;; If ORIGIN is before next object in element, there's
 -               ;; no point in looking further.
 -               (if (> (cdr closest-cand) origin) (throw 'exit parent)
 -                 (let* ((object
 -                         (progn (goto-char (cdr closest-cand))
 -                                (funcall (intern (format "org-element-%s-parser"
 -                                                         (car closest-cand))))))
 -                        (cbeg (org-element-property :contents-begin object))
 -                        (cend (org-element-property :contents-end object))
 -                        (obj-end (org-element-property :end object)))
 -                   (cond
 -                    ;; ORIGIN is after OBJECT, so skip it.
 -                    ((<= obj-end origin) (goto-char obj-end))
 -                    ;; ORIGIN is within a non-recursive object or at
 -                    ;; an object boundaries: Return that object.
 -                    ((or (not cbeg) (< origin cbeg) (>= origin cend))
 -                     (throw 'exit
 -                            (org-element-put-property object :parent parent)))
 -                    ;; Otherwise, move within current object and
 -                    ;; restrict search to the end of its contents.
 -                    (t (goto-char cbeg)
 -                       (narrow-to-region (point) cend)
 -                       (org-element-put-property object :parent parent)
 -                       (setq parent object
 -                             restriction (org-element-restriction object)
 -                             candidates 'initial)))))))
 -           parent))))))
 +       (let* ((restriction (org-element-restriction type))
 +            (parent element)
 +            (candidates 'initial)
 +            (cache (and (org-element--cache-active-p)
 +                        (gethash element org-element--cache-objects)))
 +            objects-data next)
 +       (prog1
 +           (catch 'exit
 +             (while t
 +               ;; Get list of next object candidates in CANDIDATES.
 +               ;; When entering for the first time PARENT, grab it
 +               ;; from cache, if available, or compute it.  Then,
 +               ;; for each subsequent iteration in PARENT, always
 +               ;; compute it since we're beyond cache anyway.
 +               (unless next
 +                 (let ((data (assq (point) cache)))
 +                   (if data (setq candidates (nth 1 (setq objects-data data)))
 +                     (push (setq objects-data (list (point) 'initial))
 +                           cache))))
 +               (when (or next (eq 'initial candidates))
 +                 (setq candidates
 +                       (org-element--get-next-object-candidates
 +                        restriction candidates))
 +                 (setcar (cdr objects-data) candidates))
 +               ;; Compare ORIGIN with next object starting position,
 +               ;; if any.
 +               ;;
 +               ;; If ORIGIN is lesser or if there is no object
 +               ;; following, look for a previous object that might
 +               ;; contain it in cache.  If there is no cache, we
 +               ;; didn't miss any object so simply return PARENT.
 +               ;;
 +               ;; If ORIGIN is greater or equal, parse next
 +               ;; candidate for further processing.
 +               (let ((closest
 +                      (and candidates
 +                           (rassq (apply #'min (mapcar #'cdr candidates))
 +                                  candidates))))
 +                 (if (or (not closest) (> (cdr closest) origin))
 +                     (catch 'found
 +                       (dolist (obj (cddr objects-data) (throw 'exit parent))
 +                         (when (<= (org-element-property :begin obj) origin)
 +                           (let ((end (org-element-property :end obj)))
 +                             (cond
 +                              ((> end origin) (throw 'found (setq next obj)))
 +                              ((and (= end origin) (= (point-max) end))
 +                               (org-element-put-property obj :parent parent)
 +                               (throw 'exit obj))
 +                              (t (throw 'exit parent)))))))
 +                   (goto-char (cdr closest))
 +                   (setq next
 +                         (funcall (intern (format "org-element-%s-parser"
 +                                                  (car closest)))))
 +                   (push next (cddr objects-data))))
 +               ;; Process NEXT to know if we need to skip it, return
 +               ;; it or move into it.
 +               (let ((cbeg (org-element-property :contents-begin next))
 +                     (cend (org-element-property :contents-end next))
 +                     (obj-end (org-element-property :end next)))
 +                 (cond
 +                  ;; ORIGIN is after NEXT, so skip it.
 +                  ((<= obj-end origin) (goto-char obj-end))
 +                  ;; ORIGIN is within a non-recursive next or
 +                  ;; at an object boundaries: Return that object.
 +                  ((or (not cbeg) (< origin cbeg) (>= origin cend))
 +                   (org-element-put-property next :parent parent)
 +                   (throw 'exit next))
 +                  ;; Otherwise, move into NEXT and reset flags as we
 +                  ;; shift parent.
 +                  (t (goto-char cbeg)
 +                     (narrow-to-region (point) cend)
 +                     (org-element-put-property next :parent parent)
 +                     (setq parent next
 +                           restriction (org-element-restriction next)
 +                           next nil
 +                           objects-data nil
 +                           candidates 'initial))))))
 +         ;; Store results in cache, if applicable.
 +         (org-element--cache-put element cache)))))))
  
  (defun org-element-nested-p (elem-A elem-B)
    "Non-nil when elements ELEM-A and ELEM-B are nested."
Simple merge