Emmanuel Oga's Blog

VIM config snippets

2011-11-28T00:00:00-08:00

There are lots of things you can do to better organize your vim configuration, starting with using pathogen.

Apart from using pathogen, what I like to do is having small snippets of configuration on separate files to tweak specific things. Here's my .vimrc:

" Setup for pathogen.
call pathogen#runtime_append_all_bundles()
call pathogen#helptags()

" Load additional plugin configurations and stuff
for rc in split(globpath(&rtp, "rc/*"), "\n")
  execute "source" rc
endfor

First part is the setup for pathogen. The second part is what I'm talking about, I go through every file in my .vim/rc directory and load every snippet of that folder.

A fun thing to try is to make every snippet "self contained". That way, if someone browsing your config thinks the thing you are setting up there is cool, all he has to do is copy that single file to get the specific piece of functionality.

BTW, since I use gvim most of the time, on the .gvimrc I just source the .vimrc, plus a few GUI tweaks (removing toolbars, menus, etc).

source ~/.vim/vimrc
" ... some gui settings.

Beer Drinking Contest: Ruby versus Lua. Fight!

2011-07-29T00:00:00-07:00

Grab a gist. You probably already know what's the output of these programs.

Ruby

class Crowd < Struct.new(:bottles)
  def drink()    puts("Take one down and pass it around."); bottles.drink(1); self;  end
  def buy_more() puts("Go to the store and buy some more."); bottles.buy(99); self; end
  def sing()     puts("#{bottles} on the wall, #{bottles}."); self; end
end

class Bottles < Struct.new(:qty)
  def drink(amount) self.qty -= amount; end
  def buy(amount)   self.qty += amount; end
  def to_s() qty == 0 ? "No more bottles of beer" : "#{qty} bottle#{'s' if qty > 1} of beer" end
end

Crowd.new(Bottles.new(99)).tap do |crowd|
  99.times { crowd.drink and crowd.sing }
  crowd.buy_more.sing
end

Lua

local Crowd   = {}
Crowd.drink   = function(self) print("Take one down and pass it around.") self.bottles:drink(1) return self end
Crowd.buymore = function(self) print("Go to the store and buy some more.") self.bottles:buy(99) return self end
Crowd.sing    = function(self) print(tostring(self.bottles).." on the wall, "..tostring(self.bottles)..".") return self end

local Bottles      = {}
Bottles.__index    = Bottles
Bottles.drink      = function(self, amount) self.qty = self.qty - amount end
Bottles.buy        = function(self, amount) self.qty = self.qty + amount end
Bottles.__tostring = function(self)
  if self.qty == 0 then return "No more bottles of beer"
  else return self.qty.." bottle"..(self.qty == 0 and '' or 's').." of beer"
  end
end

local crowd = setmetatable({bottles = setmetatable({qty=99}, Bottles)}, {__index=Crowd})

crowd:sing() for i = 99, 1, -1 do crowd:drink():sing() end crowd:buymore():sing()

Let the games begin!

#/usr/bin/env sh

echo 'Baseline echo'
time for i in {0..20..1}; do echo "A long line with a number: $i" > /dev/null ; done
# real  0m0.001s user   0m0.000s sys    0m0.000s

lua -v
time for i in {0..20..1}; do lua beer.lua > /dev/null ; done
# Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio
# real  0m0.054s user   0m0.000s sys    0m0.007s

luajit-2.0.0-beta6 -v
time for i in {0..20..1}; do luajit-2.0.0-beta6 beer.lua > /dev/null ; done
# LuaJIT 2.0.0-beta6 -- Copyright (C) 2005-2011 Mike Pall. http://luajit.org/
# real  0m0.041s user   0m0.000s sys    0m0.007s

rvm 1.9.2 exec ruby -v
time for i in {0..20..1}; do rvm 1.9.2 exec ruby beer.rb > /dev/null ; done
# ruby 1.9.2p180 (2011-02-18 revision 30909) [x86_64-linux]
# real  0m17.076s user  0m12.116s sys   0m3.323s

rvm jruby exec jruby -v
time for i in {0..20..1}; do rvm jruby exec jruby beer.rb > /dev/null ; done
# jruby 1.6.2 (ruby-1.8.7-p330) (2011-05-23 e2ea975) (OpenJDK 64-Bit Server VM 1.6.0_22) [linux-amd64-java]
# real  1m35.087s user  2m21.537s sys   0m7.226s

rvm ree ruby -v
time for i in {0..20..1}; do rvm ree exec ruby beer.rb > /dev/null ; done
# ruby 1.8.7 (2011-02-18 patchlevel 334) [x86_64-linux], MBARI 0x6770, Ruby Enterprise Edition 2011.03
# real  0m18.075s user  0m12.619s sys   0m3.526s

Conclusions

I don't give any chance to the jit capable interpreters to work their magic.
I'm "measuring" the system's I/O too even when I'm directing the output to /dev/null, get over it.
Lua, including its start-up time, is FAST!. Also, object oriented programming in lua is flexible, simple and nice.
Rails does not scale.
I want a beer.

Taming a Capybara

2011-07-26T00:00:00-07:00

photo from raxdakkar.com

Running acceptance tests in our rails 3 application turned out to be non trivial, even though there are excellent tools out there, and they keep getting better.

We are currently using capybara with the capybara-webkit driver, which is great because it runs in headless mode, without annoying browser windows popping up. I heard the QT download can be pretty big for mac users though, so have some spare bandwidth around if you have a mac and are planning to give it a try.

As we kept adding tests, the size of our spec/support/capybara.rb file grew with a lot of hacks. Here is an anotated version of that file and some others related, should it be helpful to anybody out there. Perhaps somebody will want to comment on better solutions for some of the nasty hacks.

Gemfile

group :test do
  gem 'capybara', '~> 1.0.0'

  # The git version worked better for us at the time we installed it.
  gem 'capybara-webkit', :git => "git://github.com/thoughtbot/capybara-webkit"

  # This is needed by capybara's save_and_open_page method.
  gem 'launchy'

  # This *might* be needed in some setups
  gem 'database_cleaner'
end

config/initializers/session_store.rb

# We deploy our application to several different subdomains, and we need
# to configure the domain for cookies in order to avoid the sessions
# getting mixed.
# But the domain option was messing with capybara browsers' ability to
# remember cookies, so we just exclude the domain config on the test environment.
options = { :key => "_our_app_session_#{Rails.env}" }
options[:domain] = Settings.cookies_host unless Rails.env.test?

Rails.application.config.session_store :cookie_store, options

spec/spec_helper.rb

RSpec.configure do |config|
  # .. rspec stuff
end

# This is how we load our support files for rspec, this keeps the size of
# the spec_helper.rb file manageable.
Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

spec/support/capybara.rb

require "capybara/rails"
require 'capybara/rspec'

# Setup capybara webkit as the driver for javascript-enabled tests.
Capybara.javascript_driver = :webkit

# In our setup, for some reason the browsers capybara was driving were
# not openning the right host:port. Below, we force the correct
# host:port.
Capybara.server_port = 7787

# We have more than one controller inheriting from
# ActionController::Base, and, in our app, ApplicationController redefines
# the default_url_options method, so we need to redefine the method for
# the two classes.
[ApplicationController, ActionController::Base, Listing].each do |klass|
  klass.class_eval do
    def default_url_options(options = {})
      { :host => "127.0.0.1", :port => Capybara.server_port }.merge(options)
    end
  end
end

# Here we do some selective configuration for tests which run with the
# rack backend and tests which run with the webkit backend.
RSpec.configure do |config|
  # In order for the database to have the same data both for the
  # capybara process and the web application process, we need either to
  # disable transactional fixtures (which produces very slow runs),
  # or use the hack you can find below in this file.
  config.use_transactional_fixtures = true

  # Uncomment in case your db gets dirty somehow.
  # DatabaseCleaner.clean_with(:truncation)

  config.before :each do
    if Capybara.current_driver != :rack_test
      # With selenium/webkit the host is set automatically if it was nil.
      Capybara.app_host = nil
    # config.use_transactional_fixtures = false
    # $use_truncation = true
    else
      # We found Capybara.app_host needs to be nil when using rack backend,
      # but point to 127.0.0.1 when using selenium or webkit.
      Capybara.app_host = "http://127.0.0.1"
    # config.use_transactional_fixtures = true
    end
  end

# config.after :each do
#   DatabaseCleaner.clean_with(:truncation) if $use_truncation
# end
end

# Big Fat Hack (TM) so the ActiveRecord connections are shared across threads.
# This is a variation of a hack you can find all over the web to make
# capybara usable without having to switch to non transactional
# fixtures.
# http://groups.google.com/group/ruby-capybara/browse_thread/thread/248e89ae2acbf603/e5da9e9bfac733e0
Thread.main[:activerecord_connection] = ActiveRecord::Base.retrieve_connection

def (ActiveRecord::Base).connection
  Thread.main[:activerecord_connection]
end

# Last but not least, when using capybara-webkit sometimes the response
# is not available when capybara tries to retrieve the contents of the
# page. Of all the possible solutions, this was the simplest for us:
# introducing a fixed delay each time something is clicked in the browser.
# https://github.com/thoughtbot/capybara-webkit/issues/111
class Capybara::Driver::Webkit::Browser
  alias original_command command

  def command(name, *args)
    result = original_command(name, *args)
    sleep(1) if args.first == "click"
    result
  end
end

Final Thoughts

Even though the config above allows our acceptance tests to merrily run, I'm not completely satisfied with the hoops we needed to jump in order to get things to work.

I have the feeling having the acceptance tests completely isolated from the main application (even in a separate repository) could be a good thing. In this direction it would be worthy to try and write the acceptance tests using a tool like phantomjs. I'm not talking about getting a phantomjs driver for capybara, but directly writing the whole acceptance suite with phantomjs in javascript.

Downloading and unzipping a file with ruby

2011-06-21T00:00:00-07:00

Quick! I need to download a zip file from an HTTP server and unzip it! That's surely trivial with ruby... is it? Yes, it is. But! Turns out there are a bunch of zip handling gems out there, and I had to try a a couple before arriving to my final solution.

First, let's download the file. This particular resource is served via an HTTP POST method. Yeah, unusual for a zip file.

  require 'net/http'

  url = "http://someweirdserver.com/a-zip-served-via-POST.zip"
  data = { "some-bizarre-params" => "which-are-needed" }

  zipbytes = Net::HTTP.post_form(URI.parse(url), data).body

Done. Moving forward, let's unzip the file. One detail to bear in mind, I have the zip file as a buffer (a String instance), and I don't want to go trough a tempfile to unzip it. The good news is that the zipruby gem can work off buffers.

  require 'zipruby'

  Zip::Archive.open_buffer(zipbytes) do |zf|
    # this is a single file archive, so read the first file
    zf.fopen(zf.get_name(0)) do |f|
      unzipped = f.read
      # done! do something with the unzipped file.
    end
  end

Lua's multiple arguments and the "select" function

2010-12-09T00:00:00-08:00

When I first read about lua's select function I found it a little confusing.

According to lua's manual for version 5.1, select behaves as follows:

select (index, ···)

If index is a number, returns all arguments after argument number
index.  Otherwise, index must be the string "#", and select returns
the total number of extra arguments it received.

That wasn't clear to me at first, but then I remembered lua sports real multiple arguments. I remark the word real because other languages like ruby don't really support returning multiple arguments. In ruby, if a method returns multiple arguments they are automatically packed into an array. Lua, in the other hand, has built in multiple arguments, which you can convert into a table if you really need to:

function multiple_args(...)
  local arguments = {...}  -- pack the arguments in a table
  -- do something --
  return unpack(arguments) -- return multiple arguments from a table (unpack)
end

Remembering the nature of lua's multiple arguments, and the fact that multiple arguments are not returned on a lua table dressed as an array, the description on the manual started to make sense.

The select function takes as "index" the index of the first argument that you want to retrieve, and any number of arguments afterward (the count of arguments starts at 1).

print(select(1, 1, 2, 3)) --> 1, 2, 3
print(select(2, 1, 2, 3)) --> 2, 3
print(select(3, 1, 2, 3)) --> 3
print(select(4, 1, 2, 3)) --> NOTHING

print(select(1, {1, 2, 3})) --> table
print(select(2, {1, 2, 3})) --> nothing

In the last two examples, the number of variable arguments is just one, consisting of a single table.

By the way, note another subtlety of lua: if you select more that the number of arguments available you get absolutely nothing!. Not even nil: nothing. If you try to pack NOTHING into a table, you get an empty table:

print(#{(function()end)()}) --> 0

Finally, if you pass "#" as index, the function returns a count of the multiple arguments provided:

print(select("#")) --> 0
print(select("#", {1, 2, 3})) --> 1 (single table as argument)
print(select("#", 1, 2, 3)) --> 3
print(select("#", {1,2,3}, 4, 5, {6,7,8}) --> 4 (a table, 2 numbers, another table)

Ruby conferences in Brazil and Uruguay

2010-10-31T00:00:00-07:00

This year I could attend both rubyconf Brazil and Uruguay. Both conferences had great talks and summarizing everything would be overkill, so I'll instead post some brief notes.

My Notes

Brazil Opening

Fabio Akita's talk was great in motivating the audience to be more participative in open source projects as a way of continuously improving as developers.

Client side development

Yehuda Katz talked about focusing on the client side of web applications. Using Ajax techniques is a start but ajax still generates a lot of latency waiting for server responses. In order to have a better client side experience techniques like buffered DOM manipulation, object bindings and event loops on the client side, can help to do as much work on the client as possible.

Rails 3.1

José Valim talked about some great features that will be packaged on rails 3.1, as better asset packaging (in line with the functionality provided by the sprockets gems), making rails serve the stylesheets and javascript and use sass, and general improvements on a lot of areas (new ActiveRecord's identity map, better generators, etc.).

Rubinius

Both Evan Phoenix in Brazil and Brian Ford in Uruguay described great features packed on of rubinius. Some of the impressive features are the integrated console and the profiler (both triggable by command line, no additional gems required). They also talked about the modularity and extensibility of the tools bundled in the rubinius environment, made evident by the possibility to implement 3rd party languages (like the fancy programming language).

JRuby

Charles Nutter showcased some cool demos on jruby, including live coding a swt GUI from irb, using the VisualVM profiler to profile some code, running a multithreaded java environment from the command line using the trinidad gem, and a 3D game. He also showed a demo of the mirah programming language, which has a syntax similar to ruby's but contains type annotations and can produce either java code or jvm bytecode.

Webfinger

Blaine Cook talked about webfinger, a solution to provide users with an identity on the web in such a way they becomes the owners of it (as opposed as tying the identity on the web to any given service, like twitter, facebook or linkedin profile names). Slides here.

Ruby 1.9.x fibers

Aaron Patterson gave a talk about scheduling, fibers and coroutines.

OOP and SOLID

Jim Weirich gave a talk about OOP and the SOLID principles.

Git

Scott Chacon gave a tutorial for git, starting from the fundamentals and the differences with other VCS like rcs or svn.

Clojure

Federico Brubacher talked about clojure, a very nice functional programming language for the jvm, and a great alternative to scala as it is a much more simple language.

ActiveRecord and Identity Maps

Emilio Tagua talked the addition of an Identity Map to ActiveRecord to shield great memory and performance savings.

Programming patterns

Ignacio Facello talked about patterns for Ruby.

Metaprogramming

Santiago Pastorino talked about metaprogramming ruby techniques.

Android

Tim Bray gave a 30 minutes long advertisement on android, quickly dismissing ruby as a viable development option while it was on it. Despite that, android is a great platform to develop mobile applications.

Uruguay Keynote

Evan Henshaw-Plath (@rabble) closed the Uruguay conference with a great keynote where he talked about the characteristics of the ruby community.

See you at rubyconf.br!

2010-10-24T00:00:00-07:00

Tomorrow I'm travelling to Sao Pablo, Brazil, to attend my first http://rubyconf.com.br/.

Exiting times! See you there?