sábado, 5 de abril de 2014

Construyendo aplicaciones web con Golang: entorno de desarrollo (parte 2)

Comandos con Go

Los comandos de Go

El lenguaje Go viene con un grupo de comandos que nos va a ayudar a manejar un grupo de herramientas que nos van a facilitar varias tareas, usted puede ejecutar la línea de comando go para verlos:

Figura 1.3 El comando Go nos muestra información detallada
Todos estos son muy útiles para nosotros, vamos a ver como utilizar algunos de ellos.

go build

Este comando es para compilar los tests, el mismo va a compilar los paquetes de los que dependan si es necesario.
  • Si el paquete no es el principal o main como mymath de la sección 1.2, no se va a generar nada después de ejecutar el comando go build. Si usted necesita empaquetar el archivo .a en $GOPATH/pkg, debe usar el comando go install.
  • Si el paquete es el principal o main, este va a generar un archivo ejecutable en la misma carpeta. Si usted busca que el archivo sea generado en $GOPATH/bin, debe usar go install o go build -o ${PATH_HERE}/a.exe.
  • Si hay muchos archivos en la carpeta, pero solo desea compilar uno de ellos, usted debe agregar el nombre del archivo después del comando go build. Por ejemplo, go build a.go. En cambio go build va a compilar todos los archivos en la carpeta.
  • También podemos especificar con que nombre de archivo queremos que salga una vez compilado. Por ejemplo, tenemos mathapp en la sección 1.2, si usamos go build -o astaxie.exe este va a generar el archivo astaxie.exe en vez de mathapp.exe. El nombre por defecto va a ser el nombre de la carpeta (no en el paquete principal) o el nombre del primer archivo de código fuente(en el paquete principal).
(De acuerdo con Las especificaciones del lenguaje Go, el nombre del paquete debe ser el nombre después de la palabra package en la primera línea del archivo de código fuente, que no necesariamente debe ser el mismo que tiene la carpeta, y el archivo ejecutable va a ser el nombre de la carpeta de forma por defecto.])
  • go build va a ignorar los archivos que comiencen con _ o ..
  • Si usted desea tener diferentes archivos de código fuente para cada sistema operativo, puede nombrarlos con el nombre del sistema como sub-fijo. Supongamos que tenemos algunos archivos de código fuente para cargar algunos arrays, ellos deberían llamarse de la siguiente manera.
    array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go
go build va a escoger el que este asociado con su sistema operativo. Por ejemplo, solo se va a compilar array_linux.go en un sistema Linux, y se van a ignorar todos los otros.

go clean

Este comando es para limpiar los archivos que se generan por los compiladores, incluidos los siguientes archivos.
_obj/            // antiguo directorio de objetos, dejado por Makefiles
_test/           // antiguo directorio de test, dejado por Makefiles
_testmain.go     // antiguo directorio de gotest, dejado por Makefiles
test.out         // antiguo directorio de test, dejado por Makefiles
build.out        // antiguo directorio de test, dejado por Makefiles
*.[568ao]        // archivo objeto, dejado por  Makefiles

DIR(.exe)        // generado por go build
DIR.test(.exe)   // generado por go test -c
MAINFILE(.exe)   // generado por go build MAINFILE.go
Yo suelo usar este comando para limpiar mis archivos antes de subir mi proyecto a Github, estos son útiles para correr los test localmente, pero inútiles para el control de versiones.

go fmt

Las personas que trabajaron o trabajan con C/C++ deben conocer que siempre hay personas argumentando sobre como debe ser el estilo de codificación de el código fuente y siempre hablan sobre el estilo de K&R y el estilo ANSI, que uno es mejor que el otro. Sin embargo en Go, hay un solo estilo en el que deberíamos estar forzado a utilizar. Por ejemplo, tienes que poner la llave izquierda al final de la línea, y no puedes ponerlo en una sola línea, ya que obtendrás un error en la compilación! Afortunadamente, no tenes que recordar todas estas reglas, ya que el comando go fmt hace este trabajo por ti, con solo ejecutar el comando go fmt <Nombre del archivo>.go en la terminal. Yo no utilizo mucho este comando porque los IDEs normalmente lo utilizan automáticamente cuando guardas el archivo fuente, voy a hablar un poco más sobre IDEs en la siguiente sección.
Nosotros normalmente usamos gofmt -w en vez de go fmt, este último no reescribe los archivos fuente después de formatear el código. El comando gofmt -w src le va a dar formato a todo el proyecto.

go get

Este comando es para obtener paquetes remotos, este soporta BitBucket, Github, Google Code, Launchpad y muchos más. Actualmente suceden dos cosas después de ejecutarlo. La primera es la descarga del código fuente, entonces luego de eso ejecuta go install. Antes de usar este comando, debe estar seguro de que tiene instaladas las siguientes herramientas.
BitBucket (Mercurial Git)
Github (git)
Google Code (Git, Mercurial, Subversion)
Launchpad (Bazaar)
Para usar este comando, tiene que instalar estas herramientas de forma correcta. No olvide de configurar el PATH. Por cierto, también es compatible con los nombres de dominio personalizados, utilizando el comando go help remote(go help get) vamos a poder ver más detalles de como utilizarla.

go install

Este comando compila todos los paquetes y genera los archivo que luego son movidos hacia $GOPATH/pkg o $GOPATH/bin.

go test

Este comando carga todos los archivos cuyo nombre incluya *_test.go y genera los archivos de test, luego nos muestra información como la siguiente.
ok   archive/tar   0.011s
FAIL archive/zip   0.022s
ok   compress/gzip 0.033s
...
Esto testea todos los archivos de test de forma predeterminada, utilizando el comando go help testflag vamos a poder ver más detalles.

go doc

Muchas personas dicen que no necesitamos ninguna documentación de terceros para poder programar en Go(De hecho ya eh armado una CHM), Go tiene una poderosa herramienta para manejar la documentación por si mismo.
Entonces, como buscamos información de distintos paquetes en la documentación? Si uno busca obtener más detalles sobre la documentación del paquete builtin, debemos usar el comando godoc builtin, y usar el comando godoc net/http para el paquete http. Si lo que buscamos es más detalles sobre una función específica, debemos usar el comando godoc fmt Printf, y godoc -src fmt Printf para poder ver el código fuente.
Además ejecutando el comando godoc -http=:8080, y luego abriendo nuestro navegador en la dirección 127.0.0.1:8080, debería poder ver el sitio golang.org. Esto no solamente nos va a mostrar información de los paquetes estándar, si no que también vamos a poder ver los paquetes de nuestro $GOPATH/pkg. Por ejemplo esto es genial para personas que sufren por el gran corta-fuegos de China.

Otros comandos

Go nos provee más comando de los que acabamos de hablar.
go fix // nos sirve para actualizar nuestro código de versiones 
//anteriores a go1 hacia la nueva posterior a go1
go version // nos da información de nuestra versión de Go 
  go env // nos muestra las variables de entorno de Go
go list // nos lista todos los paquetes instalados
  go run // compila archivos temporales y ejecuta la aplicación
También podemos encontrar más información de los comandos ejecutando lo siguiente go help <comando>.

Herramientas de desarrollo para Go

En esta sección, les voy a mostrar algunos IDEs que tienen la habilidad de completar y dar formato de manera inteligente. Ellos son multiplataforma, por esto algunos de los pasos que vamos a mostrar no deberían ser muy diferentes si no estas utilizando el mismo sistema operativo.

LiteIDE

LiteIDE es un IDE de código abierto, liviano para el desarrollo unicamente de proyectos creados con Go, desarrollado por visualfc.

Imagen 1.4 Panel principal de LiteIDE
Características de LiteIDE.
  • Multiplataforma
    • Windows
    • Linux
    • Mac OS
  • Compilación cruzada
    • Maneja un entorno para la compilación múltiple
    • Soporta la compilación cruzada de Go
  • Manejo de proyectos estándar
    • Vista de la documentación basado en el $GOPATH
    • Sistema de compilación basado en el $GOPATH
    • Documentación de la API ordenada por índice basada en el $GOPATH
  • Editor de código fuente en Go
    • Esquematización de código
    • Soporte completo para gocode
    • Vista de la documentación de Go e índice de la API
    • Vista del código por medio de F1
    • Salto entre declaración de funciones con F2
    • Soporte para Gdb
    • Auto-formato con gofmt
  • Otros
    • Multi-lenguage
    • Sistema de plugin
    • Temas para el editor de texto
    • Soporte para la sintaxis basado en Kate
    • Completado inteligente basado en full-text
    • Configuración de atajos
    • Soporte para formato
      • Vista previa en tiempo real
      • Configuración por CSS
      • Exportar en HTML y PDF
      • Convertir y unir en HTML y PDF

LiteIDE instalación

  • Instalar LiteIDE
    Va a necesitar instalar antes Go, entonces descargue la versión para su sistema operativo. Descomprima el archivo para poder usarlo directamente.
  • Instalar gocode
    Debe instalar gocode para poder utilizar el auto-completado inteligente
    go get -u github.com/nsf/gocode
    
  • Entorno para la compilación
    Cambie la configuración en LiteIDE para ajustar su sistema operativo. En Windows y la versión de 64-bit para Go, usted debería elegir su entorno win64 en la barra de configuración para el entorno. Entonces elija opinion, busque LiteEnv en la lista de la izquierda, abra el archivo win64.env en la lista derecha.
    GOROOT=c:\go
    GOBIN=
    GOARCH=amd64
    GOOS=windows
    CGO_ENABLED=1
    
    PATH=%GOBIN%;%GOROOT%\bin;%PATH%
    。。。
    
    Reemplace GOROOT=c:\go por el PATH de su instalación de Go y guardela. Si tiene MinGW64, agregue c:\MinGW64\bin en el PATH de su variable de entorno para soportar cgo.
    En Linux y versiones de 64-bit para Go, debería elegir linux64 en la opción de configuración de la barra de herramienta. Entonces elija opinion, busque LiteEnv en la lista izquierda, abra el archivo linux64.env en la lista derecha.
    GOROOT=$HOME/go
    GOBIN=
    GOARCH=amd64
    GOOS=linux
    CGO_ENABLED=1
    
    PATH=$GOBIN:$GOROOT/bin:$PATH   
    。。。
    
    Reemplace GOROOT=$HOME/go por el PATH de su instalación de GO y guárdelo.
  • $GOPATH $GOPATH es la ruta que contiene la lista de proyectos, abra la herramienta de comandos (o presione Ctrl+ en LiteIDE) entonces tipee go help gopath para más detalles. Es muy sencillo para ver y modificar el $GOPATH en el LiteIDE. Vaya a View - Setup GOPATH para ver y modificar este valor.

Sublime Text

Aquí los voy a introducir a ver Sublime Text 2 (solo Sublime para abreviar) + GoSublime + gocode + MarGo. Déjeme explicarles porque.
  • Auto-completado inteligente

    Imagen 1.5 Completado inteligente en Sublime
  • Auto-formateado de los archivos fuentes
  • Manejo del proyecto

    Imagen 1.6 Manejo del proyecto en Sublime
  • Resaltado de sintaxis
  • Versión gratuita de pruebas por siempre, sin funcionalidades limitadas. Aunque les va a mostrar un pop-up cada cierto tiempo recordándonos de que no nos hemos registrado, pero usted solo puede ignorarlo.
Primero, descargue la versión de Sublime y elija la versión para su sistema operativo.
  1. Presione Ctrl+ ` para abrir la herramienta de comandos, eh ingrese el siguiente comando.
    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 cuando termine la instalación. Entonces va a poder encontrar la opción de Package Control como un ítem en el menú de preferencias.

    Imagen 1.7 Control de paquete en Sublime
  2. Para instalar GoSublime, SidebarEnhancements y Go Build, presione Ctrl+Shift+p para abrir la herramienta Package Control, entonces tipee pcip (abreviación para "Package Control: Install Package").

    Imagen 1.8 Instalación de paquetes en Sublime
    Ahora va a poder tipear GoSublime, presione OK para instalar, siga los mismos pasos para instalar SidebarEnhancements y Go Build. Reinicie cuando termine la instalación.
  3. Para verificar que se instalo todo correctamente, abra Sublime, entonces abra el archivo main.go para ver si tiene el resaltado de sintaxis, tipee import para ver la ayuda import "fmt", luego tipee fmt. Para ver si tiene las funciones de completado inteligente.
    Si todo esta bien, entonces ya esta todo configurado.
    Si no, verifique su $PATH nuevamente. Abra una terminal, tipee gocode, si no puede ejecutarlo, su $PATH no debe estar configurado correctamente.

Vim

Vim es un popular editor de texto para programadores, que fue desarrollado a partir del editor vi. Tiene funciones para el completado inteligente, compilación y resaltado de errores.

Imagen 1.8 Completado inteligente de Vim para Go
  1. Resaltado de sintaxis para Go
    cp -r $GOROOT/misc/vim/* ~/.vim/
    
  2. Configuración del resaltado de sintaxis
    filetype plugin indent on
    syntax on
    
  3. Instalar gocode
    go get -u github.com/nsf/gocode
    
    gocode va a ser instalado en $GOBIN por defecto
  4. Configuración de gocode
    ~ 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"
    
    Explicación de la configuración de gocode.
    propose-builtins: Completado inteligente o no, false es el valor por defecto.
    lib-path: gocode solo busca los paquetes en $GOPATH/pkg/$GOOS_$GOARCH y $GOROOT/pkg/$GOOS_$GOARCH, en esta configuración se pueden agregar otras rutas adicionales.
  5. Felicitaciones! Pruebe ejecutar :e main.go para experimentar el mundo de Go!

Emacs

Emacs llamado muchas veces el armar de Dios. Este no es solo un editor, también puede ser un IDE muy poderoso.

Imagen 1.10 Panel principal del editor de Emacs para Go
  1. Resaltado de sintaxis
    cp $GOROOT/misc/emacs/* ~/.emacs.d/
    
  2. Instalar gocode
    go get -u github.com/nsf/gocode
    
    gocode va a ser instalado por defecto en $GOBIN
  3. Configurar gocode
    ~ 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. Instalar Auto Completado Descargue y descomprima
    ~ make install DIR=$HOME/.emacs.d/auto-complete
    
    Configure el archivo ~/.emacs
    ;;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)  
    
    Siga el siguiente link para más detalles.
  5. Configure el archivo .emacs
    ;; 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. Felicitaciones! speedbar esta cerrado por defecto, quite los símbolos de comentarios en la linea ;;(speedbar 1) para tener esta característica, o puede realizarlo a través del comando M-x speedbar.

Eclipse

Eclipse es otra gran herramienta de desarrollo, le voy a mostrar como utilizarla para escribir programas en Go.

Imagen 1.1 Panel principal del editor de Eclipse para Go
  1. Descargue e instale Eclipse
  2. Descargue goclipse http://code.google.com/p/goclipse/wiki/InstallationInstructions
  3. Descargue gocode
    gocode en Github.
    https://github.com/nsf/gocode
    
    Va a necesitar instalar git en Windows, normalmente usamos msysgit
    Instalar gocode desde la linea de comandos
    go get -u github.com/nsf/gocode
    
    Puede instalarlo desde el código fuente si lo desea.
  4. Descargue e instale MinGW
  5. Configure los plugins.
    Windows->Preferences->Go
    (1).Configuración del compilador de Go

    Imagen 1.12 Configuración de Go en Eclipse
    (2).Configuración de gocode(opcional), configure el path de donde tenga el archivo gocode.exe.

    Imagen 1.13 Configuración de gocode
    (3).Configuración de gdb(opcional), configure el path de gdb donde se encuentre el archivo gdb.exe.

    Imagen 1.14 Configuración de gdb
  6. Verifique la instalación
    Cree un nuevo proyecto Go y un archivo hello.go como el siguiente.

    Imagen 1.15 Cree un nuevo proyecto y archivo
    Testee la instalación de la siguiente forma.(necesita tipear estos comandos en la consola de Eclipse)

    Imagen 1.16 Testeo de programas Go en Eclipse

IntelliJ IDEA

Las personas que trabajan con Java deben estar familiarizados con este IDE, el mismo soporta el resaltado de sintaxis para Go, auto-completado y mas por medio de plugins.
  1. Descargue el IDE, no hay diferencia entre la versión Ultimate y la Community Edition

  2. Instale el plugin para Go. Elija File - Setting - Plugins, y entonces haga click en Browser repo.

  3. Busque golang, realice doble click en download and install, espere a que termine la descarga.

    Realice click en Apply, y entonces reinicie.
  4. Ahora vas a poder crear proyectos Go.

    Ingrese la ubicación del SDK de Go en los pasos siguientes, básicamente es su $GOROOT.
( Mire también el post para configurar y utilizar el IntelliJ IDEA con Go paso a paso )

Resumen

En este capitulo, hemos hablado sobre como instalar Go de tres formas diferentes, incluyendo como hacerlo desde el código fuente, el paquete estándar y herramientas de terceros. Luego mostramos como configurar nuestro entorno de desarrollo Go, principalmente hablamos sobre el $GOPATH. Después de eso, hicimos una introducción sobre los pasos para compilar y correr nuestro programas en Go. Entonces hablamos sobre algunos de los comando de Go, estos comandos incluyen compilar, instalar, dar formato, testear. Finalmente, mostramos algunas herramientas poderosas para desarrollar programas en Go, como LiteIDE, Sublime Text, Vim, Emacs, Eclipse, IntelliJ IDEA, etc. Usted puede elegir cualquiera de ellas para comenzar a explorar el mundo de Go.

 Indice