Ubuntu en una MacBook Pro

Si instalaste Ubuntu en una MacBook Pro, seguramente hay ciertos detalles que necesitas revisar justo después de la instalación:

Wireless

Si no funciona la red inalámbrica. Conecta a un cable de red e instala los siguientes paquetes:

sudo apt-get install firmware-b43-installer b43-fwcutter

Reinicia Ubuntu para conectarte inalámbricamente.

Teclado

Para corregir el esquema del teclado:

Desde la configuración de las Preferencias escoger sólo Español (sin ninguna variante).

Y en el archivo:

sudo nano /etc/default/keyboard

Escribir o actualizar las siguientes variables:

XKBMODEL="macintosh"
XKBLAYOUT="es"
XKBVARIANT="mx"
XKBOPTIONS=""

Esto lo pondrá como Español de México, si lo quieres cómo Español de España, deja vacía la variable XKBVARIANT.

Cerrar tu sesión y volver a iniciarla para ver los cambios.

Cmd vs Ctrl

Si ya te acostumbraste a usar Cmd, seguro se te hará raro ahora usar Ctrl. Si deseas que esto funcione como en Mac, puedes intercambiarlas. Para intercambiar la tecla Cmd con Ctrl abre el archivo:

nano ~/.Xmodmap

Y pega lo siguiente:

clear control
clear mod4
 
keycode 105 =
keycode 206 =
 
keycode 133 = Control_L NoSymbol Control_L
keycode 134 = Control_R NoSymbol Control_R
keycode 37 = Super_L NoSymbol Super_L
 
add control = Control_L
add control = Control_R
add mod4 = Super_L

Puedes probar este cambio ejecutando el siguiente comando:

xmodmap ~/.Xmodmap

Para que se ejecute cada que reinicies, agrega el mismo comando a las Aplicaciones de Inicio.

Touchpad

Para hacer más similar el touchpad. Esto debido a la forma de lanzar el click Derecho en Ubuntu es con dos dedos sobre el TrackPad, puede ser confuso al principio. Además, el driver que trae por defecto, no ignora la Palma ni el Pulgar, y la gran mayoría de las personas de repente recargamos una o otra lo que ocasionará que el cursor brinque sin querer. Queda mucho mejor con otro driver especializado en estos problemas. Para instalarlo:

Agregar el repositorio:

sudo add-apt-repository ppa:mactel-support && sudo apt-get update

Instalar el paquete:

sudo apt-get install xserver-xorg-input-mtrack

Crear el archivo:

sudo nano /etc/X11/xorg.conf

Con el siguiente contenido:

Section "InputClass"
    MatchIsTouchpad "on"
    Identifier      "Touchpads"
    Driver          "mtrack"
    Option          "Sensitivity" "0.85"
    Option          "FingerHigh" "12"
    Option          "FingerLow" "1"
    Option          "IgnoreThumb" "true"
    Option          "IgnorePalm" "true"
    Option          "TapButton1" "0"
    Option          "TapButton2" "0"
    Option          "TapButton3" "0"
    Option          "TapButton4" "0"
    Option          "ClickFinger1" "1"
    Option          "ClickFinger2" "3"
    Option          "ClickFinger3" "3"
    Option          "ButtonMoveEmulate" "false"
    Option          "ButtonIntegrated" "true"
    Option          "ClickTime" "25"
    Option          "TapButton2" "0"
    Option          "TapButton3" "0"
    Option          "TapButton4" "0"
    Option          "ClickFinger1" "1"
    Option          "ClickFinger2" "3"
    Option          "ClickFinger3" "3"
    Option          "ButtonMoveEmulate" "false"
    Option          "ButtonIntegrated" "true"
    Option          "ClickTime" "25"
    Option          "BottomEdge" "25"
    Option          "SwipeLeftButton" "8"
    Option          "SwipeRightButton" "9"
    Option          "SwipeUpButton" "0"
    Option          "SwipeDownButton" "0"
    Option          "ScrollDistance" "75"
    Option          "VertScrollDelta"          "-111"
    Option          "HorizScrollDelta"         "-111"
EndSection

Esto pondrá el click derecho como normalmente es en Mac (dejando dos dedos encima del Touchpad y haciendo tap con otro) además de poner el scroll natural (invertido) como si lo hicieras desde un dispositivo touch.

Si no quieres el scroll natural, elimina las variables “VertScrollDelta” y “HorizScrollDelta”.

Si sientes el desplazamiento muy rápido o lento, cambia el valor de la variable “Sensitivity” (0.55 por ejemplo lo hará más lento).

Reinicia Ubuntu.

Leer particion de MacOS en Ubuntu

Si tienes una partición, e intentas abrirla, te saldra un error. Esto es porque para leer particiones de Mac OS se necesita un paquete extra, instalalo:

sudo apt-get install hfsprogs

Si te salen errores de que la unidad está dañada, puedes repararla con el siguiente comando (reemplazas “sda2” con el número que te salga en el cuadro de diálogo):

sudo fsck.hfsplus -f /dev/sda2

xTerm

Ciertas aplicaciones como xTerm no usan el Portapapeles normal (Ctrl+c Ctrl+v) sino algo que le llaman Primario.

En dichas aplicaciones se copia al Primario con Ctrl+Insert y se pega con Shift+Insert, debido a que Ctrl+c normalmente esta reservado para terminar.

Debido a que en la Laptop no tenemos la techa de Insert, vamos a tener que mapear a otras combinaciones.

Copiar

Para XTerm en particular, puedes hacer que al seleccionar un texto, lo copie tanto al Primario como al Clipboard.

Intenta abrir una terminal con el siguiente comando:

xterm -ls -xrm 'XTerm*selectToClipboard: true'&

Si seleccionas un texto y después te vas a Chrome e intentas pegarlo ya funcionará.

Para guardar esa configuración, edita el archivo ~/.Xdefaults con lo siguiente:

XTerm*selectToClipboard: true

Pegar

En Ubuntu existe un mapeo para pegar del Primario, que es con el Middle Click del Mouse, esto es darle click a la ruedita del Scroll. Como tampoco tenemos rueda de Scroll, aprovecharemos para usar una tecla que casi no se use.

Primero instala el siguiente programa:

sudo apt-get install xkbset

Ahora ejecuta o siguiente en una terminal:

xmodmap -e "keycode 134 = Pointer_Button2"; xkbset m

Esto mapeará la Tecla Comando de la derecha a Middle Click. Entonces si quieres pegar algo del Primario, solo presiona Comando derecha.

Restaurar respaldo con postgresql para sitio en Ruby on Rails

1.- Te conectas con ssh al servidor

2.- Desde cualquier ubicación entra a la consola de postgres:

sudo su postgres -c psql

3.- Darle todos los privilegios al usuario sobre la base de datos escribiendo:

GRANT ALL PRIVILEGES ON DATABASE nombre_base_datos TO usuario_base_datos

Recuerda que esta información debe estar dentro de tu archivo database.yml

4.- Salir de la consola de postgres con \q

5.- Entrar al directorio donde está la aplicación

en mi caso home/deployer/apps/mi_aplicacion

6.- Ejecutar el siguiente comando para tirar la base de datos:

rake db:drop RAILS_ENV=production

7.- Ejecutar el siguiente comando para crear la base de datos:

rake db:create RAILS_ENV=production

8.- Ejecutar el siguiente comando para restaurar la base de datos:

 psql -U usuario_base_datos -d nombre_base_datos -f nombre_respaldo
-U => el usuario de postgresql:       el usuario de la base de datos se encuentra dentro del archivo .yml en la ruta mi_aplicacion/config/database.yml
-d => el nombre de la base de datos:  el nombre de la base de datos se encuentra dentro del archivo .yml en la ruta mi_aplicacion/config/database.yml
-f => el nombre del respaldo:         hay que escribir la ruta en donde se encuentra el dump

Súper fácil!!!

Si te llega a salir un error como:

psql: FATAL: Peer authentication failed for user "tu_usuario"

Es porque tu Postgres está configurado para solo dar permiso a usuarios reales del sistema (que puedan hacer login). Eso lo podemos cambiar modificando el archivo (con permisos de administrador):

/etc/postgresql/9.3/main/pg_hba.conf

El 9.3 puede variar, depende de tu versión de Postgres.

Y cambias la siguiente linea:

De:

# TYPE DATABASE USER ADDRESS METHOD
local  all      all          peer

A:

# TYPE DATABASE USER ADDRESS METHOD
local  all      all          md5

Después de realizar ese cambio, reiniciamos Postgres:

sudo service postgresql restart

Y con eso ya te debe dar acceso.

Crear Respaldos con postgresql

1.- Te conectas con ssh al servidor

2.- Desde cualquier ubicación ejecuta los siguientes comandos:

sudo su
su postgres
cd ~

3.- Posteriormente vamos a generar el dump:

pg_dump -Upostgres nombre_base_en_producción > nombre_respaldo.sql

4.- Ten a la mano el password del usuario postgres ya que te lo pedirá

5.- Para saber en que ruta te encuentras para posteriormente mover el dump, escribe el siguiente comando:

pwd  
en mi caso dio lo siguiente:  /var/lib/postgresql

6.- Moverte a root con exit

7.- Para mover el dump a tu aplicación escribir el siguiente comando:

mv /var/lib/postgresql/nombre_respaldo.sql aplicacion/public/.

Nota: Si el respaldo pesa mucho, puedes comprimirlo de la siguiente manera:

zip nombre_respaldo.zip nombre_respaldo.sql

Súper fácil!!!

Levantar aplicación Rails para producción en Ubuntu con Unicorn y Nginx

Normalmente para levantar una aplicación Rails en producción, utilizamos este esquema:

  • Ubuntu como el Sistema Operativo de nuestro Servidor.
  • Unicorn como Servidor de Aplicaciones Rails.
  • Nginx como Servidor HTTP corriendo como un Front-End Reverse Proxy
  • Postgres como el manejador de nuestra Base de Datos.

En palabras más sencillas, Unicorn se encargará de interpretar todo nuestro código Ruby, Nginx de servir nuestro HTML, CSS, JS e imágenes y Postgres de leer y almacenar nuestra información. Todo esto vivirá en un servidor Ubuntu en la nube que operaremos desde la consola.

  1. Primero necesitas hacerte de un buen servidor e instalarle Ubuntu Server, recomiendo el servicio que da Linode porque el precio es muy accesible, nunca me ha fallado el servicio, son máquinas muy potentes y te dan control completo de tu servidor para instalar y desinstalar lo que tu quieras.
  2. Una vez que tengas tu servidor, necesitas instalarle Ruby, para ello puedes auxiliarte instalando rbenv con esta guía.
  3. Después instalale Nginx con estos comandos:
    sudo apt-get update
    sudo apt-get install nginx

    Por defecto Ubuntu lo activa, intenta visitar tu servidor desde un navegador, de esta forma:
    http://el_dominio_o_IP_de_tu_servidor

    Deberías ver una página como esta:
    nginx inicial

    Si no la ves, puedes iniciar Nginx manualmente desde tu servidor, los comandos para apagar, iniciar o reiniciar Nginx son lo siguientes:

    sudo service nginx stop
    sudo service nginx start
    sudo service nginx restart

    Para arrancarlo al iniciar Ubuntu ejecuta este comando:

    sudo update-rc.d nginx defaults

    En versiones recientes de Ubuntu te puede decir que ya existía el registro para iniciarlo automáticamente.

  4. Ahora instalaremos Unicorn:
    gem install unicorn

    ¡Así de fácil!

  5. Sube el código de tu aplicación al servidor. Puedes usar github, bitbucket o simplemente subir un zip si no tienes un manejador de versiones, normalmente subo mis aplicaciones Rails a un directorio apps en el home del usuario que vamos a usar para hacer los deploys, de esta forma:
    deployer@miservidor:~$ mkdir apps
    deployer@miservidor:~$ cd apps
    deployer@miservidor:~/apps$ pwd
    /home/deployer/apps/

    Para dejarlo así:

    /home/deployer/apps/mi_aplicacion
  6. Vamos a configurar un poco tu aplicación para producción:
    • Asegurate de agregar unicorn a tu Gemfile:
      gem 'unicorn'
    • Si usas Rails 4, asegurate de tener un valor en el archivo config/secrets.yml para el apartado de production, por ejemplo:
      # Do not keep production secrets in the repository,
      # instead read values from the environment.
      production:
        secret_key_base: b1329441746d18...4b14d78d744650450113242c

      La llave fue cortada a propósito, básate en las que trae tu aplicación para development y test; puedes sólo cambiarle un caracter a esas para que sea distinta la de producción.

    • Asegurate de tener configurada la Base de Datos para producción en tu archivo config/database.yml, utiliza el manejador de Base de Datos que más te agrade, por ejemplo:
      production:
        adapter: sqlite3   
        pool: 5
        timeout: 5000
        database: db/production.sqlite3
      Si en lugar de Sqlite deseas usar Postgres, basate en esta guia para instalarlo y configurarlo.
    • Instala las gemas necesarias para tu aplicación con el comando bundle
      bundle install --deployment --binstubs

      La opción binstubs genera los ejecutables en el directorio de tu aplicación ./bin para las gemas en el bundle, de esta forma cualquier herramienta como unicorn o cron asegura la versión de Ruby a usar y la versión de las gemas a usar.

    • Crea tu Base de Datos, ejecuta las migraciones y corre los seeds para el ambiente de producción:
      rake db:create RAILS_ENV=production
      rake db:migrate RAILS_ENV=production
      rake db:seed RAILS_ENV=production
    • rake db:create es solo necesario ejecutarlo una vez para crear la base de datos

    • Precompila los assets para que se compriman y optimicen:
      rake assets:precompile RAILS_ENV=production

    Nota: Si deseas saber en que manejador de base de datos estás trabajando, entra a la consola con rails c production y escribe la siguiente sentencia:

    ActiveRecord::Base.connection.adapter_name

    En mi caso salio lo siguiente:

     => "PostgreSQL"
    
  7. Ahora vamos a configurar unicorn dentro de tu aplicación, para esto necesitamos crear dos archivos:
    • El primer archivo se ubicará en la ruta config/unicorn_init.sh dentro de tu aplicación, y tendrá el siguiente código:
      #!/bin/sh
      ### BEGIN INIT INFO
      # Provides:          unicorn
      # Required-Start:    $remote_fs $syslog
      # Required-Stop:     $remote_fs $syslog
      # Default-Start:     2 3 4 5
      # Default-Stop:      0 1 6
      # Short-Description: Manage unicorn server
      # Description:       Start, stop, restart unicorn server for a specific application.
      ### END INIT INFO
      set -e
       
      # Feel free to change any of the following variables for your app:
      TIMEOUT=${TIMEOUT-60}
      APP_ROOT=/home/deployer/apps/mi_aplicacion
      PID=$APP_ROOT/tmp/pids/unicorn.pid
      CMD="cd $APP_ROOT; bundle exec unicorn -D -c $APP_ROOT/config/unicorn.rb -E production"
      AS_USER=deployer
      set -u
       
      OLD_PIN="$PID.oldbin"
       
      sig () {
        test -s "$PID" && kill -$1 `cat $PID`
      }
       
      oldsig () {
        test -s $OLD_PIN && kill -$1 `cat $OLD_PIN`
      }
       
      run () {
        if [ "$(id -un)" = "$AS_USER" ]; then
          eval $1
        else
          su -c "$1" - $AS_USER
        fi
      }
       
      case "$1" in
      start)
        sig 0 && echo >&2 "Already running" && exit 0
        run "$CMD"
        ;;
      stop)
        sig QUIT && exit 0
        echo >&2 "Not running"
        ;;
      force-stop)
        sig TERM && exit 0
        echo >&2 "Not running"
        ;;
      restart|reload)
        sig HUP && echo reloaded OK && exit 0
        echo >&2 "Couldn't reload, starting '$CMD' instead"
        run "$CMD"
        ;;
      upgrade)
        if sig USR2 && sleep 2 && sig 0 && oldsig QUIT
        then
          n=$TIMEOUT
          while test -s $OLD_PIN && test $n -ge 0
          do
            printf '.' && sleep 1 && n=$(( $n - 1 ))
          done
          echo
       
          if test $n -lt 0 && test -s $OLD_PIN
          then
            echo >&2 "$OLD_PIN still exists after $TIMEOUT seconds"
            exit 1
          fi
          exit 0
        fi
        echo >&2 "Couldn't upgrade, starting '$CMD' instead"
        run "$CMD"
        ;;
      reopen-logs)
        sig USR1
        ;;
      *)
        echo >&2 "Usage: $0 <start|stop|restart|upgrade|force-stop|reopen-logs>"
        exit 1
        ;;
      esac

      Este archivo se encargará de apagar, encender y reiniciar un proceso de Unicorn para nuestra aplicación, asegúrate de personalizar la ruta que establece el valor de APP_ROOT con la ruta en la cual viva tu aplicación, y de poner tu usuario con el que accedes al servidor en la variable AS_USER.

      Debemos darle permiso de ejecución:

      chmod go+x unicorn_init.sh
    • El siguiente archivo se ubicará en config/unicorn.rb y tendrá la siguiente información:
      root = "/home/deployer/apps/mi_aplicacion"
      working_directory root
      pid "#{root}/tmp/pids/unicorn.pid"
      stderr_path "#{root}/log/unicorn.log"
      stdout_path "#{root}/log/unicorn.log"
       
      listen "/tmp/unicorn.miaplicacion.sock"
      worker_processes 2
      timeout 30

      Este archivo define los parámetros que le daremos a Unicorn como el timeout, el numero de workers, etcétera. También se define la ubicación del socket con el que se comunicará con Nginx. Asegúrate de personalizar el root y el listen según tu ambiente.

    • Crea el directorio pids dentro de la carpeta tmp de tu proyecto, porque lo va a necesitar Unicorn, ubicándote en la carpeta de tu aplicación, ejecuta este comando:
      mkdir tmp/pids

      Para que te cree este directorio:

      /home/deployer/apps/mi_aplicacion/tmp/pids/
    • Ahora vamos a crear un acceso directo del primer archivo que creamos para tener a la mano una ubicación desde donde levantar y apagar todos nuestros unicorns, primero nos movemos al siguiente directorio:
      cd /etc/init.d/

      Y creamos un acceso directo a nuestro archivo (puedes escoger el nombre que gustes para el acceso directo, yo tiendo a ponerles unicorn_elnombredelaapp para que sea fácil recordarlo):

      sudo ln -s /home/deployer/apps/mi_aplicacion/config/unicorn_init.sh unicorn_mi_aplicacion

      ¡Y ahora procedemos a levantar Unicorn!

      sudo /etc/init.d/unicorn_mi_aplicacion start

      Recuerda que puedes apagar y reiniciar Unicorn con los siguientes comandos:

      sudo /etc/init.d/unicorn_mi_aplicacion stop
      sudo /etc/init.d/unicorn_mi_aplicacion restart

      Cada que hagas cambios en tu código, deberás reiniciar Unicorn; si llegas a agregar alguna gema, es posible que restart no sea suficiente, sino que necesites darle stop y después start.

    • Para que se ejecute automáticamente cada que se reinicie el servidor, ejecutamos el siguiente comando:
      sudo update-rc.d /etc/init.d/unicorn_mi_aplicacion defaults
  8. Ahora vamos a realizar la conexión entre Nginx y Unicorn, primero nos movemos a nuestra carpeta de la aplicación:
    ~/apps/mi_aplicacion

    Y creamos el archivo config/nginx.conf con el siguiente contenido:

    upstream miapliacion {
      server unix:/tmp/unicorn.mi_aplicacion.sock fail_timeout=0;
    }
     
    server {
      listen 80;
      server_name www.miaplicacion.com miaplicacion.com;
      root /home/deployer/apps/mi_aplicacion/public;
     
      location ^~ /assets/ {
        gzip_static on;
        expires max;
        add_header Cache-Control public;
      }
     
      try_files $uri/index.html $uri @miaplicacion;
      location @miaplicacion {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_pass http://miaplicacion;
      }
     
      error_page 500 502 503 504 /500.html;
      client_max_body_size 4G;
      keepalive_timeout 10;
    }

    Asegúrate de personalizar el valor de upstream, en el server_name poner los dominios o subdominios a los cuales quieres que responda tu aplicación, en root poner la ruta de la carpeta public de tu aplicación, y en el try_files location y proxy_pass escribir lo mismo que pusiste en upstream agregandole una arroba al inicio.

    Para que funcione tu dominio/subdominio debes apuntarlos primero a la IP de tu servidor; esto lo puedes hacer desde antes de hacer esta guía. Esto quiere decir que en este punto de la guía, al visitar tu dominio o subdominio, deberías ver la pantalla inicial de Nginx; sino, quiere decir que no has configurado dichos dominios con tu proveedor, esto se hace desde su panel de administración, por ejemplo en GoDaddy estableces los NameServers de Linode y en tu Linode agregas dichos dominios/subdominios para que al visitarlos desde tu navegador veas tu servidor.

    Muévete al directorio de los sitios disponibles de Nginx:

    cd /etc/nginx/sites-enabled/

    Crea un acceso directo como lo hicimos con unicorn:

    sudo ln -s /home/deployer/apps/mi_aplicacion/config/nginx.conf mi_aplicacion

    ¡Y reinicia Nginx!

    sudo service nginx restart

    ¡Ya deberías ver tu sitio online en ambiente productivo!

    Si te salen errores no olvides revisar los logs de producción en tu carpeta de la aplicación, los logs de unicorn igualmente dentro de tu carpeta, o los logs de nginx si te has equivocado en la configuración.

Recursos

How To Install Nginx On Ubuntu 14.04lts
How To Deploy Rails Apps Using Unicorn And Nginx On CentOS 6.5
How To Deploy with Rbenv

Cómo instalar Oracle Java 8 en Ubuntu 16.04

Para instalar la versión 8 teclea en la terminal:

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java8-installer

Para instalar la versión 7 teclea en la terminal:

sudo apt-get install oracle-java7-installer

Verifica tu instalación con este comando:

java -version

O con:

javac -version

Cambia entre Oracle Java 8 y Oracle Java 7

Cambia a Java 7 (desde Java 8):

sudo update-java-alternatives -s java-7-oracle

Cambia a Java 8 (desde Java 7):

sudo update-java-alternatives -s java-8-oracle

Si te interesa instalar la versión open source, sigue esta guía.

Referencias

Install Oracle Java 8 in Ubuntu via PPA repository [JDK8]
How to Install Oracle Java 7/8 (JDK and JRE) In Ubuntu

Rails 4: where (first) vs find_by (take)

Normalmente para encontrar un registro, que sabía de antemano era único, usaba algo como:

Usuario.where( email: "hola@correo.com" ).first

Sin embargo, me acabo de enterar que en Rails 4 agregaron un método que lo abrevia:

Usuario.find_by( email: "hola@correo.com" )

Y cuando el elemento a encontrar es forzoso, podemos agregar un “!” para que mande una excepción de ActiveRecord::RecordNotFound si no lo encuentra:

Usuario.find_by!( email: "hola@correo.com" )

Y es que no solo se escribe un poco menos, sino que es más eficiente, ya que viendo la definición de find_by:

# File activerecord/lib/active_record/relation/finder_methods.rb, line 80
def find_by(*args)
  where(*args).take
end

Nos damos cuenta que usa take en lugar de first y la diferencia entre ellos es que first hace un ORDER extra:

First:

SELECT "usuarios".* FROM "usuarios" WHERE "usuarios"."email" = 'hola@correo.com' ORDER BY "usuarios"."id" ASC LIMIT 1

Take:

SELECT "usuarios".* FROM "usuarios" WHERE "usuarios"."email" = 'hola@correo.com' LIMIT 1

Por lo que si lo que necesitamos es obtener un registro único, es mejor utilizar find_by. 🙂

Mejores mensajes de los commits en GIT

Es importante la calidad de los mensajes, para cuidar la ortografía y la longitud de líneas prefiero usar vim, por lo que veremos a continuación.

Lo instalamos en Ubuntu:

sudo apt-get install vim

Le decimos a Git que lo use:

git config --global core.editor "vim"

Creamos archivo “~/.vimrc” con lo siguiente:

autocmd Filetype gitcommit setlocal spell textwidth=72

Al hacer un commit, no usar opción -m para que lance la ventana de vim:

git commit

vim inicio

Vim tiene dos modos: el de edición y el de comando.

Al entrar a vim se estará en modo de comando por lo que al escribir algo o dar enter no se reflejará en pantalla, para ello hay que pasarse al modo texto presionando una sola vez la tecla “i”, esto hará que se pueda escribir normalmente, para saber que lo hicimos bien, podemos ver que hasta abajo dice “– INSERTAR –“.

vim insertar

Escribimos el texto del commit, por la configuración que agregamos vim automáticamente pasará a una nueva línea cuando el mensaje sea demasiado largo, además de revisar que no tengamos errores de ortografía.

ortografia

Para salir y guardar, en modo comando escribir:

:wq

Para cancelar:

:q!

Si usan español en los mensajes y no les corrige bien la ortografía, pasen al modo de comando con la tecla “ESC” y escriban el siguiente comando:

:setlocal spell spelllang=es

Les preguntará si desean crear un directorio, y si desean descargar los diccionarios, a todo digan que sí:

descargar corrector ortografia

Si siempre usan español, pueden cambiarlo en el archivo ~/.vimrc:

autocmd Filetype gitcommit setlocal spell spelllang=es textwidth=72

Recursos:
How do I make git use the editor of my choice for commits?
5 Useful Tips For A Better Commit Message
Vim en dos minutos

Teclado personalizado en Ubuntu 14.04

Hace poco tuve la necesidad de comprar un teclado USB para una laptop que tenía algunas teclas que no funcionaban.

Desafortunadamente, ningún mapeo se ajustaba por defecto a los dibujitos que tenía en mi teclado.

entradas

El más cercano era el de español de España, pero tenía los acentos invertidos (la tecla con la tilde normal la ponía invertida y viceversa).

Así que tuve que modificar el mapeo manualmente. Para esto se necesitan abrir los mapeos del español con permiso de administrador. Desde una terminal teclea:

cd /usr/share/X11/xkb/symbols/
sudo gedit es

En mi caso intercambié las entradas:

key <AD11> { [dead_grave, dead_circumflex, bracketleft, dead_abovering ] };
key <AC11> { [dead_acute, dead_diaeresis, braceleft, braceleft ] };

Dejándolas como:

key <AC11> { [dead_grave, dead_circumflex, bracketleft, dead_abovering ] };
key <AD11> { [dead_acute, dead_diaeresis, braceleft, braceleft ] };

Y lo mismo para las teclas que deseen cambiar. Después de guardar, hay que regenerar la configuración:

sudo dpkg-reconfigure xkb-data

Al lanzar la aplicación Entrada de Texto de Ubuntu ya deberían ver los cambios reflejados en el vistazo del teclado que aparece ahí.

Entrada De Texto

teclado

Después de cambiar todo lo necesario, para que los cambios se vieran en el editor de texto que ya tenía abierto, yo tuve que decirle a Ubuntu que cambiará el mapa de caracteres con el atajo Super+Espacio, osea la tecla Windows y el espacio.

Y ya se puede usar la nueva configuración personalizada en todas las aplicaciones.