My .emacs

.emacs

;; start the timer
(defvar *emacs-load-start* (current-time))

;; Package repos
(require 'package)
;; MELPA
(add-to-list 'package-archives
	     '("melpa" . "http://melpa.milkbox.net/packages/") t)
(package-initialize)
(global-set-key (kbd "C-c p") 'list-packages)

;; Set exec paths
;; NPM executables
(setenv "PATH" (concat (getenv "PATH") ":~/.npm-packages/bin"))
(setq exec-path (append exec-path '("~/.npm-packages/bin")))

;; Basic customisations
(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(ac-modes (quote (ess-mode inferior-ess-mode emacs-lisp-mode lisp-mode lisp-interaction-mode slime-repl-mode c-mode cc-mode c++-mode go-mode java-mode malabar-mode clojure-mode clojurescript-mode scala-mode scheme-mode ocaml-mode tuareg-mode coq-mode haskell-mode agda-mode agda2-mode perl-mode cperl-mode python-mode ruby-mode lua-mode ecmascript-mode javascript-mode js-mode js2-mode php-mode css-mode makefile-mode sh-mode fortran-mode f90-mode ada-mode xml-mode sgml-mode ts-mode sclang-mode verilog-mode html-mode scss-mode sass-mode)))
 '(ansi-color-names-vector ["#073642" "#dc322f" "#859900" "#b58900" "#268bd2" "#d33682" "#2aa198" "#657b83"])
 '(background-color "#002b36")
 '(background-mode dark)
 '(column-number-mode t)
 '(cursor-color "#839496")
 '(custom-safe-themes (quote ("fc5fcb6f1f1c1bc01305694c59a1a861b008c534cae8d0e48e4d5e81ad718bc6" default)))
 '(ess-roxy-template-alist (quote (("description" . ".. content for \\description{} (no empty lines) ..") ("details" . ".. content for \\details{} ..") ("param" . "") ("export" . ""))))
 '(feature-cucumber-command "RAILS_ENV=test bundle exec cucumber CUCUMBER_OPTS=\"{options}\" FEATURE=\"{feature}\"")
 '(foreground-color "#839496")
 '(indicate-empty-lines t)
 '(js-indent-level 2)
 '(js2-allow-keywords-as-property-names nil)
 '(js2-basic-offset 2)
 '(js2-indent-switch-body t)
 '(org-agenda-files (quote ("~/Documents/org-files/faks.org")))
 '(org-modules (quote (org-bbdb org-bibtex org-docview org-gnus org-info org-jsinfo org-irc org-mew org-mhe org-rmail org-vm org-wl org-w3m)))
 '(org-startup-truncated nil)
 '(safe-local-variable-values (quote ((encoding . utf-8) (ruby-compilation-executable . "ruby") (ruby-compilation-executable . "ruby1.8") (ruby-compilation-executable . "ruby1.9") (ruby-compilation-executable . "rbx") (ruby-compilation-executable . "jruby"))))
 '(save-place t nil (saveplace))
 '(scroll-bar-mode (quote left))
 '(scss-compile-at-save nil)
 '(show-paren-mode t)
 '(size-indication-mode t)
 '(tool-bar-mode nil)
 '(yas-prompt-functions (quote (yas-ido-prompt yas-completing-prompt yas-no-prompt)))
 '(yas-snippet-dirs (quote ("/home/al3xa/.emacs.d/elpa/yasnippet-20140106.1009/snippets" "/home/al3xa/.emacs.d/elpa/angular-snippets-20131125.314/snippets" "~/.emacs.d/snippets")) nil (yasnippet)))
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )


;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; General purpose stuff ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

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

;; Alt is Meta
(setq x-alt-keysym 'meta)

;; Disable C-left click (buffer menu)
(global-unset-key [C-down-mouse-1])

;; Send deleted files to Trash
(setq delete-by-moving-to-trash t)

;; ;; C-h to backspace
;; (global-set-key (kbd "C-?") 'help-command)
;; (global-set-key (kbd "M-?") 'mark-paragraph)
;; (global-set-key (kbd "C-h") 'delete-backward-char)
;; (global-set-key (kbd "M-h") 'backward-kill-word)

;; delete trailing whitespace
(add-hook 'before-save-hook 'delete-trailing-whitespace)

;; enable up/downcase region
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)

;; enable which-function-mode
(which-function-mode)

;; Make scripts executable on save
(add-hook 'after-save-hook
	  'executable-make-buffer-file-executable-if-script-p)

;; comment line
(fset 'comment-line
      [?\C-a ?\C-  ?\C-e ?\M-\;])
(global-set-key (kbd "C-:") 'comment-line)

;; comment box
(global-set-key (kbd "C-M-;") 'comment-box)

;; clear console (doesn't work with eshell)
(defun clear-shell ()
  (interactive)
  (let ((old-max comint-buffer-maximum-size))
    (setq comint-buffer-maximum-size 0)
    (comint-truncate-buffer)
    (setq comint-buffer-maximum-size old-max)
    (comint-show-maximum-output)))
(global-set-key (kbd "C-c l") 'clear-shell)

;; duplicate line
(defun duplicate-line()
  (interactive)
  (move-beginning-of-line 1)
  (kill-line)
  (yank)
  (open-line 1)
  (next-line 1)
  (yank)
  )
(global-set-key (kbd "C-c C-d") 'duplicate-line)

;; delete duplicate lines
(defun delete-duplicate-lines (beg end)
  (interactive "r")
  (let ((lines (split-string (buffer-substring beg end) "\n")))
    (delete-region beg end)
    (insert
     (mapconcat #'identity (delete-dups lines) "\n"))))

;; remove duplicate lines (leave only unique ones)
(defun uniq-lines (beg end)
  "Unique lines in region.
Called from a program, there are two arguments:
BEG and END (region to sort)."
  (interactive "r")
  (save-excursion
    (save-restriction
      (narrow-to-region beg end)
      (goto-char (point-min))
      (while (not (eobp))
        (kill-line 1)
        (yank)
        (let ((next-line (point)))
          (while
              (re-search-forward
               (format "^%s" (regexp-quote (car kill-ring))) nil t)
            (replace-match "" nil nil))
          (goto-char next-line))))))

;; indent buffer
(defun indent-buffer()
  (interactive)
  (save-excursion
    (indent-region (point-min) (point-max))))
(global-set-key (kbd "C-c o") 'indent-buffer)

;; move lines up/down

;; move line function
(defun move-line (n)
  "Move the current line up or down by N lines."
  (interactive "p")
  (setq col (current-column))
  (beginning-of-line) (setq start (point))
  (end-of-line) (forward-char) (setq end (point))
  (let ((line-text (delete-and-extract-region start end)))
    (forward-line n)
    (insert line-text)
    ;; restore point to original column in moved line
    (forward-line -1)
    (forward-char col)))

;; move line up
(defun move-line-up (n)
  "Move the current line up by N lines."
  (interactive "p")
  (move-line (if (null n) -1 (- n))))

;; move line down
(defun move-line-down (n)
  "Move the current line down by N lines."
  (interactive "p")
  (move-line (if (null n) 1 n)))

;; assign keybindings
(global-set-key (kbd "M-P") 'move-line-up)
(global-set-key (kbd "M-N") 'move-line-down)

;; move region up/down
;; move region function
(defun move-region (arg)
  (cond
   ((and mark-active transient-mark-mode)
    (if (> (point) (mark))
        (exchange-point-and-mark))
    (let ((column (current-column))
          (text (delete-and-extract-region (point) (mark))))
      (forward-line arg)
      (move-to-column column t)
      (set-mark (point))
      (insert text)
      (exchange-point-and-mark)
      (setq deactivate-mark nil)))
   (t
    (beginning-of-line)
    (when (or (> arg 0) (not (bobp)))
      (forward-line)
      (when (or (< arg 0) (not (eobp)))
        (transpose-lines arg))
      (forward-line -1)))))

;; move region down
(defun move-region-down (arg)
  "Move region (transient-mark-mode active) or current line
  arg lines down."
  (interactive "*p")
  (move-region arg))

;; move region up
(defun move-region-up (arg)
  "Move region (transient-mark-mode active) or current line
  arg lines up."
  (interactive "*p")
  (move-region (- arg)))

;; set keybindings
(global-set-key (kbd "C-M-p") 'move-region-up)
(global-set-key (kbd "C-M-n") 'move-region-down)

;; window buffer navigation
(global-set-key (kbd "C-S-j") 'windmove-left)  ; move to left windnow
(global-set-key (kbd "C-S-k") 'windmove-right) ; move to right window
(global-set-key (kbd "C-S-i") 'windmove-up)    ; move to upper window
(global-set-key (kbd "C-S-m") 'windmove-down)  ; move to downer window

;; ;; open current buffer's wd in default file manager
;; (global-set-key (kbd "C-c f")
;;                 (lambda ()
;;                   (interactive)
;;                   (shell-command "xdg-open .")))

;; other window
(global-set-key (kbd "M-o") 'other-window)

;; ido-mode <3
(require 'ido)
(require 'ido-ubiquitous)
(require 'smex)
(require 'ido-vertical-mode)
;; (autoload 'ido "ido-mode" "ido-mode" t)
;; (autoload 'ido-ubiquitous "ido-ubiquitous" "ido-ubiquitous" t)
;; (autoload 'smex "smex" "smex" t)
;; (autoload 'ido-vertical-mode "ido-vertical-mode" "ido-vertical-mode" t)
(setq ido-enable-flex-matching t)
(setq ido-everywhere t)
(setq ido-create-new-buffer 'always)
(setq ido-ignore-extensions t)
(ido-mode t)
(ido-vertical-mode t)

;; use ido-mode to search method definition in file
(defun ido-goto-symbol ()
  "Will update the imenu index and then use ido to select a
   symbol to navigate to"
  (interactive)
  (imenu--make-index-alist)
  (let ((name-and-pos '())
        (symbol-names '()))
    (flet ((addsymbols (symbol-list)
                       (when (listp symbol-list)
                         (dolist (symbol symbol-list)
                           (let ((name nil) (position nil))
                             (cond
                              ((and (listp symbol) (imenu--subalist-p symbol))
                               (addsymbols symbol))

                              ((listp symbol)
                               (setq name (car symbol))
                               (setq position (cdr symbol)))

                              ((stringp symbol)
                               (setq name symbol)
                               (setq position (get-text-property 1 'org-imenu-marer symbol))))

                             (unless (or (null position) (null name))
                               (add-to-list 'symbol-names name)
                               (add-to-list 'name-and-pos (cons name position))))))))
      (addsymbols imenu--index-alist))
    (let* ((selected-symbol (ido-completing-read "Symbol? " symbol-names))
           (position (cdr (assoc selected-symbol name-and-pos))))
      (goto-char position))))
(global-set-key (kbd "M-i") 'ido-goto-symbol)

;; make buffer names unique
(require 'uniquify)
(setq uniquify-buffer-name-style 'post-forward-angle-brackets)

;; use ibuffer by default
(global-set-key (kbd "C-x C-b") 'ibuffer)

;; switch buffers fast(er)
(defun switch-to-previous-buffer ()
  (interactive)
  (switch-to-buffer (other-buffer (current-buffer) 1)))
(global-set-key (kbd "C-S-o") 'switch-to-previous-buffer)

;; expand region
(require 'expand-region)
(global-set-key (kbd "C-S-u") 'er/expand-region)

;; ace-jump-mode
(require 'ace-jump-mode)
(define-key global-map (kbd "C-c j") 'ace-jump-mode)

;; mark-multiple
(require 'mark-multiple)

;; inline string rectangle, less error prone
(require 'inline-string-rectangle)
(global-set-key (kbd "C-x r t") 'inline-string-rectangle)

;; mark more like this
(require 'mark-more-like-this)
(global-set-key (kbd "C-<") 'mark-previous-like-this)
(global-set-key (kbd "C->") 'mark-next-like-this)
(global-set-key (kbd "C-M-m") 'mark-more-like-this)

;; rename HTML tags
(require 'rename-sgml-tag)
(define-key text-mode-map (kbd "C-c C-r") 'rename-sgml-tag)

;; auto-complete
(require 'auto-complete-config)         ; load default config
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict") ; load dicts
(ac-config-default)
(setq ac-ignore-case nil)		; case sensitive matches
(define-key ac-completing-map (kbd "C-m") 'ac-stop) ; stop completion on enter
(define-key ac-completing-map (kbd "C-n") 'ac-next) ;; was ac-next
(define-key ac-completing-map (kbd "C-p") 'ac-previous) ;; was ac-previous

;; yasnippet
(require 'yasnippet)
(yas-global-mode t)

;; flymake-cursor
(require 'flymake-cursor)

;; scratch buffers
(require 'scratch)
;; global binding for R scratch buffer
(global-set-key (kbd "C-c b r")
                (lambda ()
                  (interactive)
		  (scratch)
		  (r-mode)
		  (rename-buffer "*r-scratch*")))

;; ;; git
;; (require 'magit)
;; (global-set-key (kbd "C-c g s") 'magit-status) ; show git status

;; ;; smart operator
;; (require 'smart-operator)

;; autopair
(require 'autopair)
(autopair-global-mode)

;;;;;;;
;; R ;;
;;;;;;;

;; ESS
(require 'ess-site)
(defvar ess-R-smart-operators 'all)

;; ;; rebind assignment operator to C-- ?
;; (ess-toggle-underscore nil)
;; (define-key ess-mode-map (kbd "C--") 'ess-smart-S-assign)
;; (define-key inferior-ess-mode-map (kbd "C--") 'ess-smart-S-assign)

;; R tooltips
(require 'ess-R-object-popup)
(define-key ess-mode-map "\C-c\C-g" 'ess-R-object-popup)

;; align by <- operator
(define-key ess-mode-map (kbd "C-c a _")
  (lambda () (interactive)
    (align-regexp (region-beginning) (region-end) "\\(\\s-*\\)<-" 1 1 nil)))

;; align by =
(define-key ess-mode-map (kbd "C-c a =")
  (lambda () (interactive)
    (align-regexp (region-beginning) (region-end) "\\(\\s-*\\)=" 1 1 nil)))

;; TODO: add C-c a i for interactive alignment

;; rebind eval-<stuff>-and-go
;; line
(define-key ess-mode-map (kbd "C-c C-j") 'ess-eval-line-and-go)
(define-key ess-mode-map (kbd "C-c M-j") 'ess-eval-line)
;; region
(define-key ess-mode-map (kbd "C-c C-r") 'ess-eval-region-and-go)
(define-key ess-mode-map (kbd "C-c M-r") 'ess-eval-region)
;; function
(define-key ess-mode-map (kbd "C-c C-f") 'ess-eval-function-and-go)
(define-key ess-mode-map (kbd "C-c M-f") 'ess-eval-function)
;; buffer
(define-key ess-mode-map (kbd "C-c C-b") 'ess-eval-buffer-and-go)
(define-key ess-mode-map (kbd "C-c M-b") 'ess-eval-buffer)

;; ess-execute
(define-key ess-mode-map (kbd "C-c t") 'ess-execute-in-tb)
(define-key inferior-ess-mode-map (kbd "C-c t") 'ess-execute-in-tb)

;; load library
(define-key ess-mode-map (kbd "C-c p") 'ess-library)
(define-key inferior-ess-mode-map (kbd "C-c p") 'ess-library)

;; install packages
(define-key ess-mode-map (kbd "C-c i") 'ess-install.packages)
(define-key inferior-ess-mode-map (kbd "C-c i") 'ess-install.packages)

;; vignettes
(define-key ess-mode-map (kbd "C-c v") 'ess-display-vignettes)
(define-key inferior-ess-mode-map (kbd "C-c v") 'ess-display-vignettes)

;; ;; ;; load tracebug
;; ;; (require 'ess-tracebug)

;; ;; enable tracebug by default?
;; ;; (add-hook 'ess-post-run-hook 'ess-tracebug t)

;; define keybindigs for error navigation
(define-key ess-mode-map "\M-]" 'next-error)
(define-key ess-mode-map "\M-[" 'previous-error)
(define-key inferior-ess-mode-map "\M-]" 'next-error-no-select)
(define-key inferior-ess-mode-map "\M-[" 'previous-error-no-select)

;; set R-mode as default mode for (.)Rprofile files
(push '("\\.?Rprofile$" . R-mode) auto-mode-alist)

;; set R-mode as default mode for .Rpackages files (devtools)
(push '("\\.Rpackages$" . R-mode) auto-mode-alist)

;; ;; send R code to ESS silently
;; (setq ess-eval-visibly-p nil)

;; enable autocomplete
(setq ess-use-auto-complete t)
(define-key ac-completing-map (kbd "M-h") 'ac-quick-help) ;quick help
;; ac-settings
(setq
 ac-auto-show-menu 1
 ;; ac-candidate-limit nil
 ;; ac-delay 0.1
 ;; ac-disable-faces (quote (font-lock-comment-face font-lock-doc-face))
 ;; ac-ignore-case 'smart
 ;; ac-menu-height 10
 ;; ac-quick-help-delay 1.5
 ;; ac-quick-help-prefer-pos-tip t
 ;; ac-use-quick-help nil
 )

;; Sweave buffer - set global keybinding
;; requires symlinking of sweave.sh script to /usr/bin/
(global-set-key (kbd "C-c r s")
                (lambda ()
                  (interactive)
                  (shell-command (concat "sweave " (shell-quote-argument (buffer-file-name))))))

;; add Rdired on startup
(autoload 'ess-rdired "ess-rdired"
  "View *R* objects in a dired-like buffer." t)
(define-key inferior-ess-mode-map (kbd "C-c d") 'ess-rdired)

;; show function arguments
(require 'ess-eldoc)
(add-hook 'inferior-ess-mode-hook 'ess-use-eldoc)

;; ESS style conventions
(add-hook 'ess-mode-hook
          (lambda ()
            (ess-set-style 'RRR 'quiet)))
;; disable indent-buffer for ESS
(define-key inferior-ess-mode-map (kbd "C-c o") 0)

;; shebang
(add-hook 'find-file-hook 'insert-shebang)

;; ;; bash completion (do I really need this?)
;; (require 'bash-completion)
;; (bash-completion-setup)

;; Polymode
(require 'poly-R)
(require 'poly-markdown)
;;; Markdown
(add-to-list 'auto-mode-alist '("\\.md" . poly-markdown-mode))
;;; R modes
(add-to-list 'auto-mode-alist '("\\.Snw" . poly-noweb+r-mode))
(add-to-list 'auto-mode-alist '("\\.Rnw" . poly-noweb+r-mode))
(add-to-list 'auto-mode-alist '("\\.Rmd" . poly-markdown+r-mode))

;; LaTeX
;; (load "auctex.el" nil t t)
;; (load "preview-latex.el" nil t t)
;; add associations
(push '("\\.?tex$" . latex-mode) auto-mode-alist)
(push '("\\.?latex$" . latex-mode) auto-mode-alist)
;; create PDF from TeX
(eval-after-load 'latex '(define-key LaTeX-mode-map (kbd "C-c M-p")
                           (lambda ()
                             (interactive)
                             (shell-command (concat "pdflatex "
                                                    (shell-quote-argument
                                                     (buffer-file-name)))))))

;; org-mode
(require 'org-install)
(setq org-log-done t)
(setq org-src-fontify-natively t)
(add-to-list 'auto-mode-alist '("TODO$" . org-mode)) ; associate TODO files with org-mode by default
(add-hook 'org-mode-hook
          (lambda ()
            (org-defkey org-mode-map (kbd "C-S-k") 'org-do-demote)
            (org-defkey org-mode-map (kbd "C-S-j") 'org-do-promote)
	    ;; following should be global
            (org-defkey org-mode-map (kbd "C-c l") 'org-store-key)
            (org-defkey org-mode-map (kbd "C-c a") 'org-agenda)
            (org-defkey org-mode-map (kbd "C-c b") 'org-iswitchb)
	    ;; capture
	    (org-defkey org-mode-map (kbd "C-c c") 'org-capture)
            ))
;; set default notes file
(setq org-default-notes-file "~/.notes.org")

;; markdown
(add-to-list 'auto-mode-alist '("\\.md$" . markdown-mode))

;; pandoc
(load "pandoc-mode")
(add-hook 'markdown-mode-hook 'turn-on-pandoc)
(add-hook 'pandoc-mode-hook 'pandoc-load-default-settings)
(add-to-list 'auto-mode-alist '("\\.pandoc$" . pandoc-mode))

;; yaml
(require 'yaml-mode)
(add-to-list 'auto-mode-alist '("\\.yml$" . yaml-mode))

;; lua
(autoload 'lua-mode "lua-mode" "Lua editing mode." t)
(add-to-list 'auto-mode-alist '("\\.lua$" . lua-mode))
(add-to-list 'interpreter-mode-alist '("lua" . lua-mode))

;; flyspell
(global-set-key (kbd "C-,") 'flyspell-goto-next-error)
(global-set-key (kbd "C-<f8>") 'flyspell-buffer)
(setq-default ispell-program-name "aspell")

;; apache
(require 'apache-mode)

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

;; ack
(global-set-key (kbd "C-c k") 'ack)


;;;;;;;;;;;;;;;;;
;; webdev area ;;
;;;;;;;;;;;;;;;;;

;; JavaScript

;; js2-mode
(require 'js2-mode)
(add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))

;; enable tern mode
;; (be sure to put tern executable in PATH)
(autoload 'tern-mode "tern.el" nil t)
(add-hook 'js2-mode-hook (lambda () (tern-mode t)))
;; to use tern with auto-complete-mode
(eval-after-load 'tern
  '(progn
     (require 'tern-auto-complete)
     (tern-ac-setup)))

;; node.js
(require 'nodejs-repl)

;; JSON
(add-to-list 'auto-mode-alist '("\\.json$" . json-mode))
(add-to-list 'auto-mode-alist '(".tern-project$" . json-mode))
;; add flymake linter for JSON files
(require 'flymake-json)
(add-hook 'json-mode-hook 'flymake-json-load)

;; ;; enable autocompletion with ac-js2
;; (add-hook 'js2-mode-hook 'ac-js2-mode)

;; (setq ac-js2-evaluate-calls t)		;evaluation completions
;; ;; (add-to-list 'ac-js2-external-libraries "path/to/lib/library.js") ;add external library

;; ;; make js2-mode play nice with yasnippet
;; ;; Q: what is this for?
;; (eval-after-load 'js2-mode
;;   '(progn
;;      (define-key js2-mode-map (kbd "TAB") (lambda()
;;                                             (interactive)
;;                                             (let ((yas/fallback-behavior 'return-nil))
;;                                               (unless (yas/expand)
;;                                                 (indent-for-tab-command)
;;                                                 (if (looking-back "^\s*")
;;                                                     (back-to-indentation))))))))

;; ;; js2-mode keybindings
;; (add-hook 'js2-mode-hook '(lambda ()
;; 			    (local-set-key (kbd "C-c C-e") 'js-send-last-sexp)
;; 			    (local-set-key (kbd "C-M-x") 'js-send-last-sexp-and-go)
;; 			    (local-set-key (kbd "C-c b") 'js-send-buffer)
;; 			    (local-set-key (kbd "C-c C-b") 'js-send-buffer-and-go)
;; 			    (local-set-key (kbd "C-c l") 'js-load-file-and-go)
;; 			    (local-set-key (kbd "C-c C-r") 'js-send-region)
;; 			    (local-set-key (kbd "C-c r") 'js-send-region-and-go)
;; 			    ))

;; JSDoc
(require 'js-doc)
;; general info
(setq js-doc-mail-address "aca.blagotic@gmail.com"
      js-doc-author (format "Aleksandar Blagotić <%s>" js-doc-mail-address)
      js-doc-url "https://github.com/aL3xa/"
      js-doc-license "license name")
;; set keybindings
(add-hook 'js2-mode-hook
          #'(lambda ()
              (define-key js2-mode-map "\C-ci" 'js-doc-insert-function-doc)
              (define-key js2-mode-map "@" 'js-doc-insert-tag)))

;; PHP
;; (require 'inf-php)
;; Boris REPL
(require 'php-boris)
(add-hook 'php-mode-hook 'php-boris-minor-mode)

;; Ruby

;; ruby-mode
(require 'ruby-mode)
(require 'ruby-hash-syntax)
(require 'rhtml-mode)

(push '("\\.irbrc$" . ruby-mode) auto-mode-alist)
(push '("Gemfile" . ruby-mode) auto-mode-alist)
(add-hook 'ruby-mode-hook 'robe-mode)
(push 'ac-source-robe ac-sources)

;; rinari-launch
(add-hook 'rhtml-mode-hook
	  (lambda (rinari-launch)))

;; add more tweaks to hash indentation
(defadvice ruby-indent-line (after line-up-args activate)
  (let (indent prev-indent arg-indent)
    (save-excursion
      (back-to-indentation)
      (when (zerop (car (syntax-ppss)))
        (setq indent (current-column))
        (skip-chars-backward " \t\n")
        (when (eq ?, (char-before))
          (ruby-backward-sexp)
          (back-to-indentation)
          (setq prev-indent (current-column))
          (skip-syntax-forward "w_.")
          (skip-chars-forward " ")
          (setq arg-indent (current-column)))))
    (when prev-indent
      (let ((offset (- (current-column) indent)))
        (cond ((< indent prev-indent)
               (indent-line-to prev-indent))
              ((= indent prev-indent)
               (indent-line-to arg-indent)))
        (when (> offset 0) (forward-char offset))))))
(add-to-list 'auto-mode-alist '("\\.rb$" . ruby-mode)) ; open .rb files
(add-to-list 'interpreter-mode-alist '("ruby" . ruby-mode))


;; ;; inf-ruby mode
;; (autoload 'run-ruby "inf-ruby"
;;   "Run an inferior Ruby process")
;; (autoload 'inf-ruby-keys "inf-ruby"
;;   "Set local key defs for inf-ruby in ruby-mode")
;; (add-hook 'ruby-mode-hook
;;           '(lambda ()
;;              (inf-ruby-keys)
;;              ))

;; RVM
(require 'rvm)

;; rinari - emacs mode for rails development
(require 'rinari)
(global-rinari-mode)
(setq rinari-tags-file-name "TAGS")     ;update tags
;; fix cyrillic symbols issue
(add-hook 'ruby-mode-hook
          (lambda ()
            (defadvice ruby-mode-set-encoding
              (around ruby-mode-set-encoding-disable activate) nil)))

;; new -> old hash
(define-key ruby-mode-map (kbd "C-c h") 'ruby-toggle-hash-syntax)

;; Cucumber (for .feature files)
(require 'feature-mode)
(add-to-list 'auto-mode-alist '("\.feature$" . feature-mode))


;; ;; Rsense
;; (require 'rsense)
;; ;; Rsense + Autocomplete
;; (add-hook 'ruby-mode-hook
;;           (lambda ()
;;             (add-to-list 'ac-sources 'ac-source-rsense-method)
;;             (add-to-list 'ac-sources 'ac-source-rsense-constant)))

;; Sass
(require 'scss-mode)
(add-to-list 'auto-mode-alist '("\\.scss\\'" . scss-mode))
;; enable rainbow-mode in css/scss
(add-hook 'css-mode-hook 'rainbow-mode)

;; ;; zencoding
;; (require 'zencoding-mode)
;; (add-hook 'sgml-mode-hook 'zencoding-mode) ;; Auto-start on any markup modes
;; (define-key zencoding-mode-keymap (kbd "C-c i") 'zencoding-expand-line)
;; (define-key zencoding-mode-keymap (kbd "C-j") nil) ;ah, the joy!

;; emmet
(require 'emmet-mode)
(add-hook 'sgml-mode-hook 'emmet-mode)
(add-hook 'html-mode-hook 'emmet-mode)
(add-hook 'css-mode-hook  'emmet-mode)
(define-key emmet-mode-keymap (kbd "C-c i") 'emmet-expand-line)
(define-key emmet-mode-keymap (kbd "C-j") nil) ;ah, the joy!

;; ;; multi-web-mode
;; ;; (not as good as web-mode, but worth keeping eye on it)
;; (require 'multi-web-mode)
;; (setq mweb-default-major-mode 'html-mode)
;; (setq mweb-tags '((php-mode "<\\?php\\|<\\? \\|<\\?=" "\\?>")
;; 		  (js-mode "<script +\\(type=\"text/javascript\"\\|language=\"javascript\"\\)[^>]*>" "</script>")
;; 		  (css-mode "<style +type=\"text/css\"[^>]*>" "</style>")))
;; (setq mweb-filename-extensions '("php" "htm" "html" "ctp" "phtml" "php4" "php5"))
;; (multi-web-global-mode 1)

;; web-mode
(require 'web-mode)
;; associate modes
(add-to-list 'auto-mode-alist '("\\.phtml\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.tpl\\.php\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.jsp\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.as[cp]x\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.mustache\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.djhtml\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.handlebars?\\'" . web-mode))
(add-to-list 'auto-mode-alist '("\\.ejs?\\'" . web-mode))
;; add hooks
(defun web-mode-hook ()
  "Hooks for Web mode."
  ;; default indents
  (setq web-mode-markup-indent-offset 2)
  (setq web-mode-css-indent-offset 2)
  (setq web-mode-code-indent-offset 2)
  ;; left padding
  (setq web-mode-style-padding 1)
  (setq web-mode-script-padding 1)
  (setq web-mode-block-padding 0)
  ;; auto-pair
  (setq web-mode-extra-auto-pairs
	'(("erb" . (("open" "close")))
	  ("php" . (("open" "close") ("open" "close")))
	  ))
  ;; add emmet
  (emmet-mode t)
  )
(add-hook 'web-mode-hook 'web-mode-hook)

;; insert popular JS libraries <script> tag
;; TODO: add a keybinding
(require 'html-script-src)


;; CSV mode
(add-to-list 'auto-mode-alist '("\\.[Cc][Ss][Vv]\\'" . csv-mode))
(autoload 'csv-mode "csv-mode"
  "Major mode for editing comma-separated value files." t)


;;;;;;;;;;;;;;
;; projects ;;
;;;;;;;;;;;;;;

;; Rapporter
(defun rapporter ()
  (interactive)
  (find-file "~/projects/rails/rapporter/")
  (rvm-use "ruby-1.9.3-p194" "rapporter")
  ;; (rinari-console)
  )

;; Lampice AKA "Home monitoring"
(defun lampice ()
  (interactive)
  (find-file "~/projects/rails/lampice/")
  (rvm-use "ruby-2.0.0-p247" "lampice")
  )

(defun smart-environment ()
  (interactive)
  (find-file "~/projects/rails/smart-environment/")
  (rvm-use "ruby-2.0.0-p247" "smart-environment")
  )

;;;;;;;;;;;;;;;;;;
;; Testing area ;;
;;;;;;;;;;;;;;;;;;

;; ;; polymode
;; (setq load-path
;;       (append '("/home/al3xa/packages/emacs/polymode" "/home/al3xa/packages/emacs/polymode/modes")
;;               load-path))

;; (require 'poly-R)
;; (require 'poly-markdown)
;; (require 'poly-noweb)

;; ======================================================================

;;;;;;;;;;;;;;;;;;;;;;
;; Themes and stuff ;;
;;;;;;;;;;;;;;;;;;;;;;

;; ;; solarized theme
;; (require 'solarized-dark-theme)
;; have this set via color-theme-sanityinc-solarized package
;; as one day it stoped working in emacsclient window
(load-theme 'solarized-dark)

;; Set default font explicitly, as Emacs can't dig this on its own!!! O_o
;; Inconsolata (my fav, lacks support for cyrillic, better for laptop)
(set-default-font "Inconsolata-12")	;for laptop
;; (set-default-font "Inconsolata-13")	;for desktop
;; ;; DejaVu Sans Mono (my #2 pick, better for desktop)
;; (set-default-font "DejaVu Sans Mono-10")	;for laptop
;; (set-default-font "DejaVu Sans Mono-11")	;for desktop
;; (set-face-attribute 'default nil :height 105)

;; stop timer (and show loading time message)
;; this doesn't work with the newest emacs
;; (message ">>> Hey, hey, I loaded .emacs in %ds <<<" (destructuring-bind (hi lo ms) (current-time)
;; 						      (- (+ hi lo) (+ (first *emacs-load-start*) (second *emacs-load-start*)))))