Archive for the ‘Uncategorized’ Category

Valores por defecto para argumento hash

Thursday, December 4th, 2008

Cuando un método requiere varios argumentos puede resultar difícil recordar el orden en que deben ser pasados. Es por esto que algunos lenguajes permiten invocar métodos a través de nombres de parámetros y sus valores. Ruby no soporta esa forma, pero se puede obtener, el mismo resultado, a través del uso de un hash en el argumento.

Buscando encontré esta estupenda forma de establecer valores por defecto en un hash, de manera de obtener argumentos opcionales en la invocación.


def foo args
  args[:unidad] ||= 0
  args[:total] ||= 1
  args[:unidad] / args[:total]
end

>> foo :unidad => 23
=> 23
>> foo :total => 12
=> 0

Referencia

Hello world!

Friday, July 4th, 2008

Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!

Sanción de Ley para la prohibición de centrales nucleares

Saturday, June 21st, 2008

Logo de Eco Acción Mendoza

A vista de los eventos (especialmente lo sucedido el 16 de julio)que ocurrieron en la planta Kashiwazaki de Japón. Eco-Acción Mendoza se dispone a comenzar una campaña para que se sancione una Ley para la prohibición de centrales nucleares en Mendoza.

Eco-Acción Mendoza organiza todos los sábados a las 16hs reuniones
en el auditorio de radio nacional en Emilio Civit 460 de Ciudad.

Dejo aquí el comunicado emitido para dicha campaña

[descargar]

Almacenar objetos en una sesión

Saturday, June 21st, 2008

Voy
explicar a través de un simple ejemplo como guardar un objeto en una
sesión de php y luego recuperarlo. El ejemplo está basado en PHP 5 y
está formado por 3 archivos php:

a.php
Archivo que contiene la definición de la clase
b.php
Archivo que crea la sesión e instancia un objeto de la clase. Luego lo guarda en la variable SESSION
clase.php
Recupera el objeto de SESSION y lo muestra por pantalla
PHP:

  1. //Archivo clase.php
  2. class Clase {
  3.   private $precio;
  4.   private $cantidad;
  5.  
  6.   public function __construct($p, $c){
  7.     $this->cantidad = $c;
  8.     $this->precio = $p;
  9.   }
  10.   public function getTotal(){
  11.     return $this->precio*$this->cantidad;
  12.   }
  13.   public function __toString(){
  14.     return ‘Hay ‘.$this->cantidad.‘ de articulos, que cuestan ‘.$this->precio;
  15.   }
  16. }
PHP:

  1. //Archivo a.php
  2. include(‘./clase.php’);
  3. $obj = new Clase(3, 3.14);
  4. $_SESSION['o'] = serialize($obj);
  5. header (‘Location: ./b.php);
PHP:

  1. //Archivo b.php
  2. include(‘./clase.php’);
  3. $obj = unserialize($_SESSION['o']);
  4. echo $obj.\n;
  5. echo $obj->getTotal();
  6. unset($_SESSION['o']);

La salida de b.php sería

Hay 3 de articulos, que cuestan 3.14
9.42

Básicamente lo que hacemos es utilizar la función serialize para representar el objeto como un string y de esta manera guardarlo en SESSION. Luego con unserialize transformamos la cadena en objeto.

Es importante notar que en el lugar donde transformemos la cadena en
objeto debemos incluir el archivo que contenga la definición de la
clase, para que de esta manera PHP sepa como crear el objeto.

Aquí les dejo como luce el objeto cuando lo serializamos

O:5:"Clase":2:{s:15:" Clase cantidad";i:3;s:13:" Clase precio";d:3.140000000000000124344978758017532527446746826171875;}

Incluir licencia a nuestros proyectos en Netbeans

Friday, June 20th, 2008

La forma más sencilla es a través de los Template,
para esto sólo tendremos que editar unas propiedades y crear un archivo
con la licencia. La explicación se basa en la versión 6.0.1 de Netbeans.

Crear la licencia

Antes que nada debemos elegir (o definir) la licencia que utilizaremos, en mi caso utilizaré GPL 2.0. En la página de la GNU podemos encontrar un ejemplo que podremos agregar a nuestro código. Aquí dejo el ejemplo.


Copyright (C) yyyy name of author

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

El texto de la licencia debería estar encerrada entre delimitadores de
comentarios, según el lenguaje de programación que utilicemos en el
proyecto. Por ejemplo en un proyecto Java, tendríamos que encerrarlo
entre /* */.

Una vez elegida nuestra licencia, tenemos que escribirla en un archivo de texto plano (.txt) y guardarla con un nombre que siga a la siguiente sintaxis: license-mylicense.txt, en donde mylicense pueden poner el nombre que les parezca. Este nombre nos servirá luego para identificar a la licencia.

Cargar la licencia

Ahora hay que abrir netbeans, luego nos vamos a Tools->Templates, nos aparecerá una ventana, en la que se administra los Templates, debemos buscar una carpeta/template que diga Licenses, le damos un click y tocamos el botón Add. Ahora tan sólo tendremos que buscar el archivo que creamos anteriormente y listo.

Template Manager, para cargar la licencia

Editar las propiedades del proyecto

Tenemos que indicar al proyecto qué licencia utilizaremos.
Simplemente hay que agregar una variable en el archivo de propiedades
del proyecto. Nos vamos a la carpeta donde tenemos nuestro proyecto,
dentro hay una carpeta llamada nbproject y dentro de ésta el archivo que tenemos que editar project.properties. Al final del archivo agregamos la siguiente variable project.license y el valor de ésta es el nombre del archivo de la licencia después del license-. Nos quedaría siguiendo con el ejemplo del nombre que le colocamos.


project.license=mylicense

Ahora cada vez que creemos una clase (por ejemplo en un proyecto Java) se nos agregará al comienzo la licencia.

Bibliografía


Herencia en Rails

Friday, June 20th, 2008

Después de leer y reunir información de varios sitios pude entender como implementar la herencia en Ruby on Rails; utiliza el enfoque STI.

STI: En este enfoque cada modelo/entidad perteneciente a la jerarquía de la herencia se representa en una única tabla. Está tiene un atributo especial (columna) que identifica a qué modelo/entidad corresponde dicho registro/tupla.

Por lo tanto, tendremos una única tabla con todos los atributos de todos los modelos/entidades más un atributo especial.

Tuve problemas precisamente cuando tengo una herencia con más de un nivel, la solución es igual que tener un nivel de herencia. Dejo aquí un ejemplo ilustrativo del asunto.

Herencia citada en el ejemplo

Cada modelo podríamos asignarle los siguientes atributos

  • Vehiculo
    • nombre, del tipo String
  • Aereo
    • alas, del tipo Integer
  • Terrestre
    • ruedas, del tipo Integer
  • Auto
    • puertas, del tipo integer

Ahora creemos las cuatro clases en app/models las cuales quedarán con el siguiente aspecto

  • vehiculo.rb
    
    class Vehiculo < ActiveRecord::Base
    end
    
  • aereo.rb
    
    class Aereo < Vehiculo
    end
    
  • terrestre.rb
    
    class Terrestre < Vehiculo
    end
    
  • auto.rb
    
    class Auto < Terrestre
    end
    
    

Necesitamos crear un archivo migrate para mapear nuestros modelos a la base de datos (en este caso MySQL), este archivo tendría el siguiente aspecto:


class Ejemplo < ActiveRecord::Migration
  def self.up
    create_table :vehiculos do |t|
      t.column :nombre, :string
      t.column :alas, :integer
      t.column :ruedas, :integer
      t.column :puertas, :integer
      t.column :type, :string
    end
  end

  def self.down
    drop_table :vehiculos
  end
end

Indicaremos a Rails que implemente el esquema anterior, sólo bastará un rake:migrate. Esto nos genera la siguiente tabla



mysql> describe vehiculos;
+———+————–+——+—–+———+—————-+
| Field   | Type         | Null | Key | Default | Extra          |
+———+————–+——+—–+———+—————-+
| id      | int(11)      | NO   | PRI | NULL    | auto_increment |
| nombre  | varchar(255) | YES  |     | NULL    |                |
| alas    | int(11)      | YES  |     | NULL    |                |
| ruedas  | int(11)      | YES  |     | NULL    |                |
| puertas | int(11)      | YES  |     | NULL    |                |
| type    | varchar(255) | YES  |     | NULL    |                |
+———+————–+——+—–+———+—————-+
6 rows in set (0.01 sec)

Por último probemos como Rails resuelve la herencia, para esto utilizaremos la consola (script/console). Ire creando objetos (que se mapearan como registros en la base de datos) de los distintos modelos/entidades.


>> a = Vehiculo.create
=> #<Terrestre id: 1, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Vehiculo">

>> b = Aereo.create
=> #<Terrestre id: 2, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Aereo">
>> c = Terrestre.create
=> #<Terrestre id: 3, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Terrestre">
>> d = Auto.create
=> #<Auto id: 4, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Auto">

Como se puede ver, según el tipo de modelo creado, Rails establece el valor de la columna type. Ahora haré una serie de find, así se podrá ver cómo soluciona la herencia Rails.


>> Vehiculo.find :all
=> [#><Vehiculo id: 1, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: nil>, #<Aereo id: 2, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Aereo">, #<Terrestre id: 3, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Terrestre">, #<Auto id: 4, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Auto">]

Acá indiqué que me traiga todos los Vehiculos, es lo que se esperaba, me trajo todo los registros, ya que cada modelo hereda de Vehiculo y por la herencia cada modelo es un vehiculo.


>> Aereo.find :all
=> [#<Aereo id: 2, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Aereo">]

Como cree un sólo registro del tipo Aereo, me trae ese único. Ahora veamos el problema que comenté al inicio del post


>> Terrestre.find :all
=> [#<Terrestre id: 3, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Terrestre">, #<Auto id: 4, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Auto">]

Bien, me ha traído los dos registros, acá es igual que en el primer find que mostré, ya que Auto es un Terrestre (por la herencia), por lo tanto Rails debe traerme también ese tipo de registros


>> Auto.find :all
=> [#<Auto id: 4, nombre: nil, alas: nil, ruedas: nil, puertas: nil, type: "Auto">]

De este modo podemos implementar, en Ruby on Rails, el concepto de herencia..