Wolfe's Literate Emacs Config

(defvar wolfe/literate-config-name "README.org"
  "The name of my literate config")

(defvar wolfe/init-file (concat user-emacs-directory wolfe/literate-config-name)
  "The path to my literate config file")

(defvar wolfe/linux? (eq system-type 'gnu/linux)
  "Are we on linux?")

(defvar wolfe/windows? (eq system-type 'windows-nt)
    "Are we on windows?")

(defvar wolfe/org-ellipsis
  (if (display-graphic-p)
      "⤵"
    "...")
  "The indicates if an `org-mode' tree can be expanded")

(defvar wolfe/project-path
  (cond
   (wolfe/linux? "~/Projects/")
   (wolfe/windows? "C:/dev/")
   (:else nil))
  "Path to my projects directory")

(defvar wolfe/org-dropbox-path
  (cond
   (wolfe/linux?
    "~/Dropbox/org/")
   (wolfe/windows?
    "C:\\Users\\Josh\\Dropbox\\org\\")
   (:else nil))
  "Path to my org files inside dropbox")

(defvar wolfe/using-dark t
  "Indicates whether we're using my dark theme")

(defvar wolfe/using-light nil
  "Indicates whether we're using my light theme")

(defvar wolfe/lisp-dir-path "~/.emacs.d/lisp/"
  "Path to my custom lisp files")

(defvar wolfe/highlight-escapes-mode-list '(python-mode
                                            c-mode
                                            c++-mode
                                            web-mode)
  "List of modes to highlight escape characters in")

(defvar wolfe/irc-info-path "~/.ircinfo.gpg"
  "Location of the GPG encrypted file that has my irc login info")

(setq custom-theme-directory "~/.emacs.d/themes")

(defmacro check-and-remove-command-line-arg (argument)
  "Checks `command-line-args' for argument and removes it if found returning t or nil"
  (if (member argument command-line-args)
      (progn
        (setq command-line-args (delete argument command-line-args))
        t)
    nil))

(let ((result (check-and-remove-command-line-arg "-light")))
  (setq wolfe/using-light result)
  (setq wolfe/using-dark (not result)))

(if wolfe/using-light
    (wolfe/light-setup)
  (wolfe/dark-setup))

(add-to-list 'load-path wolfe/lisp-dir-path)
(let ((default-directory wolfe/lisp-dir-path))
  (normal-top-level-add-subdirs-to-load-path))

(setq inhibit-splash-screen t
      inhibit-startup-message t
      initial-scratch-message "") ; No scratch text
(defun display-startup-echo-area-message ()
  (message "Welcome to the church of GNU/Emacs"))

(show-paren-mode t) ; Highlights matching parens
(fset 'yes-or-no-p 'y-or-n-p) ; y/n instead of yes/no
(blink-cursor-mode -1) ; No need to flash the cursor
(column-number-mode t) ; Show column in mode-line
(delete-selection-mode 1) ; Replace selection on insert
(setq-default truncate-lines t ; Don't wrap
              indent-tabs-mode nil)
(setq vc-follow-symlinks t ; Always follow symlinks
      tags-revert-without-query t ; Don't ask to reload TAGS file
      echo-keystrokes 0.5
      custom-file "~/.emacs.d/custom.el" ; Set custom file and don't load it
      source-directory "~/Projects/emacs/")

(if (display-graphic-p)
    (use-package powerline
      :init
      (defadvice powerline-major-mode (around delight-powerline-major-mode activate)
        (let ((inhibit-mode-name-delight nil))
          ad-do-it))

      :config
      (setq powerline-arrow-shape 'curve
            powerline-display-buffer-size nil
            powerline-display-mule-info nil)
      (powerline-default-theme)
      (remove-hook 'focus-out-hook 'powerline-unset-selected-window)
      (setq powerline-height 24))

  (setq-default mode-line-format
   (list
    " "
    ;; is this buffer read-only?
    '(:eval (when buffer-read-only
              (propertize "RO"
                          'face 'font-lock-type-face
                          'help-echo "Buffer is read-only")))

    ;; was this buffer modified since the last save?
    '(:eval (when (buffer-modified-p)
              (propertize "M"
                          'face 'font-lock-warning-face
                          'help-echo "Buffer has been modified")))

    " "
    ;; the buffer name; the file name as a tool tip
    '(:eval (propertize "%b " 'face 'font-lock-keyword-face
                        'help-echo (buffer-file-name)))


    ;; the current major mode for the buffer.
    "["

    '(:eval (propertize (format-mode-line mode-name) 'face '(:family "Arial")
                        'help-echo buffer-file-coding-system))
    '(:eval (propertize (format-mode-line minor-mode-alist)
                        'face '(:family "Arial")))
    "]             "

    ;; line and column
    "(" ;; '%02' to set to 2 chars at least; prevents flickering
    (propertize "%02l" 'face 'font-lock-type-face) ","
    (propertize "%02c" 'face 'font-lock-type-face)
    ") "

    ;; relative position, size of file
    "["
    (propertize "%p" 'face 'font-lock-constant-face) ;; % above top
    "/"
    (propertize "%I" 'face 'font-lock-constant-face) ;; size
    "] "

    ;; add the time, with the date and the emacs uptime in the tooltip
    '(:eval (propertize (format-time-string "%H:%M")
                        'help-echo
                        (concat (format-time-string "%c; ")
                                (emacs-uptime "Uptime:%hh"))))
    )))

(if (fboundp 'display-line-numbers-mode)
    (progn
      (setq display-line-numbers 'relative)
      (add-hook 'prog-mode-hook 'display-line-numbers-mode))
  (progn
    (use-package nlinum-relative
      :config
      (nlinum-relative-setup-evil)
      (setq nlinum-relative-redisplay-delay 0.25)
      (setq nlinum-relative-current-symbol "")
      (add-hook 'prog-mode-hook 'nlinum-relative-mode))))

(defun what-face (pos)
  (interactive "d")
  (let ((face (or (get-char-property (point) 'read-face-name)
                  (get-char-property (point) 'face))))
    (if face (message "Face: %s" face) (message "No face at %d" pos))))

(defun wolfe/compile-no-prompt ()
  (interactive)
  (let ((compilation-read-command nil))
    (compile (eval compile-command))))

(defun wolfe/compile-dot-emacs ()
  "Byte-compile dotfiles."
  (interactive)
  (byte-recompile-directory user-emacs-directory 0))

(defun wolfe/clear-all-elc ()
  (interactive)
  (shell-command "find ~/.emacs.d/ -name \"*.elc\" -type f -delete"))

(defun wolfe/remove-elc-on-save ()
  "If you're saving an emacs-lisp file, likely the .elc is no longer valid."
  (add-hook 'after-save-hook
            (lambda ()
              (if (file-exists-p (concat buffer-file-name "c"))
                  (delete-file (concat buffer-file-name "c"))))
            nil t))
(add-hook 'emacs-lisp-mode-hook 'wolfe/remove-elc-on-save)

(defun wolfe/find-tag ()
  "Jump to the tag at point without prompting"
  (interactive)
  (find-tag (find-tag-default)))

(defun wolfe/create-tags ()
  "Create the tags table"
  (interactive)
  (save-window-excursion (shell-command "etags -R -o ETAGS *")))

(defadvice xref-find-definitions (around refresh-etags activate)
  "Rerun etags and reload tags if tag not found and redo find-tag.
   If buffer is modified, ask about save before running etags."
  (condition-case err
      ad-do-it
    (error (and (buffer-modified-p) (not (ding))
                (save-buffer))
           (save-window-excursion (shell-command "etags -R *"))
           ad-do-it)))

(defun wolfe/controlz ()
  (interactive)
  (when (eq (display-graphic-p) nil)
    (suspend-frame)))

(defun wolfe/org-open (name)
  "Opens the file in the dropbox path"
  (interactive)
  (evil-buffer-new nil (concat wolfe/org-dropbox-path name ".org")))

(defun wolfe/dropbox-start ()
  (interactive)
  (if (eq nil (file-exists-p "/virtual/wolfejos/dropbox/.dropbox-dist"))
      (call-process-shell-command "(python ~/.emacs.d/dropbox.py start -i&)")
    (call-process-shell-command "(python ~/.emacs.d/dropbox.py start&)")))

(defun wolfe/dropbox-stop ()
  (interactive)
  (call-process-shell-command "python ~/.emacs.d/dropbox.py stop&"))

(defun wolfe/load-init ()
  "Reloads init file"
  (interactive)
  (load-file "~/.emacs.d/init.el"))

(defun narrow-or-widen-dwim (p)
  "Widen if buffer is narrowed, narrow-dwim otherwise.
Dwim means: region, org-src-block, org-subtree, or
defun, whichever applies first. Narrowing to
org-src-block actually calls `org-edit-src-code'.

With prefix P, don't widen, just narrow even if buffer
is already narrowed."
  (interactive "P")
  (declare (interactive-only))
  (cond ((and (buffer-narrowed-p) (not p)) (widen))
        ((region-active-p)
         (narrow-to-region (region-beginning)
                           (region-end)))
        ((derived-mode-p 'org-mode)
         ;; `org-edit-src-code' is not a real narrowing
         ;; command. Remove this first conditional if
         ;; you don't want it.
         (cond ((ignore-errors (org-edit-src-code) t)
                (delete-other-windows))
               ((ignore-errors (org-narrow-to-block) t))
               (t (org-narrow-to-subtree))))
        ((derived-mode-p 'latex-mode)
         (LaTeX-narrow-to-environment))
        (t (narrow-to-defun))))

(defun wolfe/man ()
  (if (executable-find "man")
      (man (word-at-point))
    (woman)))

(defun wolfe/csharp-project ()
  (interactive)
  (setq path (read-file-name "File: " wolfe/project-path))
  (setq split-path (split-string path "/"))
  (if (member "src" split-path)
      (catch 'loop
        (dolist (item (reverse split-path))
          (if (string-equal item "src")
              (throw 'loop nil)
            (delete item split-path)))
        (message "src/ directory not found")))

  (if (or (equal '("c:") split-path) (equal '() split-path))
      (message "Could not find src directory for specified project")
    (progn
      (omnisharp-start-omnisharp-server (mapconcat 'identity split-path "/"))
      (find-file path))))

(defun hot-expand (str &optional additional-text)
  "Expand org template."
  (insert str)
  (org-try-structure-completion)
  (when additional-text
    (insert additional-text)
    (forward-line)))

(defun wolfe/ag-try-project ()
  (interactive)
  (if (projectile-project-p)
      (call-interactively 'projectile-ag)
    (call-interactively 'ag)))

(defun wolfe/projectile-invalidate-list ()
  (interactive)
  (projectile-invalidate-cache t))

(defun wolfe/get-user-pass (file)
  (split-string
   (car (last (split-string
               (shell-command-to-string (concat "gpg --output - --decrypt "
                                                (expand-file-name file)))
               "[|\n]" t "[     \n]"))) " "))

(defun wolfe/ag-kill-buffers-and-window ()
  (interactive)
  (ag-kill-buffers)
  (delete-window))

(defun wolfe/org-tree-set-transient-map ()
  (interactive)
  (if wolfe--enable-transient-map
      (let ((map (make-sparse-keymap)))
        (define-key map (kbd "<right>") 'org-tree-slide-move-next-tree)
        (define-key map (kbd "<left>")  'org-tree-slide-move-previous-tree)
        (define-key map (kbd "<up>")    'org-tree-slide-content)
        (define-key map (kbd "<down>")  'org-tree-slide-display-header-toggle)
        (set-transient-map map nil 'wolfe/org-tree-set-transient-map))
    (makeunbound wolfe--enable-transient-map)))

(setq org-pretty-entities t
      org-src-fontify-natively t
      org-src-tab-acts-natively t
      org-src-window-setup 'current-window
      org-fontify-whole-heading-line t
      org-fontify-done-headline t
      org-fontify-quote-and-verse-blocks t
      org-highlight-latex-and-related '(latex)
      org-log-done 'time
      org-agenda-use-time-grid nil
      org-agenda-skip-deadline-if-done t
      org-agenda-skip-scheduled-if-done t
      org-ellipsis wolfe/org-ellipsis)

(org-babel-do-load-languages
 'org-babel-load-languages
 '((shell . t)
   (  dot . t)))

(global-set-key "\C-cl" 'org-store-link)

;; ispell ignores SRC blocks
(add-to-list 'ispell-skip-region-alist '("#\\+BEGIN_SRC" . "#\\+END_SRC"))
(add-to-list 'ispell-skip-region-alist '("#\\+BEGIN_LATEX" . "#\\+END_LATEX"))

;; Refresh images after executing a src block
(add-hook 'org-babel-after-execute-hook
          '(lambda ()
             (when org-inline-image-overlays
               (org-redisplay-inline-images))))

;; Open PDFs with zathura
(add-hook 'org-mode-hook
          '(lambda ()
             (setq org-file-apps
                   (append '(("\\.pdf\\'" . "zathura \"%s\"")) org-file-apps))))

(use-package org-bullets
  :config
  (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1))))

(use-package org-agenda
  :ensure nil
  :bind (("C-c a" . org-agenda)
         :map org-agenda-mode-map
         ("j" . org-agenda-next-item)
         ("k" . org-agenda-previous-item))
  :config
  ;; Formats the agenda into nice columns
  (setq org-agenda-prefix-format
        '((agenda . " %i %-12t% s %-12(car (last (org-get-outline-path)))")
          (timeline . "  % s")
          (todo . " %i %-12:c")
          (tags . " %i %-12:c")
          (search . " %i %-12:c")))

  ;; Sets location of org files
  (setq org-agenda-files `(,(concat wolfe/org-dropbox-path "everything.org")))
  (setq browse-url-browser-function 'browse-url-chromium))

(use-package htmlize)

(require 'ox-latex)
(add-to-list 'org-latex-packages-alist '("" "minted"))
(setq org-export-allow-bind-keywords t
      org-latex-listings 'minted)
(setq org-latex-pdf-process
      '("pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"
        "pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"
        "pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f"))

(use-package org-tree-slide
  :config
  (add-hook 'org-tree-slide-mode-hook
            (lambda ()
              (if org-tree-slide-mode
                  ;; When mode is enabled
                  (progn (setq org-hide-emphasis-markers t
                               wolfe--enable-transient-map t)
                         (wolfe/org-tree-set-transient-map))
                ;; When mode is disabled
                (setq org-hide-emphasis-markers nil
                      wolfe--enable-transient-map nil)))))

(use-package hydra)

(use-package ag
  :bind (:map ag-mode-map
         ("Q" . wolfe/ag-kill-buffers-and-window)))

(use-package magit
  :defer t
  :config
  (setq magit-bury-buffer-function
        (lambda (con)
          (kill-buffer)
          (delete-window))))

(use-package projectile
  :config
  (use-package counsel-projectile
    :config
    (counsel-projectile-on))
  (setq projectile-enable-caching t)
  (setq projectile-indexing-method 'alien)
  (setq projectile-globally-ignored-file-suffixes '(".dll" ".exe" ".o"))
  (setq projectile-globally-ignored-directories '(".git" "node_modules"))
  (projectile-mode))

(use-package web-mode
  :defer t
  :config
  (add-to-list 'auto-mode-alist '("\\.html\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.php\\'" . web-mode))
  (add-to-list 'auto-mode-alist '("\\.js\\'" . web-mode))

  (setq web-mode-enable-auto-closing t)
  (setq web-mode-enable-auto-opening t)
  (setq web-mode-enable-auto-indentation t))

(use-package json-mode)

(use-package company-restclient
  :after company
  :config
  (add-to-list 'company-backends 'company-restclient))

(use-package company-tern
  :after company
  :config
  (add-to-list 'company-backends 'company-tern)
  (add-hook 'web-mode-hook 'tern-mode))

(use-package parinfer
  :defer t
  :bind
  (("C-," . parinfer-toggle-mode))
  :init
  (setq
   parinfer-extensions '(defaults pretty-parens evil smart-tab smart-yank)
   parinfer-lighters '(" Φi" . " Φp"))
  (add-hook 'clojure-mode-hook     #'parinfer-mode)
  (add-hook 'emacs-lisp-mode-hook  #'parinfer-mode)
  (add-hook 'common-lisp-mode-hook #'parinfer-mode)
  (add-hook 'scheme-mode-hook      #'parinfer-mode)
  (add-hook 'lisp-mode-hook        #'parinfer-mode))

(use-package racket-mode
  :defer t)

(use-package latex-preview-pane
  :defer t
  :ensure f)

(setq gdb-many-windows t
      gdb-show-main t
      company-clang-insert-arguments nil)

(use-package company-irony
  :after company
  :config
  (add-hook 'c++-mode-hook 'irony-mode)
  (add-hook 'c-mode-hook 'irony-mode)
  (eval-after-load 'company
    '(add-to-list 'company-backends 'company-irony)))

(use-package omnisharp
  :after company
  :config
  (setq omnisharp-server-executable-path "C:/emacs/omnisharp/Omnisharp.exe")
  (add-hook 'csharp-mode-hook 'omnisharp-mode)
  (add-to-list 'company-backends 'company-omnisharp))

(use-package elpy
  :after company
  :defer t
  :config
  (when (executable-find "ipython")
    (elpy-use-ipython))
  (elpy-enable))

(use-package company-shell
  :after company
  :config
  (add-to-list 'company-backends '(company-shell company-shell-env)))

(use-package go-mode
  :config
  (add-hook 'go-mode-hook '(lambda () (setq tab-width 4))))

(use-package company-go
  :after company
  :config
  (add-to-list 'company-backends 'company-go))

(use-package nim-mode
  :defer t)

(use-package ranger
  :config
  (setq ranger-cleanup-on-disable t)
  (ranger-override-dired-mode t))

(use-package iedit
  :config
  (setq iedit-toggle-key-default nil))

(use-package restclient
  :defer t)

(use-package rainbow-mode
  :defer t)

(use-package help-fns+)

(use-package org-jira
  :defer t
  :config
  (setq jiralib-url "https://indigoca.atlassian.net"))

(use-package delight
  :config
  (delight '((emacs-lisp-mode       "ξ" :major)
             (lisp-interaction-mode "λ" :major)
             (python-mode           "π" :major)
             (org-mode              "Ø" :major)
             (company-mode          " C" company)
             (ivy-mode              " ι" ivy)
             (projectile-mode       " ρ" projectile)
             (eldoc-mode            " ε" eldoc)
             (flycheck-mode         " ƒ" flycheck)
             (undo-tree-mode        ""   undo-tree)
             (auto-revert-mode      ""   autorevert))))

(use-package ivy
  :demand
  :bind (("M-x" . counsel-M-x)
         ("C-x C-f" . counsel-find-file)
         :map ivy-minibuffer-map
         ("TAB" . ivy-next-line)
         ("RET" . ivy-alt-done))
  :init
  (use-package smex)
  (use-package counsel)
  :config
  (setq ivy-re-builders-alist
        '((t . ivy--regex-ignore-order)))
  (setq ivy-wrap t)
  (ivy-mode 1)
  (eval-after-load "hydra" (use-package ivy-hydra)))

(use-package swiper
  :bind (("C-s" . swiper)))

(use-package company
  :bind (:map company-active-map
         ("C-n" . company-select-next)
         ("C-p" . company-select-previous))
  :init
  (global-company-mode)
  :config
  (setq company-idle-delay 0) ; Delay to complete
  (setq company-minimum-prefix-length 1)
  (setq company-selection-wrap-around t) ; Loops around suggestions

  (if (display-graphic-p)
      (define-key company-active-map [tab] 'company-select-next)
    (define-key company-active-map (kbd "C-i") 'company-select-next))

(ignore-errors
  (require 'color)
  (let ((bg (face-attribute 'default :background)))
    (custom-set-faces
     `(company-tooltip ((t (:inherit default :background ,(color-lighten-name bg 2)))))
     `(company-scrollbar-bg ((t (:background ,(color-lighten-name bg 10)))))
     `(company-scrollbar-fg ((t (:background ,(color-lighten-name bg 5)))))
     `(company-tooltip-selection ((t (:inherit font-lock-function-name-face))))
     `(company-tooltip-common ((t (:inherit font-lock-constant-face))))))))

(use-package flycheck
  :config
  (global-flycheck-mode)
  (with-eval-after-load 'flycheck
    (setq-default flycheck-disabled-checkers '(emacs-lisp-checkdoc))))

(when (require 'mu4e nil 'noerror)
  (setq mu4e-msg2pdf "/usr/bin/msg2pdf")
  (setq
   ;; set mu4e as default mail client
   mail-user-agent 'mu4e-user-agent
   ;; root mail directory - can't be switched
   ;; with context, can only be set once
   mu4e-maildir "~/.mail"
   mu4e-attachments-dir "~/Downloads/Attachments"
   ;; update command
   mu4e-get-mail-command "mbsync -q -a"
   ;; update database every seven minutes
   mu4e-update-interval (* 60 7)
   ;; use smtpmail (bundled with emacs) for sending
   message-send-mail-function 'smtpmail-send-it
   ;; optionally log smtp output to a buffer
   smtpmail-debug-info t
   ;; close sent message buffers
   message-kill-buffer-on-exit t
   ;; customize list columns
   mu4e-headers-fields '((:flags . 4)
                         (:from . 20)
                         (:human-date . 10)
                         (:subject))
   ;; for mbsync
   mu4e-change-filenames-when-moving t
   ;; pick first context automatically on launch
   mu4e-context-policy               'pick-first
   ;; use current context for new mail
   mu4e-compose-context-policy       nil
   mu4e-confirm-quit                 nil)

  (global-set-key (kbd "<f12>") 'mu4e)
  (global-set-key (kbd "<C-f12>") 'mu4e-update-mail-and-index)

  (setq mu4e-contexts
        `(,(make-mu4e-context
            :name "gmail"
            :match-func (lambda(msg)
                          (when msg
                            (mu4e-message-contact-field-matches msg :to "@gmail.com")))
            :vars '(
                    ;; local directories, relative to mail root
                    (mu4e-sent-folder . "/gmail/[Gmail]/.Sent Mail")
                    (mu4e-drafts-folder . "/gmail/[Gmail]/.Drafts")
                    (mu4e-trash-folder . "/gmail/[Gmail]/.Trash")
                    (mu4e-refile-folder . "/gmail/[Gmail]/.All Mail")
                    ;; account details
                    (user-mail-address . "joshuafwolfe@gmail.com")
                    (user-full-name . "Josh Wolfe")
                    (mu4e-user-mail-address-list . ( "@gmail.com" ))
                    ;; gmail saves every outgoing message automatically
                    (mu4e-sent-messages-behavior . delete)
                    (mu4e-maildir-shortcuts . (("/gmail/INBOX" . ?j)
                                               ("/gmail/[Gmail]/.All Mail" . ?a)
                                               ("/gmail/[Gmail]/.Trash" . ?t)
                                               ("/gmail/[Gmail]/.Drafts" . ?d)))
                    ;; outbound mail server
                    (smtpmail-smtp-server . "smtp.gmail.com")
                    ;; outbound mail port
                    (smtpmail-smtp-service . 465)
                    ;; use ssl
                    (smtpmail-stream-type . ssl)
                    ;; the All Mail folder has a copy of every other folder's contents,
                    ;; and duplicates search results, which is confusing
                    (mue4e-headers-skip-duplicates . t)))))

  (use-package evil-mu4e))

(use-package erc
  :ensure nil
  :defer t
  :config
  (add-hook 'window-configuration-change-hook
            '(lambda ()
               (setq erc-fill-column (- (window-width) 2))))
  (add-hook 'erc-mode-hook
            '(lambda ()
                (setq-local scroll-margin 1)))

  (setq erc-rename-buffers t
        erc-interpret-mirc-color t
        erc-lurker-hide-list '("JOIN" "PART" "QUIT")
        erc-autojoin-channels-alist '(("freenode.net" "#emacs"))))

(defun wolfe/irc ()
      (interactive)
      (let* ((tupple (wolfe/get-user-pass wolfe/irc-info-path))
             (user (car tupple))
             (pass (cadr tupple)))
        (erc
         :server "irc.freenode.net"
         :port 6667
         :nick user
         :password pass)))

(use-package meme
  :ensure nil
  :commands (meme meme-file))

(cond ((file-exists-p "~/Projects/org-project/")
       (load-file "~/Projects/org-project/org-project.el")
       (setq org-project-use-ag t))
      ((file-exists-p "C:/dev/SideProjects/org-project/")
       (load-file "C:/dev/SideProjects/org-project/org-project.el")
       (setq org-project-use-ag t)))

(defun wolfe/extract-dates (file-path)
  "Parse through a file for a list of all the comments"
  (let (already-open
        buf
        start
        (comments '()))
    (setq already-open (find-buffer-visiting file-path)
          buf (find-file-noselect file-path))
    (with-current-buffer buf
      (goto-char (point-min))
      (while (setq start (text-property-any
                          (point) (point-max)
                          'face 'org-date))
        (goto-char start)
        (goto-char (next-single-char-property-change (point) 'face))
        (let ((item (string-trim (buffer-substring-no-properties start (point)))))
          (setq comments (cons item comments)))))
    (unless already-open (kill-buffer buf))
    (reverse comments)))