Ejecuta el último comando, pero con sudo delante. Muy útil para todas las veces que se teclea un “churro” enorme y el sistema responde: “You don’t have permissions…”

La lógica, si es que hay alguna, detrás de todo esto es crear un sitio donde se venga a trabajar y a jugar, a aprender y a enseñar y en definitiva a construir cosas. Para un soldado de fortuna como yo, es una manera de tener acceso a un equipo de expertos que me apoye en cualquier proyecto. Para el colectivo, se suma un colaborador en el que apoyarse para multiplicar fuerzas.

Hoy inauguramos “la cueva” de BeCode, el espacio que nos une. Si tenéis una oportunidad, no dudéis en pasar a saludar y tomar algo con nosotros.

La solución, refactorizada (en pastebin, para mayor legibilidad), y los tests.

La mejoras:

• He dividido la clase Parseator en dos, creando una clase separada para el modelo de la gramática a parsear, y otro para el parseador en si.
• He usado atajos de Ruby y construcciones tipo case para simplificar (o no) el código.

La kata en si no era muy compleja (enunciado en PDF), pero el truco estaba en que había que programarla usando técnicas de TDD. Interesante, puesto que una de las desventajas del TDD es que la velocidad inicial de desarrollo es bastante baja.

Para desarrollar la kata nos emparejaron e hicimos dos pomodoros de desarrollo con cinco minutos de descanso para discutir en grupo por dónde íbamos.

Resumen de la kata

La kata en si consistía en desarrollar un intérprete de líneas de comando al que se le pasan flags de tres tipos:

• -l: Flag booleano
• -p 8080: Flag numérico
• -d /tmp/log: Flag de texto

El primer paso es desarrollar un esquema en el que se indiquen los flags que acepta el programa, de qué tipo son y el valor por defecto si se omite el flag. Una vez tenemos el esquema, el programa tiene que ser capaz de interpretar una cadena de entrada, analizar si es sintácticamente correcta, analizar si es semánticamente correcta y lanzar excepciones si la entrada no es correcta.

Finalmente… antes de enseñaos la solución

Desde aquí, gracias a la gente de CSD por organizar el Dojo en las mazmorras de su oficina y por echarnos de comer y beber (free beer!) mientras programábamos.

Nuestra solución

Aunque no conseguimos resolver la kata en dos pomodoros, aquí estos son los tests y la solución en Ruby que creamos mi compañero Yago y yo.

Los tests:

require_relative '../lib/parseator.rb'

describe Parseator do
  before :each do
    @example_in = {"l" => ["bool", false],
                           "p" => ["number", 8080],
                           "d" => ["string", "/usr/local"] }
    @parser = Parseator.new(@example_in)
  end
  describe ", Sintactic Tests" do
    it "instantiates a Parseator object" do
     @parser.should be_an_instance_of Parseator
    end
    it "parses the empty string as valid" do
      @parser.valid?("").should ==  true
    end
    it "fails if first flag does not start with -" do
      @parser.valid?("poop").should ==  false
    end
    it "parses a single boolean flag" do
      @parser.valid?("-t").should ==  true
    end
    it "parses N boolean flags" do
      @parser.valid?("-p -m").should == true
    end
    it "parses a single flag with args" do
      @parser.valid?("-p 8080").should == true
    end
    it "parses a mix of boolean and arg flags without negative numbers" do
      @parser.valid?("-p 8080 -m -l /hola/yo").should == true
    end
    it "parses a mix of boolean and arg flags without negative numbers with traling and leading spaces" do
      @parser.valid?("-p 8080 -m -l /hola/yo").should == true
    end
    it "fails with an incorrect mix of boolean and arg flags with negative numbers" do
      @parser.valid?("-p 8080 -m -500 p -l /hola/yo").should == false
    end
    it "parses a mix of boolean and arg flags with negative numbers" do
      @parser.valid?("-p 8080 -m -500 -l /hola/yo").should == true
    end
    it "parses a mix of boolean and arg flags with negative numbers without spaces before argument" do
      @parser.valid?("-p8080 -m -500 -l /hola/yo").should == true
    end
  end

  describe ", Semantic Tests, " do
    it "raises exception when passing a flag that is not defined" do
      lambda { @parser.parse("-t") }.should raise_error UndefinedParam
    end
    it "returns a hash with default value when passing a single boolean flag" do
      test_string = "-l"
      @parser.parse(test_string).should have_key("l")
      @parser.parse(test_string)["l"].should == true
    end
    it "returns a hash with false when passing an empty string, for the boolean flag" do
      @parser.parse("").should have_key("l")
      @parser.parse("")["l"].should == false
    end
    it "returns a hash with value when passing a single string" do
      test_string = "-d /usr/bin"
      @parser.parse(test_string).should have_key("d")
      @parser.parse(test_string)["d"].should == "/usr/bin"
    end
    it "returns a hash with value when passing a single number" do
      test_string = "-p 8080"
      @parser.parse(test_string).should have_key("p")
      @parser.parse(test_string)["p"].should == 8080
    end
    it "returns a hash with value when passing a single negative number" do
      test_string = "-p -8080"
      @parser.parse(test_string).should have_key("p")
      @parser.parse(test_string)["p"].should == -8080
    end
    it "returns correctly when passing mix of strings, booleans and numbers" do
      test_string = "-p -8080 -l -d /usr/test"
      @parser.parse(test_string).should have_key("p")
      @parser.parse(test_string)["p"].should == -8080
      @parser.parse(test_string).should have_key("d")
      @parser.parse(test_string)["d"].should == "/usr/test"
      @parser.parse(test_string).should have_key("l")
      @parser.parse(test_string)["l"].should == true
    end
    it "defaults correctly with some params defined" do
      test_string = "-p -8080 -d /usr/test"
      @parser.parse(test_string).should have_key("l")
      @parser.parse("")["l"].should == false
    end
    it "defaults correctly with no params defined, aka empty string test" do
      test_string = "-p -8080 -d /usr/test"
      @parser.parse(test_string).should have_key("l")
      @parser.parse("")["l"].should == false
    end
    it "fails when passing valid and invalid flags" do
      test_string = "-p -8080 -m /usr/test"
      lambda { @parser.parse(test_string) }.should raise_error UndefinedParam
    end
    it "raises exception, with explanation test when passing a flag that is not defined" do
      lambda { @parser.parse("-t") }.should raise_error UndefinedParam, "Syntax error. Correct format is UNIMPLEMENTED"
    end
    it "raises exception, with explanation, passing a defined flag with wrong param" do
      lambda { @parser.parse("-l /usr/test") }.should raise_error IncorrectParam, "Incorrect parameter -l /usr/test"
    end
    it "raises exception, with explanation, passing a number flag to a string flag" do
      lambda { @parser.parse("-d 8080") }.should raise_error IncorrectParam, "Incorrect parameter -d 8080"
    end
    it "raises exception, with explanation, passing a number flag with wrong param" do
      lambda { @parser.parse("-p /usr/test") }.should raise_error IncorrectParam, "Incorrect parameter -p /usr/test"
    end
  end
end

El código:

class UndefinedParam < StandardError; end
class IncorrectSyntax < StandardError; end
class IncorrectParam < StandardError; end

# Extend class string to check if params are numbers (floats included)
class String
  def is_numeric?
    begin Float(self) ; true end rescue false
  end
end

class Parseator
  # Constructor takes as parameter a hash with the valid flags, type and default value
  def initialize(model_hash)
    @model = model_hash
  end

  # valid? returns true if params is syntactically correct
  def valid?(params)
    if params == ""
      return true
    else
      if params =~ /^\s*(\-[a-zA-Z]{1}\s*(\-?[0-9]+|[^-\s]+)*\s*)*\s*$/
        return true
      else
        return false
      end
    end
  end

  # returns a Hash with the parameters and the set values
  # or raises an exception if there are Syntax or Semantic errors
  def parse(params)
    params_out = Hash.new
    if valid?(params) # First, check there are no syntax errors
      # first go through the input string and add that to the results
      # match[0] is the flag
      # match[1] is the value
      params.scan(/\-([a-zA-Z]{1})\s*(\-?[0-9]+|[^-\s]+)*/).each do |match|
        if @model.has_key?(match[0])
          # bool params
          if @model[match[0]][0] == "bool"
            unless match[1].nil? # bool types do not have a value
              raise IncorrectParam, "Incorrect parameter -#{match[0]} #{match[1]}"
            end
            params_out[match[0]] = true
          # string params
          elsif @model[match[0]][0] == "string"
            if match[1].nil? || match[1].is_numeric?
              raise IncorrectParam, "Incorrect parameter -#{match[0]} #{match[1]}"
            end
            params_out[match[0]] = match[1]
          # number params
          elsif @model[match[0]][0] == "number"
            if match[1].nil? || !match[1].is_numeric?
              raise IncorrectParam, "Incorrect parameter -#{match[0]} #{match[1]}"
            end
            params_out[match[0]] = match[1].to_i
          end
        else
          raise UndefinedParam, "Syntax error. Correct format is UNIMPLEMENTED"
        end
      end

      # second, go through the model and see what params are missing, to add the defaults
      @model.keys.each do |key|
        unless params_out.has_key?(key)
          params_out[key] = @model[key][1] # default value
        end
      end
      return params_out
    else # Raise syntax error if not valid?
      # This method can be refined to analyze the string for the location of the syntax error(s)
      # Left as an exercise for the reader
      raise IncorrectSyntax
    end
  end
end

Ahora que lo miro… @model huele a refactoring…

Aparte, os recomiendo que instaléis también RVM para la gestión de diferentes versiones de Ruby y Rails, que luego os simplificará la vida cuando tengáis que cambiar el entorno de desarrollo para mantener aplicaciones que ya tengáis en el servidor.

Finalmente también os recomiendo Passenger para simplificar la integración con Apache y así emular lo más posible el entorno de producción, en lugar de usar WEBrick el servidor web que lleva Rails por defecto.

Mi configuración:

• Mac OSX 10.7.3
• XCode 4.3
• RVM 1.10.3
• Ruby 1.9.3
• Rails 3.2.1
• MySQL 5.5
• Passenger 3.0.11

Ten en cuenta que muchos de los comandos instalarán las últimas versiones de las herramientas y librerías, así que tus resultados puede variar. Por ejemplo, al ejecutar ‘gem install rails’ en el momento de publicar este post, la versión que se instala es Rails 3.2.1., la última versión disponible a finales de Febrero 2012.

1. Instalar Xcode

Te lo puedes bajar en el App Store de Apple, o en el Developer center. Necesitas un Apple ID.

Con XCode 4.3 las herramientas de la línea de comando son opcionales. Instálalas en Xcode > Preferences > Downloads.

2. Homebrew

Homebrew es una applicación que nos sirve para facilitar la instalación de software libre sobre Mac OS X. Siguiendo las instrucciones:

$> /usr/bin/ruby -e "$(curl -fsSL https://raw.github.com/gist/323731)"
==> This script will install:
/usr/local/bin/brew
/usr/local/Library/Formula/...
/usr/local/Library/Homebrew/...

Press enter to continue
==> Downloading and Installing Homebrew...
==> Installation successful!
Now type: brew help

3. RVM

Para instalar RVM, el sistema de gestión (que no control) de versiones de Ruby, lo primero es instalar Git (este si que es un sistema de control de versiones, para liarlo más)

$> brew install git

Una vez tenemos git instalado, instalamos RVM…

$> bash -s stable < <(curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer)
1

... y lo configuramos:
1
$> source ~/.rvm/scripts/rvm

Pero no todo es tan fácil. Si ejecutamos

$> rvm notes

Notes for Mac OS X 10.7.3, No Xcode.

For JRuby:  Install the JDK. See http://developer.apple.com/java/download/  # Current Java version "1.6.0_26"
For IronRuby: Install Mono >= 2.6
For Ruby 1.9.3: Install libksba # If using Homebrew, 'brew install libksba'
...

Es decir, que si queremos soporte para Ruby 1.9.3 tenemos que instalar libksba:

brew install libksba

Y luego instalar RVM con clang como compilador (gracias Stack Overflow)

$> rvm install 1.9.3 --with-gcc=clang

Para hacer que 1.9.3 sea la versión por defecto:

$> rvm --default use 1.9.3
$> ruby -v
$> ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-darwin11.3.0]

4. Rails

A medida que vamos instalando herramientas, se hace más fácil la instalación:

$> gem install rails

Esto instala Rails y gems dependientes, incluyendo Bundler (gestión de gemas para deployment). Comprobemos que versión tenemos instalada.

$> rails --version
Rails 3.2.1

5. MySQL 5.5

Puedes elegir la base de datos SQL o No-SQL que más te guste. Para esta guía he elegido MySQL 5.5.

$> brew install mysql

Para crear la base de datos y los usuarios:

$> unset TMPDIR
$> mysql_install_db --verbose --user=`whoami` --basedir="$(brew --prefix mysql)" --datadir=/usr/local/var/mysql --tmpdir=/tmp

Lanza el servidor

$> mysql.server start

Haz tu instalación de MySQL más segura (cambia el password de root, borra los usuarios anónimos, bloquea el acceso remoto, borra la base de datos de test y vuelve a cargar las tablas de privilegios):

$> mysql_secure_installation

Crear un usuario de desarrollo de MySQL

$> mysql -u root -p
mysql> use mysql;
mysql> insert into user(host, user, password) values ('localhost', 'dev_user', '');

6. Passenger

Phusion passenger es un módulo de Apache para deployear (¿alguien conoce un verbo mejor?) aplicaciones de Ruby on Rails. Es el método recomendado por los creadores de Rails.

$> gem install passenger
$> passenger-install-apache2-module

Para configurar Apache con passenger, sigue las instrucciones en pantalla (te las resumo a continuación). Enciende Apache desde System Preferences > Sharing > Web Sharing (tiene que estar activado)

Edita con sudo el fichero /etc/apache2/httpd.conf e incluye la configuración de Passenger al final del fichero:

Include /etc/apache2/other/passenger.conf

Cierra httpd.conf y crea el fichero de configuración para passenger

touch /etc/apache2/other/passenger.conf

Edita con sudo el fichero /etc/apache2/passenger.conf

LoadModule passenger_module /Users/cesar/.rvm/gems/ruby-1.9.3-p125/gems/passenger-3.0.11/ext/apache2/mod_passenger.so
PassengerRoot /Users/cesar/.rvm/gems/ruby-1.9.3-p125/gems/passenger-3.0.11
PassengerRuby /Users/cesar/.rvm/wrappers/ruby-1.9.3-p125/ruby

Ten en cuenta que mi directorio home es 'cesar', pero el tuyo seguramente será otro.

Reinicia Apache

sudo apachectl restart

Comprueba en /var/log/apache2/error_log que no hay errores. Por ejemplo:

[Thu Feb 23 18:00:21 2012] [notice] Apache/2.2.21 (Unix) DAV/2 Phusion_Passenger/3.0.11 configured -- resuming normal operations

7. Crea una aplicación Rails de ejemplo

Voy a seguir el ejemplo típico del blog de Rails, que está en la guía Getting Started with Rails.

Crear el directorio para los proyectos rails. Yo lo tengo en mi home:

$> cd ~
$> mkdir railsprojects
$> cd railsprojects

Para crear la aplicación:

$> rails new blog

Configura Passenger y Apache para esta aplicación, activando virtual hosts si no está activado en /etc/apache2/httpd.conf . Busca:

# Virtual hosts
# Include /private/etc/apache2/extra/httpd-vhosts.conf

Borra el '#' de la segunda línea, para incluir el fichero de hosts virtuales. A continuación, edita (con sudo) /private/etc/apache2/extra/httpd-vhosts.conf y añade:

<VirtualHost *:80>
       ServerName blog.lvh.me
       DocumentRoot /Users/cesar/railsprojects/blog/public
       RailsEnv development
       <Directory /Users/cesar/railsprojects/blog/public>
           AllowOverride all
           Order allow,deny
           Allow from all
           Options -Indexes +FollowSymLinks MultiViews
       </Directory>
</VirtualHost>

Ten en cuenta que mi directorio home es 'cesar', pero el tuyo puede ser otro.

Reinicia Apache una vez más con sudo apachectl restart

En tu navegador visita blog.lvh.me (ya he hablado de LVH en otro post. Es lo mismo que localhost).

Si ves esta pantalla, ya tienes Rails configurado y funcionando. Ahora hay que terminar de cerrar el stack, configurando la base de datos MySQL.

Editar el Gemfile en el directorio blog y añade:

gem 'mysql2'

Instala la nueva gema con

$> Bundle install

Edita ~/railsprojects/blog/config/database.yml y cambia la sección 'development':

development:
adapter: mysql2
encoding: utf8
database: blog_development
pool: 5
username: dev_user
password:
socket: /tmp/mysql.sock

Crea la base de datos:

$> rake db:create

Dale permisos al usuario dev_user:

$> mysql -u root -p
mysql> grant SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, RELOAD on *.* to 'dev_user'@'localhost';
$> flush privileges;

Genera el scaffolding de Post, que crea una migración con el script en SQL para modificar la base de datos:

$> rails generate scaffold Post name:string title:string content:text

Si se ha creado una tabla posts en la base de datos: Has triunfado. Enhorabuena ya tienes el entorno de Rails listo en tu Mac OS X 10.7.3

Si tenéis curiosidad por conocer la base técnica de la web, os podeis pasar el jueves 2:

20:30h
Parc Cientific de la Universitat de Valencia
Catedrático Agustín Escardino 9
Valencia

SELECT *
FROM `statuses`
WHERE update_id in (
   select id
   from updates
   where timestamp >='2011-12-01' and timestamp < '2012-01-01'
)

El problema es que al usar mysqldump me daba un error: Table ‘updates’ was not locked with LOCK TABLES (1100)

La solución: llamar a mysqldump con el parámetro “–lock-all-tables”

mysqldump -t -u root --lock-all-tables -p bisicalcdb_prod statuses --where="update_id in (select id from updates where timestamp >='2011-12-01' and timestamp < '2012-01-01')" > 201112_december_statuses.sql

Estación 86: Gaspar Aguilar – Vicente Parra, 20 bornetas

Estación 258: Pintor Rafael Solves – Jose Soto Mico, 15 bornetas

Estación 262: Tres forques – Colonia Española de México, 19 bornetas

Estación 263: Padre Esteban Pernet – Casa Misericordia, 17 bornetas

Estación 264: Av. del Cid – Marconi, 19 bornetas

Estación 266: Canal de Navarrés – Maestro Rodrigo, 17 bornetas

Estación 40: Barcas 11, 25 bornetas

Estación 70: Colón 27, 17 bornetas

Estación 272: Vicente la Roda – Doctor Alvaro López, 16 bornetas

Estación 275: Moreras – Rona de Nazaret, 13 bornetas

Cuatro estaciones añadidas pero aún no disponibles:

Estación 91: Grabador Jordan – Escultor Pastor
Estación 93: Blasco Ibañez – Poeta Durán Tortajada
Estación 273: Moraira – Alta del Mar
Estación 274: Castell de Pop – San Francisco de Paula

Dos situaciones en las que nos puede ser útil este truco:

1. Trabajando con una aplicación web en un host virtual de apache:

<VirtualHost *:80>
       ServerName bisicalc.local
       DocumentRoot /Users/cesar-mb/railsprojects/bisicalcdb/public
       <Directory /Users/cesar-mb/railsprojects/bisicalcdb/public>
           AllowOverride all
           Options -MultiViews
       </Directory>
</VirtualHost>

Cada nuevo host virtual sería una modificación del fichero hosts, y otra del fichero de virtual hosts de apache.

2. Trabajando con subdominios: barcelona.bisicalc.local, valencia.bisicalc.local, etc. Cada uno require una nueva entrada en el fichero hosts.

Yo tenía los dos problemas: virtual hosts y subdominios, uno por ciudad.

DNS al rescate. Una entrada wildcard apuntando a 127.0.0.1 y ya no hay que modificar más el fichero hosts. ¿No administras un dominio o DNS?, no hay problema. Tim Pope ha configurado *.smackaho.st para que apunte a 127.0.0.1. ¿Demasiado largo? *.lvh.me hace lo mismo.

Simplemente apunta tu browser a cualquier subdominio de lvh.me (es.lvh.me, en.lvh.me, etc.) y ambos se resolverán a localhost, sin necesidad de modificar el fichero hosts.

Esta semana pondré un par de artículos sobre las cosas que he aprendido, sobre todo de Rails routing y precompilación de assets (que no termina de convencerme).