life.events.each { |event| learn_from(event) }

The latest release of RubyShell is so cool, it’s skipping right over 0.4 and straight to 0.5. If you want to skip the explanation, you can go ahead and download it now.

It bears mentioning also that this release marks the first release of RubyShell on Rubyforge. Thanks to Rubyforge for being awesome :)

RubyShell 0.5 adds some tasty flavors to the table with four new treats. First up are shell objects.

Shell Objects

Shell objects are not my idea :) viraptor waited until the moment that RubyShell was on Rubyforge to unleash this cool little concept. Basically, these are objects that represent handy Ruby interfaces to useful concepts. Along with an initial implementation, viraptor provided two such object classes: ps and if_config. ps is used to get to information about processes, while if_config gives information about network interfaces (just like their command counterparts). Here are some examples of using ps (with some parts abbreviated):

RubyShell> procs.collect { |proc| proc.name } .inspect
=>["init", "migration/0", "ksoftirqd/0", "migration/1", "ksoftirqd/1",
"events/0", "events/1", "khelper", "kthread", "kblockd/0", "kblockd/1", 
"kacpid", "ksuspend_usbd", ...,"artsd"]
RubyShell> ps.named('nspluginviewer').inspect
=>[#<RubyShell::ShellObjects::Ps::Process:0xb78a3b8c @name="nspluginviewer",
@cmdline=["/usr/kde/3.5/bin/nspluginviewer", "-dcopid", "nspluginviewer-27450"], @pid=27521>]
RubyShell> ps.named(/ns/).inspect
=>[#<RubyShell::ShellObjects::Ps::Process:0xb7878edc @name="mdnsd", @cmdline=["/usr/sbin/mdnsd"],
 @pid=6809>, #<RubyShell::ShellObjects::Ps::Process:0xb785ac20 @name="nspluginviewer",
@cmdline=["/usr/kde/3.5/bin/nspluginviewer", "-dcopid", "nspluginviewer-27450"], @pid=27521>]
RubyShell> ps.pids.inspect
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 88, 89, 90, 223, 226, 228, 240, 261, 262, 263, 861, 1019,
1066, 1068, 1069, 5006, 5090, 5173, 5174, 5180, 5181, 5182, 5183, 5186, 5199,
5201, 5337, 5381, 5443, 5532, 5949, 6060, 6202, 6224, 6225, 6226, 6316, 6633, ..., 29380, 31581]
RubyShell> ps.from_pid(1).inspect
=>#<RubyShell::ShellObjects::Ps::Process:0xb783a948 @cmdline=["init [3]"], @pid=1>
RubyShell> ps.from_name('init').inspect
=>#<RubyShell::ShellObjects::Ps::Process:0xb7834ae8 @name="init", @cmdline=["init [3]"], @pid=1>

You can also kill a process (ps.from_pid(1).kill ‘TERM’, for example) and do a few other things like check if it’s alive or if it’s a kernel process and get the parent process.

A couple of bugs made their way into the 0.5 release, including output that doesn’t call inspect automatically on its results and a ruby indicator that isn’t followed by a space. There’s also a bug in the Process class used in ps that means if it’s printed without an inspect, an error arises. These will all be fixed in RubyShell 0.6 (and, in fact, already are in trunk).

Here is some of what you can do with if_config:

RubyShell> if_config.interfaces.inspect
=>[#<RubyShell::ShellObjects::IfConfig::Base::Interface:0xb780ace8 @name="lo">,
#<RubyShell::ShellObjects::IfConfig::Base::Interface:0xb780ac48 @name="eth0">]
RubyShell> if_config.names.inspect
=>["lo", "eth0"]
RubyShell> if_config['eth0']
=>#<RubyShell::ShellObjects::IfConfig::Base::Interface:0xb77f4c2c @name="eth0">
RubyShell> if_config.eth0.inspect
=>#<RubyShell::ShellObjects::IfConfig::Base::Interface:0xb77f4c2c @name="eth0">
RubyShell> if_config['eth0'].ip
=>192.168.2.39
RubyShell> if_config['eth0'].mask
=>255.255.255.0

There’s the potential for much much more, but for the time being this is about it for if_config.

So these are shell objects. They’re a very promising idea, and I hope some people will contribute more objects. Note, though, that the way shell objects are implemented in 0.5 and currently in trunk is likely to change, I just haven’t thought it through 100% yet.

File Handling

Until 0.5, RubyShell only operated interactively—i.e., you couldn’t just hand it a file and have it read and run that file. That is no longer the case. Now, you can pass files on the command line to the ruby_shell.rb script and it will execute all of them. Currently, it executes them all in the same context; I’m still deciding whether or not I like this better than executing them in separate contexts.

Hand in hand with this new addition is the addition of an initialization file. RubyShell will now try to read a ~/.rbshrc and run whatever initialization code is there before running, either for files or interactively. This file can contain anything that’s valid RubyShell code. Here’re the contents of mine as it stands:

require 'colored'
hostname | host = $pipe.strip
shell.prompt = Proc.new do
  "\#{ENV['USER']}@\#{host}".green + " \#{Dir::pwd.gsub(File.expand_path('~'), '~')} # ".blue
end

alias 'ls', 'ls --color'

Whammo! And therein lie hints as to the two remaining treats that await within…

Interpolation

RubyShell now supports interpolation of RubyShell code. That is to say, it supports executing code and replacing that section of the line with the code’s results. This is what’s usually done in ``s in other shells like bash. As it turns out, RubyShell 0.5 uses #{} for this, just like string interpolation for Ruby.

Sadly, this interferes with the actual string interpolation. As you can see above, you can escape such an interpolation using \#. If that isn’t done in the above section, you’d get an interpolation that would happen once when the RubyShell parser hit it, and never again—thus resulting in a prompt that never updated its values. RubyShell 0.6 will, instead, use the traditional backticks (``) to just dodge this problem entirely.

Command Aliases

Finally, RubyShell 0.5 supports aliasing commands. This is done through a normal Ruby method, alias_cmd. It just takes a command and what it should become. However, the command can also be a regular expression, or anything that will behave nicely under #===. For example:

RubyShell> alias_cmd 'ls', 'ls --color'
RubyShell> alias_cmd /ram/, 'ls'
RubyShell> arama
*results of alsa*

The value of the regular expression thing is one I’m still not 100% sure of, but it seems like it could be used for interesting and cool things. Also, through some hackery in the RubyEvaluator, instead of alias_cmd, you may use alias. The only caveat is that alias has to be the very very first thing in the statement. Otherwise, the replacement won’t take place (so that regular aliasing can be used). Thus:

RubyShell> alias 'ls', 'ls --color'

What’s Next

On the horizon is an implementation of output redirection. Currently, the plan is to make the syntax `word>’, where `word’ corresponds to an actual method somewhere (haven’t decided where yet) that will take the filename as a parameter and could potentially apply transformations to the output as it goes.