emacs.d/bundle/bundle--package.el

;; PACKAGE
(require 'package)
(setq package-archives
      '(("melpa" . "https://melpa.org/packages/")
        ("org" . "https://orgmode.org/elpa/")
        ("elpa" . "https://elpa.gnu.org/packages/")
        ("nongnu" . "https://elpa.nongnu.org/nongnu/")))
(package-initialize)
(unless package-archive-contents
  (package-refresh-contents))
(unless (package-installed-p 'use-package)
  (package-install 'use-package))
(require 'use-package)
(setq use-package-always-ensure t)

(load "bundle--gui")

(add-hook 'emacs-lisp-mode-hook (lambda () (prettify-symbols-mode)))

(use-package shrface
  :defer t
  :config
  (shrface-basic)
  (shrface-trial)
  (shrface-default-keybindings) ; setup default keybindings
  (setq shrface-href-versatile t
        shrface-toggle-bullets t
        shr-width nil))

(use-package nov
  :hook (nov-mode . visual-line-mode)
  :mode ("\\.epub\\'" . nov-mode)
  :init
  (add-hook 'nov-mode-hook #'shrface-mode)
  :config
  (setq nov-text-width 82
        nov-variable-pitch t)
  (require 'shrface)
  (setq nov-shr-rendering-functions '((img . nov-render-img) (title . nov-render-title)))
  (setq nov-shr-rendering-functions (append nov-shr-rendering-functions shr-external-rendering-functions))
  (when (eq system-type 'windows-nt)
    (when (directory-name-p "c:/msys64/")
      (setq nov-unzip-program "c:/msys64/usr/bin/unzip.exe"))))

(use-package eglot
  :defer t
  :config
  (add-to-list 'eglot-server-programs '((c++-mode c-mode) "ccls")))

(use-package lisp-mode
  :ensure nil
  :init
  (add-hook 'lisp-mode-hook (lambda () (prettify-symbols-mode)))
  :mode (("\\.lisp$" . lisp-mode)
         ("\\.lsp$" . lisp-mode)
         ("\\.cl$" . lisp-mode)))

(use-package cc-mode
  ;; https://www.gnu.org/prep/standards/html_node/Writing-C.html
  :ensure nil
  ;;  :hook (c-mode . eglot-ensure)
  :hook (c-mode-common . c-toggle-auto-newline)
  :custom
  (fill-column 79)                      ; according to gnu style guide
  (c-basic-offset 2)                    ; ""
  :config
  (defun me/c-mode-style-hook ()
    ;; if linux kernel source use linux style, else use gnu style
    (c-set-style
     (if (and (buffer-file-name)
              (string-match "/usr/src/linux" (buffer-file-name)))
         "linux"
       "gnu")))
  (add-hook 'c-mode-common-hook 'me/c-mode-style-hook))
  ;; (defun me/c-mode-compile-command-hook ()
  ;;   ;; if no makefile use gcc for compile command
  ;;   (unless (or (file-exists-p "makefile")
  ;;       	(file-exists-p "Makefile"))
  ;;     (set (make-local-variable 'compile-command)
  ;;          (concat "gcc " "-Wall " "-g " buffer-file-name " -o "
  ;;                  (file-name-sans-extension buffer-file-name)))))
  ;; (add-hook 'c-mode-common-hook 'me/c-mode-compile-command-hook)
  ;; (defun me/c-mode-compile-on-save ()
  ;;   ;; compile on save hook
  ;;   (make-local-variable 'after-save-hook)
  ;;   (add-hook 'after-save-hook (lambda () (compile compile-command))))
  ;; (add-hook 'c-mode-common-hook 'me/c-mode-compile-on-save))

(use-package js-mode
  :ensure nil
  :hook (js-mode . eglot-ensure)
  :mode (("\\.webmanifest\\'" . js-mode)
         ("\\.js\\'" . js-mode)))

(use-package go-mode
  :mode ("\\.go\\'" . go-mode)
  :hook ((before-save . gofmt-before-save)
         (go-mode . eglot-ensure))
  :config
  (defun me/go-mode-compile-command-hook ()
    ;; if no makefile use go vet for compile command
    (unless (or (file-exists-p "makefile")
		(file-exists-p "Makefile"))
      (set (make-local-variable 'compile-command)
	   (concat "go " "vet " buffer-file-name))))
  (add-hook 'go-mode-hook 'me/go-mode-compile-command-hook)
  (defun me/go-mode-compile-on-save ()
    ;; compile on save hook
    (make-local-variable 'after-save-hook)
    (add-hook 'after-save-hook (lambda () (compile compile-command))))
  ;; (add-hook 'go-mode-hook 'me/go-mode-compile-on-save))
  )

(use-package web-mode
  ;; :hook html-mode
  :mode (("\\.html?\\'" . web-mode)
         ("\\.xhtml?\\'" . web-mode)
         ("\\.tmpl\\'" . web-mode)
         ("\\.hbs\\'" . web-mode)
         ("\\.handlebars\\'" . web-mode))
  :custom
  (web-mode-markup-indent-offset 2)
  (web-mode-css-indent-offset 2)
  (web-mode-code-indent-offset 2)
  (web-mode-enable-auto-pairing nil)
  (web-mode-enable-auto-closing t)
  (web-mode-enable-current-element-highlight t)
  (web-mode-enable-current-column-highlight t))

(use-package python
  :mode (("\\.py\\'" . python-mode)
         ("\\.wsgi$" . python-mode)
         ("\\.j2" . python-mode))
  :hook (python-mode . abbrev-mode)
  :init
  (setq python-indent-offset 4)
  (setq-default indent-tabs-mode nil)
  :custom
  (fill-column 79))

(use-package slime
  :defer t
  :custom
  (slime-autodoc-use-multiline-p 1)
  :bind ("C-c C-q" . slime-close-all-parens-in-sexp)
  :config
  (slime-setup '(slime-autodoc
                 slime-banner
                 slime-tramp
                 slime-fancy
                 slime-asdf
                 slime-indentation
                 slime-editing-commands
                 slime-sbcl-exts))
  (progn
    (setq common-lisp-hyperspec-root
          (let ((file (if (eq system-type 'windows-nt) "file:///" "file://")))
            (concat file
                    (expand-file-name "~/Documents/sites/lisp-docs/HyperSpec-7-0/HyperSpec/"))))
    (setq common-lisp-hyperspec-symbol-table
          (concat common-lisp-hyperspec-root "Data/Map_Sym.txt"))
    (setq common-lisp-hyperspec-issuex-table
          (concat common-lisp-hyperspec-root "Data/Map_IssX.txt")))
  (if (eq system-type 'windows-nt)
      (setq sbcl-exe "C:\\Program Files\\Steel Bank Common Lisp\\sbcl.exe"
            sbcl-core "C:\\Program Files\\Steel Bank Common Lisp\\sbcl.core"
            inferior-lisp-program "sbcl"
            slime-lisp-implementations `((sbcl (,sbcl-exe "--noinform" "--core" ,sbcl-core))))
    (setq inferior-lisp-program "/usr/bin/sbcl --noinform"))
  (let ((helper (expand-file-name "~/quicklisp/slime-helper.el")))
    (when (file-exists-p helper) (load helper)))
  (let* ((docs-dir
          (if (eq system-type 'windows-nt)
              (expand-file-name "d:/visua/Documents")
            (expand-file-name "~/Documents")))
         (file (concat docs-dir "/slime_filename_translations.el")))
    (when (file-exists-p file)
      (load-file file))))
(use-package simple-httpd
  :defer t)

;; (use-package go-translate
;;   :defer t
;;   :config
;;   (setq gts-translate-list '(("en" "de")))
;;   (setq gts-default-translator
;;        (gts-translator
;;         :picker (gts-prompt-picker)
;;         :engines (list (gts-google-engine) (gts-google-rpc-engine))
;;         :render (gts-buffer-render))))

(use-package sql
  :ensure nil
  :defer t
  :config
  (when (eq system-type 'windows-nt)
    (when (directory-name-p "c:/msys64/")
      (setq sql-sqlite-program "c:/msys64/mingw64/bin/sqlite3.exe"))))

(use-package magit
  :bind ("C-x g" . magit-status)
  :config
  (global-set-key (kbd "C-x M-g") 'magit-dispatch))

(use-package yaml-mode
  :mode "\\.yml\\'")

(use-package csv-mode
  :mode "\\.csv\\'")

(use-package markdown-mode
  :mode "\\.md\\'")

(use-package typescript-mode
  :mode "\\.ts\\'"
  :hook (typescript-mode . eglot-ensure)
  :config (setq typescript-indent-level 2))

(when (eq system-type 'gnu/linux)
  (use-package spotify :bind ("S-<pause>" . spotify-playpause))
  (use-package clojure-mode)
  (use-package cider)
  (use-package racket-mode :mode "\\.rkt\\'")
  (use-package geiser
    :defer t
    :config
    (setq geiser-active-implementations '(racket guile)))
  (use-package geiser-racket
    :defer t
    :after geiser
    :config
    (when (eq system-type 'windows-nt)
      (setq geiser-racket-binary "c:/Program Files/Racket/Racket.exe")))
  (use-package geiser-guile
    :defer t
    :after geiser
    :custom (geiser-guile-binary "guile")))

(use-package mastodon
  :custom
  (mastodon-instance-url "https://emacs.ch")
  (mastodon-active-user "qhBidG3d"))

(use-package kotlin-mode)

(use-package jabber)

(use-package hyperbole
  :config
  (setq hyrolo-date-format "%Y-%m-%d %H:%M:%S")
  (add-hook 'hyperbole-init-hook
            (lambda ()
              (setq hyrolo-file-list
                    (append (hyrolo-initialize-file-list)
                            '("~/.rolo.otl")
                            (directory-files org-directory t "\\.org$")
                            (directory-files org-roam-directory t "\\.org$"))))))

(load "bundle--irc")
(load "bundle--news")
(when (eq system-type 'gnu/linux)
    (load "bundle--email"))