Merge pull request #3 from Lemoncode/feature/groovy

added Groovy demos

Author: JaimeSalas

03-cd/00-groovy/00-grovy-console.md

@@ -0,0 +1,95 @@
+# The Groovy Console
+
+Lo primero que necesitamos para trabajar con cualquier tipo de lenhuajes es algo que valide y verificque que nuestro código se comporta de la manera que nsostros esperamos.
+
+
+Nuestro objectivo final será `Jenkins`. Como nota al respecto, `Jenkins` tiene internamente, una consola de `Groovy` para validar de los `scripts`. Pero para desarrollar nos puede convenir una solución más ligera.
+
+`Apache`, tiene una herramienta como la que necesiatamos [link](http://groovy-lang.org/download.html). Esta aplicación es una aplicación de `swing`.
+
+* Algo para verificar y validar nuestro código.
+* Nuestro objetivo es `Jenkins`.
+* Un sitio para experimentar.
+
+Una alternativa a instalar de manera local, es utilizar un [contenedor de Docker](https://hub.docker.com/_/groovy?tab=description)
+
+```bash
+docker run -it --rm groovy
+
+# Running a Groovy script
+docker run --rm -v "$PWD":/home/groovy/scripts -w /home/groovy/scripts groovy groovy <script> <script-args>
+```
+
+> Referencia: https://groovy-lang.gitlab.io/101-scripts/docker/basico-en.html
+
+Crear `BasicDocker.groovy`
+
+```groovy
+println "------------------------------------------------------------------"
+println "Hello"
+System.getenv().each{
+    println it
+}
+println "------------------------------------------------------------------"
+```
+
+Ahora desde el directorio raíz en el cual hemos creado el ficero anterior, podemos ejecutar:
+
+```bash
+docker run --rm -v "$PWD":/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy BasicDocker.groovy -a 
+```
+
+* `-a` es para volcar las variables de sistema.
+* `-w` establecemos el directorio de trabajo dentro del contenedor.
+
+# Demo: La Consola de Groovy
+
+* Create `playground/00_groovy_console.groovy`
+
+```groovy
+def x = 5
+
+x += 5
+
+println x
+assert x == 10
+```
+
+Y lo podemos ejecutar de la siguiente manera:
+
+```bash
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 00_groovy_console.groovy
+$ 10
+```
+
+Si cambiamos el valor de `x`
+
+```diff
+def x = 5
+
+x += 5
+
+println x
+-assert x == 10
++assert x == 11
+```
+
+Podemos introducir un mensaje si la aseveración no pasa.
+
+```diff
+def x = 5
+
+x += 5
+
+println x
+-assert x == 11
++assert x == 11: "Value was not eleven"
+```
+
+```bash
+Jaimes-MacBook-Pro:playground jaimesalaszancada$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 00_groovy_console.groovy
+10
+Caught: java.lang.AssertionError: Value was not eleven. Expression: (x == 11). Values: x = 10
+java.lang.AssertionError: Value was not eleven. Expression: (x == 11). Values: x = 10
+        at 00_groovy_console.run(00_groovy_console.groovy:7)
+```

03-cd/00-groovy/01-tipos-de-datos.md

@@ -0,0 +1,107 @@
+# Tipos de Datos
+
+**Groovy** es un lenguaje con tipado opcional, lo que significa que podemos trabajar con tipos `primitivos de Java`, o podemos dejar que el `runtime` los deduzca del contexto, lo cuál lo hace bastante bien.
+
+* `x` es claramente un número
+* Un lenguaje opcionalmente tipado
+* Sin ninguna definición de tipo
+
+Veamos cuales son los tipo primitivos que vamos a utilizar:
+
+| Data Type | Groovy Keyword | Sample Data   |
+|:---------:|:--------------:|---------------|
+|  Strings  |     String     | "Jaime Salas" |
+|  Integers |       int      |   0, 1, 2, 3  |
+|   Floats  |      float     |    0.5, 3.8   |
+|  Boolean  |     Boolean    |  true, false  |
+
+# Demo: Tipos de Datos
+
+Creamos el siguiente fichero [01_groovy_data_types.groovy](playground/01_groovy_data_types.groovy)
+
+```groovy
+String name = "Joe Doe"
+int courseCount = 14
+float salary = 999999.99
+Boolean isProgrammer = true
+
+println name + " has created " + courseCount + " courses." // [1]
+println name + " is a programmer? " + isProgrammer // [1]
+println name + " wishes his salary was " + salary // [1]
+```
+
+1. Groovy convierte los `booleans` y  `float` a `strings`
+
+Y lo podemos ejecutar de la siguiente manera:
+
+```bash
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy 
+Joe Doe has created 14 courses.
+Joe Doe is a programmer? true
+Joe Doe wishes his salary was 1000000.0
+```
+
+Vamos a introducir una pequeña diferencia
+
+```diff
+String name = "Joe Doe"
+int courseCount = 14
+float salary = 999999.99
+Boolean isProgrammer = true
+
+println name + " has created " + courseCount + " courses."
+-println name + " is a programmer? " + isProgrammer
++println name + " is a programmer? " + isProgrammer.toString().capitalize()
+println name + " wishes his salary was " + salary
+```
+
+```bash
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy 
+Joe Doe has created 14 courses.
+Joe Doe is a programmer? True
+Joe Doe wishes his salary was 1000000.0
+```
+
+Podemos notar que `Groovy` tiene un problema al convertir de `float` a `string`, podemos tener un control más fino usando el formateo de `String`.
+
+```diff
+String name = "Joe Doe"
+int courseCount = 14
+float salary = 999999.99
+Boolean isProgrammer = true
+
+println name + " has created " + courseCount + " courses."
+println name + " is a programmer? " + isProgrammer.toString().capitalize()
+-println name + " wishes his salary was " + salary
++println name + " wishes his salary was \$" + String.format("%.2f", salary)
+```
+
+```bash
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy 
+Joe Doe has created 14 courses.
+Joe Doe is a programmer? True
+Joe Doe wishes his salary was $1000000.00
+```
+
+Seguimos teniendo un problema, simplemente podemos cambiar el tipo:
+
+```diff
+String name = "Joe Doe"
+int courseCount = 14
+-float salary = 999999.99
++BigDecimal salary = 999999.99
+Boolean isProgrammer = true
+
+println name + " has created " + courseCount + " courses."
+println name + " is a programmer? " + isProgrammer.toString().capitalize()
+-println name + " wishes his salary was \$" + String.format("%.2f", salary)
++println name + " wishes his salary was \$" + salary
+```
+
+Simplemente como nota en `Java` tenemos `;` para terminar una línea, en `Groovy` son opcionales.
+
+### Tipos de Datos y Sintaxis
+
+* "def" opcional o tipo de dato explicito
+* ¿Perder el tipado? Nop
+* Ciando devolvemos un valor está perfectamente claro el tipo devuelto

03-cd/00-groovy/02-estructuras-de-control.md

@@ -0,0 +1,113 @@
+# Estructuras de Control
+
+Para hacer algo medianamente importante en nuestros scripts, necesitamos estructuras de control. La más esencial de ellas es `if else`, que tiene la misma apariencia que en `Java` on en `C` 
+
+```groovy
+if (isProgrammer) {
+    println "He's a programmer, alright"
+}
+else {
+    println "Not a programmer, tho"
+}
+```
+ 
+Lo mismo para un `loop`
+
+```groovy
+for (int i = 0; i < courseCount; i++) {
+    println "Chris made course " + (i + 1) + "!!!"
+}
+```
+
+Lo mismo de cun un `while loop`
+
+```groovy
+int i = 0;
+
+while (i < courseCount) {
+    println "Chris made course " + (i + 1) + "!!!"
+    i++
+}
+```
+
+
+Podemos definir un `for in loop` de la siguiente manera:
+
+```groovy
+String[] singers = ["Bob", "George", "Jeff", "Roy", "Tom"]
+
+for(String singer: singers) {
+    println singer
+}
+```
+
+Podemos definir el bucle anterior de una manera más compacta:
+
+```groovy
+singers.each(x -> println(x))
+```
+
+Podemos incluso darle una vuelta de tuerca más alimentando directamente el `iterador`.
+
+```groovy
+singers.each(println(it))
+```
+
+# Demo: Estructuras de Control
+
+Crear el siguiente el fichero [02_control_structures.groovy](playground/02_control_structures.groovy)
+
+```groovy
+int courseCount = 14;
+Boolean isProgrammer = true;
+String[] singers = ["Bob", "George", "Jeff", "Roy", "Tom"]
+
+if (isProgrammer) {
+    println "He's a programmer"
+}
+else {
+    println "not a programmer"
+}
+
+for (int i = 0; i < courseCount; i++) {
+    println "Chris made course " + (i + 1) + "!!!"
+}
+
+for (String singer: singers) {
+    println singer
+}
+
+singers.each(x -> println(x))
+singers.each{println(it)}
+```
+
+Y lo ejecutamos de la siguiente manera:
+
+```bash
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 02_control_structures.groovy 
+He's a programmer
+Chris made course 1!!!
+Chris made course 2!!!
+Chris made course 3!!!
+Chris made course 4!!!
+Chris made course 5!!!
+Chris made course 6!!!
+Chris made course 7!!!
+Chris made course 8!!!
+Chris made course 9!!!
+Chris made course 10!!!
+Chris made course 11!!!
+Chris made course 12!!!
+Chris made course 13!!!
+Chris made course 14!!!
+Bob
+George
+Jeff
+Roy
+Tom
+Bob
+George
+Jeff
+Roy
+Tom
+```