/// <summary>
/// Initializes a new instance of the <see cref="CVSFolder"/> class.
/// </summary>
/// <param name="parentFolder">The parent folder.</param>
public CVSFolder(Folder parentFolder)
{
_parent = parentFolder;
CVSDirectory = new DirectoryInfo(Path.Combine(parentFolder.Info.FullName, "CVS"));
RepositoryFile = new FileInfo(Path.Combine(CVSDirectory.FullName, "Repository"));
EntriesFile = new FileInfo(Path.Combine(CVSDirectory.FullName, "Entries"));
RootFile = new FileInfo(Path.Combine(CVSDirectory.FullName, "Root"));
}
/// <summary>
/// Initializes a new instance of the Folder class
/// The sub folders in the tree use this constructor, which contains the parent parameter.
/// The Parent Info property is used with the module path name to name the new folder
/// </summary>
/// <param name="name">Name of the folder. This also is added to the module name of the parent</param>
/// <param name="parent">Parent folder</param>
public Folder(string name, Folder parent)
: base(parent)
{
DirectoryInfo di = new DirectoryInfo(Path.Combine(parent.Info.FullName, name));
Info = di;
_childItems = new List<ICVSItem>();
_cvsFolder = new CVSFolder(this);
}
public void TestEntry()
{
// starting module folder
DirectoryInfo di = new DirectoryInfo(@"c:\_temp\working\team\mymod");
Folder rootModuleFolder = new Folder(di, _connection, _repository, _module);
Entry file1 = new Entry("file1.cs", rootModuleFolder);
Assert.AreSame(rootModuleFolder, file1.Parent);
Assert.AreSame(file1.CVSFolder, rootModuleFolder.CVSFolder);
Assert.AreEqual(@"c:\_temp\working\team\mymod\file1.cs", file1.Info.FullName);
}
////public IList<IFileResponseGroup> CreateFileGroupsFromResponses(IList<IResponse> responses)
////{
//// IList<IFileResponseGroup> files = new List<IFileResponseGroup>();
//// IFileResponseGroup file = null;
//// foreach (IResponse response in responses)
//// {
//// if (response.Type == ResponseType.ModTime)
//// {
//// file = new FileResponseGroup { ModTime = (ModTimeResponse)response };
//// }
//// if (response is IMessageResponse)
//// {
//// if (file != null) file.MT = (IMessageResponse)response;
//// }
//// if (response is IFileResponse)
//// {
//// if (file != null)
//// {
//// file.FileResponse = (IFileResponse)response;
//// files.Add(file);
//// }
//// }
//// }
//// return files;
////}
///// <summary>
///// Creates the CVS file structure.
///// </summary>
///// <param name="root">The root.</param>
///// <param name="fileGroups">The file groups.</param>
///// <returns></returns>
////public Folder CreateCVSFileStructure(IRoot root, IList<IFileResponseGroup> fileGroups)
////{
//// DirectoryInfo di = PServerHelper.GetRootModuleFolderPath(root.WorkingDirectory, root.Module);
//// Folder rootFolder = new Folder(di, root.CVSConnectionString, root.Repository, root.Module);
//// Folder parent = rootFolder;
//// foreach (IFileResponseGroup fileGroup in fileGroups)
//// {
//// IFileResponse response = fileGroup.FileResponse;
//// string module = ResponseHelper.FixResponseModuleSlashes(response.Module);
//// // add file to current folder
//// if (module != parent.Module)
//// {
//// string name = ResponseHelper.GetLastModuleName(response.Module);
//// Folder folder = new Folder(name, parent);
//// parent = folder;
//// }
//// Entry entry = new Entry(fileGroup.FileResponse.Name, parent);
//// entry.Length = response.Length;
//// entry.FileContents = response.Contents;
//// }
//// return rootFolder;
////}
/// <summary>
/// Adds the file to the Folder tree and returns the folder the entry was added to.
/// </summary>
/// <param name="startingFolder">Either the root folder or the last folder an entry was added to</param>
/// <param name="file">Group of responses needed for one file</param>
/// <returns>The folder the entry was added to</returns>
public Entry AddFile(Folder startingFolder, IFileResponseGroup file)
{
string module = file.FileResponse.Module;
Folder parent = GetModuleFolder(startingFolder, module);
Entry entry = new Entry(file.FileResponse.Name, parent);
entry.Length = file.FileResponse.Length;
entry.FileContents = file.FileResponse.Contents;
entry.EntryLine = file.FileResponse.EntryLine;
return entry;
}
public void SetUp()
{
_entries = new List<string>
{
"/file1.cs/1.1/Tue Jan 5 15:47:45 2010//",
"/file2.cs/1.1/Tue Jan 5 15:47:45 2010//",
"/file3.cs/1.3/Thu Jan 7 15:49:20 2010//",
"/TestApp.csproj/1.1/Tue Jan 5 15:47:45 2010//",
"D/Properties////",
"/.gitignore/1.1/Tue Jan 5 15:47:45 2010//",
"/AssemblyVersionIncrementor.dll/1.1/Tue Jan 5 15:47:45 2010/-kb/"
};
_mocks = new MockRepository();
_readerWriter = _mocks.DynamicMock<IReaderWriter>();
ReaderWriter.Current = _readerWriter;
DirectoryInfo di = new DirectoryInfo(@"c:\_temp\working\team\mymod");
_rootModuleFolder = new Folder(di, _connection, _repository, _module);
_file1 = new Entry("file1.cs", _rootModuleFolder) { EntryLine = _entries[0] };
_proj = new Entry("TestApp.csproj", _rootModuleFolder) { EntryLine = _entries[3] };
_props = new Folder("Properties", _rootModuleFolder) { EntryLine = _entries[4] };
_file = new Entry(".gitignore", _rootModuleFolder) { EntryLine = _entries[5] };
_binary = new Entry("AssemblyVersionIncrementor.dll", _rootModuleFolder) { EntryLine = _entries[6] };
}
public Folder CreateFolderStructure(string[] folders)
{
Folder current = _root.RootFolder;
string repository = _root.Module;
for (int i = 1; i < folders.Length; i++)
{
string folderName = folders[i];
Folder folder = null;
foreach (ICVSItem item in current)
{
if ((item is Folder) && item.Name == folderName)
folder = (Folder) item;
}
if (folder == null)
{
repository += "/" + folderName;
DirectoryInfo di = new DirectoryInfo(Path.Combine(current.Info.FullName, folderName));
folder = new Folder(di, current);
//current.AddItem(folder);
}
current = folder;
}
return current;
}
/// <summary>
/// Adds the folder for the module to the Folder hierarchy in the Root object
/// </summary>
/// <param name="rootFolder">The root folder.</param>
/// <param name="module">The module.</param>
/// <returns>The new Folder that was created</returns>
public Folder AddFolderToStructure(Folder rootFolder, string module)
{
string[] modules = module.Split(new[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
string mod = string.Empty;
Folder parent = rootFolder;
Folder folder = null;
for (int i = 0; i < modules.Length; i++)
{
mod += "/" + modules[i];
mod = ResponseHelper.FixResponseModuleSlashes(mod);
folder = FindModuleFolder(rootFolder, mod);
if (folder == null)
{
string name = ResponseHelper.GetLastModuleName(mod);
folder = new Folder(name, parent);
}
parent = folder;
}
return folder;
}
/// <summary>
/// Gets the module folder.
/// </summary>
/// <param name="startingFolder">The starting folder.</param>
/// <param name="module">The CVS module.</param>
/// <returns>Folder for the module</returns>
public Folder GetModuleFolder(Folder startingFolder, string module)
{
module = ResponseHelper.FixResponseModuleSlashes(module);
Folder folder;
folder = FindModuleFolder(startingFolder, module);
if (folder == null)
folder = AddFolderToStructure(startingFolder.GetRootFolder(), module);
return folder;
}
/// <summary>
/// Finds the module Folder in sub folders.
/// </summary>
/// <param name="startingFolder">The starting folder.</param>
/// <param name="module">The module.</param>
/// <returns>The Folder if it exists, else null</returns>
public Folder FindModuleInSubFolders(Folder startingFolder, string module)
{
Folder returnFolder = null;
if (module == startingFolder.Module)
returnFolder = startingFolder;
if (returnFolder == null)
{
IList<Folder> subFolders = startingFolder.GetSubFolders().ToList();
foreach (Folder folder in subFolders)
{
if (returnFolder == null)
returnFolder = FindModuleInSubFolders(folder, module);
}
}
// return the folder that was found or null if it was not found
return returnFolder;
}
/// <summary>
/// Finds the module folder.
/// </summary>
/// <param name="startingFolder">The starting folder.</param>
/// <param name="module">The module.</param>
/// <returns>The Folder if it exists, else null</returns>
public Folder FindModuleFolder(Folder startingFolder, string module)
{
Folder returnFolder = FindModuleInSubFolders(startingFolder, module);
// if the folder was not found, start from the root and find again
if (returnFolder == null)
{
Folder rootFolder = startingFolder.GetRootFolder();
if (!startingFolder.Equals(rootFolder))
returnFolder = FindModuleInSubFolders(startingFolder.GetRootFolder(), module);
}
return returnFolder;
}
public void WriteToDisk(Folder module)
{
module.Write();
foreach (ICVSItem item in module)
{
if (item is Folder)
WriteToDisk((Folder) item);
else
item.Write();
}
}
public void SetUp()
{
_processor = new ResponseProcessor();
DirectoryInfo di = new DirectoryInfo(@"c:\_temp\cvs\abougie");
_rootFolder = new Folder(di, "connection string", "/usr/local/cvsroot/sandbox", "abougie");
_sub1 = new Folder("sub1", _rootFolder);
_sub2 = new Folder("sub2", _sub1);
_sub21 = new Folder("sub21", _sub2);
_sub211 = new Folder("sub211", _sub21);
_sub3 = new Folder("sub3", _sub2);
_sub11 = new Folder("sub11", _sub1);
_sub12 = new Folder("sub12", _sub11);
}
public void SetUp()
{
DirectoryInfo di = new DirectoryInfo(@"c:\_temp");
_parent = new Folder(di, "my connection", "/f1/f2/f3", "mymod");
}
public void TestFolder()
{
// starting module folder
DirectoryInfo di = new DirectoryInfo(@"c:\_temp\working\team\mymod");
Folder rootModuleFolder = new Folder(di, _connection, _repository, _module);
Assert.IsNull(rootModuleFolder.Parent);
Assert.AreEqual("mymod", rootModuleFolder.Module);
Assert.AreEqual(_connection, rootModuleFolder.Connection);
Assert.AreEqual(_repository, rootModuleFolder.Repository);
CVSFolder cvsfolder = rootModuleFolder.CVSFolder;
Assert.AreEqual(@"c:\_temp\working\team\mymod\CVS", cvsfolder.CVSDirectory.FullName);
// add sub folder
di = new DirectoryInfo(@"c:\_temp\working\team\mymod\project1");
Folder project1 = new Folder("project1", rootModuleFolder);
Assert.AreSame(rootModuleFolder, project1.Parent);
Assert.AreEqual("mymod/project1", project1.Module);
Assert.AreEqual(_connection, project1.Connection);
Assert.AreEqual(_repository, project1.Repository);
cvsfolder = project1.CVSFolder;
Assert.AreEqual(@"c:\_temp\working\team\mymod\project1\CVS", cvsfolder.CVSDirectory.FullName);
Assert.AreEqual(1, rootModuleFolder.Count);
Assert.AreSame(project1, rootModuleFolder[0]);
// add sub-sub folder
di = new DirectoryInfo(@"c:\_temp\working\team\mymod\project1\Properties");
Folder prop = new Folder("Properties", project1);
Assert.AreEqual("mymod/project1/Properties", prop.Module);
Assert.AreSame(project1, prop.Parent);
cvsfolder = prop.CVSFolder;
Assert.AreEqual(@"c:\_temp\working\team\mymod\project1\Properties\CVS", cvsfolder.CVSDirectory.FullName);
Assert.AreEqual(1, project1.Count);
Assert.AreSame(prop, project1[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="CVSItemBase"/> class.
/// </summary>
/// <param name="parent">The parent.</param>
protected CVSItemBase(Folder parent)
{
Parent = parent;
Parent.AddItem(this);
}
/// <summary>
/// Processes the responses of each request. When all the requests
/// needed to save a file have been retrieved from the CVS server,
/// the file is saved and the information contained in the command
/// is deleted for performance.
/// </summary>
/// <param name="request">The request.</param>
protected internal override void AfterRequest(IRequest request)
{
if (request is ExportRequest)
{
IResponse response;
IFileResponseGroup file = null;
IList<IResponse> messages = null;
bool gettingFile = false;
ResponseProcessor processor = new ResponseProcessor();
response = Connection.GetResponse();
ProcessResponse(response);
do
{
if (gettingFile)
{
if (response is MTMessageResponse)
messages.Add(response);
if (response is UpdatedResponse)
{
messages = ResponseHelper.CollapseMessagesInResponses(messages);
file.MT = (IMessageResponse)messages[0];
file.FileResponse = (IFileResponse)response;
// process each file
Entry entry = processor.AddFile(CurrentFolder, file);
entry.Save(true);
Folder folder = entry.Parent;
if (SaveCVSFolder)
{
if (folder.Module != CurrentFolder.Module)
folder.SaveCVSFolder();
}
CurrentFolder = folder;
file = null;
RemoveProcessedResponses();
gettingFile = false; // all done getting file
}
}
else
{
if (response is ModTimeResponse)
{
file = new FileResponseGroup();
messages = new List<IResponse>();
file.ModTime = (ModTimeResponse)response;
gettingFile = true;
}
}
response = Connection.GetResponse();
ProcessResponse(response);
}
while (response != null);
}
else
{
base.AfterRequest(request);
}
}
