Also, the library searches inside .pdf, .docx, .xlsx, .pptx, asn and .txt files for emails addresses and adds them to the list of found accounts. Finally, we have support for .docs files but for now only in Windows Platforms. (For more information visit: Github .

In order to install it you simple add the repository and then install the gem, as shown below.
> gem sources -a http://gems.github.com
> gem install FreedomCoder-esearchy
Once the gem is installed, you can create a new search opening and/or use the “esearchy” CLI tool but it’s really basic so far and it does not has all of the plugins.
require 'esearchy'

ESearchy::LOG.level = ESearchy::APP #Output to the stdout.


ESearchy.create "domain.com" do |d|
d.yahoo_key = "yourAPIkeygoeshere"
d.bing_key = "yourAPIkeygoeshere"
# if you want to also look in LinkedIn
d.company_name "Company Name"
#A user is needed in order to search within Linkedin
d.linkedin_credentials "myuser@linkedin.com", "mypwd"
d.maxhits = 50
d.search
d.save_to_file "company_emails.txt"
end
If you have any comments, issues or want to submit a bug please do so on
http://github.com/FreedomCoder/esearchy/issues

Hopefully it will be useful to you.

Yeah, I know this might not even works, but it’s still cool. =D

Well here it goes

Use it at your own discretion and listen to your ghost …

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”
Esearchy.create "domain.com" do |domain|
domain.maxhits = 500
domain.search
domain.clean {|e| e =~ /<|>/ }
domain.save_to_file "~/emails.txt"
end

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

domain = Esearchy.new :query => "domain.com", :maxhits => 500
domain.search
domain.save_to_file "~/emails.txt"

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

NOTE: As a word of advice, it is worth mentioning that this situation where only the Japanese have ruby code, has happened several times before with weird and undocumented methods or libraries. So it’s always good to look in google.jp for ruby code

You may say why to even bother to do a Transparent proxy in ruby which is able to inject code, well maybe the answer is just because I want to see if I can do it.

I decided to do my PoC with the native library WEBrick, a simple and light HTTPserver among other things.


Simple Proxy :
The first thing I usually do is check the official site and Rdoc for the lib. Unluckily, I was only able to find how to do a normal proxy. and work with the request.

require 'webrick'
require 'webrick/httproxy'

a.start
Simple Proxy server.


Fixing the URI :
With this we can setup Firefox, safari or any other web browser to use the proxy on localhost:8080 and Eureka, we have a proxy that will printout the unparsed_uri for our request.
This in theory works like a charm , but wait. If you see the request Firefox is doing the following
GET http://www.sarasa.com/ HTTP/1.1
...Browser request using a proxy server.

Normal the brower when requesting a page , will use HTTP/1.1 and use the header “Host” to specified the url and just connect using a:

GET / HTTP/1.1
Host: www.sarasa.comBrowser request.

Having said this, here is the first wall I encounter. This is something that was undocumented: how do we turn our proxy into a transparent proxy?
The answer is simple. let’s modified our code and change the request. All the information is there we just have to re-write it to fit our need.
Before, we start we should know that our req is of type WEBrick::HTTPRequest. Knowing this we will do a little monkey patching to add a new method to the class and

require 'webrick'
require 'webrick/httproxy'

a.startTransparent Proxy Server.

Injecting:
Well, a transparent proxy is cool , but we could do the same with squid or some other product. Let’s take it a little further and make it more interesting by adding an inject_payload to our response class.

require 'webrick'
require 'webrick/httproxy'

a.startInjectable Transparent Proxy server.

Last but not least :
Well, there is one more thing , but this is more at an operating system level we know want to reroute everything that is coming from the port 80 to port 8080 where our transparent proxy is listening. The following example shows a possible way to redirect HTTP traffic assuming that is coming from the interface eth0 and the proxy is listening on port 8080.

iptables -t nat -A PREROUTING -i eth0 -p tcp –dport 80 -j REDIRECT –to-port 8080

Now we have a transparent proxy in our hands capable of injecting code into their request.

Enjoy.

def create_pdf(list,name=nil)
require 'prawn'
require 'prawn/layout'
Prawn::Document.generate(name || "output.pdf") do

table data,
:position => :center,
:headers => ["Port", "IP Adresses"],
:header_color => "0046f9",
:row_colors => :pdf_writer, #["ffffff","ffff00"],
:font_size => 10,
:vertical_padding => 2,
:horizontal_padding => 5
end
end

Para bajar la ultima versi?n del repositorio Git :

http://github.com/FreedomCoder/nmapports/tree/master

Agregar los repositorios de rpmfusion:

# rpm -Uvh http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm

# rpm -Uvh http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm

Instalar GStreamer plugins:

# yum install gstreamer gstreamer-plugins-bad gstreamer-plugins-ugly

Instalar otras app y librer?as:

* Amarok con soporte para MP3:

# yum install amarok phonon-backend-gstreamer

* MPlayer con soporte para MP3:

# yum install mplayer gnome-mplayer gnome-mplayer-common mencoder

* XMMS con soporte para MP3:

# yum install xmms xmms-mp3

* xine con soporte para MP3:

# yum install xine xine-lib-extras-nonfree

* Para crear MP3s con LAME :

# yum install lame lame-mp3x

* Para instalar todo junto con un solo comando:

# yum install xmms xine mplayer amarok xmms-mp3 gstreamer phonon-backend-gstreamer gstreamer-plugins-bad gstreamer-plugins-ugly xine-lib-extras-nonfree mplayer gnome-mplayer-common mencoder gnome-mplayer lame lame-mp3x

Primero tenemos que agregar un par de funciones a nuestro .zsh o .bashrc

Funciones:
function parse_git_status {
[[ $(git status 2> /dev/null | tail -n1) != "nothing to commit (working directory clean)" ]] &&
echo "*"
}
function parse_git_branch {
git branch --no-color 2> /dev/null | sed -e '/^[^*]/d' -e "s/* \(.*\)/[\1$(parse_git_status)]/"
}

Una vez que tengamos estas funciones tenes que agregar la funci?n a nuestro shell PROMPT para que cada vez que estemos en algun dir que sea un repositorio de git nos agregue el branch donde estamos y el status. Para esto necesitamos agregar el llamado a nuestra funci?n:
Llamado a Funcion:
$(parse_git_branch)%
Antes:
PROMPT='[$PR_BLUE%n$PR_WHITE@$PR_GREEN%m] $PR_WHITE%d $PR_NO_COLOR%% '
Despu?s:
PROMPT='[$PR_BLUE%n$PR_WHITE@$PR_GREEN%m] $PR_WHITE%d $PR_NO_COLOR%
%{$fg_bold[yellow]%}$(parse_git_branch)%{$reset_color%}%% '

O si preferimos que este a la derecha solito podemos hacerlo de la siguiente manera:
Prompt Derecha:
PROMPT='[$PR_BLUE%n$PR_WHITE@$PR_GREEN%m] $PR_WHITE%d $PR_NO_COLOR%% '
RPROMPT='%{$fg_bold[yellow]%}$(parse_git_branch)%{$reset_color%}'

Bueno, espero que les sirva tanto como a mi.

Siempre me dije, loco que mal que linux no tenga esto.  Hoy haciendo uso de utility_belt me di cuenta que  Giles, no habia implementado  la plataforma :linux en su gem y fue eso lo que me hizo preguntar: existira o no una tool para manejar el clipboard desde la consola?, no puede ser que osx lo tenga pero linux no. 

Luego de preguntarle al Oraculo de la Matrix AKA Google, encontre un paquete que se llama xsel. 

Instalacion

> emerge xsel # en Gentoo
> sudo apt-get install xsel # Ubuntu o Debian
> sudo yum install xsel #centos, fedora, RHE, etc…

Uso

> ls | xsel -i #Copia el resultado de ls al clipboard.
> xsel #Muestra lo que sea que este en el clipboard.

Bueno, espero que les sirva para algo como me sirve a mi y ademas les cuento que mande un diff a Giles (autor de utility_belt) para que patchee utility_belt y habilite toda las tools que hacen uso de clipboard (ie. pastie)  en linux.
CODE:

clipboard.rb
diff --git a/lib/utility_belt/clipboard.rb b/lib/utility_belt/clipboard.rb
index 67bcf7e..1525d56 100644
--- a/lib/utility_belt/clipboard.rb
+++ b/lib/utility_belt/clipboard.rb
@@ -22,7 +22,27 @@ module UtilityBelt
IO.popen('pbcopy', 'w+') {|clipboard| clipboard.write(stuff)}
end
@@implemented = true
-
+
+ when :linux
+
+ if File.exist?('/usr/bin/xsel')
+ || File.exist?('/usr/local/bin/xsel')
+ || File.exist?('/usr/X11/bin/xsel')
+
+ def self.read
+ IO.popen('xsel') {|clipboard| clipboard.read}
+ end
+
+ def self.write(stuff)
+ IO.popen('xsel -i', 'w+') {|clipboard| clipboard.write(stuff)}
+ end
+ @@implemented = true
+ else
+ raise "You need to install package xsel\n
+ ubuntu,debian: sudo apt-get install\n
+ Gentoo: sudo emerge xsel\n
+ fedora,centos,opensuse: yum install xsel\n"
+ end
when :mswin

begin

UPDATE: Google search linux support and pastie now opens up in default browser. I also decided to fork the github project to share all my changes so far. Github link

google.rb
diff --git a/lib/utility_belt/google.rb b/lib/utility_belt/google.rb
index 04d419f..11d0180 100644
--- a/lib/utility_belt/google.rb
+++ b/lib/utility_belt/google.rb
@@ -19,7 +19,8 @@ module UtilityBelt
Kernel.system("open #{url}")
when :windows
Kernel.system("start #{url}")
- #when :linux
+ when :linux
+ Kernel.system("xdg-open #{url}")
else
puts "Sorry, don't know how to open an URL from the command line on your platform"
end
pastie.rb
diff --git a/lib/utility_belt/pastie.rb b/lib/utility_belt/pastie.rb
index 0756f4b..99e6100 100644
--- a/lib/utility_belt/pastie.rb
+++ b/lib/utility_belt/pastie.rb
@@ -20,6 +20,8 @@ module UtilityBelt
Kernel.system("open #{pastie_url}")
when :mswin
Kernel.system("start #{pastie_url}")
+ when :linux
+ kernel.system("xdg-open #{pastie_url}")
end

return pastie_url

El Sabado primero de Noviembre se realizo la conferencia de Software Libre en la Universidad Tecnologica Nacional – Facultad Reginal Parana. Gracias a Rodolinux termine dando 3 charlas  en el correspondiente orden:

1) Intro a Ruby
2) Ruby Metaprogramming
3) Vulnerabilidades en la Matrix

Dentro de las charlas a destacar encontr? la de Rodolinux
(http://www.rodolinux.com.ar) y otra de Gramos
(http://gastonramos.wordpress.com/), siendo la primera muy filos?fica y psicologica y la otra altamente tecnica.

La conferencia fue todo un ?xito aunque realmente esperaba mas gente. Siendo critico constructivo para ir pensando en LugParanaConf 09, creo que se deber?a haber realizado mucho mas propaganda en tiempo y forma en todas las universidades y colegios t?cnicos de la zona.

Siguiendo la filosof?a de full disclosure, es importante mencionar que la primera charla, fue una peque?a introducci?n a Ruby que hice en el bondi y un rato a la madrugada ( 6 – 8 AM ) cuando llegue a Parana, Asi que pido que sepan comprender y disculparme si contiene errores.
Dicho esto, las otra dos, no. Asi que sientanse libre de hacer comentarios sobre las 3 pero no me maten con la primera.

Saludos y es importante destacar que mis charlas son distribuidas bajo la licencia Creative Commons
Attribution + Noncommercial + ShareAlike (by-nc-sa)

Test.rb Code:

require "Colorize"

c = Colorize.new( :red => /<.*html>|<.*body>/,
:blue => /".*"/,
:cyan => /src/)
puts c.paint(html)

Por ultimo, se aprecian mucho comentarios, ideas y/o preguntas sobre cosas que les gustar?a ver en Colorize, etc …

Luego Tres (3) dias de mucho Ruby, Software Libre, amigos, cerveza, charlas, keynotes de astronautas e intercambio de ideas en los pasillos, logre –en los tiempos libres– dar un par de charlas.
Aca les dejo los slides de las presentaciones:

* RubyCocoa:

http://www.freedomcoder.com.ar/files/JRSL08/ruby-cocoa.pdf

* Ruby Metraprogramming:

http://www.freedomcoder.com.ar/files/JRSL08/ruby-meta.pdf

* Photos :

http://www.flickr.com/photos/freedomcoder/sets/72157606962173346/

Try it and tell me what you think.
Project’s site : http://rubyi.st/rgte/

It is pretty common to have iterations over Arrays that can be safely run in parallel. With multicore chips becoming pretty common, single threaded processing is about as cool as Pog. Unfortunately, standard Ruby hates real threads pretty hardcore at the present time; however, for some ruby projects alternate VMs like JRuby do give multicores some lovin’. Peach exists to make this power simple to use with minimal code changes.

Functions like map, each, and delete_if are often used in a functional, side-effect free style. If the operation in the block is computationally intense, performance can often be gained by multithreading the process. That’s where Peach comes in. In the simplest case, you are one letter away from harnessing the power of parallelism and unlocking the secret of a guilt-free tan. At this stage, the goggles are purely optional.
Using Peach

Suppose you are going about your day job hacking away at code for the WOPR when you stumble upon the code:
cities.each {|city| thermonuclear_war(city)}
Clearly, the only winning move is to declare war in parallel. With Peach, the new code is:
require 'peach'

cities.peach {|city| thermonuclear_war(city)}
Requiring peach.rb monkey patches Array into submission. Currently Peach provides peach, pmap, and pdelete_if. Each of these functions takes an optional argument n, which represents the desired number of worker threads with the default being one thread per Array element. For cheaper operations on a large number of elements, you probably want to set n to something reasonably low.

(0...10000).to_a.pmap(4) {|x| process(x)}
Constructing the threads and adding on a few layers of indirection does add a bit of overhead to the iteration especially on MRI. Keep this in mind and remember to benchmark when unsure.
Syntax (without all the words)

require 'peach'

[1,2,3,4].peach(2){|x| f(x)} #Spawns 2 threads, => [1,2,3,4]
[1,2,3,4].pmap(2){|x| f(x)} #Spawns 2 threads, => [f(1),f(2),f(3),f(4)]
[1,2,3,4].pdelete_if(2){|x| x > 2} #Spawns 2 threads, => [3,4]

Extracted from the Developers’s web site: http://peach.rubyforge.org/

UPDATE: Gracias!, Irlandes Borracho por la correccion en el titulo.

2. When I decided to move to higher degrees the application was able to retrieve the data but the library (graphviz) was unable to generate a jpg or png. In the case of a SVG I was able to create the file but, neither Linux nor Linux64 nor OSX where able to load the image. When I tried to generate a png or jpg the gd or the application gave me a core dump. Thanks Juan, for lending me your Linux64 computation time .


3. I decided to try with GraphML format instead of the graphviz’s dot format. It is worth noting that the degree 2 graph were generated much faster, but again we run into trouble when rendering the huge load of node and edges when I came down to 3 or more degrees. This time was not a matter of not being able to render the images but instead the program I was using Yed, I guess is using an algorithm that does not take into account the fact that I want to see something instead of a huge ball of edges and nodes .

4. Again more problems, but this time with the application not handling the loads. Now I decided I was a good time to redesign the application for more scalability and this is what I’m doing so far. So I will post the code as soon as I have that.
Cheers and hopefully someone likes or can use this post for something. Ohh.. and this is not finished by far hopefully from here a lot of thing will be created and some new functions will be added to the app. And of course all this is written in RUBY !

Bueno, entonces un #sudo apt-get install ruby-full resolvio todos mis problemas.

The most important thing, installation:

1. Open a terminal, and type:
gem install passenger
2. Type:
passenger-install-apache2-module
And follow the instructions.

Well, enjoy and let the party begin with Apache and Rails. Hopefully, my provider Dreamhost will be deploying this soon to production.