# 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.

![](images/1.4.liteide.png?raw=true)

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

	![](images/1.4.sublime1.png?raw=true)

	Figura 1.5 Auto-complete inteligente no Sublime

- Formatação automática
- Gerenciamento de Projetos

	![](images/1.4.sublime2.png?raw=true)

	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".

	![](images/1.4.sublime3.png?raw=true)

	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").

	![](images/1.4.sublime4.png?raw=true)

	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.

![](images/1.4.vim.png?raw=true)

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.

![](images/1.4.emacs.png?raw=true)

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.

![](images/1.4.eclipse1.png?raw=true)

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

	![](images/1.4.eclipse2.png?raw=true)

	Figure 1.12 Configuração Go no Eclipse

	(2).Configure o gocode(opcional), usando o diretório onde você o instalou (gocode.exe)

	![](images/1.4.eclipse3.png?raw=true)

	Figure 1.13 Configuração do gocode

	(3).Configure o gdb(opcional),  usando o diretório onde você o instalou (gdb.exe).

	![](images/1.4.eclipse4.png?raw=true)

	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.

	![](images/1.4.eclipse5.png?raw=true)

	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)

	![](images/1.4.eclipse6.png?raw=true)

	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

	![](images/1.4.idea1.png?raw=true)

2. Instale o Go plugin. Selecione `File - Setting - Plugins`, e então clique em `Browser repo`.

	![](images/1.4.idea3.png?raw=true)

3. Procure por `golang`, duplo-clique em `download and install` e aguarde a finalização do download.

	![](images/1.4.idea4.png?raw=true)

	Clique em `Apply` e reinicie o IDE.
4. Agora você está apto para criar um projeto Go.

	![](images/1.4.idea5.png?raw=true)

	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)