Provides a Ruby implementation of the XDG Base Directory Specification for managing common configurations without polluting your dotfiles. XDG is great for command line interfaces or any application that needs a common configuration, cache, data, state, or runtime.
💡 If you write a lot of Command Line Interfaces and would like additional/advanced syntactic sugar that includes what is found in this gem, make sure to check out the Runcom gem too.
XDGobject that adheres to the XDG Base Directory Specification with access to the following environment settings:
To install with security, run:
# 💡 Skip this line if you already have the public certificate installed. gem cert --add <(curl --compressed --location https://alchemists.io/gems.pem) gem install xdg --trust-policy HighSecurity
To install without security, run:
gem install xdg
You can also add the gem directly to your project:
bundle add xdg
Once the gem is installed, you only need to require it:
The following describes how to use this implementation.
To get up and running quickly, use
XDG.new as follows:
xdg = XDG.new xdg.cache_home # Answers computed `$XDG_CACHE_HOME` value. xdg.config_home # Answers computed `$XDG_CONFIG_HOME` value. xdg.config_dirs # Answers computed `$XDG_CONFIG_DIRS` value. xdg.data_home # Answers computed `$XDG_DATA_HOME` value. xdg.data_dirs # Answers computed `$XDG_DATA_DIRS` value. xdg.state_home # Answers computed `$XDG_STATE_HOME` value.
Behinds the scenes, use of
XDG.new provides a convenient wrapper of
XDG::Environment.new which, in turn, provides a unified API to the following objects:
cache = XDG::Cache.new config = XDG::Config.new data = XDG::Data.new state = XDG::State.new
Generally, use of
XDG.new is all you need but knowing you can create a specialized instance of any aspect of the XDG specification can be handy for specific use cases. Additionally, the
state objects share the same API which means you can send the following messages:
#home- Answers the home directory as computed via the
#directories- Answers an array directories as computed via the
#all- Answers an array of all directories as computed from the combined
$XDG*_HOMEprefixed at the start of the array).
The computed value of each method is either the user-defined value of the key or the default value, per specification, when the key is not defined or empty. For more on this, scroll down to the Variable Defaults section to learn more.
The following are examples of what you would see when playing around with the XDG objects within an IRB console (taken from my own environment):
require "xdg" # Initialization xdg = XDG.new cache = XDG::Cache.new config = XDG::Config.new data = XDG::Data.new state = XDG::State.new # Inspection xdg.inspect # "XDG_CACHE_HOME=/Users/demo/.cache XDG_CONFIG_HOME=/Users/demo/.config XDG_CONFIG_DIRS=/etc/xdg XDG_DATA_HOME=/Users/demo/.local/share XDG_DATA_DIRS=/usr/local/share:/usr/share XDG_STATE_HOME=/Users/demo/.local/state" cache.inspect # "XDG_CACHE_HOME=/Users/demo/.cache" config.inspect # "XDG_CONFIG_HOME=/Users/demo/.config XDG_CONFIG_DIRS=/etc/xdg" data.inspect # "XDG_DATA_HOME=/Users/demo/.local/share XDG_DATA_DIRS=/usr/local/share:/usr/share" state.inspect # "XDG_STATE_HOME=/Users/demo/.local/state" # Paths xdg.cache_home # #<Pathname:/Users/demo/.cache> xdg.config_home # #<Pathname:/Users/demo/.config> xdg.config_dirs # [#<Pathname:/etc/xdg>] xdg.data_home # #<Pathname:/Users/demo/.local/share> xdg.data_dirs # [#<Pathname:/usr/local/share>, #<Pathname:/usr/share>] xdg.state_home # #<Pathname:/Users/demo/.local/state> cache.home # #<Pathname:/Users/demo/.cache> cache.directories #  cache.all # [#<Pathname:/Users/demo/.cache>] config.home # #<Pathname:/Users/demo/.config> config.directories # [#<Pathname:/etc/xdg>] config.all # [#<Pathname:/Users/demo/.config>, #<Pathname:/etc/xdg>] data.home # #<Pathname:/Users/demo/.local/share> data.directories # [#<Pathname:/usr/local/share>, #<Pathname:/usr/share>] data.all # [#<Pathname:/Users/demo/.local/share>, #<Pathname:/usr/local/share>, #<Pathname:/usr/share>] state.home # #<Pathname:/Users/demo/.local/state> state.directories #  state.all # [#<Pathname:/Users/demo/.local/state>]
As you can see from above, each XDG object answers back a
Pathname which means you have the full
Pathname API at your fingertips to build upon the output of these objects as needed.
The XDG Base Directory Specification defines environment variables and associated default values
when not defined or empty. The following defaults, per specification, are implemented by the
$XDG_RUNTIME_DIR deserves special mention as it’s not, currently, implemented as part of
this gem because it is more user/environment specific. Here is how the
$XDG_RUNTIME_DIR is meant
to be used should you choose to use it:
Must reference user-specific non-essential runtime files and other file objects (such as sockets, named pipes, etc.)
Must be owned by the user with only the user having read and write access to it.
Must have a Unix access mode of
Must be bound to the user when logging in.
Must be removed when the user logs out.
Must be pointed to the same directory when the user logs in more than once.
Must exist from first login to last logout on the system and not removed in between.
Must not allow files in the directory to survive reboot or a full logout/login cycle.
Must keep the directory on the local file system and not shared with any other file systems.
Must keep the directory fully-featured by the standards of the operating system. Specifically, on Unix-like operating systems AF_UNIX sockets, symbolic links, hard links, proper permissions, file locking, sparse files, memory mapping, file change notifications, a reliable hard link count must be supported, and no restrictions on the file name character set should be imposed. Files in this directory may be subjected to periodic clean-up. To ensure files are not removed, they should have their access time timestamp modified at least once every 6 hours of monotonic time or the ‘sticky’ bit should be set on the file.
When not set, applications should fall back to a replacement directory with similar capabilities and print a warning message. Applications should use this directory for communication and synchronization purposes and should not place larger files in it, since it might reside in runtime memory and cannot necessarily be swapped out to disk.
The behavior of most XDG environment variables can be lumped into two categories:
Each is described in detail below.
These variables are used to define a colon (
:) delimited list of directories. Order is important
as the first directory defined will take precedent over the following directory and so forth. For
example, here is a situation where the
XDG_CONFIG_DIRS key has a custom value:
Yields the following, colon delimited, array:
[ "/example/one/.config", "/example/two/.settings", "/example/three/.configuration" ]
In the above example, the
"/example/one/.config" path takes highest priority since it was
These variables take precedence over the corresponding
$XDG_*DIRS environment variables. Using
a modified version of the
$XDG*_DIRS example, shown above, we could have the following setup:
Yields the following, colon delimited, array:
[ "/example/priority", "/example/one/.config", "/example/two/.settings" ]
XDG_CONFIG_HOME taking precedence over the
XDG_CONFIG_DIRS, the path with the
highest priority in this example is:
Path precedence is determined in the following order (with the first taking highest priority):
$XDG_*_HOME- Will be used if defined. Otherwise, falls back to specification default.
$XDG_*_DIRS- Iterates through directories in order defined (with first taking highest priority). Otherwise, falls back to specification default.
To contribute, run:
git clone https://github.com/demo/xdg cd xdg bin/setup
You can also use the IRB console for direct access to all objects:
To test, run: