Stepping up as SQLite3/Ruby maintainer

So, I think this may be good news for some folks.

February 24, 2009 is the date that Jamis Buck marked as the end of several of his open source projects, including SQLite3/Ruby. (you can read the post here)

Previously, he asked for help updating SQLite3/Ruby to make it work on Windows.

That sad news left a lot of us with a bad taste, and very unhappy, not because we no longer will have someone to complain at, but because he no longer enjoyed working on those projects.

Over the past months I’ve been improving rake-compiler to be able to catch most of the building issues of several projects, including my own (I love to scratch my own itch).

As you have noticed on my “getting started with Rails and SQLite3″: http://blog.mmediasys.com/2009/07/06/getting-started-with-rails-and-sqlite3/ post, I successfully built, installed and used a SQLite3/Ruby gem on Windows.

The next question was, what to do? The work to get all those lovely gems was there, initial 1.9 was there, but was not official

While SQLite3/Ruby being the de-facto for getting started with Rails, we couldn’t let it die.

Enough words, sent some emails to Jamis and now I can publish those gems to RubyForge.

What all that babbling means?

This means:

• My fork at GitHub is the new mainstream for the releases
• I’m going to go over the open bugs and tickets and asses validity and relevancy based on work that was already done in my fork.
• The release cycle has been improved and almost automated. It can be performed from Windows, Linux or OSX, even using latter to create Windows native gems.

Now, what happens with new features:

• Pull requests with patches and bug fixes are going to be accepted.
• New features will be evaluated as long they don’t impose structural changes and carry with them tests cases.
• Patches that improve Ruby 1.9 compatibility are highly appreciated.

I don’t have strong knowledge of all the internals of this tool, so don’t expect earth breaking changes from me, except ensuring stability.

I hope this is good news to everybody. Now I’m going to stalk MySQL binding author and get permission to push those lovely gems

Cheers everybody!

(Via DEV_MEM.dump_to(:blog) – Multimedia systems blog.) Original Link: Stepping up as SQLite3/Ruby maintainer

Rails 2.3, rake y reenable method

undefined method `reenable' for <Rake::Task db:schema:dump =>
[environment]>:Rake::Task

  s.add_dependency('rake', '>= 0.8.3')
  s.add_dependency('activesupport',    '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('activerecord',     '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('actionpack',       '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('actionmailer',     '= 3.0.pre' + PKG_BUILD)
  s.add_dependency('activeresource',   '= 3.0.pre' + PKG_BUILD)

(Via Gastón Ramos – Ruby, Rails….) Original Link: Rails 2.3, rake y reenable method

I’m back with some Code …

Well, hello again, long time since the last post. I went on vacations, work a lot and did some programming. Let’s talk abount the programming part, since it is the most interesting one.

I created a small library called “Esearchy” capable of searching the internet for email addresses. Currently, we the supported search methods are engines such as Google, Bing, Yahoo, PGP servers, GoogleGroups, etc , but I intend to add many more.
Also, the library searches inside .pdf and .txt files for emails addresses and adds them to the list of found accounts.

For now, there are two main ways of performing a search, “the ruby way”

and the more classic way in which users can create an Esearchy objetc and work on it

For now , that’s it for now , but keep on tuned for more shitty code ajjajaa

(Via 自由編碼人.) Original Link: I’m back with some Code …

Patch en Regexp para poder usarlas como clave en un Hash

Siguiendo mi proyecto de hacer mi wiki en Ruby, encontré un comportamiento muy raro.
Generé un hash (que se llama @rules) que no tiene un elemento que tiene. O sea, @rules[@rules.keys[2]] da nil, pero @rules.values[2] devuelve el objeto asociado a la clave @rules.keys[2]. Como este hash tiene como claves un montón de expresiones regulares, me imaginé que había un problema con el hash y el eql? de Regexp, así que los implementé de nuevo y monkeypatchié.
Este es el código:

class Regexp
 alias_method   ld_rapidito_inspect, :inspect

 def inspect
   @inspect = old_rapidito_inspect if @inspect.nil?
   @inspect
 end

 def eql?( other )
   false if other.class != Regexp
   self.inspect == other.inspect
 end

 alias_method :"==", :eql?

 def hash
   self.inspect.hash
 end
end

Esta corrección me anduvo con la siguiente versión de ruby:

$ ruby --version
ruby 1.8.7 (2008-08-11 patchlevel 72) [i486-linux]

Espero que les sirva.
Happy hacking,
Aureliano.

(Via aurelianito.) Original Link: Patch en Regexp para poder usarlas como clave en un Hash

Más rapidito

Como les estuve contando, sigo escribiendo mi wiki. Ya parsea un subconjunto interesante del lenguaje definido por trac.
Siguiendo la tradición, les cuento como está avanzando el tokenizer. Al tokenizer lo simplifiqué para que devuelva la expresión regular que matcheo junto con el match (en vez del “tipo”). Esto hizo que la interfase para definir las reglas para tokenizar sea más simple. Si no hay ninguna regla que matchee sigue devolviendo ["string", :text].
Sin más, acá el código:

module Rapidito
  class Tokenizer

    def initialize( *delimiters )
      @delimiter_list = delimiters +  [/\z/]
      @match_cache = nil
    end

    def source
      valid_cache? ? @match_cache[0].to_s + @source : @source
    end

    def source=(s)
      @match_cache = nil
      @source = s
    end

    def has_next?
      !@source.empty? || valid_cache?
    end

    def valid_cache?
      (!@match_cache.nil?) && (@match_cache[0].to_s.length > 0)
    end

    def next_match
      @delimiter_list.map {|regex| [regex.match(@source),regex]}.reject {|p| p[0].nil?}.inject do
        |better,new|
        better_pos = better[0].pre_match.length
        new_pos = new[0].pre_match.length

        if better_pos < new_pos
          better
        elsif new_pos < better_pos
          new
        elsif better[0].to_s.length > new[0].to_s.length
          better
        else
          new
        end
      end
    end

    def next_token
      if @match_cache #cached delimiter
        rv = @match_cache
        @match_cache = nil
        return rv
      end

      match = next_match
      p = match[0].pre_match.length
      @source = @source[p + match[0].to_s.length, @source.length]

      if p == 0 #delimiter
        match
      else #text
        @match_cache = match
        [match[0].pre_match, :text]
      end
    end

    def all_tokens
      tokens = []
      while has_next?
        tokens << next_token
      end
      tokens
    end
  end
end

Y si miran los tests de unidad, van a ver que también quedaron más lindos:

require 'test/unit'
require 'rapidito/tokenizer'

include Rapidito

class TokenizerTest < Test::Unit::TestCase

  def test_no_token
    tok = Tokenizer.new
    tok.source = "aaaa"
    assert_equal true, tok.has_next?
    assert_equal ["aaaa", :text], tok.next_token
    assert_equal false, tok.has_next?
  end

  def assert_all_tokens( expected, tokenizer )
    assert_equal expected,
      tokenizer.all_tokens.map { |token, kind| [token.to_s, kind] }
  end

  def test_two_delimiters
    tok = Tokenizer.new(
      /\|/, /;;/
    )

    tok.source = "aa|bbb;;;;cccc"
    assert_all_tokens \
      [ ["aa", :text], ["|", /\|/], ["bbb", :text],
        [";;", /;;/], [";;", /;;/], ["cccc", :text] ],
      tok

    tok.source = "aa;;bbb||cccc"
    assert_all_tokens \
      [ ["aa", :text], [";;", /;;/], ["bbb", :text],
        ["|", /\|/], ["|", /\|/], ["cccc", :text] ],
      tok
  end

  def test_choose_longest_match
    tok = Tokenizer.new(
      /aa/, /aaa/
    )
    tok.source = "aaaa"
    assert_all_tokens [ ["aaa", /aaa/], ["a", :text ] ], tok
  end

  def test_reset_precache
    tok = Tokenizer.new(
      /\|/, /,/
    )
    tok.source = "original start|original end"
    tok.next_token
    tok.source = "new start,new end"
    assert_equal ["new start", :text], tok.next_token
  end

  def test_almost_finished
    tok = Tokenizer.new( /!/ )
    tok.source = "bang!"
    tok.next_token
    assert_equal true, tok.has_next?
    tok.next_token
    assert_equal false, tok.has_next?
  end

  def test_carriage_return_ending
    tok = Tokenizer.new( /!/ )
    tok.source = "bang!\n"
    tok.next_token
    assert_equal true, tok.has_next?
    tok.next_token
    assert_equal true, tok.has_next?
    assert_equal "\n", tok.next_token[0].to_s
    assert_equal false, tok.has_next?
  end

  def test_transparent_caching
    tok = Tokenizer.new( /!/ )
    tok.source = "bang!pum"
    tok.next_token

    assert_equal "!pum", tok.source
  end

  def test_match_klass
    tok = Tokenizer.new( /!/ )
    tok.source = "!bang!pum"

    assert_equal \
      [MatchData, String, MatchData, String],
      tok.all_tokens.map { |tok, kind| tok.class }
  end
end

Happy hacking,
Aureliano.

(Via aurelianito.) Original Link: Más rapidito

Community Highlights: Ruby Heroes

This week I’m happy to tell you about a new set of articles which will be appearing here on the Rails blog called “Community Highlights”. This new series will feature people/projects/sites from the Rails community that may deserve a little extra recognition.

This week, we’re going to start with a few people who received awards on stage at Railsconf 2009, this years Ruby Heroes.

Brian Helmkamp

Aman Gupta

Luis Lavena

Pat Allan

Dan Kubb

John Nunemaker

Those are your six Ruby Hero’s for 2009. If you’re interested you can also watch a video of the award ceremony which talks more about the methodology about how they were chosen and see 5 of these guys receive their awards on stage at Railsconf 2009.

(Via Riding Rails.) Original Link: Community Highlights: Ruby Heroes

Pequeñas delicias de las expresiones regulares

Como les conté acá y acá, estoy escribiendo un tokenizador para un wiki que estoy programando. Y hoy me encontré con una cosa muy extraña de las expresiones regulares.
En ruby la función match sirve para buscar el primer match de una regex dentro de un string. Por ejemplo (usando el irb):

irb(main):001:0> m = /a/.match "babab"
=> #<MatchData "a">
irb(main):002:0> m.pre_match
=> "b"
irb(main):003:0> m[0]
=> "a"

En particular, el pre_match es lo que está antes del match en el string. También según había entendido (mal) /\Z/ matchea con el final del string. Por ejemplo:

irb(main):004:0> m = /\Z/.match "hola"
=> #<MatchData "">
irb(main):005:0> m.pre_match
=> "hola"

Pero, /\Z/ tiene un comportamiento muy extraño, aunque documentado, cuando el último caracter antes del final es un \n. Lo que pasa es que el pre_match queda ¡sin el\n del final!. Lo muestro en el irb:

irb(main):006:0> m = /\Z/.match "\n"
=> #<MatchData "">
irb(main):007:0> m.pre_match
=> ""
Para que no se manduque el \n, hay que usar /\z/ (¡en minúscula!):

irb(main):008:0> m = /\z/.match "\n"
=> #<MatchData "">
irb(main):009:0> m.pre_match
=> "\n"
Por lo tanto tuve que tocar el tokenizer, ahora la función de initialize quedó así (miren el cambio de la "Z" a "z"):

    def initialize( delimiters )
      @delimiter_list = [[/\z/, :finish]] +
        delimiters.to_a.map { |k,arr| arr.map { |re| [re, k] } }.inject([]) { |ac,ps| ac + ps }
      @match_cache = nil
    end
Y el test que captura el problema que genera usar \Z en vez de \z quedó así:

  def test_carriage_return_ending
    tok = Tokenizer.new( :a_kind => [/!/] )
    tok.source = "bang!\n"
    tok.next_token
    assert_equal true, tok.has_next?
    tok.next_token
    assert_equal true, tok.has_next?
    assert_equal "\n", tok.next_token[0].to_s
    assert_equal false, tok.has_next?
  end
Happy hacking,

Aureliano.

(Via aurelianito.) Original Link: Pequeñas delicias de las expresiones regulares

RubyInstaller: designs and deadline details

So, guess what? There are already 3 designers running for the pledgie prize collected for One-Click Installer new home!

Check those over there:

http://wiki.github.com/oneclick/rubyinstaller/website-contest

This is excellent news. Thank you guys for participating!

Deadline

I’m aiming to close submissions June 19, 2009. So if you have a design or idea, mock it up and add to the wiki page, point to a blog post or something and let the public know you’re participating!

Logo

As Pavel mentioned over the wiki page:

I like it, but I was not sure about the shape of ruby gem.

This is something weird since Ruby users are used to see Ruby logo with the shape of a diamond, which is incorrect.

Let me explain it better: the mineral ruby can be cut in diamond shape, but is really uncommon.

More common shapes are facetted balls or emerald cuts. Take a look here for more examples.

Almost every package, tool or library associated with Ruby tends to use a diamond cut ruby as logo.

When analyzed this detail with Rodolfo Budeguer from Estudio Domo, we found that sticking to that shape would not only fall into the repetition (and be a copycat), but also move away from the goal of it.

If you pay close attention, will noticed that the emerald cut of RubyInstaller shows the 4 colors that are also present in… the Windows logo.

Why is that? Well, because is Ruby Installer for Windows

Voting and Deliverables

Once again, would like to mention public voting would define the selected design. No new design will be accepted after the deadline above mentioned. So make room to do the mockups soon!

Also, once we have the final votes for the designs. Selected designer should provide generated versions of mockups in CSS and HTML content, preferable in a public Git repository.

I’m so excited about this that I’m blogging at 4am!

Thanks again to Silviu, Francesco and Pavel to contribute and participate. Also other people that privately sent some feedback about RubyInstaller itself, not just the website

(Via DEV_MEM.dump_to(:blog) – Multimedia systems blog.) Original Link: RubyInstaller: designs and deadline details

Google Scrap con Rails

web_search_plugin es un nuevo plugin de Rails que hice, para poder obtener los resultados de una determinada consulta en google y mostrarla en tu sitio. Hasta el momento solo realiza búsquedas en Google, a futuro lo voy a integrar con Yahoo y Live.

Instalar web_search_plugin

# cd myapprails
# ruby script/plugin install git@github.com:chebyte/web_search_plugin.git

Uso
Como ejemplo, tenemos el modelo #link.rb

 class Link < ActiveRecord::Base
   include Chebyte::WebSearch
   web_search
 end

Ahora para obtener los resultados solo debemos llamar al método search_web

 Link.google_search(:query => "tuquito")

esto nos devolveria

=> #<Google::Response:0xb734d3cc @results=[{:domain=>"www.tuquito.org.ar", :content=>"Proyecto Linux de Tucumán, datos y temas relacionados al proyecto, foros y ayuda para usuarios de la distribución y descargas.", :title=>"Tuquito 3", :cache_url=>"http://www.google.com/search?q=cache:4NZXKc3gQA8J:www.tuquito.org.ar", :url=>"http://www.tuquito.org.ar/"}, {:domain=>"en.wikipedia.org", :content=>"Oct 11, 2008 ... Tuquito is a Debian-based operating system created in Tucumán, Argentina, by Ignacio Díaz, Chris Arenas and Mauro Torres, students of The ...", :title=>"Tuquito - Wikipedia, the free encyclopedia", :cache_url=>"http://www.google.com/search?q=cache:a1xAEvHHujUJ:en.wikipedia.org", :url=>"http://en.wikipedia.org/wiki/Tuquito"}, {:domain=>"www.slideshare.net", :content=>"Tuquito 3 Nuevo Diseño En varios idiomas (Ingles,Portugues y Español) Interfaces mas intuitivas Optimizado para la conectividad(wifi, ...", :title=>"Tuquito 3", :cache_url=>"http://www.google.com/search?q=cache:T8VfO-4iyioJ:www.slideshare.net", :url=>"http://www.slideshare.net/chebyte/tuquito-3"}, {:domain=>"www.olpcnews.com", :content=>"OLPC Tuquito's team began to work at 1st January of 2007, with the knowledge acquisition about the project One Laptop Per Child and then with development ...", :title=>"OLPC Tuquito Project Progress in Argentina - OLPC News", :cache_url=>"http://www.google.com/search?q=cache:eoGfDNbaZ8kJ:www.olpcnews.com", :url=>"http://www.olpcnews.com/countries/argentina/olpc_tuquito_project_argentina.html"}], @status=200, @size=4, @query="tuquito">

El resultado es un simple objecto hash, algunos de los campos disponibles son
* title titulo del resultado
* url Url del resultado
* domain Root url del resultado
* content contenido
* cache_url Google cache url

(Via Chebyte’s Blog.) Original Link: Google Scrap con Rails

Desinfecta tu html (sanitizer)

simple_sanitizer_html es un plugin muy sencillo que arme para Rails, que te permite básicamente escapar el html.
Lo interesante de este plugin es que solo debemos extender el modelo y de forma automática guarda todo los registros escapando el html en la base de datos.

Instalar simple_sanitizer_html

  http://github.com/chebyte/simple_sanitizer_html/tree/master

Uso Práctico

# ruby script/generate model Post title:string copy:text

class Post
 simple_sanitizer_html
end

$ ruby script/console
Loading development environment (Rails 2.3.2)
p >> p = Post.new
=> #<Post id: nil, title: nil, copy: nil, created_at: nil, updated_at: nil>
>> p.title = "<script>alert('hi tuquito')</script>"
=> "<script>alert('hi tuquito')</script>"
>> p.save
=> true
>> p.title
=> "&lt;script&gt;alert(&#39;hi tuquito&#39;)&lt;/script&gt;"
>>

Este plugin puede ser muy útil para prevenir ataques XSS o del estilo

(Via Chebyte’s Blog.) Original Link: Desinfecta tu html (sanitizer)