nunit24/ClientUtilities/util/ProjectConfig.cs

   1 // ****************************************************************
   2 // This is free software licensed under the NUnit license. You
   3 // may obtain a copy of the license as well as information regarding
   4 // copyright ownership at http://nunit.org/?p=license&r=2.4.
   5 // ****************************************************************
   6
   7 using System;
   8 using System.Text;
   9 using System.Collections;
  10 using System.IO;
  11 using NUnit.Core;
  12
  13 namespace NUnit.Util
  14 {
  15         public enum BinPathType
  16         {
  17                 Auto,
  18                 Manual,
  19                 None
  20         }
  21
  22         public class ProjectConfig
  23         {
  24                 #region Instance Variables
  25
  26                 /// <summary>
  27                 /// The name of this config
  28                 /// </summary>
  29                 private string name;
  30
  31                 /// <summary>
  32                 /// IProject interface of containing project
  33                 /// </summary>
  34                 protected NUnitProject project = null;
  35
  36                 /// <summary>
  37                 /// List of the names of the assemblies
  38                 /// </summary>
  39                 private AssemblyList assemblies;
  40
  41                 /// <summary>
  42                 /// Base path specific to this configuration
  43                 /// </summary>
  44                 private string basePath;
  45
  46                 /// <summary>
  47                 /// Our configuration file, if specified
  48                 /// </summary>
  49                 private string configFile;
  50
  51                 /// <summary>
  52                 /// Private bin path, if specified
  53                 /// </summary>
  54                 private string binPath;
  55
  56                 /// <summary>
  57                 /// True if assembly paths should be added to bin path
  58                 /// </summary>
  59                 private BinPathType binPathType = BinPathType.Auto;
  60
  61                 #endregion
  62
  63                 #region Constructor
  64                 public ProjectConfig( string name )
  65                 {
  66                         this.name = name;
  67                         this.assemblies = new AssemblyList();
  68                         assemblies.Changed += new EventHandler( assemblies_Changed );
  69                 }
  70                 #endregion
  71
  72                 #region Properties and Events
  73
  74                 public event EventHandler Changed;
  75
  76                 public NUnitProject Project
  77                 {
  78 //                      get { return project; }
  79                         set { project = value; }
  80                 }
  81
  82                 public string Name
  83                 {
  84                         get { return name; }
  85                         set
  86                         {
  87                                 if ( name != value )
  88                                 {
  89                                         name = value;
  90                                         FireChangedEvent();
  91                                 }
  92                         }
  93                 }
  94
  95                 private bool BasePathSpecified
  96                 {
  97                         get
  98                         {
  99                                 return project.BasePathSpecified || this.basePath != null && this.basePath != "";
 100                         }
 101                 }
 102
 103                 /// <summary>
 104                 /// The base directory for this config - used
 105                 /// as the application base for loading tests.
 106                 /// </summary>
 107                 public string BasePath
 108                 {
 109                         get
 110                         {
 111                                 if ( project == null || project.BasePath == null )
 112                                         return basePath;
 113
 114                                 if ( basePath == null )
 115                                         return project.BasePath;
 116
 117                                 return Path.Combine( project.BasePath, basePath );
 118                         }
 119                         set
 120                         {
 121                                 if ( BasePath != value )
 122                                 {
 123                                         basePath = value;
 124                                         FireChangedEvent();
 125                                 }
 126                         }
 127                 }
 128
 129                 /// <summary>
 130                 /// The base path relative to the project base
 131                 /// </summary>
 132                 public string RelativeBasePath
 133                 {
 134                         get
 135                         {
 136                                 if ( project == null || basePath == null || !Path.IsPathRooted( basePath ) )
 137                                         return basePath;
 138
 139                                 return PathUtils.RelativePath( project.BasePath, basePath );
 140                         }
 141                 }
 142
 143                 private bool ConfigurationFileSpecified
 144                 {
 145                         get { return configFile != null; }
 146                 }
 147
 148                 public string ConfigurationFile
 149                 {
 150                         get
 151                         {
 152                                 return configFile == null && project != null
 153                                         ? project.ConfigurationFile
 154                                         : configFile;
 155                         }
 156                         set
 157                         {
 158                                 if ( ConfigurationFile != value )
 159                                 {
 160                                         configFile = value;
 161                                         FireChangedEvent();
 162                                 }
 163                         }
 164                 }
 165
 166                 public string ConfigurationFilePath
 167                 {
 168                         get
 169                         {
 170                                 return BasePath != null && ConfigurationFile != null
 171                                         ? Path.Combine( BasePath, ConfigurationFile )
 172                                         : ConfigurationFile;
 173                         }
 174                 }
 175
 176                 private bool PrivateBinPathSpecified
 177                 {
 178                         get { return binPath != null; }
 179                 }
 180
 181                 /// <summary>
 182                 /// The Path.PathSeparator-separated path containing all the
 183                 /// assemblies in the list.
 184                 /// </summary>
 185                 public string PrivateBinPath
 186                 {
 187                         get     { return binPath; }
 188                         set
 189                         {
 190                                 if ( binPath != value )
 191                                 {
 192                                         binPath = value;
 193                                         binPathType = binPath == null ? BinPathType.Auto : BinPathType.Manual;
 194                                         FireChangedEvent();
 195                                 }
 196                         }
 197                 }
 198
 199                 /// <summary>
 200                 /// How our PrivateBinPath is generated
 201                 /// </summary>
 202                 public BinPathType BinPathType
 203                 {
 204                         get { return binPathType; }
 205                         set
 206                         {
 207                                 if ( binPathType != value )
 208                                 {
 209                                         binPathType = value;
 210                                         FireChangedEvent();
 211                                 }
 212                         }
 213                 }
 214
 215                 /// <summary>
 216                 /// Return our AssemblyList
 217                 /// </summary>
 218                 public AssemblyList Assemblies
 219                 {
 220                         get { return assemblies; }
 221                 }
 222                 #endregion
 223
 224                 public TestPackage MakeTestPackage()
 225                 {
 226                         TestPackage package = new TestPackage( project.ProjectPath );
 227
 228                         if ( !project.IsAssemblyWrapper )
 229                                 foreach ( string assembly in this.Assemblies )
 230                                         package.Assemblies.Add( assembly );
 231
 232                         if ( this.BasePathSpecified || this.PrivateBinPathSpecified || this.ConfigurationFileSpecified )
 233                         {
 234                                 package.BasePath = this.BasePath;
 235                                 package.PrivateBinPath = this.PrivateBinPath;
 236                                 package.ConfigurationFile = this.ConfigurationFile;
 237                         }
 238
 239                         package.AutoBinPath = this.BinPathType == BinPathType.Auto;
 240
 241                         return package;
 242                 }
 243
 244                 private void assemblies_Changed( object sender, EventArgs e )
 245                 {
 246                         FireChangedEvent();
 247                 }
 248
 249                 private void FireChangedEvent()
 250                 {
 251                         if ( Changed != null )
 252                                 Changed( this, EventArgs.Empty );
 253                 }
 254         }
 255 }