/// <summary>
        /// Parses the command-line.
        /// </summary>
        /// <param name="args">Arguments from command-line.</param>
        /// <param name="commandLine">Command line object created from command-line arguments</param>
        /// <returns>True if command-line is parsed, false if a failure was occurred.</returns>
        public static bool TryParseArguments(string[] args, out CommandLine commandLine)
        {
            bool success = true;

            commandLine = new CommandLine();

            for (int i = 0; i < args.Length; ++i)
            {
                if ('-' == args[i][0] || '/' == args[i][0])
                {
                    string arg = args[i].Substring(1).ToLowerInvariant();
                    if ("?" == arg || "help" == arg)
                    {
                        return false;
                    }
                    else if ("o" == arg || "out" == arg)
                    {
                        ++i;
                        if (args.Length == i)
                        {
                            Console.Error.WriteLine(String.Format("Missing file specification for '-out' option."));
                            success = false;
                        }
                        else
                        {
                            string outputPath = Path.GetFullPath(args[i]);
                            commandLine.OutputFolder = outputPath;
                        }
                    }
                }
                else
                {
                    string[] file = args[i].Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
                    string sourcePath = Path.GetFullPath(file[0]);
                    if (!System.IO.File.Exists(sourcePath))
                    {
                        Console.Error.WriteLine(String.Format("Source file '{0}' could not be found.", sourcePath));
                        success = false;
                    }
                    else
                    {
                        commandLine.Files.Add(sourcePath);
                    }
                }
            }

            if (0 == commandLine.Files.Count)
            {
                Console.Error.WriteLine(String.Format("No inputs specified. Specify at least one file."));
                success = false;
            }

            if (String.IsNullOrEmpty(commandLine.OutputFolder))
            {
                Console.Error.WriteLine(String.Format("Ouput folder was not specified. Specify an output folder using the '-out' switch."));
                success = false;
            }

            return success;
        }

		public CommandExecutorContext(ICommandExecutor executor, CommandLine commandLine, CommandTreeNode commandNode, object parameter) : base(executor, null, commandNode, parameter)
		{
			if(commandLine == null)
				throw new ArgumentNullException("commandLine");

			_commandLine = commandLine;
		}

 static void Main(string[] args)
 {
     Console.Title = "Irony Console Sample";
       Console.WriteLine("Irony Console Sample.");
       Console.WriteLine("");
       Console.WriteLine("Select a grammar to load:");
       Console.WriteLine("  1. Expression Evaluator");
       Console.WriteLine("  2. mini-Python");
       Console.WriteLine("  Or press any other key to exit.");
       Console.WriteLine("");
       Console.Write("?");
       var choice = Console.ReadLine();
       Grammar grammar;
       switch (choice) {
     case "1":
       grammar = new ExpressionEvaluatorGrammar();
       break;
     case "2":
       grammar = new MiniPython.MiniPythonGrammar();
       break;
     default:
       return;
       }
       Console.Clear();
       var commandLine = new CommandLine(grammar);
       commandLine.Run();
 }

 public PythonCompletionData(string text, string stub, CommandLine commandLine, bool isInstance)
 {
     this.Text = text;
     this.Stub = stub;
     this.commandLine = commandLine;
     this.IsInstance = isInstance;
 }

        public void Then_options_should_be_set_if_provided()
        {
            var commandLine = new CommandLine("exe -opt1:value1 -opt4 -opt2:\"value2\"");

            Assert.AreEqual("value1", commandLine.Option1);
            Assert.AreEqual("value2", commandLine.Option2);
        }

        public void Then_options_should_be_set_if_provided()
        {
            var commandLine = new CommandLine("exe -opt1:two -opt4 -opt2:\"bbb\"");

            Assert.AreEqual(Enum1.two, commandLine.Option1);
            Assert.AreEqual(Enum2.bbb, commandLine.Option2);
        }

 public void DefaultProvider_EmptyCommandLine_Throws()
 {
     var provider = Provider.Default;
     var commandLine = new CommandLine();
     var connectionString = new ConnectionString();
     var result = ConnectionStringBuilder.GetConnectionString(provider, commandLine, connectionString);
 }

		/// <remarks>
		/// After the engine is created the standard output is replaced with our custom Stream class so we
		/// can redirect the stdout to the text editor window.
		/// This can be done in this method since the Runtime object will have been created before this method
		/// is called.
		/// </remarks>
		protected override IConsole CreateConsole(ScriptEngine engine, CommandLine commandLine, ConsoleOptions options)
		{
			ScriptingConsoleOutputStream stream = pythonConsole.CreateOutputStream();
			SetOutput(stream);
			pythonConsole.CommandLine = commandLine;
			return pythonConsole;
		}

 public void AutoLoadWithQuotes()
 {
     CommandLine commandLine = new CommandLine();
     Parser parser = new Parser("DummyProgram.exe /SourceDir:\"c:\\Program Files\"", commandLine);
     parser.Parse();
     Assert.AreEqual("c:\\Program Files", commandLine.SourceDirectory, "The source parameter is not correct.");
 }

 static void Main(string[] args)
 {
     var commandLine = new CommandLine(args);
     if (commandLine.Help)
     {
         commandLine.ShowHelp(Console.Out);
         Environment.ExitCode = 1;
         return;
     }
     if (commandLine.HasErrors)
     {
         commandLine.ShowErrors(Console.Error);
         Environment.ExitCode = 1;
         return;
     }
     try
     {
         if (SolutionFile.IsSolutionFileName(commandLine.ProjectFile))
         {
             ProcessSolutionFile(commandLine);
         }
         else
         {
             ProcessProjectFile(commandLine);
         }
         Log.Info("Done");
     }
     catch (Exception ex)
     {
         Log.Error("Unexpected exception: " + ex.Message);
         Environment.ExitCode = 1;
     }
 }

        public void Execute(Session session, CommandLine line)
        {
            session.WriteLine("usage:");
            session.WriteLine("  <command> [patameters ...]");
            session.WriteLine();

            session.WriteLine("commands:");

            var mapper = session.GetCommandMapper(line);
            if (mapper == null)
            {
                foreach (var m in session.Engine.MapperManager.GetCommandMappers())
                {
                    this.HelpFor(m, session, line);
                }
            }
            else
            {
                this.HelpFor(mapper, session, line);
                var parameterFormater = session.Engine.GetCommandMember(z => z.ParametersFormater);
                var ParameterParser = session.Engine.GetCommandMember(z => z.CommandParameterParser);
                session.WriteLine();
                session.WriteLine("parameters:");
                foreach (var formatedString in parameterFormater.Format(mapper, mapper.ExecutorBuilder.Mappers, ParameterParser))
                {
                    session.WriteLine("  " + formatedString);
                }
            }
        }

 public IUpdateProcess CreateProcess(CommandLine cmdline)
 {
     Version ver;
     var version = cmdline["version"];
     if(string.IsNullOrEmpty(version))
     {
         ver = new Version(0, 0, 0, 0);
     }
     else
     {
         if(!Version.TryParse(version, out ver))
         {
             ver = new Version(0, 0, 0, 0);
         }
     }
     var git = cmdline["git"];
     if(string.IsNullOrEmpty(git))
     {
         git = DetectGitExePath();
         if(string.IsNullOrEmpty(git)) return null;
     }
     var url = cmdline["url"];
     if(string.IsNullOrEmpty(url)) return null;
     var target = cmdline["target"];
     if(string.IsNullOrEmpty(target)) return null;
     bool skipVersionCheck = cmdline.IsDefined("skipversioncheck");
     return new UpdateFromGitRepositoryProcess(ver, git, url, target, skipVersionCheck);
 }

        private void Execute(CommandMapper mapper, CommandLine command)
        {
            var obj = mapper.CommandClassBuilder.Build();
            var executor = mapper.ExecutorBuilder.CreateExecutor(obj);
            foreach (var kvp in command.Parameters)
            {
                var r = executor.SetParameter(kvp.Key, kvp.Value, this.Engine.MapperManager.GetAgent());
                if (r.HasError)
                {
                    this.WriteLine(r);
                    return;
                }
            }
            var missing = executor.GetMissingParameters().ToArray();
            if (missing.Length != 0)
            {
                this.Engine.GetCommandMember(z => z.MissingParametersFormater)
                    .Format(this.Engine.GetCommandMember(z => z.Output), mapper, missing,
                        this.Engine.GetCommandMember(z => z.CommandParameterParser));
                this.Help(command);
                return;
            }

            executor.Execute(this, command);
        }

        static int Main( string[] args )
        {
            CommandLine     commandLine = new CommandLine();
            int             returnVal = 0;

            try
            {
                commandLine.Parse( args );

                if( commandLine.Mode == SyncAppMode.RunEngine )
                {
                    RunSyncEngine( commandLine );
                }
                else if( commandLine.Mode == SyncAppMode.CreateConfigTemplate )
                {
                    CreateConfigTemplateFile( commandLine );
                }
            }
            catch( Exception e )
            {
                Console.Error.WriteLine( "Error: {0}", e.ToString() );
                returnVal = -1;
            }

            if( commandLine.PauseOnExit )
            {
                Console.WriteLine();
                Console.WriteLine( "Press any key to exit..." );
                Console.ReadKey( true );
            }

            return returnVal;
        }

 public void WithValidOption__GetOtherOption__ReturnNull()
 {
     string[] arguments = { "/keyfile:file" };
     var commandLine = new CommandLine(arguments);
     var option = commandLine.Option("union");
     Assert.IsNull(option);
 }

        public void Then_options_should_be_set_if_provided()
        {
            var commandLine = new CommandLine("exe -opt1:12 -opt4 -opt2:\"13\"");

            Assert.AreEqual(12, commandLine.Option1);
            Assert.AreEqual(13, commandLine.Option2);
        }

 public void WithEmptyOption__GetOption__ReturnEmptyString()
 {
     string[] arguments = { "/" };
     var commandLine = new CommandLine(arguments);
     var option = commandLine.Option("");
     Assert.IsEmpty(option);
 }

 public static void RunCommand(string[] inputArgs, CommandStatusWriter consoleOut)
 {
     using (CommandLine cmd = new CommandLine(consoleOut))
     {
         cmd.Run(inputArgs);
     }
 }

		/// <summary>
		/// This is the entry point into the DLL.  It parses the command line and
		/// delegates the work out to each program.
		/// </summary>
		/// <param name="commandLine">The commandline that invoked the program.  Usually
		/// this corresponds to System.Environment.CommandLine</param>
		/// <returns></returns>
		public static void DllMain(string commandLine)
		{
			CommandLine = new CommandLine();
			Parser parser = new Parser(commandLine, CommandLine);			
			parser.Parse();

			if(CommandLine.Help)
			{
				Console.WriteLine("This program is used to import blog data from other blogging programs.");
				Console.WriteLine("  Note that this program will modify your content directory so back it up.");
				Console.WriteLine("  Also, the program will require an internet connection in some instances, ");
				Console.WriteLine("  like importing comments from an external server.");
				Console.WriteLine( parser.GetHelpText() );
			}
			else
			{
				switch(CommandLine.Source)
				{
					case BlogSourceType.Radio:
						if(CommandLine.SourceDirectory !=  null && CommandLine.SourceDirectory.Length > 0
							&& CommandLine.ContentDirectory != null && CommandLine.ContentDirectory.Length > 0)
						{
							Console.WriteLine("Importing entries from Radio...");
							DasBlog.Import.Radio.EntryImporter.Import(
								CommandLine.SourceDirectory,
								CommandLine.ContentDirectory);
						}
						else
						{
							Console.WriteLine("Entries from Radio not imported because either source directory or content directory were not specified.");
						}
						
						if(CommandLine.UserID != null && CommandLine.UserID.Length > 0 
							&& CommandLine.ContentDirectory != null && CommandLine.ContentDirectory.Length > 0)

						{
							if(CommandLine.CommentServer != null && CommandLine.CommentServer.Length > 0)
							{
								Console.WriteLine("Defaulting to comment server {0}.  You may need to check your radio source.  radiocomments2, etc",DasBlog.Import.Radio.CommentImporter.DefaultCommentServer);
							}

							Console.WriteLine("BETA: Importing comments from Radio...");
							DasBlog.Import.Radio.CommentImporter.Import(
								CommandLine.UserID, CommandLine.ContentDirectory, CommandLine.CommentServer );
						}
						else
						{
							Console.WriteLine("Comments from Radio not imported because comment server, userid or content directory were not specified.");
						}


						break;
					case BlogSourceType.none:
						goto default;
					default:
						throw new ApplicationException(
							string.Format("The source option was not specified or else was invalid."));
				}
			}
		}

        public static CommandLine Load(ICollection<string> args)
        {
            var assembly = Assembly.GetExecutingAssembly();
            var info = FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion;
            Console.WriteLine(Resources.Splash, info);
            if (null == args)
            {
                return new CommandLine();
            }

            var result = new CommandLine(args);
            if (!result.Help)
            {
                Console.WriteLine(string.Empty);
                Console.WriteLine(Resources.Usage);
                Console.WriteLine(string.Empty);
                Console.WriteLine(Resources.UsageDetails);
                Console.WriteLine(string.Empty);
                Console.WriteLine(Resources.Parameters);
                Console.WriteLine(string.Empty);
                Console.WriteLine(Resources.ParametersHelp);
                Console.WriteLine(Resources.ParametersInfo);
                Console.WriteLine(string.Empty);
                Console.WriteLine(Resources.HelpLink);
            }

            return result;
        }