a7b4929ab879c5e833097d640d23e4fa89e3a8cb
[org-ref.git] / org-ref.el
1 ;;; org-ref.el --- cite and cross-reference in org-mode
2
3 ;; Copyright(C) 2014 John Kitchin
4
5 ;; Author: John Kitchin <jkitchin@andrew.cmu.edu>
6 ;; URL: https://github.com/jkitchin/org-ref
7 ;; Version: 0.2
8 ;; Keywords: org-mode, cite, ref, label
9 ;; Package-Requires: ((org) (dash) (helm) (helm-bibtex) (hydra))
10
11 ;; This file is not currently part of GNU Emacs.
12
13 ;; This program is free software; you can redistribute it and/or
14 ;; modify it under the terms of the GNU General Public License as
15 ;; published by the Free Software Foundation; either version 2, or (at
16 ;; your option) any later version.
17
18 ;; This program is distributed in the hope that it will be useful, but
19 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21 ;; General Public License for more details.
22
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with this program ; see the file COPYING.  If not, write to
25 ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
26 ;; Boston, MA 02111-1307, USA.
27
28 ;;; Commentary:
29 ;;
30 ;; Lisp code to setup bibliography cite, ref and label org-mode links.
31 ;; also sets up reftex and helm for org-mode citations.  The links are
32 ;; clickable and do things that are useful.  You should really read
33 ;; org-ref.org for details.
34 ;;
35
36 ;;; Code:
37
38 (require 'reftex-cite)
39 (require 'dash)
40 (require 'helm)
41 (require 'helm-config)
42 (require 'helm-bibtex)
43 (require 'org)
44
45 ;; * Custom variables
46 (defgroup org-ref nil
47   "Customization group for org-ref.")
48
49 (defcustom org-ref-bibliography-notes
50   nil
51   "Filename where you will put all your notes about an entry in the default bibliography."
52   :type 'file
53   :group 'org-ref)
54
55 (defcustom org-ref-default-bibliography
56   nil
57   "List of bibtex files to search for.
58 You should use full-paths for each file."
59   :type '(repeat :tag "List of bibtex files" file)
60   :group 'org-ref)
61
62 (defcustom org-ref-pdf-directory
63   nil
64   "Directory where pdfs are stored by key.  put a trailing / in."
65   :type 'directory
66   :group 'org-ref)
67
68 (defcustom org-ref-default-citation-link
69   "cite"
70   "The default type of citation link to use."
71   :type 'string
72   :group 'org-ref)
73
74 (defcustom org-ref-insert-cite-key
75   "C-c ]"
76   "Keyboard shortcut to insert a citation."
77   :type 'string
78   :group 'org-ref)
79
80 (defcustom org-ref-bibliography-entry-format
81   '(("article" . "%a, %t, <i>%j</i>, <b>%v(%n)</b>, %p (%y). <a href=\"%U\">link</a>. <a href=\"http://dx.doi.org/%D\">doi</a>.")
82
83     ("book" . "%a, %t, %u (%y).")
84
85     ("proceedings" . "%e, %t in %S, %u (%y).")
86
87     ("inproceedings" . "%a, %t, %p, in %b, edited by %e, %u (%y)"))
88
89   "String to format an entry.  Just the reference, no numbering at the beginning, etc... see the `org-ref-reftex-format-citation' docstring for the escape codes."
90   :type 'string
91   :group 'org-ref)
92
93 (defcustom org-ref-open-notes-function
94   (lambda ()
95     (org-show-entry)
96     (show-branches)
97     (show-children)
98     (org-cycle '(64))
99     ;;(org-tree-to-indirect-buffer)
100     (outline-previous-visible-heading 1)
101     (recenter-top-bottom 0))
102   "User-defined way to open a notes entry.  This is excecuted after the entry is found, with the cursor at the beginning of the headline.  The default setting fully expands the notes, and moves the headline to the top of the buffer."
103 :type 'function
104 :group 'org-ref)
105
106
107 (defcustom org-ref-open-pdf-function
108    'org-ref-open-pdf-at-point
109 "User-defined function to open a pdf from a link.  The function must get the key at point, and derive a path to the pdf file, then open it.  The default function is `org-ref-open-pdf-at-point'."
110   :type 'function
111   :group 'org-ref)
112
113
114 (defcustom org-ref-insert-cite-function
115   'org-ref-helm-insert-cite-link
116   "Function to call to insert citation links.  The default is `org-ref-helm-insert-cite-link' which uses `helm-bibtex'.  `org-ref' modifies `helm-bibtex' a little bit to give `org-mode' citations, and to reorder default actions.  You may use `org-ref-insert-cite-link' if you like the reftex interface."
117  :type 'function
118  :group 'org-ref)
119
120
121 (defcustom org-ref-cite-onclick-function
122   'org-ref-cite-click-helm
123   "Function that runs when you click on a cite link.  The function must take no arguments.  You may also use `org-ref-cite-onclick-minibuffer-menu' if you do not like helm.  If you like `hydra', consider using `org-ref-cite-hydra'."
124  :type 'function
125  :group 'org-ref)
126
127
128 (defcustom org-ref-show-citation-on-enter t
129   "If non-nil add a hook function to show the citation summary in the minibuffer."
130  :group 'org-ref)
131
132 (defcustom org-ref-cite-types
133   '("cite" "nocite" ;; the default latex cite commands
134     ;; natbib cite commands, http://ctan.unixbrain.com/macros/latex/contrib/natbib/natnotes.pdf
135     "citet" "citet*" "citep" "citep*"
136     "citealt" "citealt*" "citealp" "citealp*"
137     "citenum" "citetext"
138     "citeauthor" "citeauthor*"
139     "citeyear" "citeyear*"
140     "Citet" "Citep" "Citealt" "Citealp" "Citeauthor"
141     ;; biblatex commands
142     ;; http://ctan.mirrorcatalogs.com/macros/latex/contrib/biblatex/doc/biblatex.pdf
143     "Cite"
144     "parencite" "Parencite"
145     "footcite" "footcitetext"
146     "textcite" "Textcite"
147     "smartcite" "Smartcite"
148     "cite*" "parencite*" "supercite"
149     "autocite" "Autocite" "autocite*" "Autocite*"
150     "Citeauthor*"
151     "citetitle" "citetitle*"
152     "citedate" "citedate*"
153     "citeurl"
154     "fullcite" "footfullcite"
155     ;; "volcite" "Volcite" cannot support the syntax
156     "notecite" "Notecite"
157     "pnotecite" "Pnotecite"
158     "fnotecite"
159     ;; multicites. Very limited support for these.
160     "cites" "Cites" "parencites" "Parencites"
161     "footcites" "footcitetexts"
162     "smartcites" "Smartcites" "textcites" "Textcites"
163     "supercites" "autocites" "Autocites"
164     ;; for the bibentry package
165     "bibentry"
166     )
167   "List of citation types known in `org-ref'."
168   :type '(repeat :tag "List of citation types" string)
169   :group 'org-ref)
170
171 (defcustom org-ref-clean-bibtex-entry-hook nil
172   "Hook that is run in `org-ref-clean-bibtex-entry'.  The functions should take no arguments, and operate on the bibtex entry at point."
173   :group 'org-ref
174   :type 'hook)
175
176 (defvar org-ref-bibliography-files
177   nil
178   "Variable to hold bibliography files to be searched.")
179
180 ;; * org-mode / reftex setup
181 (require 'reftex)
182 (defun org-mode-reftex-setup ()
183   "Setup `org-mode' and reftex for org-ref."
184     (and (buffer-file-name)
185          (file-exists-p (buffer-file-name))
186          (global-auto-revert-mode t))
187     (make-local-variable 'reftex-cite-format)
188     (setq reftex-cite-format 'org))
189
190 ;; define key for inserting citations
191 (define-key org-mode-map
192   (kbd org-ref-insert-cite-key)
193   org-ref-insert-cite-function)
194
195 (add-hook 'org-mode-hook 'org-mode-reftex-setup)
196
197 (eval-after-load 'reftex-vars
198   '(progn
199       (add-to-list 'reftex-cite-format-builtin
200                    '(org "Org-mode citation"
201                          ((?\C-m . "cite:%l")     ; default
202                           (?d . ",%l")            ; for appending
203                           (?a . "autocite:%l")
204                           (?t . "citet:%l")
205                           (?T . "citet*:%l")
206                           (?p . "citep:%l")
207                           (?P . "citep*:%l")
208                           (?h . "citeauthor:%l")
209                           (?H . "citeauthor*:%l")
210                           (?y . "citeyear:%l")
211                           (?x . "citetext:%l")
212                           (?n . "nocite:%l")
213                           )))))
214
215 ;; * Messages for link at cursor
216 (defvar org-ref-message-timer nil
217   "Variable to store the link message timer in.")
218
219
220 (defun org-ref-show-link-messages ()
221   "Turn on link messages.
222 You will see a message in the minibuffer when on a cite, ref or label link."
223   (interactive)
224   (or org-ref-message-timer
225       (setq org-ref-message-timer
226             (run-with-idle-timer 0.5 t 'org-ref-link-message))))
227
228
229 (defun org-ref-cancel-link-messages ()
230   "Stop showing messages in minibuffer when on a link."
231   (interactive)
232   (cancel-timer org-ref-message-timer)
233   (setq org-ref-message-timer nil))
234
235
236 (when org-ref-show-citation-on-enter
237   (org-ref-show-link-messages))
238
239 ;; ** Messages for context under mouse pointer
240
241 (defvar org-ref-last-mouse-pos nil
242  "Stores last mouse position for use in `org-ref-mouse-message'.")
243
244 (defun org-ref-can-move-p ()
245   "See if a character is under the mouse.  If so return the position for `goto-char'."
246   (let* ((line (cddr org-ref-last-mouse-pos))
247          (col  (cadr org-ref-last-mouse-pos)))
248     (save-excursion
249       (goto-char (window-start))
250       (forward-line line)
251       (if
252           (> (- (line-end-position) (line-beginning-position)) col)
253           (progn  (forward-char col) (point))
254         nil))))
255
256
257 (defun org-ref-mouse-message ()
258   "Display message for link under mouse cursor."
259   (interactive)
260   (when (not (equal (mouse-position) org-ref-last-mouse-pos))
261     (setq org-ref-last-mouse-pos (mouse-position))
262     (let ((p (org-ref-can-move-p)))
263       (when p
264           (save-excursion
265             (goto-char p)
266             (org-ref-link-message))))))
267
268
269 (defvar org-ref-message-timer-mouse nil
270   "Store mouse timer.")
271
272
273 (defvar org-ref-mouse-message-interval 0.5
274   "How often to run the mouse message timer in seconds.")
275
276
277 (defun org-ref-mouse-messages-on ()
278   "Turn on mouse messages."
279   (interactive)
280   (or org-ref-message-timer-mouse
281       (setq org-ref-message-timer-mouse
282             (run-at-time "0.5 sec"
283                          org-ref-mouse-message-interval
284                          'org-ref-mouse-message))))
285
286
287 (defun org-ref-mouse-messages-off ()
288   "Turn off mouse messages."
289   (interactive)
290   (cancel-timer org-ref-message-timer-mouse)
291   (setq org-ref-message-timer-mouse nil)
292   (message "Mouse messages are off"))
293
294 ;; Colorizing org-ref links
295 (defcustom org-ref-colorize-links
296   t
297   "When non-nil, change colors of links."
298   :group 'org-ref)
299
300
301 (defcustom org-ref-cite-color
302   "forest green"
303   "Color of cite like links."
304   :group 'org-ref)
305
306
307 (defcustom org-ref-ref-color
308   "dark red"
309   "Color of ref like links."
310   :group 'org-ref)
311
312
313 (defcustom org-ref-label-color
314   "dark magenta"
315   "Color of label links."
316   :group 'org-ref)
317
318
319 (defvar org-ref-cite-re nil
320  "Regexp for cite links.")
321
322
323 (setq org-ref-cite-re
324       (concat "\\(" (mapconcat
325                      (lambda (x)
326                        (replace-regexp-in-string "\*" "\\\\*" x)
327                        )
328                      org-ref-cite-types "\\|") "\\)"
329   ":\\([a-zA-Z0-9-_:]*,?\\)*"))
330
331
332 (setq org-ref-label-re
333       "label:\\([a-zA-Z0-9-_:]*,?\\)*")
334
335
336 (setq org-ref-ref-re
337       "\\(eq\\)?ref:\\([a-zA-Z0-9-_:]*,?\\)*")
338
339
340 (defface org-ref-cite-face
341   `((t (:inherit org-link :foreground ,org-ref-cite-color)))
342   "Color for cite-like links in org-ref.")
343
344
345 (defface org-ref-label-face
346   `((t (:inherit org-link :foreground ,org-ref-label-color)))
347   "Color for ref links in org-ref.")
348
349
350 (defface org-ref-ref-face
351   `((t (:inherit org-link :foreground ,org-ref-ref-color)))
352   "Face for ref links in org-ref.")
353
354
355 (defun org-ref-colorize-links ()
356   "Colorize org-ref links."
357   (hi-lock-mode 1)
358   (highlight-regexp org-ref-cite-re 'org-ref-cite-face)
359   (highlight-regexp org-ref-label-re 'org-ref-label-face)
360   (highlight-regexp org-ref-ref-re 'org-ref-ref-face))
361
362
363 (when org-ref-colorize-links
364   (add-hook 'org-mode-hook 'org-ref-colorize-links))
365
366 ;; * General org-ref utilities
367 (defun org-ref-strip-string (string)
368   "Strip leading and trailing whitespace from the STRING."
369   (replace-regexp-in-string
370    (concat search-whitespace-regexp "$" ) ""
371    (replace-regexp-in-string
372     (concat "^" search-whitespace-regexp ) "" string)))
373
374 (defun org-ref-split-and-strip-string (string)
375   "Split key-string and strip keys in STRING.
376 Assumes the key-string is comma delimited."
377   (mapcar 'org-ref-strip-string (split-string string ",")))
378
379 (defun org-ref-reftex-get-bib-field (field entry &optional format)
380   "Similar to reftex-get-bib-field, but removes enclosing braces and quotes in FIELD in the bibtex ENTRY.
381 Optional argument FORMAT bibtex format."
382   (let ((result))
383     (setq result (reftex-get-bib-field field entry format))
384     (when (and (not (string= result "")) (string= "{" (substring result 0 1)))
385       (setq result (substring result 1 -1)))
386     (when (and (not (string= result "")) (string= "\"" (substring result 0 1)))
387       (setq result (substring result 1 -1)))
388       result))
389
390 (defun org-ref-reftex-format-citation (entry format)
391   "Return a formatted string for the bibtex ENTRY (from bibtex-parse-entry) according to the FORMAT argument.
392 The format is a string with these percent escapes.
393
394 In the format, the following percent escapes will be expanded.
395
396 %l   The BibTeX label of the citation.
397 %a   List of author names, see also `reftex-cite-punctuation'.
398 %2a  Like %a, but abbreviate more than 2 authors like Jones et al.
399 %A   First author name only.
400 %e   Works like %a, but on list of editor names. (%2e and %E work a well)
401
402 It is also possible to access all other BibTeX database fields:
403 %b booktitle     %c chapter        %d edition    %h howpublished
404 %i institution   %j journal        %k key        %m month
405 %n number        %o organization   %p pages      %P first page
406 %r address       %s school         %u publisher  %t title
407 %v volume        %y year
408 %B booktitle, abbreviated          %T title, abbreviated
409 %U url
410 %D doi
411 %S series
412
413 Usually, only %l is needed.  The other stuff is mainly for the echo area
414 display, and for (setq reftex-comment-citations t).
415
416 %< as a special operator kills punctuation and space around it after the
417 string has been formatted.
418
419 A pair of square brackets indicates an optional argument, and RefTeX
420 will prompt for the values of these arguments.
421
422 Beware that all this only works with BibTeX database files.  When
423 citations are made from the \bibitems in an explicit thebibliography
424 environment, only %l is available."
425   ;; Format a citation from the info in the BibTeX ENTRY
426
427   (unless (stringp format) (setq format "\\cite{%l}"))
428
429   (if (and reftex-comment-citations
430            (string-match "%l" reftex-cite-comment-format))
431       (error "Reftex-cite-comment-format contains invalid %%l"))
432
433   (while (string-match
434           "\\(\\`\\|[^%]\\)\\(\\(%\\([0-9]*\\)\\([a-zA-Z]\\)\\)[.,;: ]*\\)"
435           format)
436     (let ((n (string-to-number (match-string 4 format)))
437           (l (string-to-char (match-string 5 format)))
438           rpl b e)
439       (save-match-data
440         (setq rpl
441               (cond
442                ((= l ?l) (concat
443                           (org-ref-reftex-get-bib-field "&key" entry)
444                           (if reftex-comment-citations
445                               reftex-cite-comment-format
446                             "")))
447                ((= l ?a) (reftex-format-names
448                           (reftex-get-bib-names "author" entry)
449                           (or n 2)))
450                ((= l ?A) (car (reftex-get-bib-names "author" entry)))
451                ((= l ?b) (org-ref-reftex-get-bib-field "booktitle" entry "in: %s"))
452                ((= l ?B) (reftex-abbreviate-title
453                           (org-ref-reftex-get-bib-field "booktitle" entry "in: %s")))
454                ((= l ?c) (org-ref-reftex-get-bib-field "chapter" entry))
455                ((= l ?d) (org-ref-reftex-get-bib-field "edition" entry))
456                ((= l ?D) (org-ref-reftex-get-bib-field "doi" entry))
457                ((= l ?e) (reftex-format-names
458                           (reftex-get-bib-names "editor" entry)
459                           (or n 2)))
460                ((= l ?E) (car (reftex-get-bib-names "editor" entry)))
461                ((= l ?h) (org-ref-reftex-get-bib-field "howpublished" entry))
462                ((= l ?i) (org-ref-reftex-get-bib-field "institution" entry))
463                ((= l ?j) (org-ref-reftex-get-bib-field "journal" entry))
464                ((= l ?k) (org-ref-reftex-get-bib-field "key" entry))
465                ((= l ?m) (org-ref-reftex-get-bib-field "month" entry))
466                ((= l ?n) (org-ref-reftex-get-bib-field "number" entry))
467                ((= l ?o) (org-ref-reftex-get-bib-field "organization" entry))
468                ((= l ?p) (org-ref-reftex-get-bib-field "pages" entry))
469                ((= l ?P) (car (split-string
470                                (org-ref-reftex-get-bib-field "pages" entry)
471                                "[- .]+")))
472                ((= l ?s) (org-ref-reftex-get-bib-field "school" entry))
473                ((= l ?S) (org-ref-reftex-get-bib-field "series" entry))
474                ((= l ?u) (org-ref-reftex-get-bib-field "publisher" entry))
475                ((= l ?U) (org-ref-reftex-get-bib-field "url" entry))
476                ((= l ?r) (org-ref-reftex-get-bib-field "address" entry))
477                ;; strip enclosing brackets from title if they are there
478                ((= l ?t) (org-ref-reftex-get-bib-field "title" entry))
479                ((= l ?T) (reftex-abbreviate-title
480                           (org-ref-reftex-get-bib-field "title" entry)))
481                ((= l ?v) (org-ref-reftex-get-bib-field "volume" entry))
482                ((= l ?y) (org-ref-reftex-get-bib-field "year" entry)))))
483
484       (if (string= rpl "")
485           (setq b (match-beginning 2) e (match-end 2))
486         (setq b (match-beginning 3) e (match-end 3)))
487       (setq format (concat (substring format 0 b) rpl (substring format e)))))
488   (while (string-match "%%" format)
489     (setq format (replace-match "%" t t format)))
490   (while (string-match "[ ,.;:]*%<" format)
491     (setq format (replace-match "" t t format)))
492   ;; also replace carriage returns, tabs, and multiple whitespaces
493   (setq format (replace-regexp-in-string "\n\\|\t\\|\s+" " " format))
494   format)
495
496 (defun org-ref-get-bibtex-entry-citation (key)
497   "Return a string for the bibliography entry corresponding to KEY.
498 Format according to the type in `org-ref-bibliography-entry-format'."
499
500   (let ((org-ref-bibliography-files (org-ref-find-bibliography))
501         (file) (entry) (bibtex-entry) (entry-type) (format))
502
503     (setq file (catch 'result
504                  (loop for file in org-ref-bibliography-files do
505                        (if (org-ref-key-in-file-p key (file-truename file))
506                            (throw 'result file)
507                          (message "%s not found in %s" key (file-truename file))))))
508
509     (with-temp-buffer
510       (insert-file-contents file)
511       (bibtex-search-entry key nil 0)
512       (setq bibtex-entry (bibtex-parse-entry))
513       (setq entry-type (downcase (cdr (assoc "=type=" bibtex-entry))))
514       (setq format (cdr (assoc entry-type org-ref-bibliography-entry-format)))
515       (if format
516           (setq entry  (org-ref-reftex-format-citation bibtex-entry format))
517         (save-restriction
518           (bibtex-narrow-to-entry)
519           (setq entry (buffer-string)))))
520     entry))
521
522 (defun org-ref-get-bibtex-keys ()
523   "Return a list of unique keys in the buffer."
524   (let ((keys '()))
525     (org-element-map (org-element-parse-buffer) 'link
526       (lambda (link)
527         (let ((plist (nth 1 link)))
528           (when (-contains? org-ref-cite-types (plist-get plist ':type))
529             (dolist
530                 (key
531                  (org-ref-split-and-strip-string (plist-get plist ':path)))
532               (when (not (-contains? keys key))
533                 (setq keys (append keys (list key))))))))
534       ;; set with-affiliated to get keys in captions
535       nil nil nil t)
536     ;; Sort keys alphabetically
537     (setq keys (cl-sort keys 'string-lessp :key 'downcase))
538     keys))
539
540 (defun org-ref-get-bibtex-entry-html (key)
541   "Return an html string for the bibliography entry corresponding to KEY."
542
543   (format "<li><a id=\"%s\">[%s] %s</a></li>" key key (org-ref-get-bibtex-entry-citation key)))
544
545 (defun org-ref-get-html-bibliography ()
546   "Create an html bibliography when there are keys."
547   (let ((keys (org-ref-get-bibtex-keys)))
548     (when keys
549       (concat "<h1>Bibliography</h1>
550 <ul>"
551               (mapconcat (lambda (x) (org-ref-get-bibtex-entry-html x)) keys "\n")
552               "\n</ul>"))))
553
554 (defun org-ref-get-bibtex-entry-org (key)
555   "Return an org string for the bibliography entry corresponding to KEY."
556   (let ((org-ref-bibliography-files (org-ref-find-bibliography))
557         (file) (entry) (bibtex-entry) (entry-type) (format))
558
559     (setq file (catch 'result
560                  (loop for file in org-ref-bibliography-files do
561                        (if (org-ref-key-in-file-p key (file-truename file))
562                            (throw 'result file)
563                          (message "%s not found in %s" key (file-truename file))))))
564
565     (with-temp-buffer
566       (insert-file-contents file)
567       (bibtex-search-entry key nil 0)
568       (setq entry (bibtex-parse-entry))
569       (format "** %s - %s
570   :PROPERTIES:
571   %s
572   :END:
573 " (org-ref-reftex-get-bib-field "author" entry)
574 (org-ref-reftex-get-bib-field "title" entry)
575 (concat "   :CUSTOM_ID: " (org-ref-reftex-get-bib-field "=key=" entry) "\n"
576         (mapconcat (lambda (element) (format "   :%s: %s"
577                                              (upcase (car element))
578                                              (cdr element)))
579                    entry
580                    "\n"))))))
581
582 (defun org-ref-get-org-bibliography ()
583   "Create an org bibliography when there are keys."
584   (let ((keys (org-ref-get-bibtex-keys)))
585     (when keys
586       (concat "* Bibliography
587 "
588               (mapconcat (lambda (x) (org-ref-get-bibtex-entry-org x)) keys "\n")
589               "\n"))))
590
591 (defun org-ref-get-bibtex-entry-ascii (key)
592   "Return an ascii string for the bibliography entry corresponding to KEY."
593
594   (format "[%s] %s" key (org-ref-get-bibtex-entry-citation key)))
595
596 (defun org-ref-get-ascii-bibliography ()
597   "Create an html bibliography when there are keys."
598   (let ((keys (org-ref-get-bibtex-keys)))
599     (when keys
600       (concat
601 "Bibliography
602 =============
603 "
604               (mapconcat (lambda (x) (org-ref-get-bibtex-entry-ascii x)) keys "\n")
605               "\n"))))
606
607 ;; * Links
608 ;; ** bibliography and bibliographystyle
609 (org-add-link-type "bibliography"
610                    ;; this code is run on clicking. The bibliography
611                    ;; may contain multiple files. this code finds the
612                    ;; one you clicked on and opens it.
613                    (lambda (link-string)
614                        ;; get link-string boundaries
615                        ;; we have to go to the beginning of the line, and then search forward
616
617                      (let* ((bibfile)
618                             ;; object is the link you clicked on
619                             (object (org-element-context))
620                             (link-string-beginning)
621                             (link-string-end))
622
623                      (save-excursion
624                        (goto-char (org-element-property :begin object))
625                        (search-forward link-string nil nil 1)
626                        (setq link-string-beginning (match-beginning 0))
627                        (setq link-string-end (match-end 0)))
628
629                        ;; We set the reftex-default-bibliography
630                        ;; here. it should be a local variable only in
631                        ;; the current buffer. We need this for using
632                        ;; reftex to do citations.
633                        (set (make-local-variable 'reftex-default-bibliography)
634                             (split-string (org-element-property :path object) ","))
635
636                        ;; now if we have comma separated bibliographies
637                        ;; we find the one clicked on. we want to
638                        ;; search forward to next comma from point
639                        (save-excursion
640                          (if (search-forward "," link-string-end 1 1)
641                              (setq key-end (- (match-end 0) 1)) ; we found a match
642                            (setq key-end (point)))) ; no comma found so take the point
643                        ;; and backward to previous comma from point
644                        (save-excursion
645                          (if (search-backward "," link-string-beginning 1 1)
646                              (setq key-beginning (+ (match-beginning 0) 1)) ; we found a match
647                            (setq key-beginning (point)))) ; no match found
648                        ;; save the key we clicked on.
649                        (setq bibfile (org-ref-strip-string (buffer-substring key-beginning key-end)))
650                        (find-file bibfile))) ; open file on click
651
652                      ;; formatting code
653                    (lambda (keyword desc format)
654                      (cond
655                       ((eq format 'org) (org-ref-get-org-bibliography))
656                       ((eq format 'ascii) (org-ref-get-ascii-bibliography))
657                       ((eq format 'html) (org-ref-get-html-bibliography))
658                       ((eq format 'latex)
659                        ;; write out the latex bibliography command
660                        (format "\\bibliography{%s}" (replace-regexp-in-string  "\\.bib" "" (mapconcat 'identity
661                                                                                                       (mapcar 'expand-file-name
662                                                                                                               (split-string keyword ","))
663                                                                                                       ",")))))))
664
665 (org-add-link-type "nobibliography"
666                    ;; this code is run on clicking. The bibliography
667                    ;; may contain multiple files. this code finds the
668                    ;; one you clicked on and opens it.
669                    (lambda (link-string)
670                        ;; get link-string boundaries
671                        ;; we have to go to the beginning of the line, and then search forward
672
673                      (let* ((bibfile)
674                             ;; object is the link you clicked on
675                             (object (org-element-context))
676
677                             (link-string-beginning)
678                             (link-string-end))
679
680                      (save-excursion
681                        (goto-char (org-element-property :begin object))
682                        (search-forward link-string nil nil 1)
683                        (setq link-string-beginning (match-beginning 0))
684                        (setq link-string-end (match-end 0)))
685
686                        ;; We set the reftex-default-bibliography
687                        ;; here. it should be a local variable only in
688                        ;; the current buffer. We need this for using
689                        ;; reftex to do citations.
690                        (set (make-local-variable 'reftex-default-bibliography)
691                             (split-string (org-element-property :path object) ","))
692
693                        ;; now if we have comma separated bibliographies
694                        ;; we find the one clicked on. we want to
695                        ;; search forward to next comma from point
696                        (save-excursion
697                          (if (search-forward "," link-string-end 1 1)
698                              (setq key-end (- (match-end 0) 1)) ; we found a match
699                            (setq key-end (point)))) ; no comma found so take the point
700                        ;; and backward to previous comma from point
701                        (save-excursion
702                          (if (search-backward "," link-string-beginning 1 1)
703                              (setq key-beginning (+ (match-beginning 0) 1)) ; we found a match
704                            (setq key-beginning (point)))) ; no match found
705                        ;; save the key we clicked on.
706                        (setq bibfile (org-ref-strip-string (buffer-substring key-beginning key-end)))
707                        (find-file bibfile))) ; open file on click
708
709                      ;; formatting code
710                    (lambda (keyword desc format)
711                      (cond
712                       ((eq format 'org) (org-ref-get-org-bibliography))
713                       ((eq format 'ascii) (org-ref-get-ascii-bibliography))
714                       ((eq format 'html) (org-ref-get-html-bibliography))
715                       ((eq format 'latex)
716                        ;; write out the latex bibliography command
717
718 ;                      (format "{\\setbox0\\vbox{\\bibliography{%s}}}"
719 ;                              (replace-regexp-in-string  "\\.bib" "" (mapconcat 'identity
720 ;                                                                                (mapcar 'expand-file-name
721 ;                                                                                        (split-string keyword ","))
722 ;                                                                                ",")))
723
724                        (format "\\nobibliography{%s}"
725                                (replace-regexp-in-string  "\\.bib" "" (mapconcat 'identity
726                                                                                  (mapcar 'expand-file-name
727                                                                                          (split-string keyword ","))
728                                                                                  ",")))
729
730                        ))))
731
732 (org-add-link-type "printbibliography"
733                    (lambda (arg) (message "Nothing implemented for clicking here."))
734                    (lambda (keyword desc format)
735                      (cond
736                       ((eq format 'org) (org-ref-get-org-bibliography))
737                       ((eq format 'html) (org-ref-get-html-bibliography))
738                       ((eq format 'latex)
739                        ;; write out the biblatex bibliography command
740                        "\\printbibliography"))
741 ))
742
743 (org-add-link-type "bibliographystyle"
744                    (lambda (arg) (message "Nothing implemented for clicking here."))
745                    (lambda (keyword desc format)
746                      (cond
747                       ((eq format 'latex)
748                        ;; write out the latex bibliography command
749                        (format "\\bibliographystyle{%s}" keyword)))))
750
751
752 (defun org-bibliographystyle-complete-link (&optional arg)
753   "Completion function for bibliographystyle link.
754 ARG does nothing."
755   (format "bibliographystyle:%s" (ido-completing-read
756                                   "style: "
757                                   '("unsrt" "plain" "alpha"
758                                     ;; natbib
759                                     ;; https://www.sharelatex.com/learn/Natbib_bibliography_styles
760                                     "dinat" "humannat" "plainnat"
761                                     "abbrnat" "unsrtnat" "rusnat"
762                                     "ksfhnat"))))
763
764
765 (defun org-bibliography-complete-link (&optional arg)
766   "Completion function for bibliography link.
767 ARG does nothing."
768   (format "bibliography:%s" (read-file-name "enter file: " nil nil t)))
769
770
771 (defun org-ref-insert-bibliography-link ()
772   "Insert a bibliography with completion."
773   (interactive)
774   (insert (org-bibliography-complete-link)))
775
776 ;; ** addbibresource
777
778 (org-add-link-type "addbibresource"
779                    ;; this code is run on clicking. The addbibresource
780                    ;; may contain multiple files. this code finds the
781                    ;; one you clicked on and opens it.
782                    (lambda (link-string)
783                        ;; get link-string boundaries
784                        ;; we have to go to the beginning of the line, and then search forward
785
786                      (let* ((bibfile)
787                             ;; object is the link you clicked on
788                             (object (org-element-context))
789
790                             (link-string-beginning)
791                             (link-string-end))
792
793                      (save-excursion
794                        (goto-char (org-element-property :begin object))
795                        (search-forward link-string nil nil 1)
796                        (setq link-string-beginning (match-beginning 0))
797                        (setq link-string-end (match-end 0)))
798
799                        ;; We set the reftex-default-addbibresource
800                        ;; here. it should be a local variable only in
801                        ;; the current buffer. We need this for using
802                        ;; reftex to do citations.
803                        (set (make-local-variable 'reftex-default-addbibresource)
804                             (split-string (org-element-property :path object) ","))
805
806                        ;; now if we have comma separated bibliographies
807                        ;; we find the one clicked on. we want to
808                        ;; search forward to next comma from point
809                        (save-excursion
810                          (if (search-forward "," link-string-end 1 1)
811                              (setq key-end (- (match-end 0) 1)) ; we found a match
812                            (setq key-end (point)))) ; no comma found so take the point
813                        ;; and backward to previous comma from point
814                        (save-excursion
815                          (if (search-backward "," link-string-beginning 1 1)
816                              (setq key-beginning (+ (match-beginning 0) 1)) ; we found a match
817                            (setq key-beginning (point)))) ; no match found
818                        ;; save the key we clicked on.
819                        (setq bibfile (org-ref-strip-string (buffer-substring key-beginning key-end)))
820                        (find-file bibfile))) ; open file on click
821
822                      ;; formatting code
823                    (lambda (keyword desc format)
824                      (cond
825                       ((eq format 'html) (format "")); no output for html
826                       ((eq format 'latex)
827                          ;; write out the latex addbibresource command
828                        (format "\\addbibresource{%s}" keyword)))))
829
830 ;; ** List of figures
831 (defun org-ref-list-of-figures (&optional arg)
832   "Generate buffer with list of figures in them.
833 ARG does nothing."
834   (interactive)
835   (save-excursion (widen)
836   (let* ((c-b (buffer-name))
837          (counter 0)
838          (list-of-figures
839           (org-element-map (org-element-parse-buffer) 'link
840             (lambda (link)
841               "create a link for to the figure"
842               (when
843                   (and (string= (org-element-property :type link) "file")
844                        (string-match-p
845                         "[^.]*\\.\\(png\\|jpg\\|eps\\|pdf\\)$"
846                         (org-element-property :path link)))
847                 (incf counter)
848
849                 (let* ((start (org-element-property :begin link))
850                        (parent (car (cdr (org-element-property :parent link))))
851                        (caption (caaar (plist-get parent :caption)))
852                        (name (plist-get parent :name)))
853                   (if caption
854                       (format
855                        "[[elisp:(progn (switch-to-buffer \"%s\")(widen)(goto-char %s))][figure %s: %s]] %s\n"
856                        c-b start counter (or name "") caption)
857                     (format
858                      "[[elisp:(progn (switch-to-buffer \"%s\")(widen)(goto-char %s))][figure %s: %s]]\n"
859                      c-b start counter (or name "")))))))))
860     (switch-to-buffer "*List of Figures*")
861     (setq buffer-read-only nil)
862     (org-mode)
863     (erase-buffer)
864     (insert (mapconcat 'identity list-of-figures ""))
865     (setq buffer-read-only t)
866     (use-local-map (copy-keymap org-mode-map))
867     (local-set-key "q" #'(lambda () (interactive) (kill-buffer))))))
868
869 (org-add-link-type
870  "list-of-figures"
871  'org-ref-list-of-figures ; on click
872  (lambda (keyword desc format)
873    (cond
874     ((eq format 'latex)
875      (format "\\listoffigures")))))
876
877 ;; ** List of tables
878 (defun org-ref-list-of-tables (&optional arg)
879   "Generate a buffer with a list of tables.
880 ARG does nothing."
881   (interactive)
882   (save-excursion
883   (widen)
884   (let* ((c-b (buffer-name))
885          (counter 0)
886          (list-of-tables
887           (org-element-map (org-element-parse-buffer 'element) 'table
888             (lambda (table)
889               "create a link for to the table"
890               (incf counter)
891               (let ((start (org-element-property :begin table))
892                     (name  (org-element-property :name table))
893                     (caption (caaar (org-element-property :caption table))))
894                 (if caption
895                     (format
896                      "[[elisp:(progn (switch-to-buffer \"%s\")(widen)(goto-char %s))][table %s: %s]] %s\n"
897                      c-b start counter (or name "") caption)
898                   (format
899                    "[[elisp:(progn (switch-to-buffer \"%s\")(widen)(goto-char %s))][table %s: %s]]\n"
900                    c-b start counter (or name ""))))))))
901     (switch-to-buffer "*List of Tables*")
902     (setq buffer-read-only nil)
903     (org-mode)
904     (erase-buffer)
905     (insert (mapconcat 'identity list-of-tables ""))
906     (setq buffer-read-only t)
907     (use-local-map (copy-keymap org-mode-map))
908     (local-set-key "q" #'(lambda () (interactive) (kill-buffer))))))
909
910 (org-add-link-type
911  "list-of-tables"
912  'org-ref-list-of-tables
913  (lambda (keyword desc format)
914    (cond
915     ((eq format 'latex)
916      (format "\\listoftables")))))
917
918
919 ;; ** label link
920 (defun org-ref-count-labels (label)
921   "Counts number of matches for LABEL in the document."
922   (+ (count-matches (format "label:%s\\b[^-:]" label) (point-min) (point-max))
923      ;; for tblname, it is not enough to get word boundary
924      ;; tab-little and tab-little-2 match then.
925      (count-matches (format "^#\\+tblname:\\s-*%s\\b[^-:]" label) (point-min) (point-max))
926      (count-matches (format "\\label{%s}" label) (point-min) (point-max))
927      ;; this is the org-format #+label:
928      (count-matches (format "^#\\+label:\\s-*%s\\b[^-:]" label) (point-min) (point-max))
929      (let ((custom-id-count 0))
930        (org-map-entries
931         (lambda ()
932           (when (string= label (org-entry-get (point) "CUSTOM_ID"))
933             (setq custom-id-count (+ 1 custom-id-count)))))
934        custom-id-count)))
935
936 (org-add-link-type
937  "label"
938  (lambda (label)
939    "on clicking count the number of label tags used in the buffer. A number greater than one means multiple labels!"
940    (let ((count (org-ref-count-labels label)))
941    (message (format "%s occurence%s"
942                     count
943                     (if (or (= count 0)
944                               (> count 1))
945                         "s"
946                       ""))
947                     (org-ref-count-labels label))))
948  (lambda (keyword desc format)
949    (cond
950     ((eq format 'html) (format "(<label>%s</label>)" path))
951     ((eq format 'latex)
952      (format "\\label{%s}" keyword)))))
953
954 (defun org-label-store-link ()
955   "Store a link to a label.  The output will be a ref to that label."
956   ;; First we have to make sure we are on a label link.
957   (let* ((object (org-element-context)))
958     (when (and (equal (org-element-type object) 'link)
959                (equal (org-element-property :type object) "label"))
960       (org-store-link-props
961        :type "ref"
962        :link (concat "ref:" (org-element-property :path object))))
963
964     ;; Store link on table
965     (when (equal (org-element-type object) 'table)
966       (org-store-link-props
967        :type "ref"
968        :link (concat "ref:" (org-element-property :name object))))
969
970     ;; store link on heading with custom_id
971     ;; this is not a ref link, but it is still what you want
972     (when (and (equal (org-element-type object) 'headline)
973                (org-entry-get (point) "CUSTOM_ID"))
974       (org-store-link-props
975        :type "custom_id"
976        :link (format "[[#%s]]" (org-entry-get (point) "CUSTOM_ID"))))
977
978     ;; and to #+label: lines
979
980     (when (and (equal (org-element-type object) 'paragraph)
981                (org-element-property :name object))
982       (org-store-link-props
983        :type "ref"
984        :link (concat "ref:" (org-element-property :name object))))))
985
986 (add-hook 'org-store-link-functions 'org-label-store-link)
987
988 ;; ** ref link
989 (org-add-link-type
990  "ref"
991  (lambda (label)
992    "on clicking goto the label. Navigate back with C-c &"
993    (org-mark-ring-push)
994    ;; next search from beginning of the buffer
995
996    ;; it is possible you would not find the label if narrowing is in effect
997    (widen)
998
999    (unless
1000        (or
1001         ;; our label links
1002         (progn
1003           (goto-char (point-min))
1004           (re-search-forward (format "label:%s\\b" label) nil t))
1005
1006         ;; a latex label
1007         (progn
1008           (goto-char (point-min))
1009           (re-search-forward (format "\\label{%s}" label) nil t))
1010
1011         ;; #+label: name  org-definition
1012         (progn
1013           (goto-char (point-min))
1014           (re-search-forward (format "^#\\+label:\\s-*\\(%s\\)\\b" label) nil t))
1015
1016         ;; org tblname
1017         (progn
1018           (goto-char (point-min))
1019           (re-search-forward (format "^#\\+tblname:\\s-*\\(%s\\)\\b" label) nil t))
1020
1021      ;; we did not find anything, so go back to where we came
1022      (org-mark-ring-goto)
1023      (error "%s not found" label))
1024    (org-show-entry)
1025    (message "go back with (org-mark-ring-goto) `C-c &`"))
1026  ;formatting
1027  (lambda (keyword desc format)
1028    (cond
1029     ((eq format 'html) (format "(<ref>%s</ref>)" path))
1030     ((eq format 'latex)
1031      (format "\\ref{%s}" keyword)))))
1032
1033
1034 (defun org-ref-get-org-labels ()
1035  "Return a list of #+LABEL: labels."
1036   (save-excursion
1037     (goto-char (point-min))
1038     (let ((matches '()))
1039       (while (re-search-forward "^#\\+label:\\s-+\\(.*\\)\\b" (point-max) t)
1040         ;; do not do this for tables. We get those in `org-ref-get-tblnames'.
1041         ;; who would have thought you have save match data here? Trust me. When
1042         ;; I wrote this, you did.
1043         (unless (save-match-data  (equal (car (org-element-at-point)) 'table))
1044           (add-to-list 'matches (match-string-no-properties 1) t)))
1045       matches)))
1046
1047
1048 (defun org-ref-get-custom-ids ()
1049  "Return a list of custom_id properties in the buffer."
1050  (let ((results '()) custom_id)
1051    (org-map-entries
1052     (lambda ()
1053       (let ((custom_id (org-entry-get (point) "CUSTOM_ID")))
1054         (when (not (null custom_id))
1055           (setq results (append results (list custom_id)))))))
1056    results))
1057
1058
1059 (defun org-ref-get-latex-labels ()
1060   "Return list of matchin LaTeX defined labels in buffer."
1061   (save-excursion
1062     (goto-char (point-min))
1063     (let ((matches '()))
1064       (while (re-search-forward "\\\\label{\\([a-zA-z0-9:-]*\\)}" (point-max) t)
1065         (add-to-list 'matches (match-string-no-properties 1) t))
1066       matches)))
1067
1068
1069 (defun org-ref-get-tblnames ()
1070   "Return list of table names in the buffer."
1071   (org-element-map (org-element-parse-buffer 'element) 'table
1072     (lambda (table)
1073       (org-element-property :name table))))
1074
1075 (defun org-ref-get-labels ()
1076   "Return a list of labels in the buffer that you can make a ref link to.
1077 This is used to complete ref links and in helm menus."
1078   (save-excursion
1079     (save-restriction
1080       (widen)
1081       (goto-char (point-min))
1082       (let ((matches '()))
1083         ;; these are the org-ref label:stuff  kinds
1084         (while (re-search-forward
1085                 "[^#+]label:\\([a-zA-z0-9:-]*\\)" (point-max) t)
1086           (add-to-list 'matches (match-string-no-properties 1) t))
1087         ;; now add all the other kinds of labels.
1088         (append matches
1089                 ;; #+label:
1090                 (org-ref-get-org-labels)
1091                 ;; \label{}
1092                 (org-ref-get-latex-labels)
1093                 ;; #+tblname: and actually #+label
1094                 (org-ref-get-tblnames)
1095                 ;; CUSTOM_IDs
1096                 (org-ref-get-custom-ids))))))
1097
1098 (defun org-ref-helm-insert-label-link ()
1099   "Insert a label link. helm just shows you what labels already exist.
1100 If you are on a label link, replace it."
1101   (interactive)
1102   (let* ((labels (org-ref-get-labels))
1103          (cb (current-buffer)))
1104     (helm :sources `(((name . "Existing labels")
1105                       (candidates . ,labels)
1106                       ;; default action is to open to the label
1107                       (action . (lambda (label)
1108                                   ;; unfortunately I do not have markers here
1109                                   (org-open-link-from-string (format "ref:%s" label))))
1110                       ;; if you select a label, replace current one
1111                       (action . (lambda (label)
1112                                   (switch-to-buffer ,cb)
1113                                   (cond
1114                                    ;;  no prefix or on a link
1115                                    ((equal helm-current-prefix-arg nil)
1116                                     (let* ((object (org-element-context))
1117                                            (last-char (save-excursion
1118                                                         (goto-char (org-element-property :end object))
1119                                                         (backward-char)
1120                                                         (if (looking-at " ")
1121                                                             " "
1122                                                           ""))))
1123                                       (when (-contains? '("label")
1124                                                         (org-element-property :type object))
1125                                           ;; we are on a link, so replace it.
1126                                         (setf
1127                                            (buffer-substring
1128                                             (org-element-property :begin object)
1129                                             (org-element-property :end object))
1130                                            (concat
1131                                             (replace-regexp-in-string
1132                                              (org-element-property :path object)
1133                                              label
1134                                              (org-element-property :raw-link object))
1135                                             last-char)))))
1136                                    ;; no prefix options defined
1137                                    ))))
1138                      ;; no matching selection creates a new label
1139                      ((name . "Create new label")
1140                       (dummy)
1141                       ;; default action creates a new label, or replaces old one
1142                       (action .  (lambda (label)
1143                                    (switch-to-buffer ,cb)
1144                                    (let* ((object (org-element-context))
1145                                           (last-char (save-excursion
1146                                                        (goto-char (org-element-property :end object))
1147                                                        (backward-char)
1148                                                        (if (looking-at " ")
1149                                                            " "
1150                                                          ""))))
1151                                      (if (-contains? '("label")
1152                                                      (org-element-property :type object))
1153                                          ;; we are on a link, so replace it.
1154                                          (setf
1155                                           (buffer-substring
1156                                            (org-element-property :begin object)
1157                                            (org-element-property :end object))
1158                                           (concat
1159                                            (replace-regexp-in-string
1160                                             (org-element-property :path object)
1161                                             helm-pattern
1162                                             (org-element-property :raw-link object))
1163                                            last-char))
1164                                        ;; new link
1165                                        (insert
1166                                         (concat
1167                                          "label:"
1168                                          (or label
1169                                              helm-pattern))))))))))))
1170
1171 (defun org-ref-complete-link (&optional arg)
1172   "Completion function for ref links.
1173 Optional argument ARG Does nothing."
1174   (let ((label))
1175     (setq label (completing-read "label: " (org-ref-get-labels)))
1176     (format "ref:%s" label)))
1177
1178 (defun org-ref-insert-ref-link ()
1179   "Completion function for a ref link."
1180  (interactive)
1181  (insert (org-ref-complete-link)))
1182
1183 (defun org-ref-helm-insert-ref-link ()
1184   "Helm menu to insert ref links to labels in the document.
1185 If you are on link, replace with newly selected label.
1186 Use C-u to insert a different kind of ref link.
1187 Use C-u C-u to insert a [[#custom-id]] link"
1188   (interactive)
1189   (let* ((labels (org-ref-get-labels))
1190          (bs (buffer-string))
1191          (contexts (with-temp-buffer
1192                      (insert bs)
1193                      (mapcar 'org-ref-get-label-context labels)))
1194          (cb (current-buffer)))
1195
1196     (helm :input (thing-at-point 'word)
1197           :sources `(((name . "Available labels to ref")
1198                       (candidates . ,(loop for label in labels
1199                                            for context in contexts
1200                                            ;; we do some kludgy adding spaces
1201                                            ;; and bars to make it "easier" to
1202                                            ;; see in helm.
1203                                            collect (cons (concat
1204                                                           label "\n"
1205                                                           (mapconcat
1206                                                            (lambda (x)
1207                                                              (concat "   |" x))
1208                                                            (split-string context "\n")
1209                                                            "\n"
1210                                                            ) "\n\n") label)))
1211                       ;; default action to replace or insert ref link.
1212                       (action . (lambda (label)
1213                                   (switch-to-buffer ,cb)
1214
1215                                   (cond
1216                                    ;;  no prefix or on a link
1217                                    ((equal helm-current-prefix-arg nil)
1218                                     (let* ((object (org-element-context))
1219                                            (last-char (save-excursion
1220                                                         (goto-char (org-element-property :end object))
1221                                                         (backward-char)
1222                                                         (if (looking-at " ")
1223                                                             " "
1224                                                           ""))))
1225                                       (if (-contains? '("ref" "eqref" "pageref" "nameref")
1226                                                       (org-element-property :type object))
1227                                           ;; we are on a link, so replace it.
1228                                           (setf
1229                                            (buffer-substring
1230                                             (org-element-property :begin object)
1231                                             (org-element-property :end object))
1232                                            (concat
1233                                             (replace-regexp-in-string
1234                                              (org-element-property :path object)
1235                                              label
1236                                              (org-element-property :raw-link object))
1237                                             last-char))
1238                                         ;; insert a new link
1239                                         (insert
1240                                          (concat
1241                                           "ref:" label))
1242                                         )))
1243                                    ;; one prefix, alternate ref link
1244                                    ((equal helm-current-prefix-arg '(4))
1245                                     (insert
1246                                      (concat
1247                                       (helm :sources '((name . "Ref link types")
1248                                                        (candidates . ("ref" "eqref" "pageref" "nameref"))
1249                                                        (action . (lambda (x) x))))
1250                                       ":" label)))
1251                                    ;; two prefixes, insert section custom-id link
1252                                    ((equal helm-current-prefix-arg '(16))
1253                                     (insert
1254                                      (format "[[#%s]]" label)))
1255                                    ))
1256                               ))))))
1257
1258 ;; *** pageref link
1259 (org-add-link-type
1260  "pageref"
1261  (lambda (label)
1262    "on clicking goto the label. Navigate back with C-c &"
1263    (org-mark-ring-push)
1264    ;; next search from beginning of the buffer
1265    (widen)
1266    (unless
1267        (or
1268         ;; our label links
1269         (progn
1270           (goto-char (point-min))
1271           (re-search-forward (format "label:%s\\b" label) nil t))
1272
1273         ;; a latex label
1274         (progn
1275           (goto-char (point-min))
1276           (re-search-forward (format "\\label{%s}" label) nil t))
1277
1278         ;; #+label: name  org-definition
1279         (progn
1280           (goto-char (point-min))
1281           (re-search-forward (format "^#\\+label:\\s-*\\(%s\\)\\b" label) nil t))
1282
1283         ;; org tblname
1284         (progn
1285           (goto-char (point-min))
1286           (re-search-forward (format "^#\\+tblname:\\s-*\\(%s\\)\\b" label) nil t))
1287
1288 ;; Commented out because these ref links do not actually translate correctly in LaTeX.
1289 ;; you need [[#label]] links.
1290         ;; CUSTOM_ID
1291 ;       (progn
1292 ;         (goto-char (point-min))
1293 ;         (re-search-forward (format ":CUSTOM_ID:\s-*\\(%s\\)" label) nil t))
1294         )
1295      ;; we did not find anything, so go back to where we came
1296      (org-mark-ring-goto)
1297      (error "%s not found" label))
1298    (message "go back with (org-mark-ring-goto) `C-c &`"))
1299  ;formatting
1300  (lambda (keyword desc format)
1301    (cond
1302     ((eq format 'html) (format "(<pageref>%s</pageref>)" path))
1303     ((eq format 'latex)
1304      (format "\\pageref{%s}" keyword)))))
1305
1306 (defun org-pageref-complete-link (&optional arg)
1307   "Completion function for ref links.
1308 Optional argument ARG Does nothing."
1309   (let ((label))
1310     (setq label (completing-read "label: " (org-ref-get-labels)))
1311     (format "ref:%s" label)))
1312
1313 (defun org-pageref-insert-ref-link ()
1314   "Insert a pageref link with completion."
1315  (interactive)
1316  (insert (org-pageref-complete-link)))
1317
1318 ;; *** nameref link
1319 (org-add-link-type
1320  "nameref"
1321  (lambda (label)
1322    "on clicking goto the label. Navigate back with C-c &"
1323    (org-mark-ring-push)
1324    ;; next search from beginning of the buffer
1325    (widen)
1326    (unless
1327        (or
1328         ;; a latex label
1329         (progn
1330           (goto-char (point-min))
1331           (re-search-forward (format "\\label{%s}" label) nil t))
1332         )
1333      ;; we did not find anything, so go back to where we came
1334      (org-mark-ring-goto)
1335      (error "%s not found" label))
1336    (message "go back with (org-mark-ring-goto) `C-c &`"))
1337  ;formatting
1338  (lambda (keyword desc format)
1339    (cond
1340     ((eq format 'html) (format "(<nameref>%s</nameref>)" path))
1341     ((eq format 'latex)
1342      (format "\\nameref{%s}" keyword)))))
1343
1344 ;; *** eqref link
1345
1346 (org-add-link-type
1347  "eqref"
1348  (lambda (label)
1349    "on clicking goto the label. Navigate back with C-c &"
1350    (org-mark-ring-push)
1351    ;; next search from beginning of the buffer
1352    (widen)
1353    (goto-char (point-min))
1354    (unless
1355        (or
1356         ;; search forward for the first match
1357         ;; our label links
1358         (re-search-forward (format "label:%s" label) nil t)
1359         ;; a latex label
1360         (re-search-forward (format "\\label{%s}" label) nil t)
1361         ;; #+label: name  org-definition
1362         (re-search-forward (format "^#\\+label:\\s-*\\(%s\\)\\b" label) nil t))
1363      (org-mark-ring-goto)
1364      (error "%s not found" label))
1365    (message "go back with (org-mark-ring-goto) `C-c &`"))
1366  ;formatting
1367  (lambda (keyword desc format)
1368    (cond
1369     ((eq format 'html) (format "(<eqref>%s</eqref>)" path))
1370     ((eq format 'latex)
1371      (format "\\eqref{%s}" keyword)))))
1372
1373 ;; ** cite link
1374
1375 (defun org-ref-get-bibtex-key-under-cursor ()
1376   "Return key under the bibtex cursor.
1377 We search forward from
1378 point to get a comma, or the end of the link, and then backwards
1379 to get a comma, or the beginning of the link.  that delimits the
1380 keyword we clicked on.  We also strip the text properties."
1381   (let* ((object (org-element-context))
1382          (link-string (org-element-property :path object)))
1383     ;; you may click on the part before the citations. here we make
1384     ;; sure to move to the beginning so you get the first citation.
1385     (let ((cp (point)))
1386       (goto-char (org-element-property :begin object))
1387       (search-forward link-string (org-element-property :end object))
1388       (goto-char (match-beginning 0))
1389       ;; check if we clicked before the path and move as needed.
1390       (unless (< cp (point))
1391         (goto-char cp)))
1392
1393     (if (not (org-element-property :contents-begin object))
1394         ;; this means no description in the link
1395         (progn
1396           ;; we need the link path start and end
1397           (save-excursion
1398             (goto-char (org-element-property :begin object))
1399             (search-forward link-string nil nil 1)
1400             (setq link-string-beginning (match-beginning 0))
1401             (setq link-string-end (match-end 0)))
1402
1403           ;; The key is the text between commas, or the link boundaries
1404           (save-excursion
1405             (if (search-forward "," link-string-end t 1)
1406                 (setq key-end (- (match-end 0) 1)) ; we found a match
1407               (setq key-end link-string-end))) ; no comma found so take the end
1408           ;; and backward to previous comma from point which defines the start character
1409           (save-excursion
1410             (if (search-backward "," link-string-beginning 1 1)
1411                 (setq key-beginning (+ (match-beginning 0) 1)) ; we found a match
1412               (setq key-beginning link-string-beginning))) ; no match found
1413           ;; save the key we clicked on.
1414           (setq bibtex-key (org-ref-strip-string (buffer-substring key-beginning key-end)))
1415           (set-text-properties 0 (length bibtex-key) nil bibtex-key)
1416           bibtex-key)
1417       ;; link with description. assume only one key
1418       link-string)))
1419
1420 (defun org-ref-find-bibliography ()
1421   "Find the bibliography in the buffer.
1422 This function sets and returns cite-bibliography-files, which is a list of files
1423 either from bibliography:f1.bib,f2.bib
1424 \bibliography{f1,f2}
1425 internal bibliographies
1426
1427 falling back to what the user has set in `org-ref-default-bibliography'"
1428   (catch 'result
1429     (save-excursion
1430       (goto-char (point-min))
1431       ;;  look for a bibliography link
1432       (when (re-search-forward "\\<bibliography:\\([^\]\|\n]+\\)" nil t)
1433         (setq org-ref-bibliography-files
1434               (mapcar 'org-ref-strip-string (split-string (match-string 1) ",")))
1435         (throw 'result org-ref-bibliography-files))
1436
1437
1438       ;; we did not find a bibliography link. now look for \bibliography
1439       (goto-char (point-min))
1440       (when (re-search-forward "\\\\bibliography{\\([^}]+\\)}" nil t)
1441         ;; split, and add .bib to each file
1442         (setq org-ref-bibliography-files
1443               (mapcar (lambda (x) (concat x ".bib"))
1444                       (mapcar 'org-ref-strip-string
1445                               (split-string (match-string 1) ","))))
1446         (throw 'result org-ref-bibliography-files))
1447
1448       ;; no bibliography found. maybe we need a biblatex addbibresource
1449       (goto-char (point-min))
1450       ;;  look for a bibliography link
1451       (when (re-search-forward "addbibresource:\\([^\]\|\n]+\\)" nil t)
1452         (setq org-ref-bibliography-files
1453               (mapcar 'org-ref-strip-string (split-string (match-string 1) ",")))
1454         (throw 'result org-ref-bibliography-files))
1455
1456       ;; we did not find anything. use defaults
1457       (setq org-ref-bibliography-files org-ref-default-bibliography)))
1458
1459     ;; set reftex-default-bibliography so we can search
1460     (set (make-local-variable 'reftex-default-bibliography) org-ref-bibliography-files)
1461     org-ref-bibliography-files)
1462
1463 (defun org-ref-key-in-file-p (key filename)
1464   "Determine if the KEY is in the FILENAME."
1465   (save-current-buffer
1466     (let ((bibtex-files (list filename)))
1467       ;; This is something I am trying because when the bibtex file is open, and
1468       ;; you have added to it, the only way I find to get the update to update
1469       ;; is to close it and reopen it. or to save it and revert it.
1470       (when (get-file-buffer filename)
1471         (set-buffer (get-file-buffer filename))
1472         (save-buffer)
1473         (revert-buffer t t))
1474       (bibtex-search-entry key t))))
1475
1476 (defun org-ref-get-bibtex-key-and-file (&optional key)
1477   "Return the bibtex KEY and file that it is in.  If no key is provided, get one under point."
1478  (let ((org-ref-bibliography-files (org-ref-find-bibliography))
1479        (file))
1480    (unless key
1481      (setq key (org-ref-get-bibtex-key-under-cursor)))
1482    (setq file     (catch 'result
1483                     (loop for file in org-ref-bibliography-files do
1484                           (if (org-ref-key-in-file-p key (file-truename file))
1485                               (throw 'result file)))))
1486    (cons key file)))
1487
1488 ;; *** key at point functions
1489
1490 (defun org-ref-open-pdf-at-point ()
1491   "Open the pdf for bibtex key under point if it exists."
1492   (interactive)
1493   (let* ((results (org-ref-get-bibtex-key-and-file))
1494          (key (car results))
1495          (pdf-file (format (concat org-ref-pdf-directory "%s.pdf") key)))
1496     (if (file-exists-p pdf-file)
1497         (org-open-file pdf-file)
1498 (message "no pdf found for %s" key))))
1499
1500
1501 (defun org-ref-open-url-at-point ()
1502   "Open the url for bibtex key under point."
1503   (interactive)
1504   (let* ((results (org-ref-get-bibtex-key-and-file))
1505          (key (car results))
1506          (bibfile (cdr results)))
1507     (save-excursion
1508       (with-temp-buffer
1509         (insert-file-contents bibfile)
1510         (bibtex-search-entry key)
1511         ;; I like this better than bibtex-url which does not always find
1512         ;; the urls
1513         (catch 'done
1514           (let ((url (bibtex-autokey-get-field "url")))
1515             (when  url
1516               (browse-url (s-trim url))
1517               (throw 'done nil)))
1518
1519           (let ((doi (bibtex-autokey-get-field "doi")))
1520             (when doi
1521               (if (string-match "^http" doi)
1522                   (browse-url doi)
1523                 (browse-url (format "http://dx.doi.org/%s" (s-trim doi))))
1524               (throw 'done nil))))))))
1525
1526
1527 (defun org-ref-open-notes-at-point ()
1528   "Open the notes for bibtex key under point."
1529   (interactive)
1530   (let* ((results (org-ref-get-bibtex-key-and-file))
1531          (key (car results))
1532          (bibfile (cdr results)))
1533     (save-excursion
1534       (with-temp-buffer
1535         (insert-file-contents bibfile)
1536         (bibtex-search-entry key)
1537         (org-ref-open-bibtex-notes)))))
1538
1539
1540 (defun org-ref-citation-at-point ()
1541   "Give message of current citation at point."
1542   (interactive)
1543   (let* ((cb (current-buffer))
1544         (results (org-ref-get-bibtex-key-and-file))
1545         (key (car results))
1546         (bibfile (cdr results)))
1547     (message "%s" (progn
1548                     (with-temp-buffer
1549                       (insert-file-contents bibfile)
1550                       (bibtex-search-entry key)
1551                       (org-ref-bib-citation))))))
1552
1553
1554 (defun org-ref-open-citation-at-point ()
1555   "Open bibtex file to key at point."
1556   (interactive)
1557   (let* ((cb (current-buffer))
1558         (results (org-ref-get-bibtex-key-and-file))
1559         (key (car results))
1560         (bibfile (cdr results)))
1561     (find-file bibfile)
1562     (bibtex-search-entry key)))
1563
1564 ;; *** cite menu
1565
1566 (defvar org-ref-cite-menu-funcs '()
1567  "Functions to run on cite click menu.
1568 Each entry is a list of (key menu-name function).
1569 The function must take no arguments and work on the key at point.  Do not modify this variable, it is set to empty in the menu click function, and functions are conditionally added to it.")
1570
1571
1572 (defvar org-ref-user-cite-menu-funcs
1573   '(("C" "rossref" org-ref-crossref-at-point)
1574     ("y" "Copy entry to file" org-ref-copy-entry-at-point-to-file)
1575     ("s" "Copy summary" org-ref-copy-entry-as-summary))
1576   "User-defined functions to run on bibtex key at point.")
1577
1578
1579 (defun org-ref-copy-entry-as-summary ()
1580   "Copy the bibtex entry for the citation at point as a summary."
1581   (interactive)
1582     (save-window-excursion
1583       (org-ref-open-citation-at-point)
1584       (kill-new (org-ref-bib-citation))))
1585
1586
1587 (defun org-ref-copy-entry-at-point-to-file ()
1588   "Copy the bibtex entry for the citation at point to NEW-FILE.
1589 Prompt for NEW-FILE includes bib files in `org-ref-default-bibliography', and bib files in current working directory.  You can also specify a new file."
1590   (interactive)
1591   (let ((new-file (ido-completing-read
1592                    "Copy to bibfile: "
1593                    (append org-ref-default-bibliography
1594                            (f-entries "." (lambda (f) (f-ext? f "bib"))))))
1595         (key (org-ref-get-bibtex-key-under-cursor)))
1596     (save-window-excursion
1597       (org-ref-open-citation-at-point)
1598       (bibtex-copy-entry-as-kill))
1599
1600     (let ((bibtex-files (list (file-truename new-file))))
1601       (if (assoc key (bibtex-global-key-alist))
1602           (message "That key already exists in %s" new-file)
1603         ;; add to file
1604         (save-window-excursion
1605           (find-file new-file)
1606           (goto-char (point-max))
1607           ;; make sure we are at the beginning of a line.
1608           (unless (looking-at "^") (insert "\n\n"))
1609           (bibtex-yank)
1610           (save-buffer))))))
1611
1612
1613 (defun org-ref-get-doi-at-point ()
1614   "Get doi for key at point."
1615   (let* ((results (org-ref-get-bibtex-key-and-file))
1616          (key (car results))
1617          (bibfile (cdr results))
1618          doi)
1619     (save-excursion
1620       (with-temp-buffer
1621         (insert-file-contents bibfile)
1622         (bibtex-search-entry key)
1623         (setq doi (bibtex-autokey-get-field "doi"))
1624         ;; in case doi is a url, remove the url part.
1625         (replace-regexp-in-string "^http://dx.doi.org/" "" doi)))))
1626
1627
1628 ;; **** functions that operate on key at point for click menu
1629 (defun org-ref-wos-at-point ()
1630   "Open the doi in wos for bibtex key under point."
1631   (interactive)
1632   (doi-utils-wos (org-ref-get-doi-at-point)))
1633
1634
1635 (defun org-ref-wos-citing-at-point ()
1636   "Open the doi in wos citing articles for bibtex key under point."
1637   (interactive)
1638   (doi-utils-wos-citing (org-ref-get-doi-at-point)))
1639
1640
1641 (defun org-ref-wos-related-at-point ()
1642   "Open the doi in wos related articles for bibtex key under point."
1643   (interactive)
1644   (doi-utils-wos-related (org-ref-get-doi-at-point)))
1645
1646
1647 (defun org-ref-google-scholar-at-point ()
1648   "Open the doi in google scholar for bibtex key under point."
1649   (interactive)
1650   (doi-utils-google-scholar (org-ref-get-doi-at-point)))
1651
1652
1653 (defun org-ref-pubmed-at-point ()
1654   "Open the doi in pubmed for bibtex key under point."
1655   (interactive)
1656   (doi-utils-pubmed (org-ref-get-doi-at-point)))
1657
1658
1659 (defun org-ref-crossref-at-point ()
1660   "Open the doi in crossref for bibtex key under point."
1661   (interactive)
1662   (doi-utils-crossref (org-ref-get-doi-at-point)))
1663
1664 ;; *** Minibuffer menu
1665
1666 (defun org-ref-cite-onclick-minibuffer-menu (&optional link-string)
1667   "Action when a cite link is clicked on.
1668 Provides a menu of context sensitive actions.  If the bibtex entry
1669 has a pdf, you get an option to open it.  If there is a doi, you
1670 get a lot of options.  LINK-STRING is used by the link function."
1671   (interactive)
1672   (let* ((results (org-ref-get-bibtex-key-and-file))
1673          (key (car results))
1674          (pdf-file (format (concat org-ref-pdf-directory "%s.pdf") key))
1675          (bibfile (cdr results))
1676          (url (save-excursion
1677                 (with-temp-buffer
1678                   (insert-file-contents bibfile)
1679                   (bibtex-search-entry key)
1680                   (bibtex-autokey-get-field "url"))))
1681          (doi (save-excursion
1682                 (with-temp-buffer
1683                   (insert-file-contents bibfile)
1684                   (bibtex-search-entry key)
1685                   ;; I like this better than bibtex-url which does not always find
1686                   ;; the urls
1687                   (bibtex-autokey-get-field "doi")))))
1688
1689     (when (string= "" doi) (setq doi nil))
1690     (when (string= "" url) (setq url nil))
1691     (setq org-ref-cite-menu-funcs '())
1692
1693     ;; open action
1694     (when
1695         bibfile
1696       (add-to-list
1697        'org-ref-cite-menu-funcs
1698        '("o" "pen" org-ref-open-citation-at-point)))
1699
1700     ;; pdf
1701     (when (file-exists-p pdf-file)
1702       (add-to-list
1703        'org-ref-cite-menu-funcs
1704        `("p" "df" ,org-ref-open-pdf-function) t))
1705
1706     ;; notes
1707     (add-to-list
1708      'org-ref-cite-menu-funcs
1709      '("n" "otes" org-ref-open-notes-at-point) t)
1710
1711     ;; url
1712     (when (or url doi)
1713       (add-to-list
1714        'org-ref-cite-menu-funcs
1715        '("u" "rl" org-ref-open-url-at-point) t))
1716
1717     ;; doi funcs
1718     (when doi
1719       (add-to-list
1720        'org-ref-cite-menu-funcs
1721        '("w" "os" org-ref-wos-at-point) t)
1722
1723       (add-to-list
1724        'org-ref-cite-menu-funcs
1725        '("c" "iting" org-ref-wos-citing-at-point) t)
1726
1727       (add-to-list
1728        'org-ref-cite-menu-funcs
1729        '("r" "elated" org-ref-wos-related-at-point) t)
1730
1731       (add-to-list
1732        'org-ref-cite-menu-funcs
1733        '("g" "oogle scholar" org-ref-google-scholar-at-point) t)
1734
1735       (add-to-list
1736        'org-ref-cite-menu-funcs
1737        '("P" "ubmed" org-ref-pubmed-at-point) t))
1738
1739     ;; add user functions
1740     (dolist (tup org-ref-user-cite-menu-funcs)
1741       (add-to-list
1742        'org-ref-cite-menu-funcs
1743        tup t))
1744
1745     ;; finally quit
1746     (add-to-list
1747      'org-ref-cite-menu-funcs
1748      '("q" "uit" (lambda ())) t)
1749
1750     ;; now we make a menu
1751     ;; construct menu string as a message
1752     (message
1753      (concat
1754       (let* ((results (org-ref-get-bibtex-key-and-file))
1755              (key (car results))
1756              (bibfile (cdr results)))
1757         (save-excursion
1758           (with-temp-buffer
1759             (insert-file-contents bibfile)
1760             (bibtex-search-entry key)
1761             (org-ref-bib-citation))))
1762       "\n"
1763       (mapconcat
1764        (lambda (tup)
1765          (concat "[" (elt tup 0) "]"
1766                  (elt tup 1) " "))
1767        org-ref-cite-menu-funcs "")))
1768     ;; get the input
1769     (let* ((input (read-char-exclusive))
1770            (choice (assoc
1771                     (char-to-string input) org-ref-cite-menu-funcs)))
1772       ;; now run the function (2nd element in choice)
1773       (when choice
1774         (funcall
1775          (elt
1776           choice
1777           2))))))
1778
1779 ;; *** Generation of the cite links
1780 (defmacro org-ref-make-completion-function (type)
1781   "Macro to make a link completion function for a link of TYPE."
1782   `(defun ,(intern (format "org-%s-complete-link" type)) (&optional arg)
1783      (interactive)
1784      (format "%s:%s"
1785              ,type
1786              (completing-read
1787               "bibtex key: "
1788               (let ((bibtex-files (org-ref-find-bibliography)))
1789                 (bibtex-global-key-alist))))))
1790
1791 (defmacro org-ref-make-format-function (type)
1792   "Macro to make a format function for a link of TYPE."
1793   `(defun ,(intern (format "org-ref-format-%s" type)) (keyword desc format)
1794      (cond
1795       ((eq format 'org)
1796        (mapconcat
1797         (lambda (key)
1798           (format "[[#%s][%s]]" key key))
1799         (org-ref-split-and-strip-string keyword) ","))
1800
1801       ((eq format 'ascii)
1802        (concat "["
1803                (mapconcat
1804                 (lambda (key)
1805                   (format "%s" key))
1806                 (org-ref-split-and-strip-string keyword) ",") "]"))
1807
1808       ((eq format 'html)
1809        (mapconcat
1810         (lambda (key)
1811           (format "<a href=\"#%s\">%s</a>" key key))
1812         (org-ref-split-and-strip-string keyword) ","))
1813
1814       ((eq format 'latex)
1815        (if (string= (substring type -1) "s")
1816            ;; biblatex format for multicite commands, which all end in s. These are formated as \cites{key1}{key2}...
1817            (concat "\\" ,type (mapconcat (lambda (key) (format "{%s}"  key))
1818                                          (org-ref-split-and-strip-string keyword) ""))
1819          ;; bibtex format
1820        (concat "\\" ,type (when desc (org-ref-format-citation-description desc)) "{"
1821                (mapconcat (lambda (key) key) (org-ref-split-and-strip-string keyword) ",")
1822                "}")))
1823       ;; for markdown we generate pandoc citations
1824       ((eq format 'md)
1825        (cond
1826         (desc  ;; pre and or post text
1827          (let* ((text (split-string desc "::"))
1828                 (pre (car text))
1829                 (post (cadr text)))
1830            (concat
1831             (format "[@%s," keyword)
1832             (when pre (format " %s" pre))
1833             (when post (format ", %s" post))
1834             "]")))
1835         (t
1836          (format "[%s]"
1837                  (mapconcat
1838                   (lambda (key) (concat "@" key))
1839                   (org-ref-split-and-strip-string keyword)
1840                   "; "))))))))
1841
1842 (defun org-ref-format-citation-description (desc)
1843   "Return formatted citation description.
1844 If the cite link has a DESC (description), it is optional text
1845 for the citation command.  You can specify pre and post text by
1846 separating these with ::, for example [[cite:key][pre text::post
1847 text]]."
1848   (cond
1849    ((string-match "::" desc)
1850     (format "[%s][%s]" (car (setq results (split-string desc "::"))) (cadr results)))
1851    (t (format "[%s]" desc))))
1852
1853 (defun org-ref-define-citation-link (type &optional key)
1854   "Add a citation link of TYPE for org-ref.
1855 With optional KEY, set the reftex binding. For example:
1856 \(org-ref-define-citation-link \"citez\" ?z) will create a new
1857 citez link, with reftex key of z, and the completion function."
1858   (interactive "sCitation Type: \ncKey: ")
1859
1860   ;; create the formatting function
1861   (eval `(org-ref-make-format-function ,type))
1862
1863   (eval-expression
1864    `(org-add-link-type
1865      ,type
1866      org-ref-cite-onclick-function
1867      (quote ,(intern (format "org-ref-format-%s" type)))))
1868
1869   ;; create the completion function
1870   (eval `(org-ref-make-completion-function ,type))
1871
1872   ;; store new type so it works with adding citations, which checks
1873   ;; for existence in this list
1874   (add-to-list 'org-ref-cite-types type)
1875
1876   ;; and finally if a key is specified, we modify the reftex menu
1877   (when key
1878     (setf (nth 2 (assoc 'org reftex-cite-format-builtin))
1879           (append (nth 2 (assoc 'org reftex-cite-format-builtin))
1880                   `((,key  . ,(concat type ":%l")))))))
1881
1882 ;; create all the link types and their completion functions
1883 (mapcar 'org-ref-define-citation-link org-ref-cite-types)
1884
1885 (defun org-ref-insert-cite-link (alternative-cite)
1886   "Insert a default citation link using reftex.
1887 If you are on a link, it appends to the end of the link,
1888 otherwise, a new link is inserted.  Use a prefix
1889 arg (ALTERNATIVE-CITE) to get a menu of citation types."
1890   (interactive "P")
1891   (org-ref-find-bibliography)
1892   (let* ((object (org-element-context))
1893          (link-string-beginning (org-element-property :begin object))
1894          (link-string-end (org-element-property :end object))
1895          (path (org-element-property :path object)))
1896
1897     (if (not alternative-cite)
1898
1899         (cond
1900          ;; case where we are in a link
1901          ((and (equal (org-element-type object) 'link)
1902                (-contains? org-ref-cite-types (org-element-property :type object)))
1903           (goto-char link-string-end)
1904           ;; sometimes there are spaces at the end of the link
1905           ;; this code moves point pack until no spaces are there
1906           (while (looking-back " ") (backward-char))
1907           (insert (concat "," (mapconcat 'identity (reftex-citation t ?a) ","))))
1908
1909          ;; We are next to a link, and we want to append
1910          ((save-excursion
1911             (backward-char)
1912             (and (equal (org-element-type (org-element-context)) 'link)
1913                  (-contains? org-ref-cite-types (org-element-property :type (org-element-context)))))
1914           (while (looking-back " ") (backward-char))
1915           (insert (concat "," (mapconcat 'identity (reftex-citation t ?a) ","))))
1916
1917          ;; insert fresh link
1918          (t
1919           (insert
1920            (concat org-ref-default-citation-link
1921                    ":"
1922                    (mapconcat 'identity (reftex-citation t) ",")))))
1923
1924       ;; you pressed a C-u so we run this code
1925       (reftex-citation))))
1926
1927 (defun org-ref-insert-cite-with-completion (type)
1928   "Insert a cite link of TYPE with completion."
1929   (interactive (list (ido-completing-read "Type: " org-ref-cite-types)))
1930   (insert (funcall (intern (format "org-%s-complete-link" type)))))
1931
1932 (defun org-ref-store-bibtex-entry-link ()
1933   "Save a citation link to the current bibtex entry.  Save in the default link type."
1934   (interactive)
1935   (let ((link (concat org-ref-default-citation-link
1936                  ":"
1937                  (save-excursion
1938                    (bibtex-beginning-of-entry)
1939                    (reftex-get-bib-field "=key=" (bibtex-parse-entry))))))
1940     (message "saved %s" link)
1941     (push (list link) org-stored-links)
1942     (car org-stored-links)))
1943
1944 ;; ** Index link
1945 (org-add-link-type
1946  "index"
1947  (lambda (path)
1948    (occur path))
1949
1950  (lambda (path desc format)
1951    (cond
1952     ((eq format 'latex)
1953       (format "\\index{%s}" path)))))
1954
1955 ;; this will generate a temporary index of entries in the file.
1956 (org-add-link-type
1957  "printindex"
1958  (lambda (path)
1959    (let ((*index-links* '())
1960          (*initial-letters* '()))
1961
1962      ;; get links
1963      (org-element-map (org-element-parse-buffer) 'link
1964        (lambda (link)
1965          (let ((type (nth 0 link))
1966                (plist (nth 1 link)))
1967
1968            (when (equal (plist-get plist ':type) "index")
1969              (add-to-list
1970               '*index-links*
1971               (cons (plist-get plist :path)
1972                     (format
1973                      "[[elisp:(progn (switch-to-buffer \"%s\") (goto-char %s))][%s]]"
1974 (current-buffer)
1975                      (plist-get plist :begin)  ;; position of link
1976                      ;; grab a description
1977                      (save-excursion
1978                        (goto-char (plist-get plist :begin))
1979                        (if (thing-at-point 'sentence)
1980                            ;; get a sentence
1981                            (replace-regexp-in-string
1982                             "\n" "" (thing-at-point 'sentence))
1983                          ;; or call it a link
1984                          "link")))))))))
1985
1986      ;; sort the links
1987      (setq *index-links*  (cl-sort *index-links* 'string-lessp :key 'car))
1988
1989      ;; now first letters
1990      (dolist (link *index-links*)
1991        (add-to-list '*initial-letters* (substring (car link) 0 1) t))
1992
1993      ;; now create the index
1994      (switch-to-buffer (get-buffer-create "*index*"))
1995      (org-mode)
1996      (erase-buffer)
1997      (insert "#+TITLE: Index\n\n")
1998      (dolist (letter *initial-letters*)
1999        (insert (format "* %s\n" (upcase letter)))
2000        ;; now process the links
2001        (while (and
2002                *index-links*
2003                (string= letter (substring (car (car *index-links*)) 0 1)))
2004          (let ((link (pop *index-links*)))
2005            (insert (format "%s %s\n\n" (car link) (cdr link))))))
2006      (switch-to-buffer "*index*")))
2007  ;; formatting
2008  (lambda (path desc format)
2009    (cond
2010     ((eq format 'latex)
2011       (format "\\printindex")))))
2012
2013 ;; ** Glossary link
2014 (org-add-link-type
2015  "newglossaryentry"
2016  nil ;; no follow action
2017  (lambda (path desc format)
2018    (cond
2019     ((eq format 'latex)
2020      (format "\\newglossaryentry{%s}{%s}" path desc)))))
2021
2022
2023 ;; link to entry
2024 (org-add-link-type
2025  "gls"
2026   nil ;; no follow action
2027  (lambda (path desc format)
2028    (cond
2029     ((eq format 'latex)
2030      (format "\\gls{%s}" path)))))
2031
2032 ;; plural
2033 (org-add-link-type
2034  "glspl"
2035   nil ;; no follow action
2036  (lambda (path desc format)
2037    (cond
2038     ((eq format 'latex)
2039      (format "\\glspl{%s}" path)))))
2040
2041 ;; capitalized link
2042 (org-add-link-type
2043  "Gls"
2044   nil ;; no follow action
2045  (lambda (path desc format)
2046    (cond
2047     ((eq format 'latex)
2048      (format "\\Gls{%s}" path)))))
2049
2050 ;; capitalized link
2051 (org-add-link-type
2052  "Glspl"
2053   nil ;; no follow action
2054  (lambda (path desc format)
2055    (cond
2056     ((eq format 'latex)
2057      (format "\\Glspl{%s}" path)))))
2058
2059 ;; * Utilities
2060 ;; ** create text citations from a bibtex entry
2061 (defun org-ref-bib-citation ()
2062   "From a bibtex entry, create and return a simple citation string.
2063 This assumes you are in an article."
2064
2065   (bibtex-beginning-of-entry)
2066   (let* ((cb (current-buffer))
2067          (bibtex-expand-strings t)
2068          (entry (loop for (key . value) in (bibtex-parse-entry t)
2069                       collect (cons (downcase key) value)))
2070          (title (replace-regexp-in-string "\n\\|\t\\|\s+" " " (reftex-get-bib-field "title" entry)))
2071          (year  (reftex-get-bib-field "year" entry))
2072          (author (replace-regexp-in-string "\n\\|\t\\|\s+" " " (reftex-get-bib-field "author" entry)))
2073          (key (reftex-get-bib-field "=key=" entry))
2074          (journal (reftex-get-bib-field "journal" entry))
2075          (volume (reftex-get-bib-field "volume" entry))
2076          (pages (reftex-get-bib-field "pages" entry))
2077          (doi (reftex-get-bib-field "doi" entry))
2078          (url (reftex-get-bib-field "url" entry))
2079          )
2080     ;;authors, "title", Journal, vol(iss):pages (year).
2081     (format "%s, \"%s\", %s, %s:%s (%s)"
2082             author title journal  volume pages year)))
2083
2084 (defun org-ref-bib-html-citation ()
2085   "From a bibtex entry, create and return a simple citation with html links."
2086
2087   (bibtex-beginning-of-entry)
2088   (let* ((cb (current-buffer))
2089          (bibtex-expand-strings t)
2090          (entry (loop for (key . value) in (bibtex-parse-entry t)
2091                       collect (cons (downcase key) value)))
2092          (title (replace-regexp-in-string "\n\\|\t\\|\s+" " " (reftex-get-bib-field "title" entry)))
2093          (year  (reftex-get-bib-field "year" entry))
2094          (author (replace-regexp-in-string "\n\\|\t\\|\s+" " " (reftex-get-bib-field "author" entry)))
2095          (key (reftex-get-bib-field "=key=" entry))
2096          (journal (reftex-get-bib-field "journal" entry))
2097          (volume (reftex-get-bib-field "volume" entry))
2098          (pages (reftex-get-bib-field "pages" entry))
2099          (doi (reftex-get-bib-field "doi" entry))
2100          (url (reftex-get-bib-field "url" entry))
2101          )
2102     ;;authors, "title", Journal, vol(iss):pages (year).
2103     (concat (format "%s, \"%s\", %s, %s:%s (%s)."
2104                     author title journal  volume pages year)
2105             (when url (format " <a href=\"%s\">link</a>" url))
2106             (when doi (format " <a href=\"http://dx.doi.org/%s\">doi</a>" doi)))
2107     ))
2108
2109 ;; ** Open pdf in bibtex entry
2110 (defun org-ref-open-bibtex-pdf ()
2111   "Open pdf for a bibtex entry, if it exists.
2112 assumes point is in
2113 the entry of interest in the bibfile.  but does not check that."
2114   (interactive)
2115   (save-excursion
2116     (bibtex-beginning-of-entry)
2117     (let* ((bibtex-expand-strings t)
2118            (entry (bibtex-parse-entry t))
2119            (key (reftex-get-bib-field "=key=" entry))
2120            (pdf (format (concat org-ref-pdf-directory "%s.pdf") key)))
2121       (message "%s" pdf)
2122       (if (file-exists-p pdf)
2123           (org-open-link-from-string (format "[[file:%s]]" pdf))
2124         (ding)))))
2125
2126 ;; ** Open notes from bibtex entry
2127
2128 (defun org-ref-open-bibtex-notes ()
2129   "From a bibtex entry, open the notes if they exist, and create a heading if they do not.
2130
2131 I never did figure out how to use reftex to make this happen
2132 non-interactively. the reftex-format-citation function did not
2133 work perfectly; there were carriage returns in the strings, and
2134 it did not put the key where it needed to be. so, below I replace
2135 the carriage returns and extra spaces with a single space and
2136 construct the heading by hand."
2137   (interactive)
2138
2139   (bibtex-beginning-of-entry)
2140   (let* ((cb (current-buffer))
2141          (bibtex-expand-strings t)
2142          (entry (loop for (key . value) in (bibtex-parse-entry t)
2143                       collect (cons (downcase key) value)))
2144          (title (replace-regexp-in-string "\n\\|\t\\|\s+" " " (reftex-get-bib-field "title" entry)))
2145          (year  (reftex-get-bib-field "year" entry))
2146          (author (replace-regexp-in-string "\n\\|\t\\|\s+" " " (reftex-get-bib-field "author" entry)))
2147          (key (reftex-get-bib-field "=key=" entry))
2148          (journal (reftex-get-bib-field "journal" entry))
2149          (volume (reftex-get-bib-field "volume" entry))
2150          (pages (reftex-get-bib-field "pages" entry))
2151          (doi (reftex-get-bib-field "doi" entry))
2152          (url (reftex-get-bib-field "url" entry))
2153          )
2154
2155     ;; save key to clipboard to make saving pdf later easier by pasting.
2156     (with-temp-buffer
2157       (insert key)
2158       (kill-ring-save (point-min) (point-max)))
2159
2160     ;; now look for entry in the notes file
2161     (if  org-ref-bibliography-notes
2162         (find-file-other-window org-ref-bibliography-notes)
2163       (error "Org-ref-bib-bibliography-notes is not set to anything"))
2164
2165     (goto-char (point-min))
2166     ;; put new entry in notes if we don't find it.
2167     (if (re-search-forward (format ":Custom_ID: %s$" key) nil 'end)
2168         (funcall org-ref-open-notes-function)
2169       ;; no entry found, so add one
2170       (insert (format "\n** TODO %s - %s" year title))
2171       (insert (format"
2172  :PROPERTIES:
2173   :Custom_ID: %s
2174   :AUTHOR: %s
2175   :JOURNAL: %s
2176   :YEAR: %s
2177   :VOLUME: %s
2178   :PAGES: %s
2179   :DOI: %s
2180   :URL: %s
2181  :END:
2182 [[cite:%s]] [[file:%s/%s.pdf][pdf]]\n\n"
2183 key author journal year volume pages doi url key org-ref-pdf-directory key))
2184 (save-buffer))))
2185
2186 (defun org-ref-open-notes-from-reftex ()
2187   "Call reftex, and open notes for selected entry."
2188   (interactive)
2189   (let ((bibtex-key )))
2190
2191     ;; now look for entry in the notes file
2192     (if  org-ref-bibliography-notes
2193         (find-file-other-window org-ref-bibliography-notes)
2194       (error "Org-ref-bib-bibliography-notes is not set to anything"))
2195
2196     (goto-char (point-min))
2197
2198     (re-search-forward (format
2199                         ":Custom_ID: %s$"
2200                         (first (reftex-citation t)) nil 'end))
2201     (funcall org-ref-open-notes-function))
2202
2203 ;; ** Open bibtex entry in browser
2204 (defun org-ref-open-in-browser ()
2205   "Open the bibtex entry at point in a browser using the url field or doi field."
2206 (interactive)
2207 (save-excursion
2208   (bibtex-beginning-of-entry)
2209   (catch 'done
2210     (let ((url (bibtex-autokey-get-field "url")))
2211       (when  url
2212         (browse-url url)
2213         (throw 'done nil)))
2214
2215     (let ((doi (bibtex-autokey-get-field "doi")))
2216       (when doi
2217         (if (string-match "^http" doi)
2218             (browse-url doi)
2219           (browse-url (format "http://dx.doi.org/%s" doi)))
2220         (throw 'done nil)))
2221     (message "No url or doi found"))))
2222
2223 ;; ** upload entry to citeulike
2224
2225 (defun org-ref-upload-bibtex-entry-to-citeulike ()
2226   "With point in  a bibtex entry get bibtex string and submit to citeulike.
2227
2228 Relies on the python script /upload_bibtex_citeulike.py being in the user directory."
2229   (interactive)
2230   (message "uploading to citeulike")
2231   (save-restriction
2232     (bibtex-narrow-to-entry)
2233     (let ((startpos (point-min))
2234           (endpos (point-max))
2235           (bibtex-string (buffer-string))
2236           (script (concat "python " starter-kit-dir "/upload_bibtex_citeulike.py&")))
2237       (with-temp-buffer (insert bibtex-string)
2238                         (shell-command-on-region (point-min) (point-max) script t nil nil t)))))
2239
2240 ;; ** Build a pdf of the bibtex file
2241 (defun org-ref-build-full-bibliography ()
2242   "Build pdf of all bibtex entries, and open it."
2243   (interactive)
2244   (let* ((bibfile (file-name-nondirectory (buffer-file-name)))
2245         (bib-base (file-name-sans-extension bibfile))
2246         (texfile (concat bib-base ".tex"))
2247         (pdffile (concat bib-base ".pdf")))
2248     (find-file texfile)
2249     (erase-buffer)
2250     (insert (format "\\documentclass[12pt]{article}
2251 \\usepackage[version=3]{mhchem}
2252 \\usepackage{url}
2253 \\usepackage[numbers]{natbib}
2254 \\usepackage[colorlinks=true, linkcolor=blue, urlcolor=blue, pdfstartview=FitH]{hyperref}
2255 \\usepackage{doi}
2256 \\begin{document}
2257 \\nocite{*}
2258 \\bibliographystyle{unsrtnat}
2259 \\bibliography{%s}
2260 \\end{document}" bib-base))
2261     (save-buffer)
2262     (shell-command (concat "pdflatex " bib-base))
2263     (shell-command (concat "bibtex " bib-base))
2264     (shell-command (concat "pdflatex " bib-base))
2265     (shell-command (concat "pdflatex " bib-base))
2266     (kill-buffer texfile)
2267     (org-open-file pdffile)
2268     ))
2269
2270 ;; ** Extract bibtex entries in org-file
2271
2272 (defun org-ref-extract-bibtex-entries ()
2273   "Extract the bibtex entries referred to by cite links in the current buffer into a src block at the bottom of the current buffer.
2274
2275 If no bibliography is in the buffer the variable
2276 `reftex-default-bibliography' is used."
2277   (interactive)
2278   (let* ((temporary-file-directory (file-name-directory (buffer-file-name)))
2279          (tempname (make-temp-file "extract-bib"))
2280          (contents (buffer-string))
2281          (cb (current-buffer))
2282          basename texfile bibfile results)
2283
2284     ;; open tempfile and insert org-buffer contents
2285     (find-file tempname)
2286     (insert contents)
2287     (setq basename (file-name-sans-extension
2288                     (file-name-nondirectory buffer-file-name))
2289           texfile (concat tempname ".tex")
2290           bibfile (concat tempname ".bib"))
2291
2292     ;; see if we have a bibliography, and insert the default one if not.
2293     (save-excursion
2294       (goto-char (point-min))
2295       (unless (re-search-forward "^bibliography:" (point-max) 'end)
2296         (insert (format "\nbibliography:%s"
2297                         (mapconcat 'identity reftex-default-bibliography ",")))))
2298     (save-buffer)
2299
2300     ;; get a latex file and extract the references
2301     (org-latex-export-to-latex)
2302     (find-file texfile)
2303     (reftex-parse-all)
2304     (reftex-create-bibtex-file bibfile)
2305     (save-buffer)
2306     ;; save results of the references
2307     (setq results (buffer-string))
2308
2309     ;; kill buffers. these are named by basename, not full path
2310     (kill-buffer (concat basename ".bib"))
2311     (kill-buffer (concat basename ".tex"))
2312     (kill-buffer basename)
2313
2314     (delete-file bibfile)
2315     (delete-file texfile)
2316     (delete-file tempname)
2317
2318     ;; Now back to the original org buffer and insert the results
2319     (switch-to-buffer cb)
2320     (when (not (string= "" results))
2321       (save-excursion
2322         (goto-char (point-max))
2323         (insert "\n\n")
2324         (org-insert-heading)
2325         (insert (format " Bibtex entries
2326
2327 #+BEGIN_SRC text :tangle %s
2328 %s
2329 #+END_SRC" (concat (file-name-sans-extension (file-name-nondirectory (buffer-file-name))) ".bib") results))))))
2330
2331 ;; ** Find bad citations
2332 (require 'cl)
2333
2334 (defun index (substring list)
2335   "Return the index of SUBSTRING in a LIST of strings."
2336   (let ((i 0)
2337         (found nil))
2338     (dolist (arg list i)
2339       (if (string-match (concat "^" substring "$") arg)
2340           (progn
2341             (setq found t)
2342             (return i)))
2343       (setq i (+ i 1)))
2344     ;; return counter if found, otherwise return nil
2345     (if found i nil)))
2346
2347
2348 (defun org-ref-find-bad-citations ()
2349   "Create a list of citation keys in an org-file that do not have a bibtex entry in the known bibtex files.
2350
2351 Makes a new buffer with clickable links."
2352   (interactive)
2353   ;; generate the list of bibtex-keys and cited keys
2354   (let* ((bibtex-files (org-ref-find-bibliography))
2355          (bibtex-file-path (mapconcat (lambda (x) (file-name-directory (file-truename x))) bibtex-files ":"))
2356          (bibtex-keys (mapcar (lambda (x) (car x)) (bibtex-global-key-alist)))
2357          (bad-citations '()))
2358
2359     (org-element-map (org-element-parse-buffer) 'link
2360       (lambda (link)
2361         (let ((plist (nth 1 link)))
2362           (when (-contains? org-ref-cite-types (plist-get plist :type))
2363             (dolist (key (org-ref-split-and-strip-string (plist-get plist :path)))
2364               (when (not (index key bibtex-keys))
2365                 (setq
2366                  bad-citations
2367                  (append
2368                   bad-citations
2369                   `(,(format "%s [[elisp:(progn (switch-to-buffer-other-frame \"%s\")(goto-char %s))][not found here]]\n"
2370                              key
2371                              (buffer-name)
2372                              (plist-get plist :begin)))))
2373                 )))))
2374       ;; set with-affilates to t to get citations in a caption
2375       nil nil nil t)
2376
2377     (if bad-citations
2378       (progn
2379         (switch-to-buffer-other-window "*Missing citations*")
2380         (org-mode)
2381         (erase-buffer)
2382         (insert "* List of bad cite links\n")
2383         (insert (mapconcat 'identity bad-citations ""))
2384                                         ;(setq buffer-read-only t)
2385         (use-local-map (copy-keymap org-mode-map))
2386         (local-set-key "q" #'(lambda () (interactive) (kill-buffer))))
2387
2388       (when (get-buffer "*Missing citations*")
2389           (kill-buffer "*Missing citations*"))
2390       (message "No bad cite links found"))))
2391
2392 ;; ** helm interface to bad citations, labels, refs in orgfile
2393 (defun org-ref-bad-cite-candidates ()
2394   "Return a list of conses (key . marker) where key does not exist in the known bibliography files, and marker points to the key."
2395   (let* ((cp (point))                   ; save to return to later
2396          (bibtex-files (org-ref-find-bibliography))
2397          (bibtex-file-path (mapconcat
2398                             (lambda (x)
2399                               (file-name-directory (file-truename x)))
2400                             bibtex-files ":"))
2401          (bibtex-keys (mapcar (lambda (x) (car x))
2402                               (bibtex-global-key-alist)))
2403          (bad-citations '()))
2404
2405     (org-element-map (org-element-parse-buffer) 'link
2406       (lambda (link)
2407         (let ((plist (nth 1 link)))
2408           (when (-contains? org-ref-cite-types (plist-get plist :type))
2409             (dolist (key (org-ref-split-and-strip-string (plist-get plist :path)) )
2410               (when (not (index key bibtex-keys))
2411                 (goto-char (plist-get plist :begin))
2412                 (re-search-forward key)
2413                 (push (cons key (point-marker)) bad-citations)))
2414             )))
2415       ;; add with-affiliates to get cites in caption
2416       nil nil nil t)
2417     (goto-char cp)
2418     bad-citations))
2419
2420
2421 (defun org-ref-bad-ref-candidates ()
2422   "Return a list of conses (ref . marker) where ref is a ref link that does not point to anything (i.e. a label)."
2423   ;; first get a list of legitimate labels
2424   (let ((cp (point))
2425         (labels (org-ref-get-labels))
2426         (bad-refs '()))
2427     ;; now loop over ref links
2428     (goto-char (point-min))
2429     (org-element-map (org-element-parse-buffer) 'link
2430       (lambda (link)
2431         (let ((plist (nth 1 link)))
2432           (when (or  (equal (plist-get plist ':type) "ref")
2433                      (equal (plist-get plist ':type) "eqref")
2434                      (equal (plist-get plist ':type) "pageref")
2435                      (equal (plist-get plist ':type) "nameref"))
2436             (unless (-contains? labels (plist-get plist :path))
2437               (goto-char (plist-get plist :begin))
2438               (add-to-list
2439                'bad-refs
2440                (cons (plist-get plist :path)
2441                      (point-marker))))))))
2442     (goto-char cp)
2443     bad-refs))
2444
2445
2446 (defun org-ref-bad-label-candidates ()
2447   "Return a list of labels where label is multiply defined."
2448   (let ((labels (org-ref-get-labels))
2449         (multiple-labels '()))
2450     (when (not (= (length labels)
2451                   (length (-uniq labels))))
2452       (dolist (label labels)
2453         (when (> (-count (lambda (a)
2454                            (equal a label))
2455                          labels) 1)
2456           ;; this is a multiply defined label.
2457           (let ((cp (point)))
2458             (goto-char (point-min))
2459             (while (re-search-forward
2460                     (format  "[^#+]label:%s\\s-" label) nil t)
2461               (push (cons label (point-marker)) multiple-labels))
2462             (goto-char (point-min))
2463             (while (re-search-forward
2464                     (format  "\\label{%s}\\s-?" label) nil t)
2465               (push (cons label (point-marker)) multiple-labels))
2466
2467             (goto-char (point-min))
2468             (while (re-search-forward
2469                     (format  "^#\\+label:\\s-*%s" label) nil t)
2470               (push (cons label (point-marker)) multiple-labels))
2471
2472             (goto-char (point-min))
2473             (while (re-search-forward
2474                     (format   "^#\\+tblname:\\s-*%s" label) nil t)
2475               (push (cons label (point-marker)) multiple-labels))
2476             (goto-char cp)))))
2477       multiple-labels))
2478
2479 ;;;###autoload
2480 (defun org-ref ()
2481   "Opens a helm interface to actions for org-ref.
2482 Shows bad citations, ref links and labels"
2483   (interactive)
2484   (let ((cb (current-buffer))
2485         (bad-citations (org-ref-bad-cite-candidates))
2486         (bad-refs (org-ref-bad-ref-candidates))
2487         (bad-labels (org-ref-bad-label-candidates)))
2488
2489     (helm :sources `(((name . "Bad citations")
2490                        (candidates . ,bad-citations)
2491                        (action . (lambda (marker)
2492                                    (switch-to-buffer (marker-buffer marker))
2493                                    (goto-char marker))))
2494                      ;;
2495                      ((name . "Bad Labels")
2496                       (candidates . ,bad-labels)
2497                       (action . (lambda (marker)
2498                                    (switch-to-buffer (marker-buffer marker))
2499                                    (goto-char marker))))
2500                      ;;
2501                      ((name . "Bad ref links")
2502                       (candidates . ,bad-refs)
2503                       (action . (lambda (marker)
2504                                           (switch-to-buffer (marker-buffer marker))
2505                                           (goto-char marker))))
2506                      ;;
2507                      ((name . "Utilities")
2508                       (candidates . (("Check buffer again" . org-ref)
2509                                      ("Insert citation" . helm-bibtex)
2510                                      ("Insert label link" . org-ref-helm-insert-label-link)
2511                                      ("Insert ref link" . org-ref-helm-insert-ref-link)
2512                                      ("List of figures" . org-ref-list-of-figures)
2513                                      ("List of tables" . org-ref-list-of-tables)
2514                                      ("Table of contents" . nil)
2515                                      ))
2516                       (action . (lambda (x)
2517                                   (switch-to-buffer ,cb)
2518                                   (funcall x))))
2519                      ;;
2520                      ((name . "Export functions")
2521                       (candidates . (("Extract cited entries" . org-ref-extract-bibtex-entries)
2522                                      ("Export to html and open" . (lambda () (org-open-file (org-html-export-to-html))))
2523                                      ("Export to pdf and open" . (lambda ()
2524                                                                    (org-open-file (org-latex-export-to-pdf))))
2525                                      ("Export to manuscript pdf and open" . ox-manuscript-export-and-build-and-open)
2526                                      ("Export submission manuscript pdf and open" . ox-manuscript-build-submission-manuscript-and-open)
2527
2528                                      ))
2529                       (action . (lambda (x)
2530                                   (switch-to-buffer ,cb)
2531                                   (funcall x))))
2532                       ))))
2533
2534 ;; ** Find non-ascii charaters
2535 (defun org-ref-find-non-ascii-characters ()
2536   "Find non-ascii characters in the buffer.  Useful for cleaning up bibtex files."
2537   (interactive)
2538   (occur "[^[:ascii:]]"))
2539
2540 ;; ** Sort fields in a bibtex entry
2541
2542 (defun org-ref-sort-bibtex-entry ()
2543   "Sort fields of entry in standard order and downcase them."
2544   (interactive)
2545   (bibtex-beginning-of-entry)
2546   (let* ((master '("author" "title" "journal" "volume" "number" "pages" "year" "doi" "url"))
2547          (entry (bibtex-parse-entry))
2548          (entry-fields)
2549          (other-fields)
2550          (type (cdr (assoc "=type=" entry)))
2551          (key (cdr (assoc "=key=" entry))))
2552
2553     ;; these are the fields we want to order that are in this entry
2554     (setq entry-fields (mapcar (lambda (x) (car x)) entry))
2555     ;; we do not want to reenter these fields
2556     (setq entry-fields (remove "=key=" entry-fields))
2557     (setq entry-fields (remove "=type=" entry-fields))
2558
2559     ;;these are the other fields in the entry
2560     (setq other-fields (remove-if-not (lambda(x) (not (member x master))) entry-fields))
2561
2562     (cond
2563      ;; right now we only resort articles
2564      ((string= (downcase type) "article")
2565       (bibtex-kill-entry)
2566       (insert
2567        (concat "@article{" key ",\n"
2568                (mapconcat
2569                 (lambda (field)
2570                   (when (member field entry-fields)
2571                     (format "%s = %s," (downcase field) (cdr (assoc field entry))))) master "\n")
2572                (mapconcat
2573                 (lambda (field)
2574                   (format "%s = %s," (downcase field) (cdr (assoc field entry)))) other-fields "\n")
2575                "\n}\n\n"))
2576       (bibtex-find-entry key)
2577       (bibtex-fill-entry)
2578       (bibtex-clean-entry)
2579        ))))
2580
2581 ;; ** Clean a bibtex entry
2582 (defun org-ref-clean-bibtex-entry(&optional keep-key)
2583   "clean and replace the key in a bibtex function. When keep-key is t, do not replace it. You can use a prefix to specify the key should be kept"
2584   (interactive "P")
2585   (bibtex-beginning-of-entry)
2586 (end-of-line)
2587   ;; some entries do not have a key or comma in first line. We check and add it, if needed.
2588   (unless (string-match ",$" (thing-at-point 'line))
2589     (end-of-line)
2590     (insert ","))
2591
2592   ;; check for empty pages, and put eid or article id in its place
2593   (let ((entry (bibtex-parse-entry))
2594         (pages (bibtex-autokey-get-field "pages"))
2595         (year (bibtex-autokey-get-field "year"))
2596         (doi  (bibtex-autokey-get-field "doi"))
2597         ;; The Journal of Chemical Physics uses eid
2598         (eid (bibtex-autokey-get-field "eid")))
2599
2600     ;; replace http://dx.doi.org/ in doi. some journals put that in,
2601     ;; but we only want the doi.
2602     (when (string-match "^http://dx.doi.org/" doi)
2603       (bibtex-beginning-of-entry)
2604       (goto-char (car (cdr (bibtex-search-forward-field "doi" t))))
2605       (bibtex-kill-field)
2606       (bibtex-make-field "doi")
2607       (backward-char)
2608       (insert (replace-regexp-in-string "^http://dx.doi.org/" "" doi)))
2609
2610     ;; asap articles often set year to 0, which messes up key
2611     ;; generation. fix that.
2612     (when (string= "0" year)
2613       (bibtex-beginning-of-entry)
2614       (goto-char (car (cdr (bibtex-search-forward-field "year" t))))
2615       (bibtex-kill-field)
2616       (bibtex-make-field "year")
2617       (backward-char)
2618       (insert (read-string "Enter year: ")))
2619
2620     ;; fix pages if they are empty if there is an eid to put there.
2621     (when (string= "-" pages)
2622       (when eid
2623         (bibtex-beginning-of-entry)
2624         ;; this seems like a clunky way to set the pages field.But I
2625         ;; cannot find a better way.
2626         (goto-char (car (cdr (bibtex-search-forward-field "pages" t))))
2627         (bibtex-kill-field)
2628         (bibtex-make-field "pages")
2629         (backward-char)
2630         (insert eid)))
2631
2632     ;; replace naked & with \&
2633     (save-restriction
2634       (bibtex-narrow-to-entry)
2635       (bibtex-beginning-of-entry)
2636       (message "checking &")
2637       (replace-regexp " & " " \\\\& ")
2638       (widen))
2639
2640     ;; generate a key, and if it duplicates an existing key, edit it.
2641     (unless keep-key
2642       (let ((key (bibtex-generate-autokey)))
2643
2644         ;; first we delete the existing key
2645         (bibtex-beginning-of-entry)
2646         (re-search-forward bibtex-entry-maybe-empty-head)
2647         (if (match-beginning bibtex-key-in-head)
2648             (delete-region (match-beginning bibtex-key-in-head)
2649                            (match-end bibtex-key-in-head)))
2650         ;; check if the key is in the buffer
2651         (when (save-excursion
2652                 (bibtex-search-entry key))
2653           (save-excursion
2654             (bibtex-search-entry key)
2655             (bibtex-copy-entry-as-kill)
2656             (switch-to-buffer-other-window "*duplicate entry*")
2657             (bibtex-yank))
2658           (setq key (bibtex-read-key "Duplicate Key found, edit: " key)))
2659
2660         (insert key)
2661         (kill-new key))) ;; save key for pasting
2662
2663     ;; run hooks. each of these operates on the entry with no arguments.
2664     ;; this did not work like  i thought, it gives a symbolp error.
2665     ;; (run-hooks org-ref-clean-bibtex-entry-hook)
2666     (mapcar (lambda (x)
2667               (save-restriction
2668                 (save-excursion
2669                   (funcall x))))
2670             org-ref-clean-bibtex-entry-hook)
2671
2672     ;; sort fields within entry
2673     (org-ref-sort-bibtex-entry)
2674     ;; check for non-ascii characters
2675     (occur "[^[:ascii:]]")
2676     ))
2677
2678 (defun org-ref-get-citation-year (key)
2679   "Get the year of an entry with KEY.  Return year as a string."
2680   (let* ((results (org-ref-get-bibtex-key-and-file key))
2681          (bibfile (cdr results)))
2682     (with-temp-buffer
2683       (insert-file-contents bibfile)
2684       (bibtex-search-entry key nil 0)
2685       (prog1 (reftex-get-bib-field "year" (bibtex-parse-entry t))
2686         ))))
2687
2688 ;; ** Sort cite in cite link
2689 (defun org-ref-sort-citation-link ()
2690  "Replace link at point with sorted link by year."
2691  (interactive)
2692  (let* ((object (org-element-context))
2693         (type (org-element-property :type object))
2694         (begin (org-element-property :begin object))
2695         (end (org-element-property :end object))
2696         (link-string (org-element-property :path object))
2697         keys years data)
2698   (setq keys (org-ref-split-and-strip-string link-string))
2699   (setq years (mapcar 'org-ref-get-citation-year keys))
2700   (setq data (mapcar* (lambda (a b) `(,a . ,b)) years keys))
2701   (setq data (cl-sort data (lambda (x y) (< (string-to-int (car x)) (string-to-int (car y))))))
2702   ;; now get the keys separated by commas
2703   (setq keys (mapconcat (lambda (x) (cdr x)) data ","))
2704   ;; and replace the link with the sorted keys
2705   (cl--set-buffer-substring begin end (concat type ":" keys))))
2706
2707 ;; ** Shift-arrow sorting of keys in a cite link
2708
2709 (defun org-ref-swap-keys (i j keys)
2710  "Swap the KEYS in a list with index I and J."
2711  (let ((tempi (nth i keys)))
2712    (setf (nth i keys) (nth j keys))
2713    (setf (nth j keys) tempi))
2714   keys)
2715
2716
2717 (defun org-ref-swap-citation-link (direction)
2718  "Move citation at point in DIRECTION +1 is to the right, -1 to the left."
2719  (interactive)
2720  (let* ((object (org-element-context))
2721         (type (org-element-property :type object))
2722         (begin (org-element-property :begin object))
2723         (end (org-element-property :end object))
2724         (link-string (org-element-property :path object))
2725         key keys i)
2726    ;;   We only want this to work on citation links
2727    (when (-contains? org-ref-cite-types type)
2728         (setq key (org-ref-get-bibtex-key-under-cursor))
2729         (setq keys (org-ref-split-and-strip-string link-string))
2730         (setq i (index key keys))  ;; defined in org-ref
2731         (if (> direction 0) ;; shift right
2732             (org-ref-swap-keys i (+ i 1) keys)
2733           (org-ref-swap-keys i (- i 1) keys))
2734         (setq keys (mapconcat 'identity keys ","))
2735         ;; and replace the link with the sorted keys
2736         (cl--set-buffer-substring
2737          begin end
2738          (concat
2739           type ":" keys
2740           ;; It seems the space at the end can get consumed, so we see if there
2741           ;; is a space, and add it if so. Sometimes there is a comma or period,
2742           ;; then we do not want a space.
2743           (when
2744               (save-excursion
2745                 (goto-char end)
2746                 (looking-back " ")) " ")))
2747         ;; now go forward to key so we can move with the key
2748         (re-search-forward key)
2749         (goto-char (match-beginning 0)))))
2750
2751 ;; add hooks to make it work
2752 (add-hook 'org-shiftright-hook (lambda () (org-ref-swap-citation-link 1)))
2753 (add-hook 'org-shiftleft-hook (lambda () (org-ref-swap-citation-link -1)))
2754
2755 ;; ** context around org-ref links
2756 (defun org-ref-get-label-context (label)
2757   "Return a string of context around a LABEL."
2758   (save-excursion
2759     (catch 'result
2760       (goto-char (point-min))
2761       (when (re-search-forward
2762              (format "label:%s\\b" label) nil t)
2763         (throw 'result (buffer-substring
2764                         (progn
2765                           (previous-line)
2766                           (beginning-of-line)
2767                           (point))
2768                         (progn
2769                           (forward-line 4)
2770                           (point)))))
2771
2772       (goto-char (point-min))
2773       (when (re-search-forward
2774              (format "\\label{%s}" label) nil t)
2775         (throw 'result (buffer-substring
2776                         (progn
2777                           (previous-line)
2778                           (beginning-of-line)
2779                           (point))
2780                         (progn
2781                           (forward-line 4)
2782                           (point)))))
2783
2784       (goto-char (point-min))
2785       (when (re-search-forward
2786              (format "^#\\+label:\\s-*\\(%s\\)\\b" label) nil t)
2787         (throw 'result (buffer-substring
2788                         (progn
2789                           (previous-line)
2790                           (beginning-of-line)
2791                           (point))
2792                         (progn
2793                           (forward-line 4)
2794                           (point)))))
2795
2796       (goto-char (point-min))
2797       (when (re-search-forward
2798              (format "^#\\+tblname:\\s-*\\(%s\\)\\b" label) nil t)
2799         (throw 'result (buffer-substring
2800                         (progn
2801                           (previous-line)
2802                           (beginning-of-line)
2803                           (point))
2804                         (progn
2805                           (forward-line 4)
2806                           (point)))))
2807       (throw 'result "!!! NO CONTEXT FOUND !!!"))))
2808
2809
2810 (defun org-ref-link-message ()
2811   "Print a minibuffer message about the link that point is on."
2812   (interactive)
2813   (when (eq major-mode 'org-mode)
2814     (let* ((object (org-element-context))
2815            (type (org-element-property :type object)))
2816       (save-excursion
2817         (cond
2818          ;; cite links
2819          ((-contains? org-ref-cite-types type)
2820           (message (org-ref-get-citation-string-at-point)))
2821
2822          ;; message some context about the label we are referring to
2823          ((string= type "ref")
2824           (message "%scount: %s"
2825                    (org-ref-get-label-context
2826                     (org-element-property :path object))
2827                    (org-ref-count-labels
2828                         (org-element-property :path object))))
2829
2830          ((string= type "eqref")
2831           (message "%scount: %s"
2832                    (org-ref-get-label-context
2833                     (org-element-property :path object))
2834                    (org-ref-count-labels
2835                         (org-element-property :path object))))
2836
2837          ;; message the count
2838          ((string= type "label")
2839           (let ((count (org-ref-count-labels
2840                         (org-element-property :path object))))
2841             ;; get plurality on occurrence correct
2842             (message (concat
2843                       (number-to-string count)
2844                       " occurence"
2845                       (when (or (= count 0)
2846                                 (> count 1))
2847                         "s")))))
2848
2849          ((string= type "custom-id")
2850           (save-excursion
2851             (org-open-link-from-string
2852              (format "[[#%s]]" (org-element-property :path object)))
2853             (message "%s" (org-get-heading))))
2854
2855          ;; check if the bibliography files exist.
2856          ((string= type "bibliography")
2857           (let* ((bibfile)
2858                  ;; object is the link you clicked on
2859                  (object (org-element-context))
2860                  (link-string (org-element-property :path object))
2861                  (link-string-beginning)
2862                  (link-string-end))
2863             (save-excursion
2864               (goto-char (org-element-property :begin object))
2865               (search-forward link-string nil nil 1)
2866               (setq link-string-beginning (match-beginning 0))
2867               (setq link-string-end (match-end 0)))
2868
2869              ;; make sure we are in link and not before the :
2870             (when (> link-string-beginning (point))
2871               (goto-char link-string-beginning))
2872
2873             ;; now if we have comma separated bibliographies
2874             ;; we find the one clicked on. we want to
2875             ;; search forward to next comma from point
2876             (save-excursion
2877               (if (search-forward "," link-string-end 1 1)
2878                   (setq key-end (- (match-end 0) 1)) ; we found a match
2879                 (setq key-end (point)))) ; no comma found so take the point
2880
2881             ;; and backward to previous comma from point
2882             (save-excursion
2883               (if (search-backward "," link-string-beginning 1 1)
2884                   (setq key-beginning (+ (match-beginning 0) 1)) ; we found a match
2885                 (setq key-beginning (point)))) ; no match found
2886             ;; save the key we clicked on.
2887             (setq bibfile
2888                   (org-ref-strip-string
2889                    (buffer-substring key-beginning key-end)))
2890             (if (file-exists-p bibfile)
2891                 (message "%s exists." bibfile)
2892               (message "!!! %s NOT FOUND !!!" bibfile))))
2893          )))))
2894
2895 ;; ** aliases
2896 (defalias 'oro 'org-ref-open-citation-at-point)
2897 (defalias 'orc 'org-ref-citation-at-point)
2898 (defalias 'orp 'org-ref-open-pdf-at-point)
2899 (defalias 'oru 'org-ref-open-url-at-point)
2900 (defalias 'orn 'org-ref-open-notes-at-point)
2901 (defalias 'ornr 'org-ref-open-notes-from-reftex)
2902
2903 (defalias 'orib 'org-ref-insert-bibliography-link)
2904 (defalias 'oric 'org-ref-insert-cite-link)
2905 (defalias 'orir 'org-ref-insert-ref-link)
2906 (defalias 'orsl 'org-ref-store-bibtex-entry-link)
2907
2908 (defalias 'orcb 'org-ref-clean-bibtex-entry)
2909
2910 ;; * Helm bibtex setup
2911
2912 (setq helm-bibtex-additional-search-fields '(keywords))
2913
2914 (defun helm-bibtex-candidates-formatter (candidates source)
2915   "Formats BibTeX entries for display in results list.
2916 Argument CANDIDATES helm candidates.
2917 Argument SOURCE the helm source."
2918   (cl-loop
2919    with width = (with-helm-window (helm-bibtex-window-width))
2920    for entry in candidates
2921    for entry = (cdr entry)
2922    for entry-key = (helm-bibtex-get-value "=key=" entry)
2923    if (assoc-string "author" entry 'case-fold)
2924      for fields = '("author" "title" "year" "=has-pdf=" "=has-note=" "=type=")
2925    else
2926      for fields = '("editor" "title" "year" "=has-pdf=" "=has-note=" "=type=")
2927    for fields = (--map (helm-bibtex-clean-string
2928                         (helm-bibtex-get-value it entry " "))
2929                        fields)
2930    for fields = (-update-at 0 'helm-bibtex-shorten-authors fields)
2931    for fields = (append fields
2932                          (list  (or (helm-bibtex-get-value "keywords" entry)
2933                                     "" )))
2934    collect
2935    (cons (s-format "$0 $1 $2 $3 $4$5 $6" 'elt
2936                    (-zip-with (lambda (f w) (truncate-string-to-width f w 0 ?\s))
2937                               fields (list 36 (- width 85) 4 1 1 7 7)))
2938          entry-key)))
2939
2940 ;; * org-ref bibtex keywords
2941 ;; adapted from bibtex-utils.el
2942 ;; these are candidates for selecting keywords/tags
2943 (defun org-ref-bibtex-keywords ()
2944   "Get keywords defined in current bibtex file.
2945 These are in the keywords field, and are comma or semicolon separated."
2946   (save-excursion
2947     (goto-char (point-min))
2948     (let (keywords kstring)
2949       (while (re-search-forward "^\\s-*keywords.*{\\([^}]+\\)}" nil t)
2950         ;; TWS - remove newlines/multiple spaces:
2951         (setq kstring (replace-regexp-in-string "[ \t\n]+" " " (match-string 1)))
2952         (mapc
2953          (lambda (v)
2954            (add-to-list 'keywords v t))
2955          (split-string kstring "\\(,\\|;\\)[ \n]*\\|{\\|}" t)))
2956       keywords)))
2957
2958
2959 (defun org-ref-set-bibtex-keywords (keywords &optional arg)
2960   "Add KEYWORDS to a bibtex entry.
2961 If KEYWORDS is a list, it is converted to a comma-separated
2962 string.  The KEYWORDS are added to the beginning of the
2963 field.  Otherwise KEYWORDS should be a string of comma-separate
2964 keywords.  Optional argument ARG prefix arg to replace keywords."
2965   (interactive "sKeywords: \nP")
2966   (bibtex-set-field
2967    "keywords"
2968    (if arg
2969        ;; replace with arg
2970        (if (listp keywords)
2971            (mapconcat 'identity keywords ", ")
2972          keywords)
2973      ;; else concatentate
2974      (concat
2975       (if (listp keywords)
2976           (mapconcat 'identity keywords ", ")
2977         keywords)
2978       (when (not (string= "" (bibtex-autokey-get-field "keywords")))
2979         (concat ", "  (bibtex-autokey-get-field "keywords"))))))
2980   (save-buffer))
2981
2982
2983 (defun helm-tag-bibtex-entry ()
2984   "Helm interface to add keywords to a bibtex entry.
2985 Run this with the point in a bibtex entry."
2986   (interactive)
2987   (let ((keyword-source `((name . "Existing keywords")
2988                           (candidates . ,(org-ref-bibtex-keywords))
2989                           (action . (lambda (candidate)
2990                                       (org-ref-set-bibtex-keywords
2991                                        (mapconcat
2992                                         'identity
2993                                         (helm-marked-candidates)
2994                                         ", "))))))
2995         (fallback-source `((name . "Add new keywords")
2996                            (dummy)
2997                            (action . (lambda (candidate)
2998                                        (org-ref-set-bibtex-keywords helm-pattern)
2999                                        )))))
3000     (helm :sources '(keyword-source fallback-source))))
3001
3002 (defun helm-bibtex-show-entry (key)
3003   "Show the entry for KEY in the BibTeX file.
3004 The original function in `helm-bibtex' has a bug where it finds the
3005 first key that partially matches.  This version avoids that."
3006   (catch 'break
3007     (dolist (bibtex-file (if (listp helm-bibtex-bibliography)
3008                              helm-bibtex-bibliography
3009                            (list helm-bibtex-bibliography)))
3010       (let ((buf (helm-bibtex-buffer-visiting bibtex-file))
3011             (entries '()))
3012         (find-file bibtex-file)
3013         (bibtex-map-entries
3014          (lambda (key start end)
3015            (add-to-list 'entries (cons key start))))
3016         (if (assoc key entries)
3017             (progn
3018               (goto-char (cdr (assoc key entries)))
3019               (throw 'break t))
3020           (unless buf
3021             (kill-buffer)))))))
3022
3023 (defun org-ref-helm-tag-entries (candidates)
3024   "Set tags on selected bibtex entries from `helm-bibtex'.
3025 User is prompted for tags.  This function is called from `helm-bibtex'.
3026 Argument CANDIDATES helm candidates."
3027   (message "")
3028   (let ((keywords (read-input "Keywords (comma separated): ")))
3029     (loop for key in (helm-marked-candidates)
3030           do
3031           (save-window-excursion
3032             (helm-bibtex-show-entry key)
3033             (bibtex-set-field
3034              "keywords"
3035              (concat
3036               keywords
3037               ", " (bibtex-autokey-get-field "keywords")))
3038             (save-buffer)))))
3039
3040 (setq helm-source-bibtex
3041       '((name                                      . "BibTeX entries")
3042         (init                                      . helm-bibtex-init)
3043         (candidates                                . helm-bibtex-candidates)
3044         (filtered-candidate-transformer            . helm-bibtex-candidates-formatter)
3045         (action . (("Insert citation"              . helm-bibtex-insert-citation)
3046                    ("Show entry"                   . helm-bibtex-show-entry)
3047                    ("Open PDF file (if present)"   . helm-bibtex-open-pdf)
3048                    ("Open URL or DOI in browser"   . helm-bibtex-open-url-or-doi)
3049                    ("Insert formatted reference"   . helm-bibtex-insert-reference)
3050                    ("Insert BibTeX key"            . helm-bibtex-insert-key)
3051                    ("Insert BibTeX entry"          . helm-bibtex-insert-bibtex)
3052                    ("Attach PDF to email"          . helm-bibtex-add-PDF-attachment)
3053                    ("Edit notes"                   . helm-bibtex-edit-notes)
3054                    ("Add keywords to entries"      . org-ref-helm-tag-entries)
3055                    ))))
3056
3057 (defun helm-bibtex-format-org-ref (keys)
3058   "Insert selected KEYS as cite link. Append KEYS if you are on a link.
3059 Technically, this function should return a string that is inserted by helm. This function does the insertion and gives helm an empty string to insert. This lets us handle appending to a link properly.
3060
3061 In the helm-bibtex buffer, C-u will give you a helm menu to select a new link type for the selected entries.
3062
3063 C-u C-u will change the key at point to the selected keys."
3064   (let* ((object (org-element-context))
3065          (last-char (save-excursion
3066                       (goto-char (org-element-property :end object))
3067                       (backward-char)
3068                       (if (looking-at " ")
3069                           " "
3070                         ""))))
3071     (cond
3072      ;; case where we are in a link
3073      ((and (equal (org-element-type object) 'link)
3074            (-contains?
3075             org-ref-cite-types
3076             (org-element-property :type object)))
3077       (cond
3078        ;; no prefix. append keys
3079        ((equal helm-current-prefix-arg nil)
3080         (goto-char (org-element-property :end object))
3081         (while (looking-back " ") (backward-char))
3082         (insert (concat "," (mapconcat 'identity keys ","))))
3083        ;; double prefix, replace key at point
3084        ((equal helm-current-prefix-arg '(16))
3085         (setf (buffer-substring
3086                (org-element-property :begin object)
3087                (org-element-property :end object))
3088               (concat
3089                (replace-regexp-in-string
3090                 (car (org-ref-get-bibtex-key-and-file)) ; key
3091                 (mapconcat 'identity keys ",")          ; new keys
3092                 (org-element-property :raw-link object))
3093                ;; replace space at end to avoid collapsing into next word.
3094                last-char))
3095         ;; and we want to go to the end of the new link
3096         (goto-char
3097          (org-element-property :end (org-element-context))))
3098        (t
3099         (message "Not found"))))
3100
3101      ;; We are next to a link, and we want to append
3102      ;; next to a link means one character back is on a link.
3103      ((save-excursion
3104         (backward-char)
3105         (and (equal (org-element-type (org-element-context)) 'link)
3106              (-contains?
3107               org-ref-cite-types
3108               (org-element-property :type (org-element-context)))))
3109       (while (looking-back " ") (backward-char))
3110       (insert (concat "," (mapconcat 'identity keys ","))))
3111
3112      ;; insert fresh link
3113      (t
3114       ;;(message-box "fresh link")
3115       (insert
3116        (concat (if (equal helm-current-prefix-arg '(4))
3117                    (helm :sources `((name . "link types")
3118                                     (candidates . ,org-ref-cite-types)
3119                                     (action . (lambda (x) x))))
3120                org-ref-default-citation-link)
3121                ":"
3122                (s-join "," keys))))))
3123   ;; return empty string for helm
3124   "")
3125
3126 (setq helm-bibtex-format-citation-functions
3127       '((org-mode . helm-bibtex-format-org-ref)))
3128
3129 ;;;###autoload
3130 (defun org-ref-helm-insert-cite-link (arg)
3131   "org-ref function to use helm-bibtex to insert a citation link.
3132 With one prefix arg, insert a ref link.
3133 With two prefix args, insert a label link."
3134   (interactive "P")
3135   (cond
3136    ((equal arg nil)
3137      (let ((helm-bibtex-bibliography (org-ref-find-bibliography)))
3138        (helm-bibtex)))
3139    ((equal arg '(4))
3140     (org-ref-helm-insert-ref-link))
3141    ((equal arg '(16))
3142     (org-ref-helm-insert-label-link))))
3143
3144
3145 ;; add our own fallback entries where we want them. These appear in reverse order of adding in the menu
3146 (setq helm-bibtex-fallback-options
3147       (-insert-at 1 '("Crossref" . "http://search.crossref.org/?q=%s") helm-bibtex-fallback-options))
3148
3149 (setq helm-bibtex-fallback-options
3150       (-insert-at
3151        1
3152        '("Scopus" . "http://www.scopus.com/scopus/search/submit/xadvanced.url?searchfield=TITLE-ABS-KEY(%s)")
3153        helm-bibtex-fallback-options))
3154
3155 (setq helm-bibtex-fallback-options
3156       (-insert-at 1 '("WOS" . "http://gateway.webofknowledge.com/gateway/Gateway.cgi?topic=%s&GWVersion=2&SrcApp=WEB&SrcAuth=HSB&DestApp=UA&DestLinkType=GeneralSearchSummary") helm-bibtex-fallback-options))
3157
3158 (defun org-ref-get-citation-string-at-point ()
3159   "Get a string of a formatted citation."
3160   (let* ((results (org-ref-get-bibtex-key-and-file))
3161          (key (car results))
3162          (bibfile (cdr results)))
3163     (if bibfile
3164         (save-excursion
3165           (with-temp-buffer
3166             (insert-file-contents bibfile)
3167             (bibtex-search-entry key)
3168             (org-ref-bib-citation)))
3169       "!!! No entry found !!!" )))
3170
3171
3172 (defun org-ref-cite-candidates ()
3173   "Generate the list of possible candidates for click actions on a cite link.
3174 Checks for pdf and doi, and add appropriate functions."
3175   (let* ((results (org-ref-get-bibtex-key-and-file))
3176          (key (car results))
3177          (pdf-file (format (concat org-ref-pdf-directory "%s.pdf") key))
3178          (bibfile (cdr results))
3179          (url (save-excursion
3180                 (with-temp-buffer
3181                   (insert-file-contents bibfile)
3182                   (bibtex-search-entry key)
3183                   (bibtex-autokey-get-field "url"))))
3184          (doi (save-excursion
3185                 (with-temp-buffer
3186                   (insert-file-contents bibfile)
3187                   (bibtex-search-entry key)
3188                   ;; I like this better than bibtex-url which does not always find
3189                   ;; the urls
3190                   (bibtex-autokey-get-field "doi"))))
3191          (candidates `(("Quit" . org-ref-citation-at-point)
3192                        ("Open bibtex entry" . org-ref-open-citation-at-point))))
3193     ;; for some reason, when there is no doi or url, they are returned as "". I
3194     ;; prefer nil so we correct this here.
3195     (when (string= doi "") (setq doi nil))
3196     (when (string= url "") (setq url nil))
3197
3198     ;; Conditional pdf functions
3199     (if (file-exists-p pdf-file)
3200         (add-to-list
3201          'candidates
3202          '("Open pdf" . org-ref-open-pdf-at-point)
3203          t)
3204       (add-to-list
3205        'candidates
3206        '("Try to get pdf" . (lambda ()
3207                               (save-window-excursion
3208                                 (org-ref-open-citation-at-point)
3209                                 (bibtex-beginning-of-entry)
3210                                 (doi-utils-get-bibtex-entry-pdf))))
3211        t))
3212
3213
3214     (add-to-list
3215      'candidates
3216      '("Open notes" . org-ref-open-notes-at-point)
3217      t)
3218
3219     ;; conditional url and doi functions
3220     (when (or url doi)
3221       (add-to-list
3222        'candidates
3223        '("Open in browser" . org-ref-open-url-at-point)
3224        t))
3225
3226     (when doi
3227       (mapc (lambda (x)
3228               (add-to-list 'candidates x t))
3229             `(("WOS" . org-ref-wos-at-point)
3230               ("Related articles in WOS" . org-ref-wos-related-at-point)
3231               ("Citing articles in WOS" . org-ref-wos-citing-at-point)
3232               ("Google Scholar" . org-ref-google-scholar-at-point)
3233               ("Pubmed" . org-ref-pubmed-at-point)
3234               ("Crossref" . org-ref-crossref-at-point)
3235               )))
3236
3237     (add-to-list
3238      'candidates
3239      '("Copy formatted citation to clipboard" . org-ref-copy-entry-as-summary)
3240      t)
3241
3242     (add-to-list
3243      'candidates
3244      '("Copy key to clipboard" . (lambda ()
3245                                   (kill-new
3246                                    (car (org-ref-get-bibtex-key-and-file)))))
3247      t)
3248
3249     (add-to-list
3250      'candidates
3251      '("Copy bibtex entry to file" . org-ref-copy-entry-at-point-to-file)
3252      t)
3253
3254     (add-to-list
3255      'candidates
3256      '("Email bibtex entry and pdf" . (lambda ()
3257                   (save-excursion
3258                     (org-ref-open-citation-at-point)
3259                     (email-bibtex-entry))))
3260      t)
3261   ;; finally return a numbered list of the candidates
3262   (loop for i from 0
3263         for cell in candidates
3264         collect (cons (format "%2s. %s" i (car cell))
3265                       (cdr cell)))))
3266
3267
3268 (defvar org-ref-helm-user-candidates '()
3269   "List of user-defined candidates to act when clicking on a cite link.
3270 This is a list of cons cells '((\"description\" . action)). The action function should not take an argument, and should assume point is on the cite key of interest.")
3271
3272 ;; example of adding your own function
3273 (add-to-list
3274  'org-ref-helm-user-candidates
3275  '("Example" . (lambda () (message-box "You did it!")))
3276  t)
3277
3278 ;;;###autoload
3279 (defun org-ref-cite-click-helm (key)
3280   "Open helm for actions on a cite link.
3281 subtle points.
3282
3283 1. get name and candidates before entering helm because we need
3284 the org-buffer.
3285
3286 2. switch back to the org buffer before evaluating the
3287 action.  most of them need the point and buffer.
3288
3289 KEY is returned for the selected item(s) in helm."
3290   (interactive)
3291   (let ((name (org-ref-get-citation-string-at-point))
3292         (candidates (org-ref-cite-candidates))
3293         (cb (current-buffer)))
3294
3295     (helm :sources `(((name . ,name)
3296                       (candidates . ,candidates)
3297                       (action . (lambda (f)
3298                                   (switch-to-buffer cb)
3299                                   (funcall f))))
3300                      ((name . "User functions")
3301                       (candidates . ,org-ref-helm-user-candidates)
3302                       (action . (lambda (f)
3303                                   (switch-to-buffer cb)
3304                                   (funcall f))))
3305                      ))))
3306
3307 ;; * Hydra menus in org-ref
3308
3309 (when (featurep 'hydra)
3310   (require 'hydra)
3311   (setq hydra-is-helpful t)
3312
3313   (defhydra org-ref-cite-hydra (:color blue)
3314     "
3315 _p_: Open pdf     _w_: WOS          _g_: Google Scholar _K_: Copy citation to clipboard
3316 _u_: Open url     _r_: WOS related  _P_: Pubmed         _k_: Copy key to clipboard
3317 _n_: Open notes   _c_: WOS citing   _C_: Crossref       _f_: Copy bibtex entry to file
3318 _o_: Open entry   _e_: Email entry and pdf
3319 "
3320     ("o" org-ref-open-citation-at-point nil)
3321     ("p" org-ref-open-pdf-at-point nil)
3322     ("n" org-ref-open-notes-at-point nil)
3323     ("u" org-ref-open-url-at-point nil)
3324     ("w" org-ref-wos-at-point nil)
3325     ("r" org-ref-wos-related-at-point nil)
3326     ("c" org-ref-wos-citing-at-point nil)
3327     ("g" org-ref-google-scholar-at-point nil)
3328     ("P" org-ref-pubmed-at-point nil)
3329     ("C" org-ref-crossref-at-point nil)
3330     ("K" org-ref-copy-entry-as-summary nil)
3331     ("k" (progn
3332            (kill-new
3333             (car (org-ref-get-bibtex-key-and-file)))) nil)
3334     ("f" org-ref-copy-entry-at-point-to-file nil)
3335
3336     ("e" (save-excursion
3337            (org-ref-open-citation-at-point)
3338            (email-bibtex-entry)) nil)))
3339
3340 ;; * org-ref-help
3341 (defun org-ref-help ()
3342   "Open the org-ref manual."
3343   (interactive)
3344   (find-file (expand-file-name
3345               "org-ref.org"
3346               (file-name-directory
3347                (find-library-name "org-ref")))))
3348
3349 ;; * org-ref menu
3350 (defun org-ref-org-menu ()
3351   "Add org-ref menu to the Org menu."
3352
3353   (easy-menu-change
3354    '("Org") "org-ref"
3355    '( ["Insert citation" org-ref-helm-insert-cite-link]
3356       ["Insert ref" org-ref-helm-insert-ref-link]
3357       ["Insert label" org-ref-helm-insert-label-link]
3358       "--"
3359       ["List of figures" org-ref-list-of-figures]
3360       ["List of tables" org-ref-list-of-tables]
3361       ["Extract bibtex entries" org-ref-extract-bibtex-entries]
3362       ["Check org-file" org-ref]
3363       "--"
3364       ["Help" org-ref-help]
3365       ["Customize org-ref" (customize-group 'org-ref)])
3366    "Show/Hide")
3367
3368   (easy-menu-change '("Org") "--" nil "Show/Hide"))
3369
3370 (add-hook 'org-mode-hook 'org-ref-org-menu)
3371
3372 ;; * The end
3373 (provide 'org-ref)
3374
3375 ;;; org-ref.el ends here