init.el

(line-number-mode t)
(column-number-mode t)
(global-display-line-numbers-mode t)
(global-whitespace-mode t)
(electric-pair-mode t)

(menu-bar-mode -1)

(setq require-final-newline t)

(setq scroll-conservatively 1)
(setq scroll-margin 10)
(setq warning-minimum-level :error)

(setq make-backup-files nil)
(setq auto-save-default nil)
(setq auto-save-list-file-prefix nil)
(setq initial-scrarch-message nil)
(setq whitespace-line-column 80
      whitespace-style '(face
                         trailing lines space-before-tab empty space-after-tab
                         tab-mark))

;; elpaca install script
(defvar elpaca-installer-version 0.6)
(defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
(defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
(defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
(defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                              :ref nil
                              :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                              :build (:not elpaca--activate-package)))
(let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
       (build (expand-file-name "elpaca/" elpaca-builds-directory))
       (order (cdr elpaca-order))
       (default-directory repo))
  (add-to-list 'load-path (if (file-exists-p build) build repo))
  (unless (file-exists-p repo)
    (make-directory repo t)
    (when (< emacs-major-version 28) (require 'subr-x))
    (condition-case-unless-debug err
        (if-let ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
                 ((zerop (call-process "git" nil buffer t "clone"
                                       (plist-get order :repo) repo)))
                 ((zerop (call-process "git" nil buffer t "checkout"
                                       (or (plist-get order :ref) "--"))))
                 (emacs (concat invocation-directory invocation-name))
                 ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                       "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                 ((require 'elpaca))
                 ((elpaca-generate-autoloads "elpaca" repo)))
            (progn (message "%s" (buffer-string)) (kill-buffer buffer))
          (error "%s" (with-current-buffer buffer (buffer-string))))
      ((error) (warn "%s" err) (delete-directory repo 'recursive))))
  (unless (require 'elpaca-autoloads nil t)
    (require 'elpaca)
    (elpaca-generate-autoloads "elpaca" repo)
    (load "./elpaca-autoloads")))
(add-hook 'after-init-hook #'elpaca-process-queues)
(elpaca `(,@elpaca-order))

;; Install use-package support
(elpaca elpaca-use-package
  ;; Enable :elpaca use-package keyword.
  (elpaca-use-package-mode)
  ;; Assume :elpaca t unless otherwise specified.
  (setq elpaca-use-package-by-default t))

;; Block until current queue processed.
(elpaca-wait)

;; company
(use-package company
  :ensure t
  :init
  (add-hook 'after-init-hook 'global-company-mode)
  :config
  (setq company-idle-delay 0)
  (setq company-minimum-prefix-length 2)
  (setq company-selection-wrap-around t)
  :defer t)

;; helm
(use-package helm
  :ensure t
  :bind (("M-x" . helm-M-x)
         ("C-x b" . helm-mini)
         ("C-x C-f" . helm-find-files)
         ("M-y" . helm-show-kill-ring)
         :map helm-read-file-map
         ("<tab>" . helm-execute-persistent-action)
         :map helm-find-files-map
         ("<tab>" . helm-execute-persistent-action))
  :config
  (helm-mode 1)
  :defer t)
(use-package helm-ag
  :ensure t
  :after helm
  :defer t
  :bind ("C-x g" . helm-ag)
  :config
  (setq helm-ag-base-command "rg -S --vimgrep --no-heading"))

;; editorconfig
(use-package editorconfig
  :ensure t
  :defer t
  :config
  (editorconfig-mode t))

;; rust-mode
(use-package rust-mode
  :ensure t
  :defer t
  :config
  (setq rust-format-on-save t))

;; cargo
(use-package cargo
  :ensure t
  :defer t
  :hook (rust-mode . cargo-minor-mode))

;; LSP
(use-package lsp-mode
  :ensure t
  :init
  ;; set prefix for lsp-command-keymap (few alternatives - "C-l", "C-c l")
  (setq lsp-keymap-prefix "C-c l")
  (setf lsp-prefer-capf t)
  :hook (;; replace XXX-mode with concrete major-mode(e. g. python-mode)
         (c-mode . lsp)
         (rust-mode . lsp)
         (markdown-mode . lsp)
         ;; if you want which-key integration
         (lsp-mode . lsp-enable-which-key-integration))
  :commands lsp
  :defer t)
(use-package lsp-ui
  :ensure t
  :commands lsp-ui-mode
  :hook (lsp-mode . lsp-ui-mode)
  :defer t)
(use-package helm-lsp
  :ensure t
  :commands helm-lsp-workspace-symbol
  :defer t)
(use-package clang-format
  :ensure t
  :defer t)
(use-package markdown-mode
  :ensure t
  :hook (markdown-mode . (lambda () (setq tab-width 8)))
  :defer t)

(elpaca-process-queues)