1. Instalación de paquetes

Actualizamos el Sistema Operativo (en mi caso use Centos 5.3 y necesitaba actualizarlo a la última rama del 5, es decir el 5.7)

su -c ‘yum update’

Podemos comprobar la versión con un

cat /etc/redhat_release

Los repositorios de CentOS 5 no están muy actualizados, así que si queremos trabajar con últimas versiones (o versiones específicas) necesitaremos compilar algunas cosas.

Paquetes necesarios para compilar

yum groupinstall ‘Development Tools’

Cabeceras C para que Ruby se compile con soporte para OpenSSL

yum install openssl-devel

Cabeceras de CURL, se ocuparán para que Passenger tenga soporte SSL

yum install curl-devel

Ngingx necesita PCRE  (Perl Compatible Regular Expressions) para su módulo rewrite

yum install pcre-devel

* Cabeceras para Sqlite (no es necesario si ocupamos otra base de datos que no es Sqlite , la cual viene por defecto con Rails en entorno de desarrollo)

yum install sqlite-devel

2. Instalación de Ruby

CentOS 5 tiene en los repositorios Ruby 1.8, pero como sabemos pronto acabará su soporte en favor de Ruby 1.9, entre otros motivos, por tal razón instalaremos Ruby 1.9.2 (versión estable hasta este momento).

Descargamos Ruby 1.9.2 y compilamos

wget ftp://ftp.ruby-lang.org/pub/ruby/ruby-1.9.2-p290.tar.gz
tar zxvf ruby-1.9.2-p290.tar.gz
cd ruby-1.9.2
./configure
make
sudo make install
cd ..

3. Instalación de Gem

Descagamos e instalamos Gem

wget http://rubyforge.org/frs/download.php/75573/rubygems-1.8.12.tgz
tar zxvf rubygems-1.8.12.tgz
cd rubygems-1.8.12
sudo ruby setup.rb
gem update

4. Instalación de Passenger

gem install passenger

5. Instalación de Nginx

A diferencia de  Apache, hacer que Passenger funcione con Nginx no es tan simple como cargar un módulo, lo que tenemos que hacer es compilar Nginx con soporte para Passenger. Para esto Passenger tiene un asistente de instalación para Nginx:

passenger-install-nginx-module

La opción 1 es mas más conveniente, sin embargo no usa la última versión de Nginx, y en caso de que queramos usar la última versión (o alguna en específico) deberemos bajar la fuente y usar la opción 2.

Cancelamos el asistente y bajamos la ultima versión de Nginx, luego descomprimimos

 wget http://nginx.org/download/nginx-1.0.11.tar.gz
tar zxvf nginx-1.0.11.tar.gz

*Es importante anotar la dirección de la carpeta donde se descomprimió Nginx, en mi caso /root/nginx-1.0.11

Ahora si corremos el asistente de Passenger  utilizando la opción 2 y completamos los datos solicitados (entre ellos la ruta de la carpeta descomprimida de Nginx)

passenger-install-nginx-module

Por defecto Nginx se instalará en /opt/nginx, pero eso lo podemos cambiar en el asistente. Ahora por comodidad crearemos los script para administrar Nginx como servicio:

wget http://library.linode.com/assets/662-init-rpm.sh
mv init-rpm.sh /etc/rc.d/init.d/nginx
chmod +x /etc/rc.d/init.d/nginx
chkconfig --add nginx
chkconfig --level 2345 nginx on 

Una breve descripción de lo usado allá arriba:

Línea 1: bajamos un script muy útil de linode que usaremos para la administración de Nginx
Línea 2: movemos el script donde los demás servicios
Línea 4: agregamos el servicio para ser manejado por chkconfig, el cual se encargará de revisar que cuente con los comandos de start y kill en cada uno de los niveles de ejecución.
Línea 5: indicamos que Nginx iniciará  en los niveles de ejecucion 2,3,4,5

Ahora iniciamos Nging (con soporte para Passenger) como cualquier servicio:

/etc/init.d/nginx start

Podemos comprobar los servicios corriendo:

chkconfig –list

6. Instalar Rails

Ya casi terminamos, ahora solo instalamos Rails, y creamos una aplicación de prueba para comprobar

gem install rails

 cd /opt/nginx/html
rails new prueba

7. Configurar Nginx y Passenger

Configuramos Nginx y Passenger para correr nuestra aplicación, para esto editamos y creamos una nueva entrada en /opt/nginx/conf/nginx.conf

server {
listen          80;
server_name     www.aqui-tu-dominio.com;  #Dominio
root            /opt/nginx/html/prueba/public; #Ruta de la app (apuntar a public)
passenger_enabled on; #Para que passenger haga el despliegue
error_log    /opt/nginx/html/siac/log/error.log;
access_log    /opt/nginx/html/siac/log/access.log;
}

Finalmente reiniciamos Nginx para que hagan efecto los cambios

/etc/init.d/nginx restart

Y Listo, ya tenemos nuestra aplicación Rails corriendo con Nginx y Passenger sobre Ruby 1.9.2 en CenOS 5

Pasos Opcionales

*Dependiendo  de la base de datos que usará tu aplicación te dejo los script para instalar MySQL y SQLite

Instalación de MySQL desde los repositorios

yum install mysql
yum install mysql-server
yum install mysql-devel
/etc/init.d/mysqld start

Instalación de SQLite compilado

wget http://www.sqlite.org/sqlite-autoconf-3070900.tar.gz
tar zxvf sqlite-autoconf-3070900.tar.gz
cd sqlite-autoconf-3070900
./configure
make
make install

1. Instalar Apache

Probablemente esta parte ya la tengas lista. Si no lo instalamos, en Ubuntu o Debian debería ser tan sencillo como:

sudo aptitude install apache2

2. Instalar RVM

RVM servirá para aislar las gemas de la aplicación, además de instar Ruby en caso que aun no lo tengamos. Para su instalación puedes ver la guía en el sitio oficial o seguir esta pequeña guía que escribí. Ten en cuenta las dependencias que necesitarás tener instaladas en tu servidor.

Para comprobar que RVM se ha instalado puede escribir en la consola: type rvm | head -1 si devuelve rvm is a function entonces todo bien, si no revisa un poco aquí los problemas más comunes y sus soluciones.

3. Instalar Ruby a través de RVM

Si ya tienes instalado Ruby no hay problema, puedes usar esa versión, si no igualmente puedes instalar la versión que quieras a través de RVM.

Para ejemplificar instalaremos la versión 1.8.7 de Ruby y lo dejaremos como versión por defecto del sistema, para esto escribimos en la consola:

rvm install 1.8.7 --default

*Al momento de escribir esto aún no hay una solución práctica para que Passenger pueda correr diferentes versiones de Ruby en RVM simultaneamente. Así que deberías usar una misma versión de Ruby para trabajar con todas tus aplicaciones.

4. Instalar gema passenger

En RVM existe un compartimiento global que puede ser usado por todos gemset que creemos. Es decir, todas las gemas puestas ahí estarán disponibles por cada gemset. Este gemset existe por defecto, y siguiendo con el ejemplo anterior (Ruby 1.8.7) podemos acceder a el de la siguiente forma:

rvm 1.8.7@global

y una vez dentro de ese contenedor, procedemos a instalar Passenger como gema global

gem install passenger

5. Instalar Passenger como módulo de Apache

Passenger está disponible tanto para Apache, como para Ngix. En este caso para instalarlo sobre Apache usaremos:

passenger-install-apache2-module

Una vez ejecutado el comando, nos aparecerá un asistente para guiarnos en la revisión de dependencias ,instalación y configuración de Passenger.

Para más información aquí la documentación oficial.

6. Configurar Apache para que corra Ruby y Passenger a través de RVM

Una vez finalizada la instalación anterior (passenger-install-apache2-module), luego de varias lineas de compilación e instalación,  la consola imprimirá 3 lineas necesarias para la configuración de Apache:

Copiar esas líneas y ponerlas en el archivo de configuración de Apache. En Ubuntu/Debian el archivo está en /etc/apache2/apache2.conf

Solo resta reiniciar Apache y ya tendrá soporte para Passenger :)

7. Instalar Rails

A este punto, el servidor está listo para la implementación de las aplicaciones en Rails, de esta forma el siguiente  paso es configurar el sitio/proyecto bajo todo el entorno que previamente hicimos. La idea base es que cada aplicación corra dentro de su propio contenedor de gemas.

7.1. Crear el contendor:

rvm gemset create contenedor

7.2. Iniciar en el intérprete y contenedor de gemas

rvm 1.8.7@contenedor

7.3. Instalar Rails

gem install rails

*Lo más seguro es que no te interese instalar la documentación de las gemas, así que te recomiendo instalar rails con los parámetros no-rdoc , no-ri

8. Configurar Aplicación

8.1 Crear/Migrar proyecto

En el directorio donde queremos poner nuestra aplicación (por lo general /var/www/ ): Creamos una nueva aplicación Rails con el comando rails new proyecto (en caso de ser Rails 3 lo que hayamos instalado) o copiamos el proyecto que queremos migrar.

8.2 Configurar Virtual Host de Apache

Si vamos a tener varios sitios corriendo en el mismo servidor, es recomendable configurar Virtual Host de Apache. En el caso de Debian/Ubuntu , esas configuraciones están en: /etc/apache2/sites-enabled (pero se habilitan en /etc/apache2/apache2.conf ). Podemos configurar la entrada por defecto 000-default o crear una nueva. Básicamente las configuraciones son:

<VirtualHost *:80>
  ServerName www.nombredelsitio.com
  DocumentRoot /tu_aplicacion/public    # <-- Confirmar que apunte al directorio 'public'
  <Directory /tu_aplicacion/public>
  AllowOverride all              # <-- Cambiar , por defecto viene en none
  Options -MultiViews            # <-- cambiar, MultiViews deben estar desabilitadas
  </Directory>
 </VirtualHost>

8.3 Configurar rutas

Lo siguiente es decirle a tu aplicación como y donde encontrar las gemas y versión de Ruby que usará Passenger ( Esto es necesario por que lo estamos haciendo a través de RVM), la información detallada está en la documentación de RVM > Intergación con Passenger, pero básicamente es:

8.3.1. Crear un archivo .rvmrc

Creamos un archivo llamado “.rvmrc” en la raiz del proyecto, para indicar  las rutas de Ruby y contenedor de gemas que utilizamos con RVM, (esto es por cada proyecto). Para esto, corremos en la consola el comando

rvm use 1.8.7@contenedor --rvmrc --create

*Recuerda cambiar la versión del intérprete y contenedor que usas.

8.3.2. Crear archivo setup_load_paths.rb

Finalmente en la carpeta /config/ del proyecto de Rails  crear un archivo llamado setup_load_paths.rb, En el caso del ejemplo utilizando Rails 3, el contenido del archivo seria:

if ENV['MY_RUBY_HOME'] && ENV['MY_RUBY_HOME'].include?('rvm')
 begin
 rvm_path     = File.dirname(File.dirname(ENV['MY_RUBY_HOME']))
 rvm_lib_path = File.join(rvm_path, 'lib')
 $LOAD_PATH.unshift rvm_lib_path
 require 'rvm'
 RVM.use_from_path! File.dirname(File.dirname(__FILE__))
 rescue LoadError
 # RVM is unavailable at this point.
 raise "RVM ruby lib is currently unavailable."
 end
end

ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', File.dirname(__FILE__))
require 'bundler/setup'

En el caso de ser Rails 2, el contenido del archivo sería

if ENV['MY_RUBY_HOME'] && ENV['MY_RUBY_HOME'].include?('rvm')
 begin
 rvm_path     = File.dirname(File.dirname(ENV['MY_RUBY_HOME']))
 rvm_lib_path = File.join(rvm_path, 'lib')
 $LOAD_PATH.unshift rvm_lib_path
 require 'rvm'
 RVM.use_from_path! File.dirname(File.dirname(__FILE__))
 rescue LoadError
 # RVM is unavailable at this point.
 raise "RVM ruby lib is currently unavailable."
 end
end

Para más información sobre la integración de Passenger con RVM esta la documentación oficial y  el artículo The Path to Better RVM & Passenger Integration de donde se tomo parte de las mejoras para RVM y Passenger.

Con la recien salida de Rails 3, se introdujeron bastantes cambios y obviamente actualizaciones de las gemas bases.Si instalamos Rails 3 (y sus dependencias) en la misma computadora en que tenemos aplicaciones corriendo bajo alguna versión anterior de Rails, probablemente tengamos problemas, con las aplicaciones viejas, por conflictos entre gemas (en caso que no hayamos utilizado Bundler o congelado la aplicación)

Para solucionar estos inconvenientes existe Ruby Version Manager (a partir de aquí simplemente RVM). La idea es que tengamos ambientes aislados en los que cada uno pueda tener su propia versión de Ruby y gemas instaladas, de esta manera podemos probar nuestra aplicación en varios escenarios y/o tener aplicaciones con requerimientos diferentes corriendo sin conflictos.

A Instalar RVM!

1. Instalar RVM

Primero, lo primero: La manera más práctica de instalarlo es mediante sus repositorios

mkdir -p ~/.rvm/src/ && cd ~/.rvm/src && rm -rf ./rvm/ && git clone --depth 1 git://github.com/wayneeseguin/rvm.git && cd rvm && ./install

Ya les dije que necesitamos tener git?, mmm si necesitamos git, y configurar algunas variables en el path. Algo como:

$ source ~/.rvm/scripts/rvm

O de manera definitiva modificando el  .bash_profile

[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm"  # This loads RVM into a shell session.

Para más información y solución de problemas sobre la instalación aquí la documentación oficial , tranquilo, esta es la parte más problemática luego todo va sobre rieles ;).

2. Instalar versión Ruby

Una vez que ya este corriendo RVM, vamos a instalar la versión de Ruby que queremos.
(Nota: Necesitamos openssl)

Si por ejemplo queremos instalar Rails 3 corriendo sobre Ruby 1.9.2, primero tenemos que instalar Ruby 1.9.2 (lógico? xD)

$ rvm install 1.9.2 --with-openssl-dir=/usr/local 

Esperamos que se descargue, se configure, compile, e  instale ….

3. Crear el sandbox de gemas

Ya tenemos el intérprete, ahora necesitamos las gemas. Por tal razón creamos un contenedor donde estarán aprisionadas y no podran salir!

rvm gemset create contenedor1

4. Iniciar en el intérprete y contenedor de gemas deseado

rvm 1.9.2@contenedor1

Listo, ya estamos corriendo ruby 1.9.2 en un contendor aislado. Verificando…

Todo bien, y solo falta instalar Rails:

gem install rails

6. Volver al modo normal

Si ya estamos aburridos de jugar con nuestra aplicación, o queremos volver a los programas instalados en nuestra computadora (fuera de todo contenedor) lo hacemos con:

rvm system

Para recientes proyectos escribí un plugin que le diera la libertad al usuario de poder cambiar elementos en portada,  como pensé que sería útil lo envié a directorio de plugins de WordPress , lo aceptaron  y aquí esta una reseña del plugin :

http://wordpress.org/extend/plugins/ev-widget-post/

Funcionamiento

Una vez instalado el plugin, te agregará en las opciones de Widget, un nuevo módulo llamado “EV Widget Post” , lo arrastras como cualquier Widget a la posición deseada y completas las opciones:

• Title: Título del Widget
• Category: Se mostrarán las entradas de la categoría que escojas
• Order by: Modo de ordenamiento, aleatorio o por fecha
• How many post: Número de entradas a mostrar
• Show excerpt: Si habilitas la opción se mostrará el extracto
• Show thumbnail: Si habilitas la opción se mostrarán las miniaturas
• Thumbnail size: Tamaño de la miniatura
• Enable secondary format: Habilita un segundo formato para entradas ( con mismas opciones q la principal)
• Show *See More* link: Si habilitas la opción aparecerá al final del widget un enlace a la categoría escogida

FAQ

¿De dónde toma las imágenes?

La imagen la toma del elemento definido en “Usar como imagen destacada” en las opciones de la entrada. Para esto es necesario tener habilitada la opcion the_post_thumbnail en tu tema.

¿Dónde cambio el tamaño de las imágenes?

Los tamaños de la imagen están definidas por los parámetros establecidos en las opciones de Multimedia de  WordPress.  Por defecto estos tamaños son:

• thumbnail 150px x 150px max
• medium 300px x 300px max
• large 640px x 640px max

¿Cómo cambio los estilos?

Puedes definir tus propios estilos en el archivo style.css de tu tema, El widget genera sus propias definiciones de clase ( puedes verlo usando herramientas como Firebug, Web Inspector, Dragonfly, o similares). Por ejemplo si quieres cambiar el tamaño del título, puedes definir una regla como: h3.ev-widget-post-tittle {font-size:16px;}

Donar

Con la salida de la versión 3 de la API de Google Maps (para javascript) no se necesitan más API keys para trabajar sobre los mapas de Google, y la verdad han mejorado bastante la manera de tratar con ellos.

De manera sencilla, para hacer una invocación de un mapa necesitaremos:

• La librería javascript de Google Maps
• Un espacio donde dejaremos caer el mapa (un div o realmente cualquier declaración tipo bloque )
• El script que hagamos para invocar el mapa y agregarle interactividad

Reuniendo estos elementos nos queda algo así:

<html>
 <head>
 <!-- Invocar la libreria de Google Maps-->
 <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false"></script>

 <!-- Script donde creamos el mapa y agregamos interactividad-->
 <script type="text/javascript">
 function dibujar_mapa() {
 var centro = new google.maps.LatLng(12.129334, -86.266365); // Coordenadas del centro del mapa
 var opciones = { // parametros del mapa
 zoom: 12, // Zoom, puede ir desde 1 a 18
 center: centro, // definimos el centro (que previamente fue establecido en la variable latlng)
 mapTypeId: google.maps.MapTypeId.ROADMAP // Tipo de Mapa
 };
 var map = new google.maps.Map(document.getElementById("mapa"),opciones); // Hacemos que el mapa se dibuje en la el elemento #mapa
}
 </script>
 </head>
 <body onload="dibujar_mapa()"> <!-- Cuando cargue el sitio dibujar mapa -->
 <div id="mapa" style="width:100%; height:100%"></div>
 </body>
</html>

Ver Ejemplo

Si queremos agregar algún punto, agregaríamos al script anterior, lo siguiente:

var marcador = new google.maps.Marker();
 marcador.setPosition(centro);
 marcador.setMap(map);

Ver Ejemplo

Geolocalización

Ahora la parte de la Geolocalización, basicamente consiste en obtener tu dirección IP y basado en eso recopilar información sobre los puntos de acceso  cercanos para proporcionarte una aproximación de tu ubicación. En las versiones recientes de los navegadores modernos ya podemos contar con esta característica.

Para trazar nuestra posición tenemos que ubicar en el centro del mapa nuestra posición para luego dibujarla.

function getUsersLocation() {
 if (navigator.geolocation) { // Preguntar si el navegador soporta geolocalizacion
 navigator.geolocation.getCurrentPosition(function(position) {//obtener nuestra posicion
 var pos = new google.maps.LatLng(position.coords.latitude,
 position.coords.longitude);
 map.panTo(pos); //Mover el mapa hasta la nueva posicion geolocalizada
 }, function() {
 // En caso de no encontrar la ubicacion hacer algo
 });
 }
}

Momento de mezclar todo:

<html>
 <head>
 <title> Flasheves - Experimento de Geolocalizacion con javascript </title>
 <style type="text/css">
 html, body {
 height: 100%;
 margin: 0;
 }

 #map {
 height: 100%;
 }
 </style>
 <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false"></script>

 <script type="text/javascript">
 function init() {
 if (navigator.geolocation) {
 navigator.geolocation.getCurrentPosition(function(position) {
 var pos = new google.maps.LatLng(position.coords.latitude,position.coords.longitude);
 var marcador = new google.maps.Marker();

 var map = new google.maps.Map(document.getElementById('map'), {
 zoom: 14,
 center: pos,
 mapTypeId: google.maps.MapTypeId.ROADMAP
 });

 marcador.setPosition(pos);
 marcador.setMap(map)

 }, function() {
 alert("nel pastel, su navegador tiene que soportar Geolocalizacion");
 });
 }
 }

 google.maps.event.addDomListener(window, 'load', init);

 </script>

 </head>
 <body>
 <div id="map"></div>
 </body>
</html>

Ver Ejemplo

Creo que el código se entiende por si mismo, a grandes rasgos lo que hace es:

• Llamar las librería necesaria para Google Maps
• Crear el espacio para dibujar el mapa
• En caso que el navegador soporte geolocalización > obtener nuestra posición
• Dibujar el mapa tal como lo hicimos en el primero ejemplo, con la diferencia que esta vez trazará como centro nuestra posición
• En caso nuestro navegador no soporte geolocalización mostrar un mensaje

La geolocalización cada vez tiene más presencia, ya hemos visto ejemplos como Foursquare, Google Places, Facebook Places , sacando más provecho aún con la ola de nuevos dispositivos con GPS. Así mismo  se podrían crear iniciativas locales, para terminar les dejo los enlaces de La documentación oficial de Google Maps y esta muy buena presentación expuesta en el Google Dev Fest.

Por un lado, podemos instalar la gema ruby-debug, la cual nos permitirá debuggear nuestras aplicaciones (tanto en un IDE como fuera de el)

 sudo gem install ruby-debug 

Con la gema anterior ya podemos hacer debug, sin embargo para NetBeans y Eclipse  está la gema ruby-debug-ide la cual es más rápida y tiene mejor soporte. Asi bien, la instalamos :)

 sudo gem install ruby-debug-ide 

Listo, ahora abrimos nuestro proyecto con NetBeans e iniciamos el servidor en modo debug

Eso es todo > ahora podemos empezar a debuggear, definir Break Point, ver el estado de las varibales (y expresiones), ver los Call Stack, entre otros.

Revisando un poco por ahi me encuentro con que es posible configurar el App Engine para que funcione con  Ruby on Rails, a continuación detallo los pasos para lograrlo. Por cierto los pasos son para una instalación en Unix (ya que uso Ubuntu :) para trabajar en RoR, por que lo he usado en Windows y es muy inestable)

1. Para empezar necesitas tener habilidato el servicio de App Engines  en tu cuenta de Google (y crear una aplicación),  tener instalado en tu computador ruby 1.8.7 o mayor (aunque he leido que desde  ruby 1.8.4 funciona) y gem.
2. Instalar la gem de Google App Engine:
   

    sudo gem install google-appengine 

3. El App Engine ya soporta el beta de Rails 3.  Sin embargo como aún se no está disponible el release estable, (aún esta en RC1) te recomiendo usar la última rama el 2. que es Rails 2.3.8
   

   sudo gem install rails -v "2.3.8" 

4. Como App Engine usa BigTable para almacenar la información necesitaremos las siguientes gemas
   

    sudo gem install rails_dm_datastore
    sudo gem install activerecord-nulldb-adapter

5. Una aplicación RoR base con algunas configuraciones propias de Google para funcionar, deben descargar el archivo  http://appengine-jruby.googlecode.com/hg/demos/rails2/rails238_appengine.rb
6. Ahora solo deberas correr el archivo que descargaste para hacer la aplicación base:
   

   ruby rails238_appengine.rb 

7. Modificar el archivo app.yaml para que coinsida con tu aplicación en App Engine
   

   application: ID-DE-TU-APLICACION
   version: 1
   runtime: jruby
   ...
   

8. Listo, ahora puedes subir tu aplicación RoR en App Engine con el comando.
   

    ruby script/publish.sh 

Cuando trabajamos con WordPress en localhost se almacenan referencias de imágenes y otras opciones de configuración; con nuestro dominio local (ej: http://localhost/sitiodeprueba) que posteriormente debemos actualizar para que direccionen a nuestro dominio real (ej: http://www.dominioreal.com).

Aquí hay un listado de consultas sql que puedes generar para corregir los registros y que dirijan al nuevo dominio. Sin embargo mi recomendación es que cuando inicies tu proyecto, configures el archivo hosts para que el dominio final del sitio este configurado con tu localhost, de esta manera una vez que publiques la página en el servidor de producción no tengas que cambiar las URLs  y GUID almacenados en la base de datos.

Para esto primero debes abrir el archivo hosts:
Si usas Windows este archivo debería esta en C:\Windows\System32\drivers\etc\hosts
En las distribuciones de Linux esta en /etc/hosts
Y en los  Mac OS en /private/etc/hosts

En el debes insertar en una linea nueva la correspondencia dominio-dirección IP. Como lo que queremos es que el dominio haga referencia a nuestro localhost quedaria algo como:

127.0.0.1      dominioreal.com
127.0.0.1       www.dominioreal.com

Guardamos y listo, ya podemos trabajar de manera local usando el dominio final. Recordemos que una vez configurados los DNS con nuestro proveedor deberemos eliminar esa directiva local para que veamos realmente los cambios en el sitio publicado en el servidor de producción.

no-etiqueta-inicio es un plugin para WordPress que te permitirá eliminar de la portada (home) los post (entradas) con las etiquetas que especifiques.

Nace por un requerimiento en un proyecto, pero si a alguien le sirve (muy probablemente te sea útil!) aqui esta.

Funcionamiento:

En el panel “No Etiquetas“  ingresas el nombre de las etiquetas (separados por coma) de los post que no quieres que aparescan en portada.

Si por ejemplo escribes “viajes, otros“  todos los post que posean esas etiquetas desaparecerán del home, pero si estarán disponibles en las vistas de categorias, etiquetas y otras páginas.

Instalación:

1. Descargas el plugin aqui
2. Descomprimes los archivos
3. Subes la carpeta  ‘no-etiqueta-inicio’  al directorio de plugin de tu WordPress  ‘/wp-content/plugins/’
4. Activas el plugin a través del menú ‘Plugins’ de WordPress

Fuente del Plugin en GitHub
Descargar Plugin

Un tiempo atrás estaba buscando un WebService para obtener el tipo de cambio de dólar – córdoba, todos inexactos. Y el único lugar para encontrar el cambio oficial es en la página del Banco Central de Nicaragua sin embargo la única manera de obtenerlo era mediante una tabla horrible que actualizan mensualmente.

De esta manera construí un pequeño WebService para que cualquier persona que necesite estos datos en una aplicación, los pueda usar de manera transparente (y estándar). A continuación los detalles del WebService:

Tipo de WebService: REST

URL: http://www.elpueblopresidente.com/servicios/wsmoneda.php?

Parámetros:

dia: [Entero]

Número para identificar el día en que se quiere el tipo de cambio. Si no se pasa parámetros toma el dia actual.

mes: [Entero]

Número para identificar el mes que se quiere el tipo de cambio. Por defecto toma el mes actual

ano: [Entero]

Número para identificar el año que se quiere el tipo de cambio. Por defecto toma el año actual

formato: [Cadena] xml  / json / jsonvalido

Cadena para definir el formato de salida del servicio web, “xml” por defecto, “jsonvalido” para json válido, y “json” para salida json contenido entre paréntesis “( )”  *Necesario por algunos framework javascript.

limite: [Entero]

Número para definir la cantidad de registros consecutivos a partir la fecha especificada.

Ejemplos de uso:

http://www.elpueblopresidente.com/servicios/wsmoneda.php

http://www.elpueblopresidente.com/servicios/wsmoneda.php?dia

http://www.elpueblopresidente.com/servicios/wsmoneda.php?dia=15&mes=9&ano=2009

http://www.elpueblopresidente.com/servicios/wsmoneda.php?formato=json

http://www.elpueblopresidente.com/servicios/wsmoneda.php?formato=jsonvalido

http://www.elpueblopresidente.com/servicios/wsmoneda.php?limite=7

* El WebService no tiene una definición WSDL

** La información del WebService es obtenida a partir de la tabla de tipo de cambio que actualiza el www.bcn.gob.ni mensualmente,mediante un robot que parsea los datos y los ingresa una base de datos ( fuera de BCN )