?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
(DISTFILES): Comment out a few missing files.
[mono-project.git] / mcs / nunit20 / util / NUnitProject.cs
blob5f2edd5faaf43ba0a567d51936b42b472af48127
1 #region Copyright (c) 2002-2003, James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole, Philip A. Craig
2 /************************************************************************************
3 '
4 ' Copyright 2002-2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole
5 ' Copyright 2000-2002 Philip A. Craig
6 '
7 ' This software is provided 'as-is', without any express or implied warranty. In no
8 ' event will the authors be held liable for any damages arising from the use of this
9 ' software.
10 '
11 ' Permission is granted to anyone to use this software for any purpose, including
12 ' commercial applications, and to alter it and redistribute it freely, subject to the
13 ' following restrictions:
14 '
15 ' 1. The origin of this software must not be misrepresented; you must not claim that
16 ' you wrote the original software. If you use this software in a product, an
17 ' acknowledgment (see the following) in the product documentation is required.
18 '
19 ' Portions Copyright 2002-2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole
20 ' or Copyright 2000-2002 Philip A. Craig
21 '
22 ' 2. Altered source versions must be plainly marked as such, and must not be
23 ' misrepresented as being the original software.
24 '
25 ' 3. This notice may not be removed or altered from any source distribution.
26 '
27 '***********************************************************************************/
28 #endregion
29
30 using System;
31 using System.Collections;
32 using System.Xml;
33 using System.Xml.Schema;
34 using System.IO;
35 using System.Threading;
36 using NUnit.Core;
37
38 namespace NUnit.Util
39 {
40 /// <summary>
41 /// Types of changes that may occur to a config
42 /// </summary>
43 public enum ProjectChangeType
44 {
45 ActiveConfig,
46 AddConfig,
47 RemoveConfig,
48 UpdateConfig,
49 Other
50 }
51
52 /// <summary>
53 /// Arguments for a project event
54 /// </summary>
55 public class ProjectEventArgs : EventArgs
56 {
57 public ProjectChangeType type;
58 public string configName;
59
60 public ProjectEventArgs( ProjectChangeType type, string configName )
61 {
62 this.type = type;
63 this.configName = configName;
64 }
65 }
66
67 /// <summary>
68 /// Delegate to be used to handle project events
69 /// </summary>
70 public delegate void ProjectEventHandler( object sender, ProjectEventArgs e );
71
72 /// <summary>
73 /// Class that represents an NUnit test project
74 /// </summary>
75 public class NUnitProject
76 {
77 #region Static and instance variables
78
79 /// <summary>
80 /// Used to generate default names for projects
81 /// </summary>
82 private static int projectSeed = 0;
83
84 /// <summary>
85 /// The extension used for test projects
86 /// </summary>
87 private static readonly string nunitExtension = ".nunit";
88
89 /// <summary>
90 /// Path to the file storing this project
91 /// </summary>
92 protected string projectPath;
93
94 /// <summary>
95 /// Whether the project is dirty
96 /// </summary>
97 protected bool isDirty = false;
98
99 /// <summary>
100 /// Collection of configs for the project
101 /// </summary>
102 protected ProjectConfigCollection configs;
103
104 /// <summary>
105 /// The currently active configuration
106 /// </summary>
107 private ProjectConfig activeConfig;
108
109 /// <summary>
110 /// Flag indicating that this project is a
111 /// temporary wrapper for an assembly.
112 /// </summary>
113 private bool isAssemblyWrapper = false;
114
115 #endregion
116
117 #region Constructor
118
119 public NUnitProject( string projectPath )
120 {
121 this.projectPath = Path.GetFullPath( projectPath );
122 configs = new ProjectConfigCollection( this );
123 }
124
125 #endregion
126
127 #region Static Methods
128
129 // True if it's one of our project types
130 public static bool IsProjectFile( string path )
131 {
132 return Path.GetExtension( path ) == nunitExtension;
133 }
134
135 // True if it's ours or one we can load
136 public static bool CanLoadAsProject( string path )
137 {
138 return IsProjectFile( path ) ||
139 VSProject.IsProjectFile( path ) ||
140 VSProject.IsSolutionFile( path );
141 }
142
143 public static string GenerateProjectName()
144 {
145 return string.Format( "Project{0}", ++projectSeed );
146 }
147
148 public static NUnitProject EmptyProject()
149 {
150 return new NUnitProject( GenerateProjectName() );
151 }
152
153 public static NUnitProject NewProject()
154 {
155 NUnitProject project = EmptyProject();
156
157 project.Configs.Add( "Debug" );
158 project.Configs.Add( "Release" );
159 project.IsDirty = false;
160
161 return project;
162 }
163
164 /// <summary>
165 /// Return a test project by either loading it from
166 /// the supplied path, creating one from a VS file
167 /// or wrapping an assembly.
168 /// </summary>
169 public static NUnitProject LoadProject( string path )
170 {
171 if ( NUnitProject.IsProjectFile( path ) )
172 {
173 NUnitProject project = new NUnitProject( path );
174 project.Load();
175 return project;
176 }
177 else if ( VSProject.IsProjectFile( path ) )
178 return NUnitProject.FromVSProject( path );
179 else if ( VSProject.IsSolutionFile( path ) )
180 return NUnitProject.FromVSSolution( path );
181 else
182 return NUnitProject.FromAssembly( path );
183
184 }
185
186 /// <summary>
187 /// Creates a project to wrap a list of assemblies
188 /// </summary>
189 public static NUnitProject FromAssemblies( string[] assemblies )
190 {
191 // if only one assembly is passed in then the configuration file
192 // should follow the name of the assembly. This will only happen
193 // if the LoadAssembly method is called. Currently the console ui
194 // does not differentiate between having one or multiple assemblies
195 // passed in.
196 if ( assemblies.Length == 1)
197 return NUnitProject.FromAssembly(assemblies[0]);
198
199
200 NUnitProject project = NUnitProject.EmptyProject();
201 ProjectConfig config = new ProjectConfig( "Default" );
202 foreach( string assembly in assemblies )
203 {
204 string fullPath = Path.GetFullPath( assembly );
205
206 if ( !File.Exists( fullPath ) )
207 throw new FileNotFoundException( string.Format( "Assembly not found: {0}", fullPath ) );
208
209 config.Assemblies.Add( fullPath );
210 }
211
212 project.Configs.Add( config );
213
214 // TODO: Deduce application base, and provide a
215 // better value for loadpath and project path
216 // analagous to how new projects are handled
217 string basePath = Path.GetDirectoryName( Path.GetFullPath( assemblies[0] ) );
218 project.projectPath = Path.Combine( basePath, project.Name + ".nunit" );
219
220 project.IsDirty = true;
221
222 return project;
223 }
224
225 /// <summary>
226 /// Creates a project to wrap an assembly
227 /// </summary>
228 public static NUnitProject FromAssembly( string assemblyPath )
229 {
230 if ( !File.Exists( assemblyPath ) )
231 throw new FileNotFoundException( string.Format( "Assembly not found: {0}", assemblyPath ) );
232
233 string fullPath = Path.GetFullPath( assemblyPath );
234
235 NUnitProject project = new NUnitProject( fullPath );
236
237 ProjectConfig config = new ProjectConfig( "Default" );
238 config.Assemblies.Add( fullPath );
239 project.Configs.Add( config );
240
241 project.isAssemblyWrapper = true;
242 project.IsDirty = false;
243
244 return project;
245 }
246
247 public static NUnitProject FromVSProject( string vsProjectPath )
248 {
249 NUnitProject project = new NUnitProject( Path.GetFullPath( vsProjectPath ) );
250
251 VSProject vsProject = new VSProject( vsProjectPath );
252 project.Add( vsProject );
253
254 project.isDirty = false;
255
256 return project;
257 }
258
259 public static NUnitProject FromVSSolution( string solutionPath )
260 {
261 NUnitProject project = new NUnitProject( Path.GetFullPath( solutionPath ) );
262
263 string solutionDirectory = Path.GetDirectoryName( solutionPath );
264 StreamReader reader = new StreamReader( solutionPath );
265
266 char[] delims = { '=', ',' };
267 char[] trimchars = { ' ', '"' };
268
269 string line = reader.ReadLine();
270 while ( line != null )
271 {
272 if ( line.StartsWith( "Project" ) )
273 {
274 string[] parts = line.Split( delims );
275 string vsProjectPath = Path.Combine( solutionDirectory, parts[2].Trim(trimchars) );
276
277 if ( VSProject.IsProjectFile( vsProjectPath ) )
278 project.Add( new VSProject( vsProjectPath ) );
279 }
280
281 line = reader.ReadLine();
282 }
283
284 project.isDirty = false;
285
286 return project;
287 }
288
289 /// <summary>
290 /// Figure out the proper name to be used when saving a file.
291 /// </summary>
292 public static string ProjectPathFromFile( string path )
293 {
294 string fileName = Path.GetFileNameWithoutExtension( path ) + nunitExtension;
295 return Path.Combine( Path.GetDirectoryName( path ), fileName );
296 }
297
298 #endregion
299
300 #region Properties and Events
301
302 public static int ProjectSeed
303 {
304 get { return projectSeed; }
305 set { projectSeed = value; }
306 }
307
308 /// <summary>
309 /// The path to which a project will be saved.
310 /// </summary>
311 public string ProjectPath
312 {
313 get { return projectPath; }
314 set
315 {
316 projectPath = Path.GetFullPath( value );
317 isDirty = true;
318 }
319 }
320
321 /// <summary>
322 /// The base path for the project is the
323 /// directory part of the project path.
324 /// </summary>
325 public string BasePath
326 {
327 get { return Path.GetDirectoryName( projectPath ); }
328 }
329
330 /// <summary>
331 /// The name of the project.
332 /// </summary>
333 public string Name
334 {
335 get { return Path.GetFileNameWithoutExtension( projectPath ); }
336 }
337
338 public ProjectConfig ActiveConfig
339 {
340 get
341 {
342 // In case the previous active config was removed
343 if ( activeConfig != null && !configs.Contains( activeConfig ) )
344 activeConfig = null;
345
346 // In case no active config is set or it was removed
347 if ( activeConfig == null && configs.Count > 0 )
348 activeConfig = configs[0];
349
350 return activeConfig;
351 }
352 }
353
354 // Safe access to name of the active config
355 public string ActiveConfigName
356 {
357 get
358 {
359 ProjectConfig config = ActiveConfig;
360 return config == null ? null : config.Name;
361 }
362 }
363
364 public bool IsLoadable
365 {
366 get
367 {
368 return ActiveConfig != null &&
369 ActiveConfig.Assemblies.Count > 0;
370 }
371 }
372
373 // A project made from a single assembly is treated
374 // as a transparent wrapper for some purposes until
375 // a change is made to it.
376 public bool IsAssemblyWrapper
377 {
378 get { return isAssemblyWrapper; }
379 }
380
381 public string ConfigurationFile
382 {
383 get
384 {
385 // TODO: Check this
386 return isAssemblyWrapper
387 ? Path.GetFileName( projectPath ) + ".config"
388 : Path.GetFileNameWithoutExtension( projectPath ) + ".config";
389 }
390 }
391
392 public bool IsDirty
393 {
394 get { return isDirty; }
395 set { isDirty = value; }
396 }
397
398 public ProjectConfigCollection Configs
399 {
400 get { return configs; }
401 }
402
403 public event ProjectEventHandler Changed;
404
405 #endregion
406
407 #region Instance Methods
408
409 public void SetActiveConfig( int index )
410 {
411 activeConfig = configs[index];
412 OnProjectChange( ProjectChangeType.ActiveConfig, activeConfig.Name );
413 }
414
415 public void SetActiveConfig( string name )
416 {
417 foreach( ProjectConfig config in configs )
418 {
419 if ( config.Name == name )
420 {
421 activeConfig = config;
422 OnProjectChange( ProjectChangeType.ActiveConfig, activeConfig.Name );
423 break;
424 }
425 }
426 }
427
428 public void OnProjectChange( ProjectChangeType type, string configName )
429 {
430 isDirty = true;
431
432 if ( isAssemblyWrapper )
433 {
434 projectPath = Path.ChangeExtension( projectPath, ".nunit" );
435 isAssemblyWrapper = false;
436 }
437
438 if ( Changed != null )
439 Changed( this, new ProjectEventArgs( type, configName ) );
440
441 if ( type == ProjectChangeType.RemoveConfig && activeConfig.Name == configName )
442 {
443 if ( configs.Count > 0 )
444 SetActiveConfig( 0 );
445 }
446 }
447
448 public void Add( VSProject vsProject )
449 {
450 foreach( VSProjectConfig vsConfig in vsProject.Configs )
451 {
452 string name = vsConfig.Name;
453
454 if ( !this.Configs.Contains( name ) )
455 this.Configs.Add( name );
456
457 ProjectConfig config = this.Configs[name];
458
459 foreach ( string assembly in vsConfig.Assemblies )
460 config.Assemblies.Add( assembly );
461 }
462 }
463
464 public void Load()
465 {
466 XmlTextReader reader = new XmlTextReader( projectPath );
467
468 string activeConfigName = null;
469 ProjectConfig currentConfig = null;
470
471 try
472 {
473 reader.MoveToContent();
474 if ( reader.NodeType != XmlNodeType.Element || reader.Name != "NUnitProject" )
475 throw new ProjectFormatException(
476 "Invalid project format: <NUnitProject> expected.",
477 reader.LineNumber, reader.LinePosition );
478
479 while( reader.Read() )
480 if ( reader.NodeType == XmlNodeType.Element )
481 switch( reader.Name )
482 {
483 case "Settings":
484 if ( reader.NodeType == XmlNodeType.Element )
485 activeConfigName = reader.GetAttribute( "activeconfig" );
486 break;
487
488 case "Config":
489 if ( reader.NodeType == XmlNodeType.Element )
490 {
491 string configName = reader.GetAttribute( "name" );
492 currentConfig = new ProjectConfig( configName );
493 currentConfig.BasePath = reader.GetAttribute( "appbase" );
494 currentConfig.ConfigurationFile = reader.GetAttribute( "configfile" );
495
496 string binpath = reader.GetAttribute( "binpath" );
497 string type = reader.GetAttribute( "binpathtype" );
498 if ( type == null )
499 if ( binpath == null )
500 currentConfig.BinPathType = BinPathType.Auto;
501 else
502 currentConfig.BinPathType = BinPathType.Manual;
503 else
504 currentConfig.BinPathType = (BinPathType)Enum.Parse( typeof( BinPathType ), type, true );
505 Configs.Add( currentConfig );
506 if ( configName == activeConfigName )
507 activeConfig = currentConfig;
508 }
509 else if ( reader.NodeType == XmlNodeType.EndElement )
510 currentConfig = null;
511 break;
512
513 case "assembly":
514 if ( reader.NodeType == XmlNodeType.Element && currentConfig != null )
515 {
516 string path = reader.GetAttribute( "path" );
517 string test = reader.GetAttribute( "test" );
518 bool hasTests = test == null ? true : bool.Parse( test );
519 currentConfig.Assemblies.Add(
520 Path.Combine( currentConfig.BasePath, path ),
521 hasTests );
522 }
523 break;
524
525 default:
526 break;
527 }
528
529 this.IsDirty = false;
530 }
531 catch( XmlException e )
532 {
533 throw new ProjectFormatException(
534 string.Format( "Invalid project format: {0}", e.Message ),
535 e.LineNumber, e.LinePosition );
536 }
537 catch( Exception e )
538 {
539 throw new ProjectFormatException(
540 string.Format( "Invalid project format: {0} Line {1}, Position {2}",
541 e.Message, reader.LineNumber, reader.LinePosition ),
542 reader.LineNumber, reader.LinePosition );
543 }
544 finally
545 {
546 reader.Close();
547 }
548 }
549
550 public void Save()
551 {
552 projectPath = ProjectPathFromFile( projectPath );
553
554 XmlTextWriter writer = new XmlTextWriter( projectPath, System.Text.Encoding.UTF8 );
555 writer.Formatting = Formatting.Indented;
556
557 writer.WriteStartElement( "NUnitProject" );
558
559 if ( configs.Count > 0 )
560 {
561 writer.WriteStartElement( "Settings" );
562 writer.WriteAttributeString( "activeconfig", ActiveConfigName );
563 writer.WriteEndElement();
564 }
565
566 foreach( ProjectConfig config in Configs )
567 {
568 writer.WriteStartElement( "Config" );
569 writer.WriteAttributeString( "name", config.Name );
570 if ( config.RelativeBasePath != null )
571 writer.WriteAttributeString( "appbase", config.RelativeBasePath );
572
573 string configFile = config.ConfigurationFile;
574 if ( configFile != null && configFile != this.ConfigurationFile )
575 writer.WriteAttributeString( "configfile", config.ConfigurationFile );
576
577 if ( config.BinPathType == BinPathType.Manual )
578 writer.WriteAttributeString( "binpath", config.PrivateBinPath );
579 else
580 writer.WriteAttributeString( "binpathtype", config.BinPathType.ToString() );
581
582 foreach( AssemblyListItem assembly in config.Assemblies )
583 {
584 writer.WriteStartElement( "assembly" );
585 writer.WriteAttributeString( "path", config.RelativePathTo( assembly.FullPath ) );
586 if ( !assembly.HasTests )
587 writer.WriteAttributeString( "test", "false" );
588 writer.WriteEndElement();
589 }
590
591 writer.WriteEndElement();
592 }
593
594 writer.WriteEndElement();
595
596 writer.Close();
597 this.IsDirty = false;
598
599 // Once we save a project, it's no longer
600 // loaded as an assembly wrapper on reload.
601 this.isAssemblyWrapper = false;
602 }
603
604 public void Save( string projectPath )
605 {
606 this.ProjectPath = projectPath;
607 Save();
608 }
609
610 #endregion
611 }
612 }
Mirror of the official Mono project git repository