Logo de La Coctelera

mamuso.net

inicio sindicaci;ón

Categoría: Ruby on Rails

Hola de nuevo! Vuelvo a la carga tras mi temporada de barbecho digital bloguero en la que he hecho en the cocktail cosas tan divertidas y bonitas como la web de mtv españa. Qué voy a decir yo que no haya dicho álvaro.

Ahora a divertirme. Jugando con la api de youtube vemos que podemos conseguir lo básico para poder tirar de su información con nuestra aplicación. Tenemos una gema que nos hace la vida más fácil.

Lo único que no nos devuelve la api de youtube directamente es la url del flv que va a cargar su player. No es que nos valga para muchas cosas, pero en casos concretos nos puede interesar (nah, nada de detalles).

Pongamos el caso de la url este video. La anatomía de la url (http://www.youtube.com/watch?v=0xaX7ZfX054) nos da la id del video, y incluso sin tirar de la gema sabremos que la url del player es http://www.youtube.com/v/0xaX7ZfX054.

La url directa al flv no es tan intuitiva de construir.

http://www.youtube.com/get_video.php?video_id=la sabemos&t=token de youtube a averiguar

Así que con un poquito de ruby (y definiendo un método string.to_hash):

require 'open-uri'
 
 class String
    def to_hash(seperation='&', assignment='=')
      hash = Hash.new
      self.split(seperation).each do |elemement|
        pieces = elemement.split(assignment)
        hash[pieces[0]] = pieces[1]
      end
      hash.delete_if { |key, value| value.nil? }
    end
 end
 
 
 def get_flv(url)
   getparams = nil
   open(url) {|f|
       getparams = f.base_uri.request_uri.split("?")[1]
   }
   unless getparams.nil?
     parameters = getparams.to_hash()
     url = "http://www.youtube.com/get_video.php?video_id=#{parameters['video_id']}&t=#{parameters['t']}"
   end  
   return url
 end

Así con una simple llamada a get_flv('http://www.youtube.com/v/0xaX7ZfX054') nos devolverá la url al flv.

A disfrutar!

  • Tags: , , , ,
  • compártelo favorito

Hace MUCHO que comencé a andar con smupf, cuando todavía era una buena idea. Como toda buena idea pedía a gritos una ejecución rápida e imperfecta impulsada por una buena dosis de ilusión, pero fue a parar conmigo (uno no elige a sus padres) y se fué atascando en sucesivos bucles de refinado y reescritura.

El proyecto se basa (basaba más bien) en la creación de un interfaz para el blogueo de mapas tomando como base google maps y como público aquellos que nunca tocarán una línea de su api. He perdido muchas horas definiendo la interacción, y una cantidad vergonzosa de tiempo desarrollando adelante y atrás, empollando apis e incorporando ideas.

Y el perfeccionismo mató a la idea.

Ahora existe la opción de 'mis mapas', que lejos de quedarse en un pequeño servicio, va creciendo en funcionalidad a pasos agigantados, así que la posibilidad de bloguear un mapa desde el propio google es cuestión de tiempo, y es totalmente imbatible.

Duele un poquito decidir que quieres dejar de hacer una cosa a la que le has dedicado tantísimo tiempo y de la que has hablado a la gente que te importa, pero es necesario cerrar los viejos proyectos antes de afrontar los nuevos.

Esta decisión se me hace un poquito más dramática porque la he tomado mientras terminaba de crear una cuentas de prueba para los sospechosos habituales (esos que me importan) y que iban a ser convenientemente enviadas esta semana.

Acaba de subir la revisión 779 al repositorio, y ahí quedará para recordarme que la próxima vez debo de ser más rápido.

De todo esto queda una bonita experiencia, un camino de aprendizaje que no siempre ha sido fácil y un plugin para rails :)

  • Tags: , ,
  • compártelo favorito

Si te gusta jugar con rails y nunca has probado hpricot (del siempre genial y bizarro whytheluckystiff) te lo recomiendo. En mi caso lo había probado un par de veces, pero para funciones muy básicas.

En este caso vamos a jugar con la opción que tiene para 'arreglar' inputs de html que vengan un poco escacharraillos ¿quién no se ha dejado un div sin cerrar? Pues esta gema nos va a ayudar a dejar el código limpito de verdad.

No descubro nada que no esté en la documentación, pero es que me ha parecido genial.

Cojamos el código a parsear, bien desde un archivo:

doc = Hpricot(open("tudocumento.html"))
 

Bien desde una variable:

doc = Hpricot(param[:mivariable])
 

Tenemos dos opciones. No toques mi código, sólo cierra lo que esté abierto:

doc = Hpricot(mivariable_o_documento) { |f| Hpricot f, :fixup_tags => true }
 

O bien cierra todo lo que esté abierto, y además convierte mi código en xhtml estricto:

doc = Hpricot(mivariable_o_documento) { |f| Hpricot f, :xhtml_strict => true }
 

Problemas, los hay. Cuando te enfrentas a un código (pegado desde word, por ejemplo) con 300 niveles de anidación no es capaz de decir más que 'too much stack levels'. Evidentemente no es el ejemplo más común, para código normal hecho por gente normal y con unos niveles de errores incluso algo bestia funciona.

Me queda comprobar cuánto consume realmente. Es mucho más ligero que otros parsers de html para rails, pero cuando da el 'stack levels' se come tu máquina y la del vecino. Imagino que se podrá controlar pero todavía no se como.

Ahora, para trabajos sencillo es ideal.

  • Tags: , , ,
  • compártelo favorito

Dos cositas que estoy revisando a ratitos libres:

P.D. El blog en estos momentos no se termina de ver bien... ¿por qué? pues por la máxima esa de la casa del herrero y las cucharas de palo :D

  • Tags: , , ,
  • compártelo favorito

Me encanta cycle

La primera vez que me encontré con blat habló del helper cycle.

Hoy haciendo una pruebecita lo he vuelto a usar, y me encanta que rails venga con estas tonterías de serie.

Así que cuando tengais que hacer una tablita y aplicarle un pijama (o hacer que elementos alternos tengan clases distintas):

 <tr class="<%= cycle("oscuro", "claro") %>">
      [... lo que sea]
 </tr>
 

Estoy de acuerdo con que 'el precio de la magia' (nando tm) a veces juega malas pasadas, y que a veces hay atajos que tocan las narices en cuestiones de rendimiento, pero esto es genial y rápidito.

  • Tags: , ,
  • compártelo favorito

... y con ella el upgrade/susto. Durante unas horas han habido gemas con errores en el aire. Yo he sido una víctima de la actualización. Una cosa que no funciona, un upgrade de una gema y cuando te quieres dar cuenta tienes la 1.2 con unos cuantos errores al compilar.

Hay que reconocer que en un tiempo razonable han puesto remedio a los fallitos.

Ahora con el cambio de versión nos vienen las revisiones de los métodos obsoletos a los que tendremos que ir perdiendo la costumbre. Y si no mirad el mensajito que me deja el log de una aplicación cuando encuentra algo:

 DEPRECATION WARNING: The :dependent => true option is deprecated and will be removed from Rails 2.0.  Please use :dependent => :destroy instead.  
 See http://www.rubyonrails.org/deprecation for details.
 

Imagino que no todos los 'deprecated' serán tan educados y que nos vamos a dar algún que otro cabezazo cuando algo falle y no esté documentado.

Actualmente la página a la que nos refiere el log está vacía, imagino que en los próximos días se irá llenando.


Reconoced que el mensajito que nos han puesto, Nothing lasts forever, tiene un puntito de cachondeo :D

  • Tags: , ,
  • compártelo favorito

Mi buen amigo Sergio me sugiere una revisión del post anterior complicando un poquito más el baremo.

El nivel de desconexión en este caso se mediría tomando como base no el número de posts, sino el funcionamiento de bloglines:

Bloglines guarda un máximo de 200 items por feed (esto no lo he podido confirmar, pero seguro que googleando un poquito sale). Por tanto 200 x número de feed a los que estás suscrito => 100%. Así que sólo tenemos que compararlo con los items que nos faltan por leer, y el resultado será nuestro nivel de desconexión.

Esto se complica un poquito (por no decir bastante), más que nada porque la api de bloglines no nos deja sacar así por las buenas el número de feeds al que estamos suscritos, nos los devuelve en un opml monísimo, pero poco práctico para lo que nos hace falta. Para hacer eso nos pide que además de nuestro email de suscripción le demos nuestra contraseña (pero bueno, todo sea por saber cuanto estamos de desconectados).

Así que variaciones las variaciones con respecto al script anterior son:

  • Necesitamos el email y el password para poder pasar.
  • Tenemos que parsear el ompl que nos devuelva el listsubs.

De este modo nos quedaría una acción tal como esta:

     def desconector2
       
       begin
         bloglines = Bloglines::WebServices.new(:user => params[:username], :password => params[:password])    
         content = bloglines.listsubs
     
         @subscripciones = 0
         # parseamos el xml de subscripciones
         REXML::XPath.match(content, '//outline').each do |item|
           if item.has_attributes?
             @subscripciones = @subscripciones+1 if !item.attributes['xmlUrl'].nil?
           end
         end
     
         @maximo = @subscripciones*200
     
         @post_pendientes = bloglines.update
         desconexion = (@post_pendientes*100)/@maximo
         @resultado = "Estoy al #{desconexion.to_s}% de desconexion"
       rescue Exception => e
     
         @resultado =  e 
     
       end
         
     end
 

Para que hagais vuestras pruebas correspondientes he metido en mi routes.rb

     map.connect 'desconector/:username/:password', :controller => "bloglines", :action => 'desconector2'
 

Así que para probar podeis ir a http://mamuso.net/desconector/tuemail/tucontraseña.

Como se que no andan los tiempos como para ir dejando por ahí contraseñas en texto plano, debemos de buscar una alternativa. Otra forma de obtener el opml propio es a través de la página pública de blogroll. De esta manera los únicos datos que necesitaríamos serían nuestro email de suscripción y nuestro nombre de usuario para la página pública. Si no sabes cual es entra en la opción share de tu bloglines.

Por tanto unas leves modificaciones y… hecho:

 def desconector3
   begin
   
     bloglines = Bloglines::WebServices.new(:user => params[:username])    
     
     @subscripciones = 0
     # parseamos el xml de subscripciones
 
     url= "http://www.bloglines.com/export?id=#{params[:screenname]}"
     xmldata = Net::HTTP.getresponse(URI.parse(url)).body
     doc = REXML::Document.new(xmldata)
     
     REXML::XPath.match(doc, '//outline').each do |item|
       if item.hasattributes?
         @subscripciones = @subscripciones+1 if !item.attributes['xmlUrl'].nil?
       end
     end
 
     @maximo = @subscripciones200
 
     @post_pendientes = bloglines.update
     desconexion = (@post_pendientes100)/@maximo
     @resultado = "Estoy al #{desconexion.to_s}% de desconexion"
   rescue Exception => e
 
     @resultado =  e 
 
   end
     
 end
 

En el routes.rb:

     map.connect 'desconectorb/:username/:screenname', :controller => "bloglines", :action => 'desconector3'
 

De manera que podéis probar con http://mamuso.net/desconectorb/tuemail/tunombredeusuario.

Este baremo tampoco es perfecto, porque yo tengo feeds que no actualizan nada desde junio, por tanto si tienes muchos blogs de este tipo, tu nivel de desconexión será ‘irrealmente bajo’, además si estás suscrito a muchísimos blogs raramente pasarás del 5-10% con más de 2000 items sin leer. A lo mejor podríamos combinarlo con el nivel de desconexión que tienen nuestros suministradores de feeds hacia nosotros (uuuuh, esto se complica brothers!).

Como veis el fin de semana ha sido largo y aburrido. ¿Pensabais que este post era interminable? Yo también :D

  • Tags: , , , ,
  • compártelo favorito

Hoy es día de trastear con APIs, y he pensado que podía retomar una vieja idea de furilo(tm) y jugar un poco con la de bloglines.

Se trata de mostrar tu nivel de desconexión con la realidad en base a los posts que te quedan por leer en bloglines y aplicar un baremo. Ya que hemos empezado con el post de furilo, pues tomaremos la proporción que él planteaba: 787 items pendientes = 65% de desconexión, por lo que 1210 serían el 100%.

Podríamos hacerlo sin instalar absolutamente nada, simplemente deberíamos de tratar lo que devuelve el rpc, pero para facilitar el trabajo usaremos la gema Bloglines4R 0.1.0, que tiene poquitos métodos pero los suficientes para hacer lo que queremos. De hecho es una de las cosas más básicas que se pueden hacer.

  • Conseguimos los posts pendientes de leer
  • Operamos para obtener el porcentaje de desconexión
  • Et voilà
 class BloglinesController < ApplicationController
 
   require 'bloglines'
 
   def desconector
     
     maximo = 1210
     
     begin
       
       bloglines = Bloglines::WebServices.new(:user => params[:id])
       post_pendientes = bloglines.update
       desconexion = (post_pendientes*100)/maximo
       @resultado = "Estoy al #{desconexion.to_s}% de desconexion"
     
     rescue Exception => e
       
       @resultado =  e 
     
     end
   
   end
 
 end
 

El manejo de excepciones en este caso no es más que recoger si el usuario existe o no (ni lo traduzco en este caso)

Podéis probarlo aquí mismo entrando a http://mamuso.net/bloglines/desconector/tuemail@debloglines.com. Si funciona a la velocidad de la tortuga coja es porque dreamhost es lento hasta decir basta (pero barato, eso sí).

Un host en condiciones, unos test (que el personal se me echa encima si no), un formateo en javascript para poder incrustarlo en cualquier blog de forma fácil, y servicio hecho :)

Yo estoy varios días desatendiendo mi bloglines así que según el script Estoy al 218% de desconexion. Así que voy a ponerme al día ya!

  • Tags: , , , ,
  • compártelo favorito