Programando em Python no Emacs

  |   Código

Esse tutorial tem por objetivo mostrar como podemos ser produtivos programando em Python no Emacs. Além disso, o tutorial vai mostrar um pouco do meu ambiente de desenvolvimento e para quem tiver curiosidade, eu vou deixar alguns links no final para quem quiser se aprofundar no assunto.

Para começar escolha a versão de Emacs que mais se adeque ao seu gosto e ao seu sistema operacional, tem até versão para Windows e depois de tê-lo instalado, faça o tutorial para começar a se acostumar com os conceitos fundamentais do Emacs.

Configurando o Emacs para uso geral

Se você estiver usando Emacs no Linux, e eu realmente espero que esteja, na instalação foi criada uma pasta oculta dentro da pasta do seu usuário de nome .emacs.d. Para facilitar a configuração, crie dentro dessa pasta uma outra pasta de nome plugins.

Toda a nossa configuração ficará colocada dentro do seguinte arquivo: /home/<nome_usuario>/.emacs.d/init.el. Como já devem ter lido por aí, a grande vantagem de uso do Emacs é a customização, é como brincar de lego para montar a sua IDE personalizada. Toda a configuração do Emacs é feita em LISP, mas não se preocupe, você não precisa conhecer LISP a fundo para entender esse tutorial, a maior parte dos comandos é bem fácil de entender. Abra esse arquivo no próprio Emacs ou em outro editor de texto de sua preferência. Todos os trechos de código expostos nesse post devem ser colocados dentro desse arquivo de configuração.

Passo 1

Coloque essas linhas abaixo no início do arquivo de configuração.

:::common-lisp
(add-to-list 'load-path "~/.emacs.d")
(add-to-list 'load-path "~/.emacs.d/plugins")

Essas linhas acima carregam as pastas onde serão procurados os arquivos com extensão .el, que são os arquivos que representam extensões e plugins que usaremos durante esse tutorial.

Passo 2

Agora, vamos baixar o primeiro plugin da nossa configuração, é o ido-mode. Baixe esse arquivo e coloque na pasta ~/.emacs.d/plugins. Depois adicione o seguinte trecho no arquivo de configuração.

:::common-lisp
(require 'ido)
(ido-mode t)

Esse plugin serve para facilitar a abertura de arquivos dentro do Emacs e também a troca entre os buffers. Como o Emacs pode ser bastante confuso para os iniciantes esse plugin é mais do que recomendado.

Passo 3
:::common-lisp
(cua-mode t)
(setq cua-auto-tabify-rectangles nil) ;; Don't tabify after rectangle commands
(transient-mark-mode 1) ;; No region when it is not highlighted
(setq cua-keep-region-after-copy t) ;; Standard Windows behaviour

(delete-selection-mode 1)

cua-mode vai servir para deixar o Emacs parecido com qualquer outra IDE comum permitindo usar as teclas de atalho Ctrl + C, Ctrl + V e assim por diante. Só é preciso ter cuidado pois esses atalhos conflitam com alguns outros do Emacs e por isso somente estão ativos quando algum texto está selecionado.

As demais linhas desse passo são opcionais, chamo a atenção para a linha do delete-selection-mode, essa linha faz com que, toda vez que um texto estiver selecionado, qualquer inserção será inserida no lugar do texto selecionado.

Passo 4

[Auto Complete Mode] melhora a funcionalidade de auto-completar do Emacs. A parada é realmente inteligente. Para instalar:

:::bash
$ cd ~/.emacs.d/plugins/
$ curl http://cx4a.org/pub/auto-complete/auto-complete-1.3.1.tar.bz2 | tar jx
$ cd auto-complete-1.3.1
$ make byte-compile

Para configurar:

:::common-lisp
(add-to-list 'load-path "~/.emacs.d/plugins/auto-complete-1.3.1/")
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/plugins/auto-complete-1.3.1/ac-dict")
(ac-config-default)
Passo 5

Instale o YASnippet. Esse cara cria um menu no Emacs onde podemos usar um sistema de templates semelhante ao TextMate.

Passo 6
:::common-lisp
(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)

O último passo dessa customização geral é o uso do uniquify, esse modo é extremamente útil quando começamos a trabalhar com vários arquivos abertos e que alguns tenham nomes iguais.

Configurando o Emacs para programar com Python

Antes de entrar no passo-a-passo de como configurar o Emacs para Python é importante avisar algo. Para não deixar a instalação original de Python no meu Ubuntu ficar poluída com todas as bibliotecas que eu quero instalar, eu instalo uma ferramenta conhecida como virtualenv, e para instalação de pacotes do Python, eu uso uma ferramenta chamada pip. Basicamente, virtualenv é uma ferramenta para criar ambientes isolados de Python, e pip é simplesmente o melhor gerenciador de pacotes Python que eu conheço.

Para essa configuração eu criei um ambiente de Python isolado com virtualenv apenas para servir ao Emacs. Sugiro que, se estiver seguindo esse tutorial, você faça o mesmo. Vamos continuar com o passo-a-passo.

Passo 1
:::common-lisp
(setq-default indent-tabs-mode nil)  ; use only spaces and no tabs
(setq default-tab-width 4)

Python usa indentação para definição de blocos de código, assim é extremamente importante que usemos essas linhas código para definir o tamanho da indentação e também definir que sempre serão usados espaços ao invés de tabs.

Passo 2

Agora vamos instalar um pacote essencial para uso de Python no Emacs, o nome desse pacote é Pymacs. Se estiver usando Linux, vá até o seu terminal e digite os comandos abaixo:

  • Instalação Pymacs (Parte Emacs) :::bash $ curl -L https://github.com/pinard/Pymacs/tarball/v0.24-beta2 | tar zx $ cd pinard-Pymacs-016b0bc $ make $ cp pymacs.el ~/.emacs.d/pymacs.el $ emacs -batch -eval '(byte-compile-file "~/.emacs.d/pymacs.el")'

  • Instalação Pymacs (Parte Python) :::bash $ pip install https://github.com/pinard/Pymacs/tarball/v0.24-beta2

Agora vamos ao arquivo de configuração no Emacs e incluir o seguinte trecho:

:::common-lisp
(setenv "PYMACS_PYTHON" "~/<caminho_virtualenv>/bin/python")

(autoload 'pymacs-apply "pymacs")
(autoload 'pymacs-call "pymacs")
(autoload 'pymacs-eval "pymacs" nil t)
(autoload 'pymacs-exec "pymacs" nil t)
(autoload 'pymacs-load "pymacs" nil t)

A primeira linha será necessária apenas se você estiver usando o virtualenv.

Passo 3

Nesse passo, vamos instalar o Ropemacs e o Rope. Rope é uma poderosa biblioteca de refactoring para Python, e Ropemacs obviamente um plugin do Emacs para uso do Rope.

Para instalar o Rope e Ropemacs, digite no terminal:

:::bash
$ pip install http://bitbucket.org/agr/ropemacs/get/tip.tar.gz

No arquivo de configuração do Emacs:

:::common-lisp
(require 'pymacs)

(pymacs-load "ropemacs" "rope-")
(setq ropemacs-enable-autoimport t)
Passo 4

Chegamos em uma das partes que eu mais gosto do Emacs, análise automática, on-the-fly, do código Python. O responsável por isso é o Flymake que já vem por padrão, a partir da versão 23 do Emacs. O que vamos precisar instalar aqui é o pep8 e o pyflakes que são bibliotecas para análise estática de código-fonte Python.

:::bash
$ pip install pyflakes pep8

Depois, precisamos configurar o Flymake no Emacs:

:::common-lisp
(when (load "flymake" t)
  (defun flymake-pyflakes-init ()
    (let* ((temp-file (flymake-init-create-temp-buffer-copy
                       'flymake-create-temp-inplace))
           (local-file (file-relative-name
                        temp-file
                        (file-name-directory buffer-file-name))))
      (list "/home/lslf/<caminho_virtualenv>/bin/pyflakes" (list local-file))))

  (add-to-list 'flymake-allowed-file-name-masks
               '("\\.py\\'" flymake-pyflakes-init)))

(add-hook 'find-file-hook 'flymake-find-file-hook)

(defun my-flymake-show-help ()
  (when (get-char-property (point) 'flymake-overlay)
   (let ((help (get-char-property (point) 'help-echo)))
    (if help (message "%s" help)))))

(add-hook 'post-command-hook 'my-flymake-show-help)

(delete '("\\.html?\\'" flymake-xml-init) flymake-allowed-file-name-masks)
Passo 5

O último passo desse tutorial, também se refere a análise de código, mas ao invés de análise automática, vamos configurar uma análise de código através de um comando do Emacs.

Primeiro crie um arquivo no caminho ~/.emacs.d/ chamado pychecker.sh. O conteúdo do arquivo será:

:::bash
#!/bin/bash
~/<caminho_virtualenv>/bin/pyflakes $1
echo "## pyflakes acima, pep8 abaixo ##"
~/<caminho_virtualenv>/bin/pep8 --repeat $1

Agora a configuração do Emacs:

:::common-lisp
(custom-set-variables
  '(py-pychecker-command "~/.emacs.d/pychecker.sh")
  '(py-pychecker-command-args (quote ("")))
  '(python-check-command "~/.emacs.d/pychecker.sh")
)

Dicas extras

Além de tudo o que foi colocado aí acima, você pode querer ir além e melhorar cada vez mais o seu uso do Emacs, para ficar do seu gosto, aqui vão algumas dicas:

  • O Emacs já funciona automaticamente com Subversion, basta aprender a usar;
  • Você pode configurar o Emacs para te ajudar com o Django também;
  • Coloque o seu diretório ~/.emacs.d sob controle de versão;
  • Explore a infinidade de possibilidades de customização do Emacs.

Conclusão

Eu sei que esse tutorial ficou bem longo, mas eu tentei colocar todas as principais dicas de otimização de tempo e produtividade que eu adquiri em pouco tempo usando o Emacs, como eu disse antes, é como brincar de lego para montar a sua IDE, com as funcionalidades que você precisa.

Deixe as suas impressões nos comentários, se houver algum problema, pode entrar em contato que tentarei ajudar o máximo que puder.

Referências

Ryan McGuire: Emacs as a powerful Python IDE

SaltyCrane: My Emacs Python environment

Lei Chen: Setup Perfect Python Environment In Emacs

Jesse Legg: Emacs for Python Programmers: Basics

Jesse Legg: Emacs for Python Programmers #2: Virtualenv, IPython & Daemon Mode

Brandon Rhodes: Installing Python packages for Emacs with virtualenv

Alex Clemesha: Tools of modern Python hacker: Virtualenv, Fabric and pip

Comments powered by Disqus
Share