The Ruby Ahead - home

Smaller Update

2010-03-14T00:00:00+01:00

I just wanted to let you know, that this blog just moved from mephisto to jekyll. This move will make it easier to keep the content online. While I was quit lazy in the past years, I also do not plan to get much more active, in the forcoming future. Having static pages, served by a rock-solid apache web server, will be much more reliable, then the old mongrel + mod_proxy_balance setup.

Unfortunately I was not able to keep the comments. There were not many of them, so I might copy them manually. All future post will not receive any. I you want to comment on the posts, you may want to send an email. Apart from that, this site will become a one-way street.

Seven Things

2009-01-23T00:00:00+01:00

It was way too long ago, that this site was updated. Sorry for that. Let’s use this meme as opportunity to start again.

These are the rules:

Link your original tagger(s), and list these rules on your blog.
Share seven facts about yourself in the post — some random, some weird.
Tag seven people at the end of your post by leaving their names and the links to their blogs.
Let them know they’ve been tagged by leaving a comment on their blogs and/or Twitter.

And here are the facts:

“The Ruby Ahead” is a more or less obvious variation of “The Road Ahead” - A book by Bill Gates covering the his thoughts on the development of broad band internet, cloud vs. desktop computing and general predictions.
I really liked writing blog entries about my master’s thesis, but writing the thesis itself was the horror.
I still owe Christian Neukirchen a paper copy of my thesis. He gave me permission to use the name ContextR and I promised to send him a copy in turn.
I’m using pons.eu to write this article.
I’ve just developed my first mobile website. Everybody complaining about IE6 should be glad.
The movie “Forrest Gump” brings tears to my eyes regularly.
I really dislike these kinds of “Stöckchen” or chain letters.

Concerning the 7th fact I will disobey the laws and not torture 7 others with this kind of stuff.

Done

2008-04-16T00:00:00+02:00

Today I finished my master’s thesis. Hooray. The title is “ContextR & ContextWiki - Modularisierung von Webanwendungen mit kontextorientierter Programmierung” or “Modularization of Web Applications Using Context-oriented Programming”. An abstract will be available, after it was graded. The full version will be public as well, although I’m not sure when.

In the mean time, you might be happy with the code. ContextR and ContextWiki are available at github.

Euruko 2008

2008-03-19T00:00:00+01:00

I will happily attend the Euruko 2008 in Prague. Hope to see you there.

Mechanize Use Case

2008-03-16T00:00:00+01:00

I’m using www.bibsonomy.org to manage my bibtex entries. This is a must have, when writing any scientific paper. Bibsonomy is like del.icio.us just for bibtex. Among the social and webscraping features to collect bibliography entries it has a bibtex export to create .bib-files for your local latex project.

The problem, we will solve today: Fetch the bibtex export from bibsonomy.

The older solution:

wget http://www.bibsonomy.org/bib/user/schmidtwisser?items=1000 -O literatur.bib

This solution is simple and was useful for a long time. Unfortunately I recently added private bib-entries. Since this solution doesn’t use any authentication, it only delivers my public entries.

Mechanize

So I needed to either use bibsonomy’s API, which would need registration, or I need to authenticate, keep the cookie and then fetch my bibliography. Enter mechanize:

require "rubygems"
require "active_support"
require "mechanize"

config = YAML::load_file(File.join(ENV['HOME'], 
                                   ".bibsonomy.yml")).symbolize_keys

agent = WWW::Mechanize.new
page = agent.get('http://www.bibsonomy.org/')

form = page.forms.action('/login_process').first
form.userName = config[:username]
form.loginPassword = config[:password] 
page = agent.submit(form)

page = agent.get("/bib/user/#{config[:username]}?items=1000")

File.open("literatur.bib", "w") do |f|
  f.puts page.body 
end

It is so easy, I won’t even explain the code.

Just one bit: Don’t embed your password in any public code, so do I. My credentials are therefore stored in my Home-directory.

The difference between alias_method_chain and plain old super

2008-03-07T00:00:00+01:00

Today a simple question arose. How to use alias_method_chain for class methods a.k.a. singleton methods a.k.a. instance specific methods for class. I just tried to answer the question, but finally I recognized, that it was’t actually necessary to use alias_method_chain at all. The aim was to add behavior to validates_presence_of, an ActiveRecord method, that installs a check to ensure, that a certain value is set, before data is send to the database.

So let’s have a look at the prerequisites first. I’ll translate the actual implementation into an easier example. ActiveRecord will most likely implement class methods in a module, that is mixed into the singleton class of all subclasses. This looks a lot like the following code, where ActiveRecord::Base becomes Base and validates_presence_of becomes class_method.

class Base
  module ClassMethods
    def class_method
      "base implementation used"
    end
  end

  def self.inherited(sub)
    sub.extend ClassMethods
  end
end

Whenever this class is subclassed, the inherited method will be called an the class methods added as described. If you want to add more specific behavior to the class_method you got multiple options. But there is no need to use method aliasing with ActiveSupport’s alias_method_chain. Modules, even the ones extending Objects have an inheritance relation. So let’s use super powers.

First option: Reusability

Define your own ExtendedBase that you may mix in to your classes, that need the additional behavior.

module ExtendedBase
  module ClassMethods
    def class_method
      "extended and " + super
    end
  end
  def self.included(sub)
    sub.extend ClassMethods
  end
end

This code uses the same ClassMethods technique as the class above, but the call back is called inherited this time. It provides a special implementation for class_method and delegates to the next one in the inheritance chain for the more general stuff.

It is used like the following:

class A < Base
  include ExtendedBase
end

Second option: Ad hoc usage

If no reuse is necessary, you may savely add the behavior to the single class, where you need it. Just open up the metaclass a.k.a. eigenclass a.k.a. singleton class and define your methods. Again, you may simply delegate to the base implementation using super.

class A < Base
  def self.class_method
    "custom and " + super
  end
end

Hehe. The description was more verbose than the code, but trust me it was still correct.

Never trust your code without tests

To make clear, that everything works as expected, I will add a test. I assume, that all the above definitions are loaded.

require "rubygems"
require "dust"

unit_tests do
  test "should call all three implementations" do
    assert_equal("custom and extended and base implementation used",
                 A.class_method)
  end
end

Conclusion: Know your inheritance chain

You should always have a look at your tools and know how your inheritance hierarchy looks like. It can things so much easier. Ruby’s method lookup follows a simple rule.

Definitions in the class itself
Definitions in included modules, modules included later are used first
Definitions in super classes

It is always possible to jump from one implementation to the other with the use of super. And if you are not sure, which implementation will be used first, ask your ancestors.

In this case a super call is much more expressive than the use of method aliasing. It does not pollute your objects instance methods list and it will never produce name clashes.

undef_method != remove_method

2008-02-28T00:00:00+01:00

When trying to remove behavior from your classes or objects, you will quickly stumble upon undef_method and remove_method. Even when your are just trying to change an implementation you will need one of these. Otherwise Ruby will warn you, that you are discarding an older code chunk.

So let’s quickly examine the basic difference between the two. The RDoc of undef_method already gives good starting point.

Prevents the current class from responding to calls to the named method. Contrast this with remove_method, which deletes the method from the particular class; Ruby will still search superclasses and mixed-in modules for a possible receiver.

There is also some sample code, but mine will be better. (No, it will not, but have you ever heard of NIH?) And I will use two test techniques promoted by Jay Fields to make sure, your mind is still able to move a bit. These are dust and anonymous classes for tests. Not too much magic for the rest of us, but both make posting test code a lot easier, quicker and more readable.

I will post it in chunks. At the end of the article you will have a complete ruby test.

require "rubygems"
require "dust"

No magic. Just wait a bit more…

unit_tests do

This is dust’s way to say class FooTest < Test::Unit::TestCase. I really like dust.

  def setup
    @base_class = Class.new do
      def method
        "answered in base class"
      end
    end
    @sub_class = Class.new(@base_class) do
      def method
        "answered in sub class"
      end
    end
    @base_instance = @base_class.new
    @sub_instance = @sub_class.new
  end

The setup method is pretty basic. We are creating a fresh inheritance hierarchy for every test method. This will simply prevent undesired side effects. Changes to classes are so global. Okay, the @base_class – actually it has no name, but anyways – has a single method method. @sub_class inherits from @base_class – now I get the naming schema – and defines its own version of the method method.

For each run, I also instantiate an instance for each class to play with.

  test "Basic setup works" do
    assert_equal @base_instance.method, "answered in base class"
    assert_equal @sub_instance.method, "answered in sub class"
  end

This is dust’s way to say def test_basic_setup_works; ...; end. How do you fell?

The code itself is really basic. I’m just making sure, that the setup works and nobody changed my tests significantly.

`remove_method`

Let’s start with the well-behaving twin: remove_method.

  test "remove_method let's you undo method definitions" do
    @sub_class.send(:remove_method, :method)

    assert_equal @base_instance.method, "answered in base class"
    assert_equal @sub_instance.method, "answered in base class"
  end

I’m using send here to circumvent the visibility restrictions. Don’t do this at home. Use class_eval instead. Your children (using 1.9) will be happier.

After removing a method, its definition is removed from the class itself. When you try to access it, the correct implementation will be searched within the ancestors. This way you can get rid of your customizations and activate a more general definition. This is mainly the thing you would want to use, before redefining a method, to get rid of the warning.

There is not much else to say about it. Sorry.

`undef_method`

The less it sounds like plain english, the hackier it is (ref. awk vs. grep). undef_method does not only remove the definition from the current class, but causes Exceptions. Let’s have a look at the tests first.

  test "undef_method causes NoMethodErrors" do
    @sub_class.send(:undef_method, :method)

    assert_raise(NoMethodError) { @sub_instance.method }
  end

Although, there is a definition in the base class, it is not used. Instead, we get an error. Okay, but this might make you think, that now, the method method is totally gone …

  test "undef_method does not affect superclasses" do 
    @sub_class.send(:undef_method, :method)
    
    assert_equal @base_instance.method, "answered in base class"
  end

… no it is not. It is still there – in the base class. undef_method actually hides all implementations in superclasses. This somehow breaks the inheritance relation. Although sub inherits from base and although base has an implementation and sub does not, the happy programmer caused a NoMethodError. The following test shall stress this reasoning.

  test "undef_method breaks inheritance" do
    @sub_class.send(:undef_method, :method)
    
    assert @base_class.instance_methods.include?("method")
    assert @sub_instance.kind_of?(@base_class)
    
    # This is the point where you should say: No!
    assert !@sub_instance.respond_to?(:method)
  end

We are still missing an

end

here. The test is done, it will work on all 1.8 compatible machines.

Strange summary

More or less – without the hooks to update the functionality of respond_to, instance_methods and their friends – remove_method and undef_method could be implemented like the following

class Module
  def remove_method(name)
    define_method(name) do
      super
    end
  end
  
  def undef_method(name)
    define_method(name) do
      raise NoMethodError, 
            "undefined method `#{name}' for #{self}", 
            caller(1)
    end
  end
end

The one passes control flow to an implementation somewhere else, the other raises Exceptions. Try it, think about it, and tell me, why one needs undef_method.

Syntax Highlighting enabled

2008-02-28T00:00:00+01:00

Were you as annoyed as I was about this site having no syntax highlighting but loads of code examples. The times they are a-changing. Thanks to Dan Webb for the JavaScript and Henrik for the CSS.

Quick Rake Goodies

2008-02-27T00:00:00+01:00

Since we are all social guys, telling everybody what we are doing right now, as often and as detailed as possible, it is just right, to do this automatically. So for everybody living on the command line and in Ruby the following quick snippets might be useful.

As you might know, I’m currently writing my master’s thesis – in LaTeX. And there is a quick command to calculate the current word count.

detex mainfile.tex | wc -w

detex strips all the LaTeX commands out of your document, but it follows includes, so all you got in the end is a plain text version on STDOUT. wc is one of this great old unix tools, it simply counts lines, words and characters. The -w options limits the output to a single number – the number of words.

This will be the first building block.

Skype

The first target of social striptease will be Skype. At least in my contact list, it is usual to let everybody know what you are listening to, where you are and what you are doing, with the help of mood messages. Sometimes they are even used for chatting. To set a mood message from the command line is pretty easy. I will be using the rb-appscript gem which allows to execute AppleScript from Ruby. Consequently this works only on a Mac.

require 'rubygems'
require 'appscript'
include Appscript

app("Skype").send_ :script_name => "Raketask",
                   :command => "SET PROFILE MOOD_TEXT I'm in Ruby mood"

The necessary information for this snippet were taken from the rb-skypemac gem (the way to talk to Skype via rb-appscript) and from this blog post (german) of a friend of mine (the way to set a mood message via AppleScript).

Twitter

Wouldn’t it be great if all my friends get an SMS, when I wrote five words, yes it would. So let’s build a simple Twitter integration. There is the great twitter gem which let’s you forget all the API nastiness and gives you really simple access from Ruby and your plain old command line. If you set up your Twitter credentials in ~/.twitter the command line tool automatically picks them to authenticate. I will use them to minimize the setup costs. Unfortunately, the Ruby API has no official way to access the config file in your home directory. But this is not a reason to stop. I’m using the send method here to circumvent visibility restrictions.

require "rubygems"
require "twitter"
require "twitter/command"

config = Twitter::Command.send(:create_or_find_config)

Twitter::Base.new(config['email'], config['password']).post("Ruby? Anybody?")

All together now

I have a Rakefile to compile my thesis using latex. In there are options to do a quick compile for preview and a longer compile including images for a final version. I have a task to open the generated PDF in Preview (using AppleScript again) or to fetch my bibtex file from bibsonomy.org. So why not add tasks to count words and to post the current status to Skype and Twitter. Now we have everything in place. So without and further ado, here is a snippet from my Rakefile:

desc "Counts words of main document"
task :count do
  puts "#{`detex #{PROJECT_NAME} | wc -w`.strip} words in thesis"
  if (file = ENV["file"])
    puts "#{`detex #{file} | wc -w`.strip} words in #{file}"
  end
end

This is the main count task. It simply prints the current word count to the command line. Additionally it is possible to count the words in a single file by passing in a file parameter (rake count file=chapter_1.tex).

namespace :count do
  def count
    count = `detex #{PROJECT_NAME} | wc -w`.strip
    "Current word count in master's thesis: #{count}"
  end

  desc "Post word count to Twitter"
  task :twitter do
    require "rubygems"
    require "twitter"
    require "twitter/command"

    config = Twitter::Command.send(:create_or_find_config)

    Twitter::Base.new(config['email'], config['password']).post(count)
  end

  desc "Post word count to Skype"
  task :skype do
    require 'rubygems'
    require 'appscript'
    include Appscript

    app("Skype").send_ :script_name => "Raketask",
                       :command => "SET PROFILE MOOD_TEXT #{count}"
  end              
end

This code may look familiar. It is the Skype and Twitter integration. The task use a common method count to get the numbers from the command line.

This were the not so quick Rake goodies. Thanks for your attention.

structured_warnings Highlights

2008-02-22T00:00:00+01:00

After my short Announcement yesterday, I’d like to go on an name some of the highlights.

Besides the basic functionality proposed in the original article, it has some more neat features, that make the life of its users enjoyable and fun.

So you better start using structured_warnings now.

Dynamic scoping

Using the block syntax to disable warnings provides a dynamic scope of deactivation. Not only everything within the block will raise no warning, but every piece of code, that is accessed from there on. This can become very powerful for certain uses.

Last one wins

You never know exactly, so deactivating a warning for a dynamic scope may be overridden by enabling it again in a deeper scope and the other way round.

Warner architecture

Each warning is passed to a warner instance, which it there to format the information, which is put to stdout. This warner may be changed for –again – a dynamic scope. This way you may instruct your favourite web framework to use a specific warner, that fetches all the information and writes it to a database instead of stdout.

Perhaps you want to have warnings in your merchant library to be to you via twitter message. Who knows? It will be pretty easy. Just have a look at the warner that is used for the test assertions. It will give you a good start.

Inheritance done right

Instead of redefining the Kernel#warn method directly, structured_warnings simply defines its own warn. The module is mixed into Object, so that every warn will go to this implementation first. After collecting all the necessary information, checking if the current warning is not disabled and formatting the output, the resulting message is passed on to the base implementation.

This way it is possible to add other extensions to you warning mechanism, you may freely redirect stderr to whatever you want. structured_warnings warn will just do, what it is supposed to.

Fully documented sources

Today I finished the documentation part. Now each and every method, public or not is documented. Just have a look at the RDoc generated API site.

Performance

Come on. The main goal is to avoid the use of code, that raises warnings. With the help of this library it is as easy as it gets to do that. A warning should always be an exception (not in the sense of the Ruby class, but in the sense of “not common”), so who will be concerned about performance.

The only thing I can tell you is, that structured_warnings will slow down calls to warn but it will not slow down your whole code and that is what counts.