init.el

;;; init.el --- Emacs configuration file -*- lexical-binding: t -*-

;; No splash message
(setq inhibit-splash-screen t)

;; No backup files
(setq make-backup-files nil)

;; No toolbar
(progn (if (fboundp 'tool-bar-mode) (tool-bar-mode -1)))

;; Show column number
(column-number-mode 1)

;; Highlight current line
(global-hl-line-mode 1)

;; Store Customs in different place
(setq custom-file (expand-file-name "custom.el" user-emacs-directory))
(load custom-file 'noerror)


;; Enable Which Function Mode
(which-function-mode 1)

;; Wrap lines
(global-visual-line-mode 1)

;; Calendar starts on Moday
(setq calendar-week-start-day 1)

;; Shortkey to comment region
(global-set-key (kbd "C-c C-c") 'comment-region)

;; Install use-package if not already installed
(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))
(package-initialize)

(unless package-archive-contents
  (package-refresh-contents))

(unless (package-installed-p 'use-package)
  (package-install 'use-package))

(eval-when-compile
  (require 'use-package)
  (require 'use-package-ensure)
  (setq use-package-always-ensure t))

;; Quelpa handler for use-package
(use-package quelpa-use-package
  :init
  (setq quelpa-update-melpa-p nil)
  (setq quelpa-self-upgrade-p nil))

;; Diminished modes are minor modes with no modeline display
(use-package diminish)

;; Major-mode for editing CMake sources
(use-package cmake-mode
  :mode "\\.cmake\\'")

;; Major mode for editing Docker's Dockerfiles
(use-package dockerfile-mode)

;; Incremental Vertical completYon
(use-package ivy
  :diminish
  :config
  (ivy-mode 1))

;; Various completion functions using Ivy
(use-package counsel
  :diminish
  :after ivy
  :config
  (counsel-mode 1))

;; EditorConfig Emacs plugin
(use-package editorconfig
  :diminish
  :config
  (editorconfig-mode 1))

;; Define and query search engines from within Emacs
(use-package engine-mode
  :config
  (engine-mode t)
  (defengine github
    "https://github.com/search?q=%s&type=code"
    :keybinding "g")
  (defengine duckduckgo
    "https://duckduckgo.com/?q=%s"
    :keybinding "d"))

;; Major mode for Markdown-formatted text
(use-package markdown-mode
  :mode "\\.md\\'")

;; Major mode for the Meson build system files
(use-package meson-mode)

;; Outline-based notes management and organizer
(use-package org
  :config
  (setq org-directory "~/Misc/orgfiles")
  (setq org-agenda-files (list org-directory))
  (setq org-refile-use-outline-path 'file)
  (setq org-refile-targets '((org-agenda-files :maxlevel . 1)))
  (setq org-export-backends '(ascii html md odt))
  (setq org-capture-templates
        '(("t" "Todo [Inbox]" entry
           (file "~/Misc/orgfiles/inbox.org")
           "* TODO %i%?")))
  (setq org-clock-persist t)
  (setq org-clock-in-resume t)
  (setq org-clock-persist-query-resume nil)
  (setq org-clock-out-remove-zero-time-clocks t)
  (setq org-startup-indented t)
  (setq org-indent-indentation-per-level 1)
  (org-clock-persistence-insinuate)
  :bind
  (("C-c c" . org-capture)))

;; A simple org-mode based journaling mode
(use-package org-journal
  :after org
  :config
  (setq org-journal-dir "~/Misc/orgfiles/journal")
  (setq org-journal-file-type 'weekly)
  (setq org-journal-file-format "%Y/w%V_%Y%m%d.org")
  (setq org-journal-date-format "%A (%d %b %Y)")
  (setq org-journal-time-format "")
  (setq org-journal-time-prefix "- ")
  (setq org-journal-carryover-items "")
  (setq org-journal-file-header
        (concat
         "#+Title: Week %V\n"
         "#+OPTIONS: toc:nil tags:nil todo:nil h:2 num:1 ^:{}\n"
         "#+COLUMNS: %%ITEM(Task) %%CLOCKSUM(Clocked) %%EFFORT(Estimated)\n"
         "\n"
         "\n"))
  (progn
    (defun org-journal-aux/search-effort ()
      (if (org-entry-get (point) "Effort")
          (point)
        (if (org-up-heading-safe)
            (org-journal-aux/search-effort)
          nil)))
    (defun org-journal-aux/get-remaining-effort ()
      (let ((actual-clocked (org-clock-sum-current-item)))
        (save-excursion
          (if (org-journal-aux/search-effort)
              (org-minutes-to-clocksum-string
               (- (org-hh:mm-string-to-minutes (org-entry-get (point) "Effort"))
                  (- (org-clock-sum-current-item) actual-clocked)))
            nil))))
    (defun org-journal/add-derived-effort ()
      (if (not (org-entry-get (point) "Effort"))
          (let ((remaining-effort (org-journal-aux/get-remaining-effort)))
            (if remaining-effort
                (progn
                  (org-entry-put (point) "Effort" remaining-effort)
                  (org-entry-put (point) "DerivedEffort" "true"))))))
    (defun org-journal/remove-derived-effort ()
      (if (org-entry-get (point) "DerivedEffort")
          (progn
            (org-entry-delete (point) "Effort")
            (org-entry-delete (point) "DerivedEffort"))))
    (defun org-journal/goto-head ()
      (point-to-register 1)
      (while (org-up-heading-safe) ()))
    (defun org-journal/goto-back ()
      (register-to-point 1))
    (defun org-journal/clock-on-top ()
      (interactive)
      (let ((org-clock-in-prepare-hook '(org-journal/goto-head))
            (org-clock-in-hook '(org-journal/goto-back)))
        (org-clock-in)))
    (defun org-journal/clock-in-current ()
      (interactive)
      (let ((org-clock-in-prepare-hook '(org-journal/add-derived-effort))
            (org-clock-in-hook '(org-journal/remove-derived-effort)))
        (org-clock-in)))
    (defun org-journal/carryover-todos ()
      "Carry over items from previous date section to current date section.
TODO items are moved with full content; no-state items are copied as
heading only (no body text). DONE items are skipped.
When the previous entry is in a different file, items are always copied
instead of moved (source is left unchanged)."
      (let* ((org-journal-find-file 'find-file)
             (current-file (buffer-file-name))
             (date-level (save-excursion
                           (org-back-to-heading t)
                           (org-outline-level)))
             output-text
             seen-positions
             regions-to-delete
             different-file)
        (save-excursion
          (save-restriction
            (when (org-journal--open-entry t t)
              (setq different-file (not (string= (buffer-file-name) current-file)))
              (unless (org-journal--daily-p)
                (org-narrow-to-subtree))
              (org-map-entries
               (lambda ()
                 (let* ((level (org-outline-level))
                        (todo-state (org-get-todo-state))
                        (item-start (point))
                        (item-end (save-excursion (org-end-of-subtree t t) (point)))
                        parent-texts)
                   (cond
                    ;; Skip the date heading itself
                    ((<= level date-level) nil)
                    ;; Skip completed items and their entire subtrees
                    ((member todo-state org-done-keywords)
                     (setq org-map-continue-from item-end))
                    ;; TODO items: move full subtree with parent context
                    ;; (copy only if from a different file)
                    ((equal todo-state "TODO")
                     (save-excursion
                       (while (and (org-up-heading-safe)
                                   (> (org-outline-level) date-level))
                         (let ((pos (point)))
                           (unless (member pos seen-positions)
                             (push pos seen-positions)
                             (push (buffer-substring-no-properties
                                    pos
                                    (save-excursion (outline-next-heading) (point)))
                                   parent-texts)))))
                     (push item-start seen-positions)
                     (unless different-file
                       (push (cons item-start item-end) regions-to-delete))
                     (setq output-text
                           (concat output-text
                                   (apply #'concat (nreverse parent-texts))
                                   (buffer-substring-no-properties item-start item-end)))
                     (setq org-map-continue-from item-end))
                    ;; No state: copy heading+body if has content, move if empty
                    ;; (always copy if from a different file)
                    (t
                     (let* ((body-start (save-excursion (forward-line 1) (point)))
                            (has-content (string-match-p "\\S-"
                                                         (buffer-substring-no-properties
                                                          body-start item-end))))
                       (save-excursion
                         (while (and (org-up-heading-safe)
                                     (> (org-outline-level) date-level))
                           (let ((pos (point)))
                             (unless (member pos seen-positions)
                               (push pos seen-positions)
                               (push (buffer-substring-no-properties
                                      pos
                                      (save-excursion (outline-next-heading) (point)))
                                     parent-texts)))))
                       (push item-start seen-positions)
                       (if (or has-content different-file)
                           ;; Has content or different file: copy heading line only
                           (setq output-text
                                 (concat output-text
                                         (apply #'concat (nreverse parent-texts))
                                         (buffer-substring-no-properties item-start (line-end-position))
                                         "\n"))
                         ;; Empty and same file: move heading, remove from source
                         (push (cons item-start item-end) regions-to-delete)
                         (setq output-text
                               (concat output-text
                                       (apply #'concat (nreverse parent-texts))
                                       (buffer-substring-no-properties item-start (line-end-position))
                                       "\n"))
                         (setq org-map-continue-from item-end)))))))
               nil)
              (dolist (r (sort regions-to-delete (lambda (a b) (> (car a) (car b)))))
                (delete-region (car r) (cdr r)))
              (save-buffer))))
        (when output-text
          (save-excursion
            (org-back-to-heading t)
            (outline-end-of-subtree)
            (unless (bolp) (insert "\n"))
            (insert output-text)))))
    (defun org-journal/show-current-date (&rest _)
      "Expand the full current date section after creating a new entry."
      (save-excursion
        (while (org-up-heading-safe))
        (org-show-subtree)))
    (advice-add 'org-journal-new-entry :after #'org-journal/show-current-date))
  :bind
  (("C-c C-x C-M-i" . org-journal/clock-in-current))
  :hook
  ((org-clock-in-prepare . org-journal/goto-head)
   (org-clock-in . org-journal/goto-back)
   (org-journal-after-header-create . org-journal/carryover-todos)))
(global-set-key (kbd "C-c C-j") 'org-journal-new-entry)

;; Insert org-mode links from the clipboard
(use-package org-cliplink
  :after org
  :config
  (progn
    (defun org-cliplink-gh (&optional link)
      (interactive)
      (org-cliplink-insert-transformed-title
       (or link (org-cliplink-clipboard-content))
       (lambda (url title)
         (let* ((parsed-url (url-generic-parse-url url))
                (clean-title
                 (cond
                  ((string-match "\\([^·]*\\) · Issue #\\([0-9]+\\) · " title)   ; GitHub Issue
                   (concat "#" (match-string 2 title) " \"" (match-string 1 title) "\""))
                  ((string-match "\\([^·]*\\) by [^·]+ · Pull Request #\\([0-9]+\\) · " title)   ; GitHub Pull Request
                   (concat "!" (match-string 2 title) " \"" (match-string 1 title) "\""))
                  ((string-match "\\([^·]*\\) · [^@]*@\\([^·]*\\) · " title)   ; GitHub Commit
                   (concat (match-string 2 title) " (\"" (match-string 1 title) "\")"))
                  ((string-match "\\([^(]*\\) (#\\([0-9a-z]+\\)) · Issues" title)   ; GitLab Issue
                   (concat "#" (match-string 2 title) " \"" (match-string 1 title) "\""))
                  ((string-match "\\(.*\\) (!\\([0-9a-z]+\\)) · Merge requests" title)   ; GitLab Merge Request
                   (concat "!" (match-string 2 title) " \"" (match-string 1 title) "\""))
                  ((string-match "\\([^(]*\\) (\\([0-9a-z]+\\)) · Commits" title)   ; GitLab Commit
                   (concat (match-string 2 title) " (\"" (match-string 1 title) "\")"))
                  (t title)
                  )))
           ;; forward the title to the default org-cliplink transformer
           (org-cliplink-org-mode-link-transformer url clean-title))))))
  :bind
  (("C-c C-x l" . org-cliplink-gh)))

;; Modern looks for Org
(use-package org-modern
  :after org
  :hook (org-mode . org-modern-mode))

;; Org Twiki and Foswiki export
;; Add function that fits better with the format we need for reports
(use-package ox-twiki
  :after org
  :config
  (defun org-twiki-export-report ()
    (interactive)
    (org-twiki-export-as-twiki)
    (goto-char (point-min))
    (kill-whole-line)
    (kill-whole-line)
    (while (search-forward "---+" nil t)
      (replace-match "--"))
    (goto-char (point-min))))

;; A database abstraction layer for Org-mode
(use-package org-roam
  :after org
  :custom
  (org-roam-directory (file-truename "~/Misc/orgfiles/roam"))
  (org-roam-completion-everywhere t)
  :config
  (setq org-roam-node-display-template (concat "${title:*} " (propertize "${tags:10}" 'face 'org-tag)))
  (org-roam-db-autosync-mode)
  :bind
  (("C-c n f" . org-roam-node-find)
   ("C-c n i" . org-roam-node-insert)
   ("C-c n c" . org-roam-capture)
   :map org-mode-map
   ("C-M-i" . completion-at-point)))

;; Adds document titles to Markdown files generated with ox-md and derivatives
(use-package ox-md-title
  :after org
  :quelpa
  (ox-md-title
   :fetcher github
   :repo "jeffkreeftmeijer/ox-md-title.el")
  :config
  (org-md-title-add)
  (setq org-md-title t))

;; Modern block styling with org-indent.
(use-package org-modern-indent
  :quelpa
  (org-modern-indent
   :fetcher github
   :repo "jdtsmith/org-modern-indent")
  :config
  (add-hook 'org-mode-hook #'org-modern-indent-mode 90))

;; Manage and navigate projects in Emacs easily
(use-package projectile
  :diminish
  :config
  (projectile-mode +1)
  :custom
  (projectile-indexing-method 'hybrid)
  :bind-keymap
  ("C-c p" . projectile-command-map))

;; Ivy integration for Projectile
(use-package counsel-projectile
  :config
  (counsel-projectile-mode 1))

;; Automatic insertion, wrapping and paredit-like navigation with user
;; defined pairs
(use-package smartparens
  :config
  (require 'smartparens-config)
  (smartparens-global-mode t)
  (show-smartparens-global-mode t))

;; A tree style file explorer package
(use-package treemacs
  :bind
  (("<f8>" . treemacs)))

;;Projectile integration for treemacs
(use-package treemacs-projectile
  :after projectile treemacs)

;; Major mode for editing Twiki pages
(use-package twiki
  :quelpa
  (twiki
     :fetcher github
     :repo "christopherjwhite/emacs-twiki-mode")
  :mode ("\\.twiki\\'" . twiki-mode))

;; Major mode for editing YAML files
(use-package yaml-mode
  :mode "\\.yml\\'")

(use-package yasnippet
  :diminish
  :config
  (yas-global-mode t))

;; A low contrast color theme for Emacs
(use-package zenburn-theme
  :config
  (load-theme 'zenburn t))

;; Better experience with icons for ivy
(use-package all-the-icons-ivy-rich
  :config
  (all-the-icons-ivy-rich-mode 1))

;; More friendly display transformer for ivy
(use-package ivy-rich
  :config
  (ivy-rich-mode 1))

;; Better sorting and filtering
(use-package ivy-prescient
  :config
  (ivy-prescient-mode 1))