401 lines
16 KiB
Markdown
401 lines
16 KiB
Markdown
# Ferramentas para desenvolvimento Go
|
|
|
|
Nesta seção, vamos mostrar alguns IDEs (Integrated Development Environment ou Ambiente de Desenvolvimento Integrado) que podem ajudar você a ser um programador Go mais eficiente, com recursos como auto-complete inteligente e auto-formatação. Todas elas são compatíveis com todos os sitemas operacionais (cross-platform), então os passos descritos abaixo devem ser semelhantes independentemente do sistema que esteja utilizando.
|
|
|
|
## LiteIDE
|
|
|
|
LiteIDE é um IDE leve e de código aberto para desenvolvimento exclusivo de projetos Go. Foi desenvolvido por visualfc.
|
|
|
|
|
|
|
|
Figure 1.4 Painel principal do LiteIDE
|
|
|
|
Recursos do LiteIDE.
|
|
|
|
- Cross-platform
|
|
- Windows
|
|
- Linux
|
|
- Mac OS
|
|
- Cross-compile
|
|
- Gerenciamento de múltiplos ambientes de compilação
|
|
- Suporte a compilação cruzada (cross-compilation) da linguagem Go
|
|
- Gerenciamento do projeto
|
|
- Visão da documentação baseada na variável $GOPATH
|
|
- Sistema de compilação baseado na variável $GOPATH
|
|
- Indíce da documentação da API baseado na variável $GOPATH (N. do T.: Necessita de adaptações para o português)
|
|
- Editor de código fonte Go
|
|
- Alinhamento e identação de código
|
|
- Suporte total ao gocode
|
|
- Visualização da documentação Go e da API
|
|
- Visualização de expressões de código usando `F1`
|
|
- Movimentação entre as funções (Function declaration jump) usando `F2`
|
|
- Suporte ao Gdb (debug)
|
|
- Auto-formatação com `gofmt`
|
|
- Outros
|
|
- Multi-linguagem
|
|
- Sistema de plugins
|
|
- Temas para o editor de textos
|
|
- Suporte a sintaxe baseado no Kate
|
|
- Auto-complete inteligente baseado no texto completo
|
|
- Atalhos customizados
|
|
- Suporte a Markdown
|
|
- Preview em tempo real
|
|
- CSS customizado
|
|
- Exportação para PDF e HTML
|
|
- Conversão para PDF e HTML
|
|
|
|
### Instalação do LiteIDE
|
|
|
|
- Instale o LiteIDE
|
|
- [Página de Download](http://code.google.com/p/golangide)
|
|
- [Código Fonte](https://github.com/visualfc/liteide)
|
|
|
|
Você precisa instalar Go primeiro (conforme a seção [1.1](01.1.md)), depois faça o download da versão do LiteIDE mais apropriada para o seu sistema. Apenas descompacte e use diretamente.
|
|
|
|
- Instale o gocode
|
|
|
|
Você precisa instalar o gocode para poder usar o auto-complete inteligente.
|
|
|
|
go get -u github.com/nsf/gocode
|
|
|
|
- Ambiente de compilação
|
|
|
|
Troque a configuração no LiteIDE para configurá-lo corretamente para o seu sistema operacional.
|
|
Por exemplo, no Windows e usando a versão 64-bit da linguagem Go, você deve escolher win64 como ambiente de configuração na barra de ferramentas. Escolha `opinion`, encontre `LiteEnv` e na lista esquerda, abro o arquivo `win64.env`. Ele deve ser parecido como modelo a seguir.
|
|
|
|
GOROOT=c:\go
|
|
GOBIN=
|
|
GOARCH=amd64
|
|
GOOS=windows
|
|
CGO_ENABLED=1
|
|
|
|
PATH=%GOBIN%;%GOROOT%\bin;%PATH%
|
|
。。。
|
|
|
|
Substitua `GOROOT=c:\go` para o caminho de instalação configurado anteriormente, salve o arquivo. Para ter suporte completo ao `cgo` no windowns, você precisar ter instalado o MinGW64 e deve adicionar `c:\MinGW64\bin` a a sua variável de ambiente.
|
|
|
|
No Linux, usando uma versão 64-bit da linguagem Go, você deve escolher linux64 como configuração de ambiente na barra de ferramentas. Em seguida, escolha `opinion`, encontre `LiteEnv` no menu a esquerda e abra o arquivo `linux64.env`. Edite-o conforme segue.
|
|
|
|
GOROOT=$HOME/go
|
|
GOBIN=
|
|
GOARCH=amd64
|
|
GOOS=linux
|
|
CGO_ENABLED=1
|
|
|
|
PATH=$GOBIN:$GOROOT/bin:$PATH
|
|
。。。
|
|
|
|
Substitua `GOROOT=$HOME/go` para o caminho da sua instalação, salve o arquivo.
|
|
|
|
- $GOPATH
|
|
|
|
$GOPATH é o caminho do diretório que contém seus projetos Go. Abra a linha de comando (ou apenas use ``Ctrl+` ``no LiteIDE) e então digite `go help gopath` para maiores detalhes.
|
|
É bastante fácil visualizar e alterar a variável $GOPATH no LiteIDE. Use o menu `View - Setup GOPATH` para visualizar e alterar esses valores.
|
|
|
|
## Sublime Text
|
|
|
|
Nesse ponto, iremos introduzir o Sublime Text (ou apenas Sublime) + GoSublime + gocode + MarGo. Vamos lá.
|
|
|
|
- Auto-complete inteligente
|
|
|
|
|
|
|
|
Figura 1.5 Auto-complete inteligente no Sublime
|
|
|
|
- Formatação automática
|
|
- Gerenciamento de Projetos
|
|
|
|
|
|
|
|
Figura 1.6 Gerenciamento de Projetos no Sublime
|
|
|
|
- Destaque de sintaxe (Syntax highlight)
|
|
- A versão trial é gratuita para sempre sem nenhuma limitação nas funções. Você será lembrado em algumas ocasiões com um prompt solicitando a compra da licença, mas você pode ignorá-lo, se assim quiser. Claro, se você considerar que o editor melhora sua produtividade e você gostar realmente do produto, considere adquirir uma licença e ajudar a manter o desenvolvimento do mesmo!
|
|
|
|
Primeiro, faça o download da versão apropriada do [Sublime](http://www.sublimetext.com/) para o seu sistema operacional.
|
|
|
|
1. Pressione ``Ctrl+` ``, abra a linha de comando e insera o seguintes comandos:
|
|
|
|
import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Please restart Sublime Text to finish installation'
|
|
|
|
Reinicie o Sublime Text para finalizar a instalação. Ao reabri-lo, você deverá encontrar uma opção `Package Control` no menu "Preferences".
|
|
|
|
|
|
|
|
Figura 1.7 Sublime Package Control
|
|
|
|
2. Para instalar o GoSublime, SidebarEnhancements e Go Build, pressione `Ctrl+Shift+p` para abrir o Package Control e então digite `pcip` (um atalho para "Package Control: Install Package").
|
|
|
|
|
|
|
|
Figure 1.8 Instalando pacotes no Sublime
|
|
|
|
Busque por "GoSublime", pressione OK para instalar o pacote e repita o mesmo procedimento para instalar os pacotes SidebarEnhancements e Go Build. Mais uma vez, reinicie o editor para completar a instalação.
|
|
|
|
3. Para verificar se a instalação foi bem sucedida, abra o arquivo `main.go` no Sublime e veja se ele está destacando a sintaxe corretamente. Digite `import` e confira se aparece um prompt com sugestões de auto-complete. Inclua `import "fmt"` e em seguida insira `fmt.` em qualquer lugar depois da declaração de `import` para verificar se a função de auto-complete inteligente está corretamente ativada.
|
|
|
|
Se funcionar corretamente, está tudo pronto.
|
|
|
|
Se não funcionar, verifique seu $PATH novamente. Abra um terminal e digite `gocode`. Se mesmo isto não funcionar, possivelmente seu $PATH não está corretamente configurado.
|
|
|
|
## Vim
|
|
|
|
Vim é um popular editor de textos para programadores que evolui de seu predecessor mais simples, chamado Vi. Ele possui funções para auto-complete inteligente, compilação e também funções para iterar sobre os erros.
|
|
|
|
|
|
|
|
Figure 1.8 Auto-complete inteligente para Go no Vim
|
|
|
|
1. Primeiramente, copie as configurações padrão para o seu diretório de configuração do Vim
|
|
|
|
cp -r $GOROOT/misc/vim/* ~/.vim/
|
|
|
|
2. Ative o destaque de sintaxe (syntax highlighting)
|
|
|
|
filetype plugin indent on
|
|
syntax on
|
|
|
|
3. Instale o [gocode](https://github.com/nsf/gocode/)
|
|
|
|
go get -u github.com/nsf/gocode
|
|
|
|
O gocode será instalado em `$GOBIN` por padrão
|
|
|
|
4. Configure o [gocode](https://github.com/nsf/gocode/) digitando os comandos abaixo
|
|
|
|
~ cd $GOPATH/src/github.com/nsf/gocode/vim
|
|
~ ./update.bash
|
|
~ gocode set propose-builtins true
|
|
propose-builtins true
|
|
~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
|
|
lib-path "/home/border/gocode/pkg/linux_amd64"
|
|
~ gocode set
|
|
propose-builtins true
|
|
lib-path "/home/border/gocode/pkg/linux_amd64"
|
|
|
|
Explicações sobre a configuração do gocode:
|
|
|
|
propose-builtins: determina se deve ou não ligar o auto-complete inteligente; false por padrão.
|
|
lib-path: Por padrão, o gocode apenas busca por pacotes em `$GOPATH/pkg/$GOOS_$GOARCH` e `$GOROOT/pkg/$GOOS_$GOARCH`. Esta configuração é usada para adicionar novos diretórios como fonte.
|
|
|
|
5. Parabéns! Tente digitar `:e main.go` no modo de comandos do Vim para experimentar o mundo de Go!
|
|
|
|
## Emacs
|
|
|
|
Emacs (também conhecida como Arma de Deus) não é apenas um editor, mas também um poderoso IDE.
|
|
|
|
|
|
|
|
Figure 1.10 Painel principal do Emacs para editor Go
|
|
|
|
1. Primeiramente, copie as configurações padrão para o seu diretório de configuração da Emacs
|
|
|
|
cp $GOROOT/misc/emacs/* ~/.emacs.d/
|
|
|
|
2. Instale o [gocode](https://github.com/nsf/gocode/)
|
|
|
|
go get -u github.com/nsf/gocode
|
|
|
|
O gocode será instalado em `$GOBIN` por padrão
|
|
3. Configure o [gocode](https://github.com/nsf/gocode/) digitando os comandos abaixo
|
|
|
|
~ cd $GOPATH/src/github.com/nsf/gocode/vim
|
|
~ ./update.bash
|
|
~ gocode set propose-builtins true
|
|
propose-builtins true
|
|
~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
|
|
lib-path "/home/border/gocode/pkg/linux_amd64"
|
|
~ gocode set
|
|
propose-builtins true
|
|
lib-path "/home/border/gocode/pkg/linux_amd64"
|
|
|
|
4. Instale o [Auto Completion](http://www.emacswiki.org/emacs/AutoComplete)
|
|
Faça o download, descompacte e execute
|
|
|
|
~ make install DIR=$HOME/.emacs.d/auto-complete
|
|
|
|
Configure o arquivo ~/.emacs conforme abaixo
|
|
|
|
;;auto-complete
|
|
(require 'auto-complete-config)
|
|
(add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
|
|
(ac-config-default)
|
|
(local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
|
|
(local-set-key "." 'semantic-complete-self-insert)
|
|
(local-set-key ">" 'semantic-complete-self-insert)
|
|
|
|
Veja este [link](http://www.emacswiki.org/emacs/AutoComplete) para maiores detalhes desse processo.
|
|
5. Finalize a configuração do arquivo .emacs para usar Go
|
|
|
|
;; golang mode
|
|
(require 'go-mode-load)
|
|
(require 'go-autocomplete)
|
|
;; speedbar
|
|
;; (speedbar 1)
|
|
(speedbar-add-supported-extension ".go")
|
|
(add-hook
|
|
'go-mode-hook
|
|
'(lambda ()
|
|
;; gocode
|
|
(auto-complete-mode 1)
|
|
(setq ac-sources '(ac-source-go))
|
|
;; Imenu & Speedbar
|
|
(setq imenu-generic-expression
|
|
'(("type" "^type *\\([^ \t\n\r\f]*\\)" 1)
|
|
("func" "^func *\\(.*\\) {" 1)))
|
|
(imenu-add-to-menubar "Index")
|
|
;; Outline mode
|
|
(make-local-variable 'outline-regexp)
|
|
(setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....")
|
|
(outline-minor-mode 1)
|
|
(local-set-key "\M-a" 'outline-previous-visible-heading)
|
|
(local-set-key "\M-e" 'outline-next-visible-heading)
|
|
;; Menu bar
|
|
(require 'easymenu)
|
|
(defconst go-hooked-menu
|
|
'("Go tools"
|
|
["Go run buffer" go t]
|
|
["Go reformat buffer" go-fmt-buffer t]
|
|
["Go check buffer" go-fix-buffer t]))
|
|
(easy-menu-define
|
|
go-added-menu
|
|
(current-local-map)
|
|
"Go tools"
|
|
go-hooked-menu)
|
|
|
|
;; Other
|
|
(setq show-trailing-whitespace t)
|
|
))
|
|
;; helper function
|
|
(defun go ()
|
|
"run current buffer"
|
|
(interactive)
|
|
(compile (concat "go run " (buffer-file-name))))
|
|
|
|
;; helper function
|
|
(defun go-fmt-buffer ()
|
|
"run gofmt on current buffer"
|
|
(interactive)
|
|
(if buffer-read-only
|
|
(progn
|
|
(ding)
|
|
(message "Buffer is read only"))
|
|
(let ((p (line-number-at-pos))
|
|
(filename (buffer-file-name))
|
|
(old-max-mini-window-height max-mini-window-height))
|
|
(show-all)
|
|
(if (get-buffer "*Go Reformat Errors*")
|
|
(progn
|
|
(delete-windows-on "*Go Reformat Errors*")
|
|
(kill-buffer "*Go Reformat Errors*")))
|
|
(setq max-mini-window-height 1)
|
|
(if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t))
|
|
(progn
|
|
(erase-buffer)
|
|
(insert-buffer-substring "*Go Reformat Output*")
|
|
(goto-char (point-min))
|
|
(forward-line (1- p)))
|
|
(with-current-buffer "*Go Reformat Errors*"
|
|
(progn
|
|
(goto-char (point-min))
|
|
(while (re-search-forward "<standard input>" nil t)
|
|
(replace-match filename))
|
|
(goto-char (point-min))
|
|
(compilation-mode))))
|
|
(setq max-mini-window-height old-max-mini-window-height)
|
|
(delete-windows-on "*Go Reformat Output*")
|
|
(kill-buffer "*Go Reformat Output*"))))
|
|
;; helper function
|
|
(defun go-fix-buffer ()
|
|
"run gofix on current buffer"
|
|
(interactive)
|
|
(show-all)
|
|
(shell-command-on-region (point-min) (point-max) "go tool fix -diff"))
|
|
6. Parabéns, está tudo pronto! O Speedbar está desativado por padrão, mas remova os símbolos de comentário na linha `;;(speedbar 1)` para ativar esse recurso, ou ainda use o comando `M-x speedbar` com a mesma finalidade.
|
|
|
|
## Eclipse
|
|
|
|
O Eclipse é outra excelente ferramenta de desenvolvimento. Veja como usá-la para programar em Go.
|
|
|
|
|
|
|
|
Figure 1.1 Painel principal do Eclipse para Go
|
|
|
|
1. Faça o download e instale o [Eclipse](http://www.eclipse.org/)
|
|
2. Faça o download do [goclipse](https://code.google.com/p/goclipse/) e instale seguindo as instrução nesse [link](http://code.google.com/p/goclipse/wiki/InstallationInstructions)
|
|
3. Faça o download do [gocode](https://github.com/nsf/gocode)
|
|
|
|
Se você estiver usando no Windows, você deve instalar o git para Windows para poder instalar o gocode. Uma opção bastante usada para este fim é usar o [msysgit](https://code.google.com/p/msysgit/)
|
|
|
|
Instale pela linha de comando
|
|
|
|
go get -u github.com/nsf/gocode
|
|
|
|
Ou ainda instale diretamente pelo código-fonte se preferir.
|
|
4. Faça o download e instale o [MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)
|
|
5. Configure os plugins.
|
|
|
|
Windows->Preferences->Go
|
|
|
|
(1).Configure o compilador Go
|
|
|
|
|
|
|
|
Figure 1.12 Configuração Go no Eclipse
|
|
|
|
(2).Configure o gocode(opcional), usando o diretório onde você o instalou (gocode.exe)
|
|
|
|
|
|
|
|
Figure 1.13 Configuração do gocode
|
|
|
|
(3).Configure o gdb(opcional), usando o diretório onde você o instalou (gdb.exe).
|
|
|
|
|
|
|
|
Figure 1.14 Configuração do gdb
|
|
6. Verifique a instalação
|
|
|
|
Crie um novo projeto Go e um novo arquivo hello.go conforme segue.
|
|
|
|
|
|
|
|
Figure 1.15 Criar novo projeto e arquivo hello.go
|
|
|
|
Teste a instalação conforme abaixo.(você precisará digitar um comando no console do Eclipse)
|
|
|
|
|
|
|
|
Figure 1.16 Teste de um programa Go no Eclipse
|
|
|
|
## IntelliJ IDEA
|
|
|
|
As pessoas que trabalham com Java tem familiaridade com este IDE. Ela também suporta a sintaxe para linguagem Go e auto-complete inteligente através de um plugin.
|
|
|
|
1. Faça o download da IDEA, não há diferença entre as versões Ultimate e Community para uso com Go
|
|
|
|
|
|
|
|
2. Instale o Go plugin. Selecione `File - Setting - Plugins`, e então clique em `Browser repo`.
|
|
|
|
|
|
|
|
3. Procure por `golang`, duplo-clique em `download and install` e aguarde a finalização do download.
|
|
|
|
|
|
|
|
Clique em `Apply` e reinicie o IDE.
|
|
4. Agora você está apto para criar um projeto Go.
|
|
|
|
|
|
|
|
Se for solicitado o caminho para o seu sdk Go em alguma etapa, apenas insira o caminho para seu $GOROOT.
|
|
|
|
( ***Veja este [post](http://wuwen.org/tips-about-using-intellij-idea-and-go/) para um passo-a-passo de configuração e uso da IntelliJ IDEA com a linguagem Go*** )
|
|
|
|
## Links
|
|
|
|
- [Sumário](preface.md)
|
|
- Seção anterior: [Comandos Go](01.3.md)
|
|
- Próxima seção: [Resumo](01.5.md)
|