/// <summary>
/// Creates a new instance of the command parser.
/// </summary>
/// <param name="command"></param>
/// <param name="args"></param>
/// <param name="cvsRoot"></param>
/// <param name="workingDirectory"></param>
public CommandParserFactory(string command, string[] args,
CvsRoot cvsRoot, WorkingDirectory workingDirectory){
this.command = command;
this.args = GetArgsAfterCommandName(args);
this.cvsRoot = cvsRoot;
this.workingDirectory = workingDirectory;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="workingdirectory"></param>
/// <param name="directory"></param>
/// <param name="entry"></param>
public RemoveCommand(WorkingDirectory workingdirectory,
string directory,
Entry entry)
{
this.workingdirectory = workingdirectory;
this.directory = directory;
this.entry = entry;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="workingDirectory"></param>
public CheckoutModuleCommand(WorkingDirectory workingDirectory) {
this.workingDirectory = workingDirectory;
this.Revision = this.workingDirectory.Revision;
this.OverrideDirectory = this.workingDirectory.OverrideDirectory;
if (this.workingDirectory.HasDate) {
this.Date = this.workingDirectory.Date;
}
this.Module = this.workingDirectory.ModuleName;
}
public IExternalSource Checkout(string cvsroot, string module, string password,
out string target)
{
//Set temp checkout dir
target = System.IO.Path.Combine(Globals.TempDirectory, Guid.NewGuid().ToString());
Directory.CreateDirectory(target);
//Setup CVS vars
CvsRoot root = new CvsRoot(cvsroot);
WorkingDirectory working = new WorkingDirectory(root, target, module);
CVSServerConnection connection = new CVSServerConnection();
if (connection == null)
throw new ToolExecutionException("Unable to connect to the CVS server");
//Connect to CVS
ICSharpCode.SharpCvsLib.Commands.ICommand command =
new CheckoutModuleCommand(working);
if (command == null)
throw new ToolExecutionException("Failure to create a checkout command object");
try {
connection.Connect(working, password);
} catch (AuthenticationException) {
throw new ToolExecutionException("CVS rejected access (doublecheck all fields): Authentication failure");
} catch (Exception er) {
throw new ToolExecutionException("CVS rejected access (doublecheck all fields): " + er.Message);
}
//Execute checkout command
try {
command.Execute(connection);
connection.Close();
} catch (Exception er) {
throw new ToolExecutionException("CVS error: " + er.Message);
}
//Create source from module root
return CreateSource(Path.Combine(target, module));
}
public LogCommand(WorkingDirectory workingDirectory, Folders folders) {
this.workingDirectory = workingDirectory;
this.folders = folders;
}
/// <summary>
/// Creates a new instance of the xml log command.
/// </summary>
/// <param name="workingDirectory">Directory on the local file system that represents a
/// working "sandbox" of the remote cvs repository.</param>
/// <param name="module">Module to report on.</param>
public XmlLogCommand(WorkingDirectory workingDirectory, string module) {
this.cvsChangeLog = new CvsChangeLog(workingDirectory, module);
}
/// <summary>
/// Produce the report
/// </summary>
public LogReport Run(string password)
{
// read Root and Repository from local directory
if (null == this.cvsRoot) {
Manager manager = new Manager(localDirectory);
Root root = (Root)manager.FetchSingle (localDirectory,
Factory.FileType.Root);
cvsRoot = new CvsRoot(root.FileContents);
}
if (null == this.workingDirectory) {
workingDirectory = new WorkingDirectory(cvsRoot,
localDirectory,
module);
}
// Get a connection
CVSServerConnection connection = new CVSServerConnection();
connection.Connect(workingDirectory, password);
return Run(connection);
}
/// <summary>
///
/// </summary>
/// <param name="workingDirectory"></param>
/// <param name="module"></param>
public RLogCommand(WorkingDirectory workingDirectory, string module) : base(workingDirectory, null, null) {
this.workingDirectory = workingDirectory;
}
/// <summary>
/// Create a <code>CVS\Entries</code> management file with the given
/// entry line, or if the file exists then add the line to the
/// management file.
/// </summary>
/// <param name="workingDirectory">Local working directory.</param>
/// <param name="localPath">The local path response sent down from
/// the server.</param>
/// <param name="repositoryPath">The path to the file name on the
/// server.</param>
/// <param name="entry">The string value that represents the cvs
/// entry.</param>
/// <returns>The contents of the newly created entries file that match
/// the given file name created.</returns>
public Entry AddEntry (WorkingDirectory workingDirectory,
String localPath,
String repositoryPath,
String entry) {
PathTranslator pathTranslator =
new PathTranslator (workingDirectory,
repositoryPath);
Factory factory = CvsFactory;
Entry cvsEntry = (Entry)
factory.CreateCvsObject(pathTranslator.CurrentDir, Entry.FILE_NAME, entry);
return this.AddEntry(cvsEntry);
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
ICSharpCode.SharpCvsLib.Commands.AddCommand addCommand;
this.ParseOptions(this.unparsedOptions);
try {
// Open the Repository file in the CVS directory
Manager manager = new Manager(Environment.CurrentDirectory);
Repository repository = manager.FetchRepository(Environment.CurrentDirectory);
// If this fails error out and state the user
// is not in a CVS repository directory tree.
CurrentWorkingDirectory = new WorkingDirectory( this.cvsRoot,
Environment.CurrentDirectory, repository.FileContents);
CurrentWorkingDirectory.OverrideDirectory = Environment.CurrentDirectory;
// If fileNames has a wild card (*) like '*.txt'
// Create new AddCommand object
addCommand = new ICSharpCode.SharpCvsLib.Commands.AddCommand(
this.CurrentWorkingDirectory);
String[] files = Directory.GetFiles(Environment.CurrentDirectory, fileNames);
ArrayList copiedFiles = new ArrayList ();
foreach (String file in files) {
LOGGER.Debug("file=[" + file + "]");
// Remove the .txt when everything works, giving me bugs...
String fullPath = Path.Combine(Environment.CurrentDirectory, file);
copiedFiles.Add(fullPath);
}
addCommand.Folders = GetFoldersToAdd(copiedFiles);
}
catch (Exception e) {
LOGGER.Error (e);
throw e;
}
return addCommand;
}
/// <summary>
/// Connect to the repository.
/// </summary>
/// <param name="repository"></param>
/// <param name="password"></param>
public void Connect(WorkingDirectory repository, string password) {
this.repository = repository;
if (StartProcessEvent != null) {
this.StartProcessEvent(this, new ProcessEventArgs());
}
Authentication(password);
}
private string GetPassword(CommandLineParser parser, WorkingDirectory workingDir) {
string pwd = null;
if (null != parser && null != parser.Password &&
parser.Password.Length != 0) {
pwd = parser.Password;
} else {
LoginCommand loginCommand = new LoginCommand(workingDir.CvsRoot);
loginCommand.Execute();
pwd = loginCommand.Password;
}
if (null == pwd) {
pwd = String.Empty;
}
return pwd;
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
ICSharpCode.SharpCvsLib.Commands.RemoveCommand removeCommand;
this.ParseOptions(this.unparsedOptions);
try {
String currentDirectory = Environment.CurrentDirectory;
Entry removeEntry;
// Open the Repository file in the CVS directory
Manager manager = new Manager(currentDirectory);
Repository repository = manager.FetchRepository(currentDirectory);
removeEntry = manager.FetchEntry(currentDirectory, fileNames );
// If this fails error out and state the user
// is not in a CVS repository directory tree.
CurrentWorkingDirectory = new WorkingDirectory( this.cvsRoot,
currentDirectory, repository.FileContents);
// Create new RemoveCommand object
removeCommand = new ICSharpCode.SharpCvsLib.Commands.RemoveCommand(
this.CurrentWorkingDirectory, currentDirectory,
removeEntry);
}
catch (Exception e) {
LOGGER.Error (e);
throw e;
}
return removeCommand;
}
/// <summary>
/// Perform an rtag against the repository. The rtag command has a number
/// of request options that may be specified. These are translated into
/// boolean values where possible to calling classes. A summary of
/// available command options is listed below and is listed in the private
/// options classes.
///
/// -D date
/// Tag the most recent revision no later than date.
/// -f
/// Only useful with the `-D date' or `-r tag' flags.
/// If no matching revision is found, use the most recent
/// revision (instead of ignoring the file).
/// -F
/// Overwrite an existing tag of the same name on a different
/// revision.
/// -l
/// Local; run only in current working directory.
/// -n
/// Do not run any tag program that was specified with the `-t'
/// flag inside the `modules' file. (see section The modules
/// file).
/// -R
/// Tag directories recursively. This is on by default.
/// -r tag
/// Only tag those files that contain tag. This can be used to
/// rename a tag: tag only the files identified by the old tag,
/// then delete the old tag, leaving the new tag on exactly the
/// same files as the old tag.
///
/// In addition to the above common options, these options are
/// available:
///
/// -a
/// Use the `-a' option to have rtag look in the `Attic'
/// (see section The attic) for removed files that contain the
/// specified tag. The tag is removed from these files, which
/// makes it convenient to re-use a symbolic tag as development
/// continues (and files get removed from the up-coming
/// distribution).
/// -b
/// Make the tag a branch tag. See section Branching and merging.
/// -d
/// Delete the tag instead of creating it. In general, tags
/// (often the symbolic names of software distributions) should
/// not be removed, but the `-d' option is available as a means
/// to remove completely obsolete symbolic names if necessary
/// (as might be the case for an Alpha release, or if you
/// mistagged a module).
///
/// </summary>
/// <param name="workingDirectory">The working directory which contains
/// the repository information.</param>
public RTagCommand(WorkingDirectory workingDirectory) {
this.workingDirectory = workingDirectory;
}
/// <summary>
/// Create a new instance of the cvs changelog command.
/// </summary>
/// <param name="workingDirectory"></param>
/// <param name="module"></param>
public CvsChangeLog(WorkingDirectory workingDirectory, string module) {
logCommand = new LogReportCommand(workingDirectory, module);
}
/// <summary>
/// Produce the report
/// Alternate interface for when we are given a server cooection
/// This is needed for the SharpCvsLib command line client
/// </summary>
public LogReport Run(ICommandConnection connection)
{
// read Root and Repository from local directory
if (null == this.cvsRoot) {
Manager manager = new Manager(localDirectory);
Root root = (Root)manager.FetchSingle (localDirectory,
Factory.FileType.Root);
this.cvsRoot = new CvsRoot(root.FileContents);
}
if (null == workingDirectory) {
Manager manager = new Manager(localDirectory);
Repository repository = (Repository)manager.FetchSingle (localDirectory,
Factory.FileType.Repository);
this.workingDirectory = new WorkingDirectory(cvsRoot,
localDirectory,
repository.FileContents);
}
ILogCommand command;
// Recursively add all cvs folders/files under the localDirectory
System.Console.WriteLine("GNE workingDirectory.WorkingPath = {0}", workingDirectory.WorkingPath);
System.Console.WriteLine("GNE localDirectory: {0}", localDirectory);
// if (Directory.Exists(workingDirectory.WorkingPath)) {
if (Directory.Exists(localDirectory) && File.Exists(Path.Combine(localDirectory, "Repository"))) {
workingDirectory.FoldersToUpdate = FetchFiles(localDirectory);
command =
new LogCommand(workingDirectory, this.workingDirectory.ModuleName, null);
} else {
command =
// GNE - this wont compile new LogCommand(workingDirectory, this.workingDirectory.ModuleName);
new RLogCommand(workingDirectory, this.workingDirectory.ModuleName);
}
// add any date restrictions
if (hasStartDate && hasEndDate) {
command.AddInclusiveDateRange(startDate, endDate);
} else if (hasStartDate) {
command.AddInclusiveDateStart(startDate);
} else if (hasEndDate) {
command.AddInclusiveDateEnd(endDate);
}
// Initialse state machine
curLogReport = new LogReport(); // this is what we are going to return to the caller
curLogFile = new LogFile(this.cvsRoot);
curLogRevision = new LogRevision();
logState = LogState.WANT_FILE_HEADER_START;
if (connection.GetType() == typeof(CVSServerConnection)) {
CVSServerConnection cvsServerConnection = (CVSServerConnection)connection;
cvsServerConnection.MessageEvent.MessageEvent += new EncodedMessage.MessageHandler(OnMessage);
}
command.Execute(connection);
// return curLogReport but clear our reference to it
LogReport report = curLogReport;
curLogReport = null;
return report;
}
/// <summary>
/// Create a new connection and initialize with the working directory
/// object.
/// </summary>
/// <param name="workingDirectory"></param>
public CVSServerConnection (WorkingDirectory workingDirectory) {
this.repository = workingDirectory;
this.Init();
}
/// <summary>
/// Constructor for the import module command.
/// </summary>
/// <param name="workingdirectory"></param>
/// <param name="logmessage"></param>
public ImportModuleCommand(WorkingDirectory workingdirectory, string logmessage)
{
this.logmessage = logmessage;
this.workingdirectory = workingdirectory;
}
private void Init () {
inputStream = new CvsStream (new MemoryStream());
outputStream = new CvsStream (new MemoryStream());
this.config = SharpCvsLibConfig.GetInstance();
try {
if (config.Log.DebugLog.Enabled) {
requestLog = new RequestLog ();
responseLog = new ResponseLog ();
this.InputStream.RequestMessage.MessageEvent +=
new EncodedMessage.MessageHandler (requestLog.Log);
this.OutputStream.ResponseMessage.MessageEvent +=
new EncodedMessage.MessageHandler (responseLog.Log);
}
} catch (Exception e) {
LOGGER.Error (e);
}
if (null == config) {
config = new SharpCvsLibConfig ();
}
LOGGER.Debug("Config=[" + config.ToString() + "]");
if (this.repository == null) {
this.repository = DeriveWorkingDirectory();
}
}
/// <summary>
/// Create the root file in the local cvs directory. This file holds
/// the details about the cvs root used in this sandbox.
/// </summary>
/// <param name="workingDirectory">Holds information about the current
/// path and cvs root.</param>
/// <param name="localPath">The local path response sent down from
/// the server.</param>
/// <param name="repositoryPath">The path to the file name on the
/// server.</param>
/// <returns>The object contents of the newly created root file.</returns>
public Root AddRoot (WorkingDirectory workingDirectory,
String localPath,
String repositoryPath) {
PathTranslator pathTranslator =
new PathTranslator (workingDirectory,
repositoryPath);
Factory factory = CvsFactory;
Root root =
(Root)factory.CreateCvsObject (pathTranslator.CurrentDir, Root.FILE_NAME,
pathTranslator.CvsRoot.ToString ());
return this.AddRoot (root);
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
ICSharpCode.SharpCvsLib.Commands.LogCommand logCommand;
DirectoryInfo dir = new DirectoryInfo(Directory.GetCurrentDirectory());
this.ParseOptions(this.unparsedOptions);
try {
Repository repository = Repository.Load(dir);
if (null == repository || null == repository.FileContents) {
throw new CvsFileNotFoundException(
string.Format("Valid CVS\\Repository file not found in {0}",
dir));
}
this.repository = repository.FileContents;
Root root = Root.Load(dir);
if (null == root || null == root.FileContents) {
throw new CvsFileNotFoundException(
string.Format("Valid CVS\\Root file not found in {0}",
dir));
}
this.cvsRoot = new CvsRoot(root.FileContents);
} catch (CvsFileNotFoundException e) {
LOGGER.Error(e);
ConsoleMain.ExitProgram("Not a CVS repository.", e);
}
CurrentWorkingDirectory = new WorkingDirectory(this.cvsRoot,
dir.FullName, this.repository);
logCommand =
new ICSharpCode.SharpCvsLib.Commands.LogCommand(
CurrentWorkingDirectory, folders);
return logCommand;
}
/// <summary>
/// Login to a cvs repository with workDirectory object
/// </summary>
/// <param name="cvsRoot">The repository root.</param>
/// <param name="workingDirectory">User information</param>
public LoginCommand(CvsRoot cvsRoot, WorkingDirectory workingDirectory){
this.cvsRoot = cvsRoot;
this.workingDirectory = workingDirectory;
// Is there a password file?
// yes, get password for this username
// no, prompt user for password to use
}
/// <summary>
/// Create the repository file in the cvs sub directory of the
/// current working directory.
/// </summary>
/// <param name="workingDirectory">Holds information about the current
/// path and cvs root.</param>
/// <param name="localPath">The local path response sent down from
/// the server.</param>
/// <param name="repositoryPath">The path to the file name on the
/// server.</param>
/// <returns>The object contents of the newly created repository file.</returns>
public Repository AddRepository (WorkingDirectory workingDirectory,
String localPath,
String repositoryPath) {
PathTranslator pathTranslator =
new PathTranslator (workingDirectory,
repositoryPath);
Factory factory = CvsFactory;
String repositoryContents = String.Format("{0}/{1}",
workingDirectory.ModuleName, pathTranslator.RelativePath);
DirectoryInfo dir = pathTranslator.CurrentDir;
Repository repository =
(Repository)factory.CreateCvsObject (dir, Repository.FILE_NAME,
repositoryContents);
return this.AddRepository (repository);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="workingDirectory"></param>
public UpdateCommand2(WorkingDirectory workingDirectory) {
this.workingDirectory = workingDirectory;
}
/// <summary>
/// Create the root file in the local cvs directory. This file holds
/// the details about the cvs root used in this sandbox.
/// </summary>
/// <param name="workingDirectory">Holds information about the current
/// path and cvs root.</param>
/// <param name="localPath">The local path response sent down from
/// the server.</param>
/// <param name="repositoryPath">The path to the file name on the
/// server.</param>
/// <param name="stickyTag">The sticky tag to add to the tag file.</param>
/// <returns>The object contents of the newly created root file.</returns>
public Tag AddTag (WorkingDirectory workingDirectory, String localPath,
String repositoryPath, String stickyTag) {
PathTranslator pathTranslator =
new PathTranslator (workingDirectory,
repositoryPath);
Factory factory = CvsFactory;
FileInfo tagFile =
new FileInfo(Path.Combine(PathTranslator.AppendCvs(localPath).FullName,
Tag.FILE_NAME));
Tag tag =
(Tag)factory.CreateCvsObject (tagFile, stickyTag);
return this.AddTag (tag);;
}
/// <summary>
/// Create a new instance of the working directory.
/// </summary>
/// <param name="workingDirectory"></param>
public StatusCommand(WorkingDirectory workingDirectory){
this._workingdirectory = workingDirectory;
}
/// <summary>
/// Initialize the working directory to be used in the add.
/// </summary>
public AddCommand(WorkingDirectory workingDirectory) {
this.workingDirectory = workingDirectory;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="workingdirectory"></param>
/// <param name="directory"></param>
/// <param name="entry"></param>
public StatusCommand(WorkingDirectory workingdirectory,
string directory, Entry entry){
this._workingdirectory = workingdirectory;
this.directory = directory;
this.entry = entry;
if (null == this.Folders) {
this._folders = new Folders();
Folder folder = new Folder();
folder.Entries.Add(entry);
this._folders.Add(folder);
}
}
/// <summary>
/// Commit command two constructor
/// </summary>
/// <param name="workingdirectory"></param>
public CommitCommand2(WorkingDirectory workingdirectory)
{
this.workingdirectory = workingdirectory;
}
/// <summary>
/// Create the command object that will be used to act on the repository.
/// </summary>
/// <returns>The command object that will be used to act on the
/// repository.</returns>
/// <exception cref="Exception">TODO: Make a more specific exception</exception>
/// <exception cref="NotImplementedException">If the command argument
/// is not implemented currently. TODO: Implement the argument.</exception>
public override ICommand CreateCommand () {
DirectoryInfo dir =
new DirectoryInfo(Path.Combine(Directory.GetCurrentDirectory(), "CVS"));
StatusCommand statusCommand;
this.localDirectory = Directory.GetCurrentDirectory();
try {
this.repository = Repository.Load(dir).FileContents;
this.CvsRoot = new CvsRoot(Root.Load(dir).FileContents);
} catch (NullReferenceException) {
this.InvalidRepository();
} catch (CvsFileNotFoundException) {
this.InvalidRepository();
} catch (ICSharpCode.SharpCvsLib.Exceptions.CvsRootParseException) {
this.InvalidRepository();
}
CurrentWorkingDirectory = new WorkingDirectory(this.CvsRoot,
localDirectory, this.repository);
// Create new command object
statusCommand = new StatusCommand(CurrentWorkingDirectory);
statusCommand.Folders = this.GetCurrentDirectory(new DirectoryInfo(localDirectory));
this.ParseOptions(statusCommand, this.Args);
return statusCommand;
}
