Question

I am a newbie in Ruby coming from web development with mainly PHP/SQL. I was thinking about how I store preferences in my application. For instance, if I want to store a path as default_path and have that set also when the user restarts the application.

In the web world one would probably store this in a database or XML. Database seems overkill for a standalone application. But I am unsure wheter XML/YAML/Other-Write-Format is the way to go. And if so, where should I store these preferences? Should they be, for instance on a Mac, in ~/Library/MyAppName?

Answer 1

Ruby gives you another method for storing data called Marshaling. This will let you store a class/object to a file and reconstitute it later. If all of your user preferences are stored in a single object (or you can create an object which can hold all of the data that you need), it may be easiest to marshal the data instead of writing import/export routines to a text-based format or trying to pull in an additional library or gem.

As to where on the disk to store the data, that’s up to you. Most platforms have a standard location for storing application data based on whether it’s available to a single user or all users. It’s usually safest to follow the common practice on your target platform of choice.

Update: The simplest example of marshaling would probably be this: Say that you have a class called UserPrefs that you use to store all of your user preferences. You can use the following code to store the preferences data into a file:

my_prefs = UserPrefs.new
# ... Fill in the 'my_prefs' object with the user's preferences, etc ...

# Store the object into a file
File.open("user_prefs.data", "wb") do |file|
   Marshal.dump(my_prefs, file)
end

The next time that you load the application, you can restore those preferences using the following:

# Load prefs from file
my_prefs = nil
File.open("user_prefs.data", "rb") {|f| my_prefs = Marshal.load(f)}

At this point, the my_prefs object should be exactly the same as it was when the marshaling code was originally run. This essentially lets you take a ‘snaphot’ of an object at one point in time (say, when your program shuts down) and restore it later (say, when your program loads). Internally, all of the data in the structure is encoded into a single string and that string is what is stored to disk; the Marshal module simply takes care of the encoding and decoding for you.

Here is another example of using marshaling to store and retrieve data.

The default encode/decode routines built into the Marshal module are usually sufficient for most data-storing classes. Particularly complex classes may have problems, and if that is the case then you can define your own encode and decode methods (the first link includes an example of defining custom methods).

Some types of data, however, cannot be marshaled (things like handles to open files, Proc objects, etc) since they don’t normally persist across Ruby sessions. If you are needing to marshal a class that includes members like this that Marshal doesn’t like, you can use custom encode/decode functions to marshal the rest of the class and omit the problematic members.