init.el

;;; Init.el --- Configuración personal.
;;; Commentary:
;;; Code:

(defun toggle-window-split ()
  (interactive)
  (if (= (count-windows) 2)
      (let* ((this-win-buffer (window-buffer))
          (next-win-buffer (window-buffer (next-window)))
          (this-win-edges (window-edges (selected-window)))
          (next-win-edges (window-edges (next-window)))
          (this-win-2nd (not (and (<= (car this-win-edges)
                                    (car next-win-edges))
                                (<= (cadr this-win-edges)
                                    (cadr next-win-edges)))))
          (splitter
           (if (= (car this-win-edges)
                 (car (window-edges (next-window))))
               'split-window-horizontally
             'split-window-vertically)))
        (delete-other-windows)
        (let ((first-win (selected-window)))
          (funcall splitter)
          (if this-win-2nd (other-window 1))
          (set-window-buffer (selected-window) this-win-buffer)
          (set-window-buffer (next-window) next-win-buffer)
          (select-window first-win)
          (if this-win-2nd (other-window 1))))))

;; Definición de utilidades

(progn

  (defun package-install-maybe (package)
    (unless (package-installed-p package)
      (package-install package)))

  (defun package-install-bulk-maybe (package-list)
    (mapc 'package-install-maybe package-list))

  (package-install-bulk-maybe '(
                                transpose-mark gnuplot
                                               gnuplot-mode anything auctex
                                               cdlatex cider ac-cider ssh
                                               slime arduino-mode
                                               jabber epc helm-bibtex org-ref
                                               linum-relative google-translate
                                               hy-mode uuid
                                               help-fns+ evil-tutor
                                               evil-vimish-fold evil-surround
                                               evil-paredit evil-numbers evil-nerd-commenter
                                               evil-extra-operator
                                               evil-org org-page org-evil
                                               xclip evil-magit stumpwm-mode ebib
                                               org-attach-screenshot c-eldoc
                                               ob-spice web-mode org-trello
                                               aggressive-indent))

  );; Instalación de paquetes

(progn

  (defun require-several (packages)
    (mapc (lambda (pkg) (require pkg)) packages))

  (require-several '(epa-file
                     netrc anything
                     reftex
                     powerline))

  );; Cargar paquetes

(progn

  (defun set-key (key function)
    "Forcefully set global KEY to execute given FUNCTION."
    (global-unset-key (kbd key))
    (global-set-key (kbd key) function))

  (defun set-keys (key-pairs)
    "Forcefully `set-key' for each key KEY-PAIRS.
Example:
(set-keys '((\"C-1\" delete-other-windows)
            (\"C-2\" split-window-below)
            (\"C-3\" split-window-right)))
Is equivalent to:
(set-key \"C-1\" 'delete-other-windows)
(set-key \"C-2\" 'split-window-below)
(set-key \"C-3\" 'split-window-right)
"
    (mapc (lambda (key-pair) (apply (lambda (key function) (set-key key function)) (car key-pair) (cdr key-pair))) key-pairs))

  (set-keys '(("C-M-t" transpose-mark)
              ("C-c C-v"  comment-or-uncomment-region)
              ("C-x M-d" prelude-duplicate-and-comment-current-line-or-region)

              ("M-[" insert-pair)
              ("C-M-{" insert-pair)
              ("\"" insert-pair)

              ("<f7>" linum-relative-toggle)
              ("<f8>" linum-mode)

              ("C-c l" org-store-link)
              ("C-c a" org-agenda)
              ("C-c z" org-capture)
              ("C-c b" org-iswitchb)
              ("C-M-g" org-plot/gnuplot)

              ("C-ñ" god-mode)
              ("C-<" beginning-of-buffer)
              ("C->" end-of-buffer)
              ("M-$" flyspell-buffer)

              ("<menu>" helm-M-x)

              ("C-*" "**\C-b")
              ("C-c C-d C-f" describe-function)
              ("C-c C-d C-v" describe-variable)
              ("C-x C-8" toggle-window-split)
              ("C-x C-1" delete-other-windows)
              ("C-x C-2" split-window-below)
              ("C-x C-3" split-window-right)))

);; Definición de teclas

(progn

  (autoload 'pkgbuild-mode "pkgbuild-mode.el" "PKGBUILD mode." t)
  (setq auto-mode-alist (append '(("/PKGBUILD$" . pkgbuild-mode)) auto-mode-alist))

  );; Configuración de pkgbuild


(progn

  (defvar flyspell-default-dictionary)
  (setq flyspell-default-dictionary "es")

  );; Configuración de diccionario

(progn

  (defun my-pretty-symbols ()
    "Símbolos chulos."
    (setq prettify-symbols-alist
          '(
            ;; ("define" . 8801)   ; ≡
            ("setf" . 8801)   ; ≡
            ("defun"   . 402)   ; ƒ
            ("lambda" . 955) ; λ
            ;; ("map" . 8614)   ; ↦
            ("mapc" . 8614)   ; ↦
            ("if" . 8594)    ; →
            ("when"   . 9633)   ; □
            ("cond"   . 9671)   ; ◇
            ("let" . 8866)   ; ⊢
            ("let*" . 8872)   ; ⊨
            ("car"   . 127032)   ; 🀸
            ("cdr"   . 127039)   ; 🀿
            ("cadr"   . 127026)   ; 🀲
            ("list->vector" . 8794)   ; ≚
            ("vector->list" . 8793)   ; ≙
            ("add-hook" . 9875)   ; ⚓
            ("for" . 5572)   ; ᗄ
            ("in" . 8712)   ; ∈
            ("and" . 8743)   ; ∧
            ("or" . 8744)   ; ∨
            ("loop" . 8635)   ; ↻
            ("defvar" . 8258)   ; ⁂
            ("last" . 937) ; Ω
            ))
    (prettify-symbols-mode))

  (add-hook 'emacs-lisp-mode-hook 'my-pretty-symbols)
  (add-hook 'emacs-lisp-mode-hook 'hs-minor-mode)
  (add-hook 'gimp-mode-hook 'my-pretty-symbols)
  (add-hook 'lisp-mode-hook 'my-pretty-symbols)
  (add-hook 'lisp-mode-hook 'rainbow-delimiters-mode)

  (font-lock-add-keywords
   'gimp-mode
   '(("\\<\\(and\\|or\\|not\\|list->vector\\|vector->list\\|cadr\\|car\\|defun\\)\\>" . 'font-lock-keyword-face)))

  (font-lock-add-keywords
   'emacs-lisp-mode
   '(("\\<\\(and\\|or\\|not\\|list->vector\\|vector->list\\|cadr\\|car\\|defun\\)\\>" . 'font-lock-keyword-face)))

  (defun fontify-glyph (item glyph)
    `((,item
       (0 font-lock-keyword-face t)
       (0 (prog1
              (compose-region (match-beginning 0)
                              (match-end 0)
                              ,glyph) nil)))))

  (font-lock-add-keywords 'emacs-lisp-mode
                          (fontify-glyph "\\\\\\\\|" "+"))
  (font-lock-add-keywords 'emacs-lisp-mode
                          (fontify-glyph "\\\\\\\\(" "("))
  (font-lock-add-keywords 'emacs-lisp-mode
                          (fontify-glyph "\\\\\\\\)" ")"))
  (font-lock-add-keywords 'emacs-lisp-mode
                          (fontify-glyph "\\\\\\\\<" "<"))
  (font-lock-add-keywords 'emacs-lisp-mode
                          (fontify-glyph "\\\\\\\\>" ">"))

  ) ;; Enchulame el código

(progn

  (require 'google-translate)

  (defvar *google-translation-file* "~/.translated")
  (defvar *google-translation-buffer* "*Google Translate*")
  (setq google-translate-output-destination 'echo-area)
  ;; (setq google-translate-output-destination nil)

  (defun google-translate-to-file (from to text)
    "Uses `google'"
    (interactive)
    (switch-to-buffer *google-translation-buffer*)
    (insert (google-translate-translate from to text))
    (write-file *google-translation-file*)
    (kill-buffer))

  ;; (google-translate-to-file "auto" "es" "test")
  ;; (google-translate-translate "auto" "es" "test")

  )

(require 'prelude-helm-everywhere)

(require 'powerline)
(require 'evil)
(powerline-evil-theme)
(evil-mode)
(define-key evil-normal-state-map (kbd "SPC") nil)

(define-key evil-normal-state-map (kbd "SPC SPC") 'crux-switch-to-previous-buffer)
(define-key evil-normal-state-map (kbd "SPC b") 'helm-mini)
(define-key evil-normal-state-map (kbd "SPC 1") 'delete-other-windows)
(define-key evil-normal-state-map (kbd "SPC 2") 'split-window-below)
(define-key evil-normal-state-map (kbd "SPC 3") 'split-window-right)
(define-key evil-normal-state-map (kbd "SPC k") 'kill-this-buffer)
(define-key evil-normal-state-map (kbd "SPC o") 'other-window)
(define-key evil-normal-state-map (kbd "SPC r") 'replace-regexp)
(define-key evil-visual-state-map (kbd "SPC r") 'replace-regexp)
(define-key evil-normal-state-map (kbd "SPC R") 'regexp-builder)
(define-key evil-visual-state-map (kbd "SPC R") 'regexp-builder)
(define-key evil-normal-state-map (kbd "z i") 'ispell-word)

(define-key evil-normal-state-map (kbd "SPC 4") 'flyspell-correct-word-before-point)

(define-key evil-normal-state-map (kbd "S-SPC") 'avy-goto-char)
(evil-vimish-fold-mode 1)

(add-hook 'emacs-lisp-mode-hook 'evil-paredit-mode)

(require 'evil-surround)
(global-evil-surround-mode 1)

(require 'evil-numbers)
(define-key evil-normal-state-map (kbd "C-c +") 'evil-numbers/inc-at-pt)
(define-key evil-normal-state-map (kbd "C-c -") 'evil-numbers/dec-at-pt)

(define-key evil-normal-state-map (kbd "<kp-add>") 'evil-numbers/inc-at-pt)
(define-key evil-normal-state-map (kbd "<kp-subtract>") 'evil-numbers/dec-at-pt)

(define-key evil-normal-state-map (kbd "C-<tab>") 'vimish-fold)
(define-key evil-normal-state-map (kbd "M-n") 'vimish-fold-next-fold)
(define-key evil-normal-state-map (kbd "M-p") 'vimish-fold-previous-fold)

(define-key evil-insert-state-map (kbd "ñ") 'evil-execute-in-normal-state)
(define-key evil-normal-state-map (kbd "¿") 'helm-insert-latex-math)

;; (define-key evil-insert-state-map (kbd ">") 'rjsx-delete-creates-full-tag)

(require 'evil-nerd-commenter)
(evilnc-default-hotkeys)

(require 'evil-extra-operator)
(global-evil-extra-operator-mode 1)

(key-chord-mode nil)

(setq slime-lisp-implementations
      '((sbcl ("/bin/sbcl") :coding-system utf-8-unix)))

(add-to-list 'load-path "/usr/lib/chicken/8/")   ; Where Eggs are installed
(autoload 'chicken-slime "chicken-slime" "SWANK backend for Chicken" t)
(add-hook 'scheme-mode-hook
          (lambda ()
            (slime-mode t)))

(scroll-bar-mode)

(require 'evil-org)
(setq prelude-user-init-file (expand-file-name "personal/init.el"))
(setq select-enable-primary t)
(setq select-enable-clipboard t)

(require 'evil-magit)

(delete '("\\.js\\'" . js2-mode) auto-mode-alist)
(add-to-list 'auto-mode-alist '("\\.js$" . rjsx-mode))
(evil-define-key 'insert rjsx-mode-map (kbd "C-d") 'rjsx-delete-creates-full-tag)
(yas-global-mode t)
(yas-reload-all)
(add-hook 'rjsx-mode-hook 'emmet-mode)

(defun react-native/update-index-file ()
  (interactive)
  (let ((files (directory-files ".")))
    (setq files (remove-if (lambda (file) (or (string-equal "." file)
                                        (string-equal ".." file)
                                        (string-equal ".#index.js" file)
                                        (string-equal "index.js" file)
                                        (string-equal "./" file)
                                        ))
                           files))
    (erase-buffer)
    (mapc (lambda (f) (insert (concat "export * from './" f "'
"))) files)
    ))

(defun react-native/update-reducers-file ()
  (interactive)
  (let ((files (directory-files ".")))
    (setq files (remove-if (lambda (file) (or (string-equal "." file)
                                        (string-equal ".." file)
                                        (string-equal ".#index.js" file)
                                        (string-equal "index.js" file)
                                        (string-equal "./" file)
                                        ))
                           files))
    (erase-buffer)
    (insert "import { combineReducers } from 'redux';

export default combineReducers({
")
    (mapc (lambda (f) (insert
               (concat
                "    "
                (replace-regexp-in-string ".js" "" f)
                ": require('./" f "'),
"
                )))
       files)
    (insert "});")
    ))