Merge lp:~psybers/docky/xdg-basedir into lp:docky

[Robert Dyer]

Support the XDG Base Directory specification.

The paths service was reworked to support the spec and clean it up a bit. I attempted to make sure the rest of Docky uses that service now - specifically WindowManager.

[lp:~psybers/docky/xdg-basedir]

1422. By Robert Dyer on 2010-06-07

fix bug spotted in the diff

1423. By Robert Dyer on 2010-06-08

fix CX_APPS path

[Rico Tzschichholz (ricotz)]

PluginManager.cs uses some Paths: UserAddinInstallationDirectory, UserPluginsDirectory which could be created in PathServices

review: Needs Fixing

[lp:~psybers/docky/xdg-basedir]

1424. By Robert Dyer on 2010-06-08

fix paths in PluginManager

1425. By Robert Dyer on 2010-06-08

clean code

=== modified file 'Docky.Services/Docky.Services/PathsService.cs'
--- Docky.Services/Docky.Services/PathsService.cs	2010-05-31 19:30:58 +0000
+++ Docky.Services/Docky.Services/PathsService.cs	2010-06-08 09:03:26 +0000
@@ -1,5 +1,5 @@
 //  
-//  Copyright (C) 2010 Chris Szikszoy
+//  Copyright (C) 2010 Chris Szikszoy, Robert Dyer
 // 
 //  This program is free software: you can redistribute it and/or modify
 //  it under the terms of the GNU General Public License as published by
@@ -15,52 +15,135 @@
 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 
 using GLib;
 
 namespace Docky.Services
 {
+	/// <summary>
+	/// This class provides all paths used in Docky.
+	///
+	/// It follows the XDG Base Directory specification.  For more information see:
+	///   http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html 
+	/// </summary>
 	public class PathsService
 	{
-		static readonly File home_folder = FileFactory.NewForPath (Environment.GetEnvironmentVariable ("HOME"));
-		
-		public File SystemDataFolder {
-			get { return FileFactory.NewForPath (AssemblyInfo.DataDirectory).GetChild ("docky"); }
-		}
-
-		public File DockManagerUserDataFolder {
-			get { return FileFactory.NewForPath (Environment.GetFolderPath (Environment.SpecialFolder.LocalApplicationData)).GetChild ("dockmanager"); }
-		}
-
-		public File UserDataFolder {
-			get { return FileFactory.NewForPath (Environment.GetFolderPath (Environment.SpecialFolder.LocalApplicationData)).GetChild ("docky"); }
-		}
-		
-		File user_cache_folder;
-		public File UserCacheFolder {
-			get { 
-				if (user_cache_folder != null)  
-					return user_cache_folder;
-				
-				string xdg_cache_home = Environment.GetEnvironmentVariable ("XDG_CACHE_HOME");
-				if (!string.IsNullOrEmpty (xdg_cache_home))
-					user_cache_folder = FileFactory.NewForPath (xdg_cache_home).GetChild ("docky");
-				else
-					user_cache_folder = home_folder.GetChild (".cache").GetChild ("docky");
-				
-				if (!user_cache_folder.Exists)
-					try {
-						user_cache_folder.MakeDirectoryWithParents (null);
-					} catch {
-						Log<PathsService>.Fatal ("Could not access the cache directory '" + user_cache_folder.Path + "' or create it.  Docky will not work properly unless this folder is writable.");
-					}
-				
-				return user_cache_folder;
-			}
-		}
-
-		public File AutoStartFile {
-			get { return FileFactory.NewForPath (Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData)).GetChild ("autostart").GetChild ("docky.desktop"); }
+		#region XDG Base Directory independent paths
+		
+		/// <summary>
+		/// User's home folder - $HOME
+		/// </summary>
+		public File HomeFolder { get; protected set; }
+		
+		/// <summary>
+		/// Docky's installed data directory - defaults to /usr/share/docky for PPA
+		/// </summary>
+		public File SystemDataFolder { get; protected set; }
+		
+		#endregion
+		
+		
+		#region XDG Base Directory paths
+		
+		/// <summary>
+		/// $XDG_DATA_HOME - defaults to $HOME/.local/share
+		/// </summary>
+		public File XdgDataHomeFolder { get; protected set; }
+		
+		/// <summary>
+		/// $XDG_CACHE_HOME - defaults to $HOME/.cache
+		/// </summary>
+		public File XdgCacheHomeFolder { get; protected set; }
+		
+		/// <summary>
+		/// $XDG_DATA_DIRS - defaults to /usr/local/share/:/usr/share/
+		/// </summary>
+		public IEnumerable<File> XdgDataDirFolders { get; protected set; }
+		
+		
+		/// <summary>
+		/// defaults to XdgCacheHomeFolder/docky
+		/// </summary>
+		public File UserCacheFolder { get; protected set; }
+		
+		/// <summary>
+		/// defaults to XdgDataHomeFolder/docky
+		/// </summary>
+		public File UserDataFolder { get; protected set; }
+		
+		/// <summary>
+		/// defaults to XdgDataHomeFolder/dockmanager
+		/// </summary>
+		public File DockManagerUserDataFolder { get; protected set; }
+		
+		
+		/// <summary>
+		/// Path to the autostart file - defaults to 
+		/// </summary>
+		public File AutoStartFile { get; protected set; }
+		
+		#endregion
+		
+		
+		public PathsService ()
+		{
+			// get environment-based settings
+			File env_home         = FileFactory.NewForPath (Environment.GetFolderPath (Environment.SpecialFolder.Personal));
+			File env_data_install = FileFactory.NewForPath (AssemblyInfo.DataDirectory);
+			
+			
+			// set the non-XDG Base Directory specified directories to use
+			HomeFolder       = env_home;
+			SystemDataFolder = env_data_install.GetChild ("docky");
+			
+			
+			// get XDG Base Directory settings
+			string xdg_data_home  = Environment.GetEnvironmentVariable ("XDG_DATA_HOME");
+			string xdg_data_dirs  = Environment.GetEnvironmentVariable ("XDG_DATA_DIRS");
+			string xdg_cache_home = Environment.GetEnvironmentVariable ("XDG_CACHE_HOME");
+			
+			
+			// determine directories based on XDG with fallbacks
+			if (string.IsNullOrEmpty (xdg_cache_home))
+				XdgCacheHomeFolder = HomeFolder.GetChild (".cache");
+			else
+				XdgCacheHomeFolder = FileFactory.NewForPath (xdg_cache_home);
+			
+			if (string.IsNullOrEmpty (xdg_data_home))
+				XdgDataHomeFolder = HomeFolder.GetChild (".local").GetChild ("share");
+			else
+				XdgDataHomeFolder = FileFactory.NewForPath (xdg_data_home);
+			
+			if (string.IsNullOrEmpty (xdg_data_dirs))
+				XdgDataDirFolders = new [] { GLib.FileFactory.NewForPath ("/usr/local/share"), GLib.FileFactory.NewForPath ("/usr/share") };
+			else
+				XdgDataDirFolders = xdg_data_dirs.Split (':').Select (d => GLib.FileFactory.NewForPath (d));
+			
+			
+			// set the XDG Base Directory specified directories to use
+			UserCacheFolder           = XdgCacheHomeFolder.GetChild ("docky");
+			UserDataFolder            = XdgDataHomeFolder.GetChild ("docky");
+			DockManagerUserDataFolder = XdgDataHomeFolder.GetChild ("dockmanager");
+			AutoStartFile             = XdgDataHomeFolder.GetChild ("autostart").GetChild ("docky.desktop");
+			
+			
+			// ensure all writable directories exist
+			EnsureDirectoryExists (UserCacheFolder);
+			EnsureDirectoryExists (UserDataFolder);
+			EnsureDirectoryExists (DockManagerUserDataFolder);
+			EnsureDirectoryExists (XdgDataHomeFolder.GetChild ("autostart"));
+		}
+		
+		void EnsureDirectoryExists (File dir)
+		{
+			if (!dir.Exists)
+				try {
+					dir.MakeDirectoryWithParents (null);
+				} catch {
+					Log<PathsService>.Fatal ("Could not access the directory '" + dir.Path + "' or create it.  Docky will not work properly unless this folder is writable.");
+				}
 		}
 	}
 }

=== modified file 'Docky.Windowing/Windowing/WindowMatcher.cs'
--- Docky.Windowing/Windowing/WindowMatcher.cs	2010-06-08 08:20:21 +0000
+++ Docky.Windowing/Windowing/WindowMatcher.cs	2010-06-08 09:03:26 +0000
@@ -140,7 +140,7 @@
 				SetupWindow (w);
 
 			// Set up monitors for cache files and desktop directories
-			foreach (GLib.File dir in DesktopFileDirectories.Select (d => GLib.FileFactory.NewForPath (d)))
+			foreach (GLib.File dir in DesktopFileDirectories)
 				MonitorDesktopFileDirs (dir);
 			MonitorDesktopFileSystemCacheFiles ();
 			
@@ -149,12 +149,12 @@
 		}
 
 		#region Handle DesktopItems
-		static IEnumerable<string> DesktopFileSystemCacheFiles
+		static IEnumerable<GLib.File> DesktopFileSystemCacheFiles
 		{
 			get {
 				return DesktopFileDirectories
-					.Select (d => Path.Combine (d, string.Format ("desktop.{0}.cache", Locale)))
-					.Where (f => File.Exists (f));
+					.Select (d => d.GetChild (string.Format ("desktop.{0}.cache", Locale)))
+					.Where (f => f.Exists);
 			}
 		}
 		
@@ -167,49 +167,18 @@
 			}
 		}
 			
-		static IEnumerable<string> DesktopFileDirectories
+		static IEnumerable<GLib.File> DesktopFileDirectories
 		{
 			get {
-				return new [] {
-					// These are XDG variables...
-					"XDG_DATA_HOME",
-					"XDG_DATA_DIRS",
-					// Crossover apps
-					"CX_APPS",
-				}.SelectMany (v => ExpandPathVar (v))
-				 .Where (d => Directory.Exists (d));
+				return DockServices.Paths.XdgDataDirFolders.Select (d => d.GetChild ("applications"))
+					.Union(new [] {
+						DockServices.Paths.XdgDataHomeFolder.GetChild ("applications"),
+						DockServices.Paths.HomeFolder.GetChild (".cxoffice"),
+					})
+					.Where (d => d.Exists);
 			}
 		}
 		
-		static IEnumerable<string> ExpandPathVar (string xdgVar)
-		{
-			string envPath = Environment.GetEnvironmentVariable (xdgVar);
-			
-			if (string.IsNullOrEmpty (envPath)) {
-				switch (xdgVar) {
-				case "XDG_DATA_HOME":
-					yield return Path.Combine (
-						Environment.GetFolderPath (Environment.SpecialFolder.Personal),
-						new [] {".local", "share", "applications"}.Aggregate ((w, s) => Path.Combine (w, s))
-					);
-					break;
-				case "XDG_DATA_DIRS":
-					yield return new [] {"/usr", "local", "share", "applications"}.Aggregate ((w, s) => Path.Combine (w,s));
-					yield return new [] {"/usr", "share", "applications"}.Aggregate ((w, s) => Path.Combine (w, s));
-					break;
-				case "CX_APPS":
-					yield return Path.Combine (
-						Environment.GetFolderPath (Environment.SpecialFolder.Personal),
-						".cxoffice"
-					);
-					break;
-				}
-			} else {
-				foreach (string dir in envPath.Split (':'))
-					yield return Path.Combine (dir, "applications");
-			}
-		}
-
 		void UpdateDesktopItemsList ()
 		{
 			if (desktop_items == null)
@@ -220,8 +189,8 @@
 
 			// Get desktop items for new "valid" desktop files
 			new_items = DesktopFileDirectories
-				.SelectMany (dir => GLib.FileFactory.NewForPath (dir).SubDirs ())
-				.Union (DesktopFileDirectories.Select (f => GLib.FileFactory.NewForPath (f)))
+				.SelectMany (dir => dir.SubDirs ())
+				.Union (DesktopFileDirectories)
 				.SelectMany (file => file.GetFiles (".desktop"))
 				.Where (file => !known_desktop_files.Exists (known_file => (known_file.Path == file.Path)))
 				.Select (file => new DesktopItem (file))
@@ -244,19 +213,19 @@
 		
 		void ProcessAndMergeAllSystemCacheFiles (List<DesktopItem> items)
 		{
-			foreach (string cache_file in DesktopFileSystemCacheFiles)
+			foreach (GLib.File cache_file in DesktopFileSystemCacheFiles)
 				ProcessAndMergeSystemCacheFile (cache_file, items);
 		}
 
-		void ProcessAndMergeSystemCacheFile (string cache_file, List<DesktopItem> items)
+		void ProcessAndMergeSystemCacheFile (GLib.File cache_file, List<DesktopItem> items)
 		{
-			if (!GLib.FileFactory.NewForPath (cache_file).Exists)
+			if (!cache_file.Exists)
 			    return;
 			
-			Log<WindowMatcher>.Debug ("Processing {0}", cache_file);
+			Log<WindowMatcher>.Debug ("Processing {0}", cache_file.Path);
 			
 			try {
-				using (StreamReader reader = new StreamReader (cache_file)) {
+				using (StreamReader reader = new StreamReader (cache_file.Path)) {
 					DesktopItem desktop_item = null;
 					string line;
 					
@@ -269,9 +238,7 @@
 							if (match.Success) {
 								string section = match.Groups["Section"].Value;
 								if (section != null) {
-									GLib.File file = GLib.FileFactory
-										.NewForPath (Path.Combine (Path.GetDirectoryName (cache_file), 
-										                           string.Format ("{0}.desktop", section)));
+									GLib.File file = cache_file.Parent.GetChild (string.Format ("{0}.desktop", section));
 									desktop_item = items.First (item => item.File.Path == file.Path);
 									if (desktop_item == null && file.Exists) {
 										desktop_item = new DesktopItem (file);
@@ -413,14 +380,13 @@
 
 		void MonitorDesktopFileSystemCacheFiles ()
 		{
-			foreach (string filename in DesktopFileSystemCacheFiles) {
-				GLib.File file = GLib.FileFactory.NewForPath (filename);
+			foreach (GLib.File file in DesktopFileSystemCacheFiles) {
 				GLib.FileMonitor mon = file.Monitor (GLib.FileMonitorFlags.None, null);
 				mon.RateLimit = 2500;
 				mon.Changed += delegate {
 					DockServices.System.RunOnThread (() => {
 						lock (update_lock) {
-							ProcessAndMergeSystemCacheFile (file.Path, desktop_items);
+							ProcessAndMergeSystemCacheFile (file, desktop_items);
 							DesktopItemsChanged ();
 						}   
 					});

=== modified file 'Docky/Docky/PluginManager.cs'
--- Docky/Docky/PluginManager.cs	2010-04-11 00:41:58 +0000
+++ Docky/Docky/PluginManager.cs	2010-06-08 09:03:26 +0000
@@ -47,10 +47,6 @@
 	{
 		public static readonly string DefaultPluginIcon = "package";
 		
-		const string PluginsDirectory = "plugins";
-		const string ApplicationDirectory = "docky";
-		const string DefaultAddinsDirectory = "addins";
-		
 		const string IPExtensionPath = "/Docky/ItemProvider";
 		const string ConfigExtensionPath = "/Docky/Configuration";
 		
@@ -59,15 +55,12 @@
 		//// <value>
 		/// Directory where Docky saves its Mono.Addins repository cache.
 		/// </value>
-		public static string UserPluginsDirectory {
-			get {
-				string userData = Environment.GetFolderPath (Environment.SpecialFolder.LocalApplicationData);
-				return Path.Combine (Path.Combine (userData, ApplicationDirectory), PluginsDirectory);
-			}
+		public static GLib.File UserPluginsDirectory {
+			get { return DockServices.Paths.UserDataFolder.GetChild ("plugins"); }
 		}
 		
-		public static string UserAddinInstallationDirectory {
-			get { return Path.Combine (UserPluginsDirectory, DefaultAddinsDirectory); }
+		public static GLib.File UserAddinInstallationDirectory {
+			get { return UserPluginsDirectory.GetChild ("addins"); }
 		}
 			
 		/// <summary>
@@ -78,13 +71,13 @@
 		{
 			// Initialize Mono.Addins.
 			try {
-				AddinManager.Initialize (UserPluginsDirectory);
+				AddinManager.Initialize (UserPluginsDirectory.Path);
 			} catch (InvalidOperationException e) {
 				Log<PluginManager>.Error ("AddinManager.Initialize: {0}", e.Message);
 				Log<PluginManager>.Warn ("Rebuild Addin.Registry and reinitialize AddinManager");
 				AddinManager.Registry.Rebuild (null);
 				AddinManager.Shutdown ();
-				AddinManager.Initialize (UserPluginsDirectory);
+				AddinManager.Initialize (UserPluginsDirectory.Path);
 			}
 
 			AddinManager.Registry.Update (null);
@@ -160,8 +153,7 @@
 		{	
 			IEnumerable<string> manual;
 			
-			manual = Directory.GetFiles (UserAddinInstallationDirectory, "*.dll")
-				.Select (s => Path.GetFileName (s));
+			manual = UserAddinInstallationDirectory.GetFiles ("*.dll").Select (f => f.Basename);
 					
 			manual.ToList ().ForEach (dll => Log<PluginManager>.Info ("Installing {0}", dll));