H3RALD: Blog

New Release: RawLine 0.2.0

h3rald — Wed, 02 Apr 2008 05:33:00 -0600

~~InLine~~ RawLine 0.2.0 is out!

RawLine is the new name for InLine, in case you didn’t guess. The name was changed to avoid name collision problems with the RubyInline project.

Here’s what’s new:

Added /examples and /test directory to gem.
Escape codes can now be used in prompt.
It is now possible to use bind(key, &block) with a String as key, even if the corresponding escape sequence is not defined.
Added Editor#write_line(string) to print a any string (and “hit return”).
Library name changed to “RawLine” to avoid name collision issues (Bug 18879).
Provided alternative implementation for left and right arrows if terminal supports escape sequences (on Windows, it requires the Win32Console gem).

In particular, I decided to provide an “optimized implementation” for the left and right arrows using escape sequences rather than shameful hacks. This is now possible because the Win32Console gem now enables ANSI escape sequences on Windows as well (weehee!).

So:

If you’re on *nix all good, your terminal is smart and can understand escape sequences => the new implementation will be used.
If you’re on Windows and you installed Win32Console, your termnal is smart and can understand escape sequences => the new implementation will be used.
If you’re on Windows and you didn’t install Win32Console, then your terminal is stupid and it doesn’t understand escape sequences, so the old implementation will be used.

The new implementation is significantly faster than the old one, on Windows at least, and the cursor now blinks properly when left or right arrows are pressed.

I re-emplemented only cursor movement because I’m still having some problems in getting the delete/insert escapes to work properly (or better: how I want them to work!).

InLine name change: what's your opinion?

h3rald — Thu, 27 Mar 2008 06:30:00 -0600

I’ve been kindly asked by the lead developer of RubyInLine to change the name of my InLine project, due to potential confusion and conflicts.

This makes sense, and I’m ready to change the name of my project, although I’m not that good at choosing original and smart names, so well, any suggestion is more than welcome!

I was thinking of something like:

RawLine
EditLine
RawInput
RubyInput
RubyLine

I personally think that RawLine is probably the best option, but please, if have any better idea just speak up!

P.S.: “RedLine” is taken, unfortunately, otherwise it would have been my first choice since the beginning.

RawLine - a 100% Ruby solution for console inline editing

h3rald — Mon, 10 Mar 2008 06:59:00 -0600

One of the many things I like about Ruby is its cross-platform nature: as a general rule, Ruby code runs on everything which supports Ruby, regardless of its architecture and platform (yes, there are quite a few exceptions, but let’s accept this generalization for now).

More specifically, I liked the fact that I could use the GNU Readline library with Ruby seamlessly on both Windows and Linux. Readline offers quite a lot of features which are useful for those people like me who enjoy creating command-line scripts, in a nutshell, it provides:

File/Word completion
History support
Custom key bindings which can be modified via .inputrc
Emacs and Vi edit modes

Basically it makes your command-line interface fast and powerful, and that’s not an overstatement. Ruby’s own IRB can be enhanced by enabling readline and completion, and it works great—at least on *nix systems.

For some weird reason, some people had problems with Readline on Windows: in particular, things get nasty when you start editing long lines. Text gets garbled, the cursor goes up one or two lines and doesn’t come back, and other similar leprechaun’s tricks, which are not that funny after a while.

Apparently there’s no alternative to Readline in the Ruby world. If you wan’t tab completion that’s it, you’re stuck. Would it be difficult to implement some of Readline functionality natively in Ruby? Maybe, but the problem is that for some reason the Ruby Standard Library doesn’t have low level methods to operate on keystrokes…

…but luckily, the HighLine gem does! James Edward Gray II keeps pointing out here and here that HighLine’s own get_character method does just that: it returns the corresponding character code(s) right when a key is pressed, unlike IO#gets() which waits for the user to press ENTER.

Believe it or not, that tiny method can do wonders…

Reverse-engineering escape codes

So here’s a little script which uses get_character() in an endless loop, diligently printing the character codes corresponding to a keystroke:

#!/usr/local/bin/ruby -w

require 'rubygems'
require 'highline/system_extensions'

include HighLine::SystemExtensions

puts "Press a key to view the corresponding ASCII code(s) (or CTRL-X to exit)."

loop do

    print "=> "
    char = get_character
    case char
    when ?\C-x: print "Exiting..."; exit;
    else puts "#{char.chr} [#{char}] (hex: #{char.to_s(16)})";
    end

end

A pretty harmless little thing. Try to run it and press some keys, and see what you get:

Press a key to view the corresponding ASCII code(s) (or CTRL-X to exit).

	=> a [96] (hex: 61)
=> 1 [49] (hex: 31)
=> Q [81] (hex: 51)
=> α [224] (hex: e0)
=> K [75] (hex: 4b)

Hang on, what are the last two codes? A left arrow key on Windows, apparently.

Welcome to the wonderful world of input escape sequences!

To cut a long story short, both Windows and *nix system “terminals” translate special keystrokes into sequences of two or more codes. This applies to things like DEL, INSERT, arrows, etc. etc. For some ideas, check out:

Windows Scancodes (Thanks Huff)
VT220 Terminal Input Sequences (Thanks James)

Let’s now assume that we’re smart and we can write a program which can parse keystroke properly, including handling different input escape sequences according to the OS, what can it be used for? Well:

For normal characters, just print them back to the screen (get_character doesn’t print anything, it “steals” the keystroke)
For special characters, do something nice!

We could setup TAB to auto-complete the current word according to an array of matches, or bind the up arrow to load the last line typed in by the user, for example, that’s basically something Readline does, right?

RawLine: how it works and what it does

I created a small project on RubyForge called RawLine (not to be confused with RubyInline, a completely different thing altogether, sorry about that) to play around with the possibilities offered by the get_character method. The library is just a preview of things which can be done, but it’s already usable, provided that you’re brave enough to try it out, that is.

The basic idea behind RawLine is to be able to parse keystrokes properly on different platforms and re-bind them to a set of predefined, cross-platform actions or a user-defined code block.

Basic line-editing operations

The first challenge was to re-invent the wheel, i.e. re-bind keystrokes to their typical actions: a left arrow moves the cursor left, a backspace deletes the character at the left of the cursor and so on. Yes, because get_characters gives you the right character codes at the price of cancelling their normal effects, which is a great thing, as you’ll soon find out.

Printing a character on the screen was one of the easiest tasks (at first). IO#putc does the job pretty well: it prints a character out. What about moving left? Easy: print a non-descructive backspace (\b) and hope it is really not destructive. I did some tests and it seems to do as it’s told and move the cursor back by one position.

Moving right was a little trickier: the easiest thing I found was to re-print the character under the cursor, which will then move the cursor forward (as naive as it may seem, it does the job!). If there’s nothing under the cursor, then we must be at the end of the line and it shouldn’t move anywhere, so there we go.

What if I move left a bit and then start typing normal characters? Well, everything is rewritten of course: this will be our “character replace mode”. Unfortunately users don’t like this behavior that much, so what I did was this:

Copy all characters from the one at the left of the cursor till the end of the line
Print the character to be inserted
Re-print the previously-copied characters
Move the cursor back at the right place

Again, a primitive solution which works seamlessly on all platforms, and yes, it’s fast enough that you don’t notice the difference.

As you may have guessed, this of course means that I always had to keep track of:

The cursor position within the line
The text currently printed to the screen

Backspace and delete were implemented in a similar way, you can figure it out yourself or look at the source code: I won’t bore you any further!

History management

The next step was to implement a history for both the characters inputted by the user (to allow undoing and redoing operations) and for the whole lines. This was just an ordinary programming exercise: a simple buffer with some extra controls here and there, nothing too scary.

So every “modification” to the current line being typed is saved in a line history buffer and all the lines entered are saved in another history buffer. All is left is to allow users to navigate through these buffers back and forth. Nothing impossible: all I had to do was keeping track of the current element of the history being retrieved and then overwrite the current line with a new line stored in the buffer? How’s this line overwriting done? Same old:

Move the cursor to the beginnig of the line
Print X spaces, where X is the line length, so that the characters are no longer displayed in the console
Move the cursor back to the beginning of the line
Print the new line.

Easy and naive, as usual. But again, it works well enough.

Word completion

The other challange was word completion. The current implementation can be summarized as follows:

If TAB (or another character, if you wish) is pressed, call a user-defined completion_proc method which returns an array and show the first element of the array (in this case I actually used a cyclic RawLine::HistoryBuffer, not an array)
If the user presses TAB again, show another match, and so ad infinitum if the user keeps pressing TAB.
If the user presses another key, accept the default completion and move on.

Obviously this means that:

RawLine has to keep track of the current “word”. A word is everything separated by a user defined word_separator, which can obviously modified at runtime, with care.
Regarding the completion_proc, typically you may want to return only the elements matching the word which is currently being written, so that’s given as default parameter for your proc. Exactly like with ReadLine, the only difference is that you can access other things like the whole line and the whole history in real time, which can be really handy at times!

Here’s a simple example:

editor.completion_proc = lambda do |word|
    if word
        ['select', 'update', 'delete', 'debug', 'destroy'].find_all    { |e| e.match(/^#{Regexp.escape(word)}/) }
    end
end

Custom key bindings

All these pretty things are obviously bound to some keystrokes. If the key corresponds to only one code, everything is fine, but because special keys typically aren’t so it was necessary to implement a mechanism to track an escape key (e.g. 0xE0 and 0 on Windows and \e on Linux) and listen to further characters, in case a known sequence is found. Anyhow, the final result of the method used for character binding is the following:

bind(key, &block)

Where key can be:

A Fixnum corresponding to a single character code
An Array of one or more character codes
A String corresponding to an escape sequence
A Symbol corresponding to a known escape sequence or key
A Hash to define a new key or escape sequences

So, in the end you can do things like this:

editor.bind(:left_arrow) { editor.move_left }
editor.bind("\etest") { editor.overwrite_line("Test!!") }
editor.bind(?\C-z) { editor.undo }
editor.bind([24]) { exit }

Which, for Rubyists, it’s far sexier and more flexible than editing an .inputrc file.

How do I use it, anyway?

A code example is better than a thousand words, right? So here you are:

#!/usr/local/bin/ruby -w

require 'rubygems'
require 'rawline'

puts "*** Inline Editor Test Shell ***"
puts " * Press CTRL+X to exit"
puts " * Press CTRL+C to clear command history"
puts " * Press CTRL+D for line-related information"
puts " * Press CTRL+E to view command history"

editor = RawLine::Editor.new

editor.bind(:ctrl_c) { editor.clear_history }
editor.bind(:ctrl_d) { editor.debug_line }
editor.bind(:ctrl_e) { editor.show_history }
editor.bind(:ctrl_x) { puts; puts "Exiting..."; exit }

editor.completion_proc = lambda do |word|
    if word
        ['select', 'update', 'delete', 'debug', 'destroy'].find_all    { |e| e.match(/^#{Regexp.escape(word)}/) }
    end
end

loop do
    puts "You typed: [#{editor.read("=> ").chomp!}]"
end

This example can be found in examples/rawline_shell.rb within the RawLine source code or gem package.

Current status and availability

I currently released RawLine 0.1.0 on SourceForge, and it can be installed via:

gem install -r rawline

The RDoc documentation is available here.

Feel free to try it out. First of all try the rawline_shell.rb example, and see if it works on your machine. If it doesn’t than maybe you try re-binding some keys (use key_tester.rb to “reverse-engineer” your terminal’s input escape sequences), and let me know!

Status information and limitations:

It has been tested on Windows (XP, using the usual command prompt) and on Linux (ZenWalk, using XFCE Terminal).
It can handle lines no longer than the maximum terminal width – 2. This is to ensure that the cursor never “falls down” to the next line.
On Windows, the cursor doesn’t blink immedialy when moving left, but it moves, don’t worry.
On Linux, you should really consider installing the Termios library for a faster experience (otherwise get_character won’t parse characters correctly if you press and hold a key, and that, trust me, is a real mess!).
RawLine is very far from being a complete replacement for the ReadLine library, and it is currently in alpha stage.
Release 0.1.0 has been created after 2 weeks of sporadic coding during lunch breaks and week-ends.

For any ideas on where to go from here, comments and feedback, just reply below or send an email to my usual email address.

Beware of sudden upgrades!

h3rald — Thu, 20 Dec 2007 07:41:00 -0700

Yesterday I got a rather annoying early Christmas present: when visiting my site, I noticed that the raw source code of my dispatch.fcgi file (yes, I’m on shared hosting with FastCGI, for now) was displayed “as it is” instead of being interpreted.

After the initial moment of anger and stress (I immediately realized it was BlueHost’s fault, not mine), I opened two tickets and went to bed, hoping to see everything solved in the morning.

Unluckily it wasn’t the case, so I posted on BlueHost forum trying to be as polite as possible complaining because the issue wasn’t being dealt with. It turns out that for such issues you’re supposed to use the “Live Chat” feature instead of the tickets, so that’s what I did.

After a quick chat with “Christian”, it turns out that BlueHost decided to perform a server upgrade “silently” upgrading to Apache2, PHP5, MySQL4.1, etc. etc. Cool, pity that nobody told me that!

I was expecting some sort of PHP upgrade (not that I care like that), which was supposed to happen according to the last BlueHost newsletter:

“To alleviate any issues in the future with certain scripts that only run on one version of PHP we have developed the ability to run PHP4 and PHP5 on the same server simultaneously. This will be rolled out to all users in the next couple of weeks. Some servers already have this ability while most will see it in the next two weeks.”

But… hang on? Does it say anything about migrating to Apache2? I don’t think so! What’s worse, is that quite a few things changed with Apache2, in particular the way FastCGI handlers are declared:

# Apache 1.3:
AddHandler fastcgi-script .fcgi

# Apache 2:
AddHandler fcgid-script .fcgi

See? Different. This is due to the fact that mod_fcgid is used instead of mod_fastcgi on Apache 2.

The fix was easy, of course, and now my site is up and running again (and actually running faster)… but, I wonder, why the hell wasn’t I informed? Is it acceptable? It sounds like I might end up on a VPS sooner than expected, unless BlueHost doesn’t roll out some new exciting feature soon, as I think it might…

Announcement: RedBook v0.5.0 released

h3rald — Sun, 16 Dec 2007 08:07:00 -0700

This new beta release of RedBook introduces quite a few changes when it comes to configuration and setup. Here’s some highlights…

Regexp changes

It is now necessary to enter “proper” regular expressions for :select. Proper means between slashes, like the following:

/Work Day/
/mail/i

I changed this in order to support case-insensitive searches using the i switch. This makes queries much more powerful.

Variables

A new, interesting feature I decided to introduce in this release is variables. For now you define them inside your rbconfig.yml file, like this:

:var_monday_morning: "monday at 8 am"

:var_friday_evening: "friday at 8 pm"

:var_week_report: ":select :duration :from :%monday_morning :to :%friday_evening"

In this way, every time you type in :%week_report in RedBook, it will expand to: :select :duration :from monday at 8 am :to friday at 8 pm. By the way, completion is supported, so you’ll only have to type in something like :%we and hit .

It is possible to define variables as :var_<something> in the rbconfig.yml file and then used them inside RedBook as :%<something>.

New Operations

Five new operations have been added:

:blank

This will blank your current log after asking you if you really want to do so.

:restore

This operation will overwrite your current log with the last saved backup. Like with the :blank operation, you’re asked if you really want to proceed or not.

:archive

By typing :archive, the current log file will be archived to your :archives_folder: directory specified in the rbconfig.yml file (similarly, it is now possible to specify a :backups_folder: for your logs’ backup files).

:dataset

A simple operation to display the messages inthe current dataset.

:dump

This operation will dump the output of the last :select operation to a text file. Useful for saving the average, total time and duration of a set of activities.

Portable edition

Some Windows users will definitely love this. I finally found an easy way to run RedBook confined within the current directory, by using a simple start.bat batch file to set the INPUTRC and HOME variables temporarily to the path to the .inputrc file and the directory of RedBook executable. This makes RedBook 100% portable and suitable to be used on USB sticks &similar.

Get RedBook Portable

New Development Page

I decided to move the primary RedBook repository from Assembla to Google Code. Why? Well, nothing wrong with Assembla per se, I still think it’s an excellent free service to host your public and private projects, but Google Code is faster and offers only the features I need:

Public SVN repository access
Simple-to-use issue tracker
Very nicely developed downloads section, with download counts, and “normal” filenames.

So here’s the new RedBook Development Home:

http://code.google.com/p/redbook/

Additionally I also setup a RedBook Support Google Group, so if you have any question concerning the program, you know where to go!

Review Services

h3rald — Fri, 14 Dec 2007 12:24:00 -0700

When it comes to software, I definitely like to try out new things. My collegues takes the piss out of me because every ~~week~~ day I come up with “some new tool they have to start using” and so on. As a matter of fact, I like reviewing software as well. I enjoy writing and analyzing new things, evaluating all the new possibilities they may offer, and I also tend to have a rather critical eye for what doesn’t feel right. I’ll use a tool for months but still try out new ones which claim to do the same thing — but better — as they come out. Unfortunately — or fortunately, depends how you look at it — when it comes to software, there are very few silver bullets, and things keep changing: that’s the way it is and the way it will be.

I must try to write up a page (and ideally update it regularly, that’s the hard part) listing all the tools I use, at some point… but at any rate, if you coded some new app you think kicks ass or you found a hidden jewel in the labyrinth of freeware, just let me know: I’ll definitely try it out, and if it’s worth a post I’ll blog about it.

The same applies to books, actually, as I like reading, especially those which are related to Ruby or programming, nowadays.

The cost of such reviews and articles? Depends! Certainly I wouldn’t mind donations or some compensation of some form, especially from publishers or software companies. It may be money, books, software or even nothing: it really depends on what I have to review. Please be aware that I am not doing this full time, and I already have a job and a fiancée to look after, but I’ll do my best to publish as much as I can on my site or even elsewhere elsewhere [Note: on e-zines, magazines & similar, not on your brother’s friend’s mother-in-law’s crappy blog!].

For any inquiries, contact me (h3rald [—at—] h3rald.com).

Announcement: RedBook v0.4.0 released

h3rald — Wed, 28 Nov 2007 08:34:00 -0700

I’m pleased to announce a new release of the RedBook daily logging and time tracking script. This release introduces two new operations, four stats-related directives and a brand new Windows Installer able to setup RedBook in a blink, with (almost) no configuration at all.

Let’s have a closer look…

New Operations

Suppose that you just logged a message and you noticed one of these two things happened:

You didn’t really wanted to log it
You made a silly typo in the message or in the tags

What can you do about it? Up to RedBook 0.3, the only solution was to open the YAML file and correct the mistake manually. From now on there’s also another simpler way to operate in such situations: using the :update and :delete operations!

:update

This operation can be used to update the message and or the tags of a previously-logged activity. The usage is simple: load a dataset first, and then execute an :update command like:

:update 4 :message My updated message :with new_tag1 new_tag2

This will update the 4th message of the dataset modifying its message and tags. Of course you can update either of the two things or both; the timestamp of the activity will not be changed.

:delete

The delete operation can be used to completely delete a message from the log. Just load a dataset using a :select operation and then execute a :delete command, e.g.:

:delete 1 (will delete the first activity)
:delete 4 2 7 9 (will delete activity #2, #4, #7 and #9)
:delete (will delete the entire dataset)

A confirmation message will appear before deleting the message(s).

IMPORTANT Due to the architecture of the application, whenever an :update or :delete occurs the log file will be reloaded in memory and completely overwritten. This doesn’t cause problems, although for big log files (10,000+ activities) this may take a few seconds.

Statistics

Another important new feature introduced by this release is time tracking. It was actually already there, kind of: the :calc operation was already able to calculate the time elapsed between two activities… however, this is not really practical.

Since last release, it is possible to log the completion of an activity using the :finish command. This will basically re-log the same activity prepending [COMPLETED] to its message. If you started using the :finish command to complete your activities, RedBook can now calculate the following stats for you:

Count the number of messages in a dataset
Calculate the average time spent for the completed activities in a dataset
Calculate the total time spent for the completed activities in a dataset
Calculate the duration of each completed activity in a dataset

Each of these calculations is performed by adding special directive to a :select command, as explained in the following sections.

:count

This directive can be added to a :select command to return just the number of message of the loaded dataset. In other words, executing the following:

:select :count :with mail !work

…will return the number of activities tagged with mail but not with personal, without listing all the activities.

:avg

The :avg directive can be used to calculate the average time spent on activities matching certain criteria, for example:

:select Status Meeting :avg :with meeting

…will return the average time spent on activities whose messages matches /Status Meeting/ and are tagged with meeting.

:total

Similarly, :total can be used to return the total time spent on activities matching certain criteria, e.g.:

:select :total :with mail work

…will return the total time spent on activities tagged with mail and work.

:duration

Lastly, :duration will print each completed task along with its duration. The syntax is similar to the others:

:select :duration :with break

This will print each completed activity tagged with break along with its duration.

:nodiff and _concurrent

The logic behind the above-mentioned directives may seem trivial to implement, but it is not. The fun part was telling RedBook to subtract the duration of each sub-activity contained in another activity… a feature I considered necessary for time tracking purpose. However, if you start your work day with a Working Day activity and you complete that activity using the :finish command, when calculating the duration of the working day RedBook will subtract the duration of all the completed sub-activities from the duration of Working Day. This is not OK, so I added the directive :nodiff which can be used to prevent RedBook from calculating the difference between the parent activity’s duration and the duration of each of its child activity.

What if you’re doing two things at once? use the special _concurrent tag, and that activity will be considered symultaneous to its parent activity for time tracking purposes.

Activity Status Filters

RedBook is now fully aware of the “status” of each activity, so it is possible to display only activities in a certain status using the following directives:

:plain

Executing :select :plain :from today will return all the activities logged today, omitting their completions (if any), i.e. any activity beginning with [COMPLETED].

:pending

Executing :select :pending :from today will return all the activities logged today which have not been completed yet. Again, this was not too trivial to implement, but it seems to work (it also smart enough to detect if the same activity has been relogged etc. etc.).

WARNING: Using this directive with a large dataset may cause RedBook to take some time before delivering the result, due to the amount of iterations to perform. Use with care.

:completed

Executing :select :completed :from today will return all the activities logged today which have been completed.

Windows Installer

I decided to spend some time (half an hour) and create a proper setup file for Windows using InnoSetup. The setup will take care of almost everything for you, so you have no excuse not to try RedBook because it’s not user-friendly to install!

Check out the manual for more details.

RubyForge Project

Finally, I registered a new RubyForge Project for RedBook, which include a public SVN repository updated every week (Assembla doesn’t allow anonymous checkouts, unfortunately). This project will also host the official RedBook Gem, scheduled for the 1.0 release.

[DOWNLOAD] | [MANUAL]

Text Link Ads sidebar for Typo

h3rald — Sat, 17 Nov 2007 04:47:00 -0700

I thought it would be nice to share the code of the sidebar I created to display Text Link Ads sponsor links on my Typo powered blog.

There’s actually another plugin which was made for Typo 2.6, but unfortunately it doesn’t work with Typo 4.1.1.

Installation

Just unzip it inside your vendor/plugins directory. The new sidebar should appear in the list of your available sidebars in the Typo’s administration area.

Configuration

In Typo’s administration area, configure the following settings for this sidebar:

Title: The title of the sidebar
KEY: Your TLA’s XML key
Affiliate ID: Your TLA’s affiliate ID
Advertise Here: A message shown when no links are displayed.

Download Text Links Ads Sidebar v1.0

Announcement: RedBook v0.3.0 released

h3rald — Thu, 25 Oct 2007 07:18:00 -0600

It’s time for a new beta release of RedBook. This was actually going to be a fairly modest release in terms of features, but I actually ended up implementing a lot more than expected, even things which were planned for the first production release 1.0. So, let’s see what’s new

New operation names (which break compatibility with previous versions)

I had a look at the names I choose for the operations and I noticed that they were either not intuitive enough or too verbose. So I decided to change a fair few of them (thus breaking compatibility with previous versions, but after all that’s what beta releases are for, right?):

OLD	NEW
:complete	:finish
:load	:select
:load_config	:config
:load_log	:refresh
:timecalc	:calc
:stop	:quit

New Manual/Home Page

A while ago I discovered TiddlyWiki, but as a matter of fact I never used it for anything practical. From last week though, I started using it a work for taking notes and create short memos, and then I thought of using it to replace RedBook’s standard README file (which was made in a hurry and was kinda cryptical). Now a brand new “manual.html” ships with RedBook—308 KB (30 of actual docs and 278 of Javascript/HTML/CSS magic) with everything you need to know about it. Additionally, an online version is available at the following address:

redbook.h3rald.com

Removed Win32::Console Library

OK this is not good news for people (like me) who use RedBook on Windows, but I promise you’ll forgive me when you read about the other new features below. I discovered by chance that the Win32::Console library (which was used to get colors working on Windows) seems not to handle international characters properly and also seems to be conflicting in some way with the Readline library I decided to include (see below). I don’t know whether this is a problem of the actual library or just of the gem used to pack it.

rbconfig.yml

The config.yml file has been renamed to rbconfig.yml. Additionally, if you place a file with this name in your $HOME directory it will override the one in your RedBook folder (This was done in preparation for the RedBook RubyGem).

New operations

The following new operations are available:

:relog—Re-logs a previously-logged message (keeping the same tags and updating the timestamp)
:clear—Clears the screen.
:ruby—Evaluates arbitrary Ruby code outputting the result (use with care…)

Auto-completion

Some Mac users originally complained that the backspace key wasn’t working in RedBook (and it didn’t in Linux either). Fortunately the solution to this was easy enough: include the GNU Readline library. Readline is now being used in RedBook to:

Provide basic (Emacs-style) bindings
Auto-completion for keywords and tags
Allow the user to automatically customize key bindings via an .inputrc file placed in their $HOME directory (on Windows you’ll have to define a HOME environment variable pointing to a directory of your choice). An example .inputrc file is distributed with RedBook with some specific key bindings.

Support for international characters

Finally, I decided to implement another feature which was originally planned for the 1.0 release: international characters support. This is possible using the Iconv Ruby extension (requires GNU libiconv) which can convert strings between different character sets. The character sets needs to be configured via the rbconfig.yml file.

For more information, check out the ChangeLog

Download RedBook

Announcement: RedBook v0.2.0 released

h3rald — Mon, 08 Oct 2007 05:05:00 -0600

“Release Early, Release Often” —Eric S. Raymond, The Cathedral and the Bazaar

In other words, time for another (early) release of RedBook. There are quite a few new features which are worth examining, in particular:

Regexp search for messages

This was actually already available before, just if you inputted a search string which was not a regexp, you’d get an unhandled exception (more or less). This exception is now handled propertly so you get a pretty message instead, if an error occurs when parsing the search string.

Log Backup

A new :backup keyword is available to quickly backup your log file. Here’s what it does:

Loads all messages silently
Writes them to a file in the same directory as the original log file named <log-alias>.bkp.yml.

Handy, especially if there was a similar keyword to restore the last backup, which is planned for later on.

Support for multiple log files

This is perhaps the most important feature introduced by this release. It is now possible to configure more than one log file by adding any number of :data_<alias>: settings inside your config.yml file, where alias is the name of your log file. So, for example, if your config.yml file contains the following:

:data_test: “testlog.yml”

You can load the “test” log by typing

:use test

(:use is a shorthand for :load_log). Similarly, another new keyword :dest has been introduced to be able to log a message to a different log file without loading it into memory, like this:

:log This message will be saved to testlog.yml :dest test

Finally, a :refresh keyword has been introduced as an alias to reloading the current log.

(Almost) automatic log of completed activities

Right when I was coding the :timecalc operation, I thought it would be nice to be able to log the start and end of a task without having to type it twice. Now this is possible using the :complete keyword:

:log Testing feature X in product Y

:complete

:complete will re-log the last message prepended with [COMPLETED]:

4 Mon Oct 08 2007 – 10:47:45 AM Testing feature X in product Y

5 Mon Oct 08 2007 – 10:54:31 AM [COMPLETED] Testing feature X in product Y

What if I start another task before completing the first one? No problem, it is sufficient to load the last activities using a :load command and then issuing :complete <number> where <number> is the index of the loaded activity. This nifty little feature will become more and more important when (starting from release 0.4) I’ll implement more time tracking functions, and it will be possible to track completed tasks in a specific timeframe and/or marked with a specific tag.

Easy integration with launchers like Launchy and QuickSilver

To conclude, as someone pointed out that it would be cool to use RedBook from launchers like Launchy or Quicksilver, I made another standalone script (redbooklet.rb or redbooklet.exe) which is just able to parse a log command and write a message to the specified log file. To use it with Launchy, for example, all you have to do is the following:

Create a shortcut to redbooklet.exe (or to a way to execute the corresponding ruby script) named “log”.
Copy the “log” shortcut anywhere in your start menu
Bring up launchy (ALT+SPACE) and type in “log”
Hit tab
Type in your log message, optionally with the any :tags or :dest keywords.
The message will be logged to your default log file or to the log you specified using the :dest keyword. If an error occurs, it will appear in a command line window for 15 seconds before the program is closed.

That’s all folks! As usual, if you have any comment or suggestion feel free to reply to this post or email me. For a list of the planned features and releases, check out the Milestones page.

DOWNLOAD HERE