Re: [O] Getting heading properties from org-element

[John Kitchin]

hm. We must have different use cases in mind. Currently I am using

(save-excursion
                      (goto-char
                       (org-element-property :begin headline))
                      (org-entry-properties))

to get the properties. I thought there would be a way to get those from
the parse tree to avoid the excursion (I use this to index a few
thousand org-files so I want it to be fast). It turns out that is not
too slow, so until a better way comes along, I will use it!

Thorsten Jolitz writes:

> John Kitchin <address@hidden> writes:
>
> Hi John,
>
>> Is there a convenient way to get the properties of a headline from
>> org-element? I see they are in the parsed output, e.g. as :CATEGORIES
>> emacs,org :DATE today, but I didn't see a way to get them if I don't
>> already know what they are.
>>
>> I know how to get these from an org file, e.g. org-entry-properties, and
>> I am looking for something like this from an element.
>
>
> in my org-dp repo I have these two functions:
>
> #+BEGIN_SRC emacs-lisp
> (defun org-dp-contents (&optional element interpret-p no-properties-p)
>   "Get contents of element-at-point or ELEMENT.
> If INTERPRET-P is non-nil, call `org-element-interpret-data' on
> return value. Call `org-no-properties' on result if
> NO-PROPERTIES-P is non-nil too."
>   (let* ((elem (cond
>               ((and (not (booleanp element))
>                     (symbolp element))
>                (eval element))
>               ((stringp element)
>                (let ((el (car (read-from-string element))))
>                  (when (consp el) el)))
>               ((consp element) element)
>               (t (org-element-at-point))))
>        (beg (org-element-property :begin elem))
>        (end (org-element-property :end elem))
>        (type (org-element-type elem)))
>     (if (and beg end)
>       (save-restriction
>         (narrow-to-region beg end)
>         (let ((cont (org-element-map
>                         (org-element-parse-buffer 'object)
>                         type 'org-element-contents nil t)))
>           (cond
>            ((and interpret-p no-properties-p)
>             (org-no-properties (org-element-interpret-data cont)))
>            (interpret-p
>             (org-element-interpret-data cont))
>            (t cont))))
>       (org-element-contents elem))))
>
>
> (defun org-dp-filter-node-props (filter &optional negate-p verbose-p)
>   "Return filtered node-properties.
> FILTER should be either a symbol from `org-dp-prop-classes', the
> symbol `org' (matching the union of all `org-dp-prop-classes' and
> customizable variable `org-dp-misc-props'), a list of keys as
> strings, or a (single) regexp-string. If NEGATE-P is non-nil, the
> properties not matched by the filter are returned. If VERBOSE-P
> is non-nil, a message is printed if no property-drawer is found,
> otherwise nil is returned."
>   (let ((props (save-excursion
>                (and
>                 (or (org-at-heading-p)
>                     (outline-previous-heading))
>                 (re-search-forward
>                  org-property-drawer-re
>                  (save-excursion
>                    (org-end-of-meta-data-and-drawers)
>                    (point))
>                  'NOERROR 1)
>                 (progn
>                   (goto-char (match-beginning 0))
>                   (org-dp-contents)))))
>       filtered-props)
>     (if (not props)
>       (when verbose-p
>         (message
>          "Could not find properties at point %d in buffer %s."
>          (point) (current-buffer)))
>       (org-element-map props 'node-property
>       (lambda (--prop)
>         (let* ((key (org-element-property :key --prop))
>                (val (org-element-property :value --prop))
>                (memberp (case filter
>                           ((special custom default file global)
>                            (member-ignore-case
>                             key
>                             (eval
>                              (cdr-safe
>                               (assoc filter
>                                      org-dp-prop-classes)))))
>                           (org (member-ignore-case
>                                 key (org-dp-org-props)))
>                           (t (cond
>                               ((stringp filter)
>                                (string-match filter key))
>                               ((consp filter)
>                                (member-ignore-case key filter))
>                               (t (error "Not a valid filter: %s"
>                                         filter)))))))
>           (when (or (and negate-p (not memberp))
>                     (and (not negate-p) memberp))
>             (setq filtered-props
>                   (cons (cons key val) filtered-props))))))
>       filtered-props)))
>
> #+END_SRC
>
> maybe thats somehow related...

--
Professor John Kitchin
Doherty Hall A207F
Department of Chemical Engineering
Carnegie Mellon University
Pittsburgh, PA 15213
412-268-7803
@johnkitchin
http://kitchingroup.cheme.cmu.edu