xdg 0.3.0 → 0.4.0

data/HISTORY

@@ -1,4 +1,11 @@
-### 0.3.0 / 2008-09-11
+= CHANGE HISTORY
+
+=== 0.4.0 / 2008-10-26
+
+* Renamed instance level methods without 'xdg_' prefix.
+* Replace _file methods with _find and _glob methods.
+
+=== 0.3.0 / 2008-09-11
 
 * Renamed module level methods without 'xdg_' prefix.
 * The xdg_ versions still exist for backward compatibility.

data/MANIFEST

@@ -1,3 +1,4 @@
+MANIFEST
 test
 test/fakeroot
 test/fakeroot/home

data/RELEASE

@@ -1,10 +1,21 @@
-This release removes the xdg_ prefix from the module-level
-method names. The instance methods retain the xdg_ prefix.
-I will consider if they should also be removed for the
-next release.
+= XDG 0.4 hits the streets!
 
-### 0.3.0 / 2008-09-11
+  http://xdg.rubyforge.org
 
-* Renamed module level methods without 'xdg_' prefix.
-* The xdg_ versions still exist for backward compatibility.
+This release removes the xdg_ prefix from the instance-level
+method names. Now module and instance levels are the same.
+
+Also, data_file, config_file and cache_file have been replaced with
+data_find, config_find, cache_find, data_glob, config_glob and
+cache_glob.
+
+What' next? Well, I can't say I'm fond of the term 'glob', so I
+may rename that to 'map' or 'collect' (or 'select'?)  and then 
+add the ability to use blocks for matching too.
+
+
+### 0.4.0 / 2008-10-26
+
+* Renamed instance level methods without 'xdg_' prefix.
+* Replace _file methods with _find and _glob methods.
 

data/VERSION

@@ -1 +1 @@
-xdg 0.3.0 beta (2008-09-30)
+xdg 0.4.0 beta (2008-10-26)

data/lib/xdg.rb

@@ -3,7 +3,6 @@
 # :Copyright: (c)2008 Tiger Ops
 # :License: GPLv3
 
-
 # = XDG Base Directory Standard
 #
 # This provides a conveient library for conforming to the
@@ -32,19 +31,21 @@
 
 module XDG
 
-  def self.home
+  extend self    #module_function
+
+  def home
     ENV['HOME'] || File.expand_path('~')
   end
 
   # Location of user's personal config directory.
-  def self.config_home
+  def config_home
     File.expand_path(
-      ENV['XDG_CONFIG_HOME'] || File.join(xdg_home, '.config')
+      ENV['XDG_CONFIG_HOME'] || File.join(home, '.config')
     )
   end
 
   # List of user's shared config directories.
-  def self.config_dirs
+  def config_dirs
     dirs = ENV['XDG_CONFIG_DIRS'].to_s.split(/[:;]/)
     if dirs.empty?
       dirs = %w{/etc/xdg}
@@ -53,14 +54,14 @@ module XDG
   end
 
   # Location of user's personal data directory.
-  def self.data_home
+  def data_home
     File.expand_path(
-      ENV['XDG_DATA_HOME'] || File.join(xdg_home, '.local', 'share')
+      ENV['XDG_DATA_HOME'] || File.join(home, '.local', 'share')
     )
   end
 
   # List of user's shared data directores.
-  def self.data_dirs
+  def data_dirs
     dirs = ENV['XDG_DATA_DIRS'].split(/[:;]/)
     if dirs.empty?
       dirs = %w{/usr/local/share/ /usr/share/}
@@ -69,85 +70,132 @@ module XDG
   end
 
   # Location of user's personal cache directory.
-  def self.cache_home
+  def cache_home
     File.expand_path(
-      ENV['XDG_CACHE_HOME'] || File.join(xdg_home, '.cache')
+      ENV['XDG_CACHE_HOME'] || File.join(home, '.cache')
     )
   end
 
   # Find a file or directory in data dirs.
-  def self.data_file(file)
-    find = nil
-    [xdg_data_home, *xdg_data_dirs].each do |dir|
-      path = File.join(dir,file)
-      break find = path if File.exist?(path)
+  def data_find(*glob_and_flags)
+    data_glob(*glob_and_flags).first
+  end
+
+  def data_glob(*glob_and_flags)
+    glob, flags = *glob_and_flags.partition{ |e| String===e }
+    flag = flags.inject(0) do |m, f|
+      if Symbol === f
+        m + File::const_get("FNM_#{f.to_s.upcase}")
+      else
+        m + f.to_i
+      end
+    end
+    find = []
+    [data_home, *data_dirs].each do |dir|
+      path = File.join(dir, *glob)
+      find.concat(Dir.glob(path, flag))
     end
     find
   end
 
-  # Find a file or directory in config dirs.
-  def self.config_file(file)
-    find = nil
-    [xdg_config_home, *xdg_config_dirs].each do |dir|
-      path = File.join(dir,file)
-      break find = path if File.exist?(path)
+  # Return the fist matching file or directory
+  # from the config locations.
+  #
+  # See +config_glog+.
+  def config_find(*glob_and_flags)
+    config_glob(*glob_and_flags).first
+  end
+
+  # Return array of matching files or directories
+  # in any of the config locations.
+  #
+  # This starts with the user's home directory
+  # and then searches system directories.
+  #
+  # String parameters are joined into a pathname
+  # while Integers and Symbols treated as flags.
+  #
+  # For example, the following are equivalent:
+  #
+  #   XDG.config_glob('sow/plugins', File::FNM_CASEFOLD)
+  #
+  #   XDG.config_glob('sow', 'plugins', :casefold)
+  #
+  def config_glob(*glob_and_flags)
+    glob, flags = *glob_and_flags.partition{ |e| String===e }
+    flag = flags.inject(0) do |m, f|
+      if Symbol === f
+        m + File::const_get("FNM_#{f.to_s.upcase}")
+      else
+        m + f.to_i
+      end
+    end
+    find = []
+    [config_home, *config_dirs].each do |dir|
+      path = File.join(dir, *glob)
+      find.concat(Dir.glob(path, flag))
     end
     find
   end
 
-  # Find a file or directory in the user cache.
-  def self.cache_file(file)
-    path = File.join(xdg_cache_home,file)
-    File.exist?(path) ? path : nil
+  # Return the fist matching file or directory
+  # in the cache directory.
+  #
+  # See +cache_glog+.
+  def cache_find(*glob_and_flags)
+    cache_glob(*glob_and_flags).first
+  end
+
+  # Return array of matching files or directories
+  # from the cache directory.
+  #
+  # String parameters are joined into a pathname
+  # while Integers and Symbols treated as flags.
+  #
+  # For example, the following are equivalent:
+  #
+  #   XDG.cache_glob('sow/tmp', File::FNM_CASEFOLD)
+  #
+  #   XDG.cache_glob('sow', 'tmp', :casefold)
+  #
+  def cache_glob(*glob_and_flags)
+    glob, flags = *glob_and_flags.partition{ |e| String===e }
+    flag = flags.inject(0) do |m, f|
+      if Symbol === f
+        m + File::const_get("FNM_#{f.to_s.upcase}")
+      else
+        m + f.to_i
+      end
+    end
+    path = File.join(cache_home,*glob)
+    Dir.glob(path, flag)
   end
 
   #--
   # The following are not strictly XDG spec,
-  # but are useful in the same respect.
+  # but are useful in a similar respect.
   #++
 
   # Location of working config directory.
-  def self.config_work
+  def config_work
     File.expand_path(
-      #ENV['XDG_CONFIG_WORK'] || File.join(Dir.pwd, '.config')
       File.join(Dir.pwd, '.config')
     )
   end
 
   # Location of working data directory.
-  def self.data_work
+  def data_work
     File.expand_path(
-      #ENV['XDG_DATA_WORK'] || File.join(Dir.pwd, '.share')
       File.join(Dir.pwd, '.share')
     )
   end
 
   # Location of working cache directory.
-  def self.cache_work
+  def cache_work
     File.expand_path(
-      #ENV['XDG_CACHE_WORK'] || File.join(Dir.pwd, '.cache')
       File.join(Dir.pwd, '.cache')
     )
   end
 
-  ###############
-  module_function
-  ###############
-
-  def xdg_home        ; XDG.home        ; end
-  def xdg_config_home ; XDG.config_home ; end
-  def xdg_config_dirs ; XDG.config_dirs ; end
-  def xdg_data_home   ; XDG.data_home   ; end
-  def xdg_data_dirs   ; XDG.data_dirs   ; end
-  def xdg_cache_home  ; XDG.cache_home  ; end
-
-  def xdg_data_file(file)   ; XDG.data_file(file)   ; end
-  def xdg_config_file(file) ; XDG.config_file(file) ; end
-  def xdg_cache_file(file)  ; XDG.cache_file(file)  ; end
-
-  def xdg_config_work ; XDG.config_work ; end
-  def xdg_data_work   ; XDG.data_work   ; end
-  def xdg_cache_work  ; XDG.cache_work  ; end
-
 end # module XDG
 

data/test/test_xdg.rb

@@ -13,63 +13,84 @@ class TestXDG < Test::Unit::TestCase
 
   # Test the standard paths.
 
-  def test_xdg_home
-    assert_equal(File.join(Dir.pwd,'home'), XDG.xdg_home)
+  def test_home
+    assert_equal(File.join(Dir.pwd,'home'), XDG.home)
   end
 
-  def test_xdg_config_home
-    assert_equal(File.join(Dir.pwd,'home/.config'), XDG.xdg_config_home)
+  def test_config_home
+    assert_equal(File.join(Dir.pwd,'home/.config'), XDG.config_home)
   end
 
-  def test_xdg_config_dirs
-    assert_equal([File.join(Dir.pwd,"etc/xdg")], XDG.xdg_config_dirs)
+  def test_config_dirs
+    assert_equal([File.join(Dir.pwd,"etc/xdg")], XDG.config_dirs)
   end
 
-  def test_xdg_data_home
-    assert_equal(File.join(Dir.pwd,'home/.local/share'), XDG.xdg_data_home)
+  def test_data_home
+    assert_equal(File.join(Dir.pwd,'home/.local/share'), XDG.data_home)
   end
 
-  def test_xdg_data_dirs
-    assert_equal([File.join(Dir.pwd,'usr/share')], XDG.xdg_data_dirs)
+  def test_data_dirs
+    assert_equal([File.join(Dir.pwd,'usr/share')], XDG.data_dirs)
   end
 
-  def test_xdg_cache_home
-    assert_equal(File.join(Dir.pwd,'home/.cache'), XDG.xdg_cache_home)
+  def test_cache_home
+    assert_equal(File.join(Dir.pwd,'home/.cache'), XDG.cache_home)
   end
 
-  # Test the file lookups.
+  # Test the find methods.
 
-  def test_xdg_data_file
+  def test_data_find
     file = 'foo.dat'
-    assert_equal(File.join(Dir.pwd,'home/.local/share', file), XDG.xdg_data_file(file))
+    assert_equal(File.join(Dir.pwd,'home/.local/share', file), XDG.data_find(file))
     file = 'bar.dat'
-    assert_equal(File.join(Dir.pwd,'usr/share', file), XDG.xdg_data_file(file))
+    assert_equal(File.join(Dir.pwd,'usr/share', file), XDG.data_find(file))
   end
 
-  def test_xdg_config_file
+  def test_config_find
     file = 'foo.config'
-    assert_equal(File.join(Dir.pwd,'home/.config', file), XDG.xdg_config_file(file))
+    assert_equal(File.join(Dir.pwd,'home/.config', file), XDG.config_find(file))
     file = 'bar.config'
-    assert_equal(File.join(Dir.pwd,'etc/xdg', file), XDG.xdg_config_file(file))
+    assert_equal(File.join(Dir.pwd,'etc/xdg', file), XDG.config_find(file))
   end
 
-  def test_xdg_cache_file
+  def test_cache_find
     file = 'foo.cache'
-    assert_equal(File.join(Dir.pwd,'home/.cache', file), XDG.xdg_cache_file(file))
+    assert_equal(File.join(Dir.pwd,'home/.cache', file), XDG.cache_find(file))
+  end
+
+  # Test the glob methods.
+
+  def test_data_glob
+    file = 'foo.dat'
+    assert_equal(File.join(Dir.pwd,'home/.local/share', file), XDG.data_find(file))
+    file = 'bar.dat'
+    assert_equal([File.join(Dir.pwd,'usr/share', file)], XDG.data_glob(file))
+  end
+
+  def test_config_glob
+    file = 'foo.config'
+    assert_equal([File.join(Dir.pwd,'home/.config', file)], XDG.config_glob(file))
+    file = 'bar.config'
+    assert_equal([File.join(Dir.pwd,'etc/xdg', file)], XDG.config_glob(file))
+  end
+
+  def test_cache_glob
+    file = 'foo.cache'
+    assert_equal([File.join(Dir.pwd,'home/.cache', file)], XDG.cache_glob(file))
   end
 
   # Test the working directory variations.
 
-  def test_xdg_config_work
-    assert_equal(File.join(Dir.pwd,'.config'), XDG.xdg_config_work)
+  def test_config_work
+    assert_equal(File.join(Dir.pwd,'.config'), XDG.config_work)
   end
 
-  def test_xdg_data_work
-    assert_equal(File.join(Dir.pwd,'.share'), XDG.xdg_data_work)
+  def test_data_work
+    assert_equal(File.join(Dir.pwd,'.share'), XDG.data_work)
   end
 
-  def test_xdg_cache_work
-    assert_equal(File.join(Dir.pwd,'.cache'), XDG.xdg_cache_work)
+  def test_cache_work
+    assert_equal(File.join(Dir.pwd,'.cache'), XDG.cache_work)
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: xdg
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - tigerops-community@rubyforge.org
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-11 00:00:00 -04:00
+date: 2008-10-26 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -28,21 +28,16 @@ extra_rdoc_files:
 - VERSION
 - COPYING
 files: 
-- MANIFEST
+- lib
+- meta
 - test
-- test/fakeroot
-- test/fakeroot/home
-- test/fakeroot/usr
-- test/fakeroot/usr/share
-- test/fakeroot/usr/share/bar.dat
-- test/fakeroot/etc
-- test/fakeroot/etc/xdg
-- test/fakeroot/etc/xdg/bar.config
-- test/test_xdg.rb
+- MANIFEST
 - RELEASE
 - README
 - HISTORY
-- meta
+- VERSION
+- COPYING
+- lib/xdg.rb
 - meta/homepage
 - meta/summary
 - meta/abstract
@@ -50,10 +45,15 @@ files:
 - meta/title
 - meta/authors
 - meta/contact
-- lib
-- lib/xdg.rb
-- VERSION
-- COPYING
+- test/fakeroot
+- test/test_xdg.rb
+- test/fakeroot/home
+- test/fakeroot/usr
+- test/fakeroot/etc
+- test/fakeroot/usr/share
+- test/fakeroot/usr/share/bar.dat
+- test/fakeroot/etc/xdg
+- test/fakeroot/etc/xdg/bar.config
 has_rdoc: true
 homepage: http://xdg.rubyforge.org
 post_install_message: 
@@ -85,12 +85,4 @@ signing_key:
 specification_version: 2
 summary: XDG provides a module for supporting the XDG Base Directory Standard.
 test_files: 
-- test/fakeroot
-- test/fakeroot/home
-- test/fakeroot/usr
-- test/fakeroot/usr/share
-- test/fakeroot/usr/share/bar.dat
-- test/fakeroot/etc
-- test/fakeroot/etc/xdg
-- test/fakeroot/etc/xdg/bar.config
 - test/test_xdg.rb