using System;

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using CommandLineParser.Arguments;
using CommandLineParser.Exceptions;
using Moq;
using NUnit.Framework;
namespace CodeChallange1_800
{
class Program
{
static void Main(string[] args)
{
var factory = new Factory();
var workflow = factory.NewWorkflow();
workflow.Run(args);
}
}
[TestFixture]
public class WorkFlowTest
{
private Mock<IParser<IArgumentsValues>> _parser;
private Mock<IFactory> _factory;
private WorkFlow _workFlow;
[SetUp]
public void SetUp()
{
_factory = new Mock<IFactory>();
var arguments = Mock.Of<IArgumentsValues>();
_parser = new Mock<IParser<IArgumentsValues>>();
_parser.Setup(x => x.Parse()).Returns(arguments);
_parser.Setup(x => x.Usage).Returns("Special usage");
_factory.Setup(x => x.CommandLineParser)
.Returns(_parser.Object);
_workFlow = new WorkFlow(_factory.Object);
}
[Test]
public void PassesTheArgumentsToTheParser()
{
var args = new[] { "-I", "-O" };
WhenRan(args);
_parser.Verify(x => x.ReadArgs(args), "Parser.ReadArgs");
}
[Test]
public void ShowsHelpWithNoArgs()
{
WithAShowHelpCommandLine();
WhenRan();
_parser.Verify(x => x.Usage, "Help displayed");

}
[Test]
public void DoesNotShowTheHelpWithValidArguments()
{
WhenRan();
_parser.Verify(x=>x.Usage, Times.Never(), "Help displayed");
}
private void WithAShowHelpCommandLine()
{
_parser.SetupGet(x => x.UsageShouldBeDisplayed).Returns(true);
}
private void WhenRan(params string[] args)
{
_workFlow.Run(args);
}
}
public class WorkFlow
{
private readonly IFactory _factory;
private readonly IParser<IArgumentsValues> _commandLineParser;
public WorkFlow(IFactory factory)
{
_factory = factory;
_commandLineParser = _factory.CommandLineParser;
}
public void Run(string[] args)
{
_commandLineParser.ReadArgs(args);
if (_commandLineParser.UsageShouldBeDisplayed)
{
ShowHelp(_commandLineParser.Usage);
return;
}
Run(_commandLineParser.Parse());
}
private void Run(IArgumentsValues arguments)
{
var inputRunner = new FileFactory(arguments.InputFile);
var inputContent = inputRunner.FileRunner().Read();
var dictionaryRunner = new FileFactory(arguments.DictionaryFile);
var dicitonaryInput = dictionaryRunner.FileRunner().Read();
//var processor = new Processor(inputContent, dicitonaryInput);
//var result = processor.Process();
//Display(result);
}
private static void ShowHelp(string usage)

{
Console.Write(usage);
}
}
public class FileFactory : IFileFactory
{
private readonly FileInfo _inputFileType;
public FileFactory(FileInfo inputFileType)
{
_inputFileType = inputFileType;
}
public IInputReader FileRunner()
{
if (_inputFileType == null)
{
return new ConsoleInputReader();
}
return new FileInputReader(_inputFileType);
}
}
public class Factory : IFactory
{
private readonly Parser<IArgumentsValues> _finalParser;
public Factory()
{
var arguments = new Arguments();
_finalParser = new Parser<IArgumentsValues>(arguments);
}
public IParser<IArgumentsValues> CommandLineParser
{
get { return _finalParser; }
}
internal WorkFlow NewWorkflow()
{
return new WorkFlow(this);
}
}
public class FileInputReader : IInputReader
{
private readonly FileInfo _inputFileInfo;
public FileInputReader(FileInfo inputFileInfo)
{
_inputFileInfo = inputFileInfo;
}
public string Read()
{
return File.ReadAllText(_inputFileInfo.FullName);
}
}

public class ConsoleInputReader : IInputReader

{
public string Read()
{
return Console.ReadLine();
}
}
public interface IInputReader
{
string Read();
}
public interface IFileFactory
{
IInputReader FileRunner();
}
public interface IFactory
{
IParser<IArgumentsValues> CommandLineParser { get; }
}
public interface ICommandLine
{
string CommandLine { get; }
}
public interface IParser<T> : ICommandLine
{
string Usage { get; }
bool UsageShouldBeDisplayed { get; }
void ReadArgs(string[] args);
T Parse();
}
public class
{
internal
internal
internal

TestArguments : IArgumentsConfig<object>
const char UserShortName = 'U';
const string UserLongName = "user";
static readonly string UserShortArg = "-" + UserShortName;

internal const char NumberShortName = 'N';

internal static readonly string NumberShortArg = "-" + NumberShortName;
internal readonly ValueArgument<string> User = new ValueArgument<string>
(UserShortName, UserLongName)
{
Optional = false
};
internal readonly ValueArgument<int> Number = new ValueArgument<int>(Num
berShortName, "number");
public IEnumerable<Argument> All
{
get { return new Argument[] {User, Number}; }
}

internal readonly object Output = new object();

public object AsOutput()
{
return Output;
}
}
[TestFixture]
public class ParserTest
{
private Parser<object> _parser;
private TestArguments _arguments;
[SetUp]
public void SetUp()
{
_arguments = new TestArguments();
_parser = null;
}
[Test]
public void PublishesTheUsageString()
{
GivenANewParser();
AssertIsUsage(_parser.Usage);
}
[Test]
public void ShowsUsageWithHelpArgs()
{
GivenANewParser();
_parser.ReadArgs(new [] { "--help"});
Assert.IsTrue(_parser.UsageShouldBeDisplayed, "Parser.UsageShouldBeD
isplayed");
}
[Test]
public void DoesNotShowUsageWithValidArgs()
{
ParseArgumentsWithUser();
Assert.IsFalse(_parser.UsageShouldBeDisplayed, "Parser.UsageShouldBe
Displayed");
}
[Test]
public void ByDefaultCommandLineIsEmpty()
{
GivenANewParser();
Assert.AreEqual("", _parser.CommandLine, "Command Line");
}
[Test]
public void KnowsTheActualCommandLineTextAfterAParsing()
{
var args = new[] {TestArguments.UserShortArg, "spoke", TestArguments
.NumberShortArg, "42"};
ParseArguments(args);

Assert.AreEqual(string.Join(" ", args), _parser.CommandLine, "Comman

d line");
}
[Test]
public void ActuallyParsesTheCommandLine()
{
const string User = "Bob";
const int Number = 12;
ParseArguments(TestArguments.UserShortArg, User, TestArguments.Numbe
rShortArg, Number.ToString());
Assert.AreEqual(User, _arguments.User.Value, "Parsed user argument")
;
Assert.AreEqual(Number, _arguments.Number.Value, "Parsed number argu
ment");
}
[Test, ExpectedException(typeof(InvalidConversionException))]
public void ThrowsWhenAParsingErrorOccurs()
{
ParseArgumentsWithUser(TestArguments.NumberShortArg, "malformed numb
er ...");
}
[Test]
public void CreatesTheOutputOnSuccessfulParsing()
{
Assert.AreEqual(_arguments.Output, ParseArgumentsWithUser(), "Output
built by the parser");
}
[Test]
public void HandlesUperCaseArguments()
{
const string User = "Client";
ParseArguments("-" + TestArguments.UserLongName.ToUpper(), User);
Assert.AreEqual(User, _arguments.User.Value, "User specified with up
case argument name");
}
private object ParseArgumentsWithUser(params string[] extraArgs)
{
var allArgs = new List<string> { TestArguments.UserShortArg, "Jimmy"
};
allArgs.AddRange(extraArgs);
return ParseArguments(allArgs.ToArray());
}
private object ParseArguments(params string[] args)
{
GivenANewParser();
_parser.ReadArgs(args);
return _parser.Parse();
}

private void GivenANewParser()

{
_parser = new Parser<object>(_arguments);
}
private static void AssertIsUsage(string text)
{
Assert.That(text, Is.StringStarting("Usage:"), "Command line usage")
;
Assert.That(text, Is.StringContaining(TestArguments.UserShortArg), "
Command line usage");
Assert.That(text, Is.StringContaining(TestArguments.NumberShortArg),
"Command line usage");
}
}
public class Parser<T> : IParser<T>
{
public const int SuccessExitCode = 0;
public const int FailureExitCode = -1;
private readonly CommandLineParser.CommandLineParser _parser;
private readonly IArgumentsConfig<T> _arguments;
private string[] _args = new string[0];
internal Parser(IArgumentsConfig<T> arguments)
{
_arguments = arguments;
_parser = new CommandLineParser.CommandLineParser();
_parser.IgnoreCase = true;
_parser.Arguments.AddRange(_arguments.All);
}
public string Usage
{
get
{
TextWriter str = new StringWriter();
_parser.PrintUsage(str);
return str.ToString().Trim();
}
}
public string CommandLine
{
get { return String.Join(" ", _args); }
}
public T Parse()
{
_parser.ParseCommandLine(_args);
return _arguments.AsOutput();
}
public void ReadArgs(string[] args)
{
_args = args;

}
public bool UsageShouldBeDisplayed
{
get { return (_args.Contains("--help") || _args.Contains("/help") ||
_args.Contains("/?")); }
}
}
public class Arguments : IArgumentsConfig<IArgumentsValues>, IArgumentsValue
s
{
// short names already in use in AggregLauncher
private const char InputFileShortName = 'I';
private const char DictionaryShortName = 'D';
internal const string InputFileLongName = "input-file";
internal const string DictionaryLongName = "dictionary-file";
private readonly FileArgument _inputFile;
private readonly FileArgument _dictionaryFile;
public Arguments()
{
_inputFile = new FileArgument(InputFileShortName, InputFileLongName,
Help.InputFileArgument);
_dictionaryFile = new FileArgument(DictionaryShortName, DictionaryLo
ngName,
Help.DictionaryFileArgument)
{
DefaultValue = new FileInfo("defaultDictionary")
};
}
public IEnumerable<Argument> All
{
get
{
return GetType().GetFields(BindingFlags.Instance | BindingFlags.
NonPublic)
.Select(field => field.GetValue(this)).OfType<Argument>().To
List();
}
}
public FileInfo InputFile { get { return _inputFile.Value; } }
public FileInfo DictionaryFile { get { return _dictionaryFile.Value; } }
public IArgumentsValues AsOutput()
{
return this;
}
}
[TestFixture]
public class ArgumentsTest
{
private Arguments _arguments;

[SetUp]
public void SetUp()
{
_arguments = new Arguments();
}
[Test]
public void AllCollectsAllArguments()
{
AssertArgument<FileArgument>(Arguments.InputFileLongName);
AssertArgument<FileArgument>(Arguments.DictionaryLongName);
}
private void AssertArgument<T>(string longName) where T : Argument
{
var argument = FindArgument(longName);
Assert.IsNotNull(argument, "there should be an argument " + longName
);
Assert.IsInstanceOf(typeof(T), argument, "argument " + longName);
}
private Argument FindArgument(string longName)
{
return _arguments.All.First(x => x.LongName == longName);
}
[Test]
public void AllArgumentsShouldHaveDifferentShortNames()
{
var shortNames = _arguments.All.Select(x => x.ShortName).Where(x =>
x != ' ');
Assert.AreEqual(shortNames, shortNames.Distinct(), "distinct short n
ames");
}
[Test]
public void AllArgumentsShouldHaveDifferentLongNames()
{
var longNames = _arguments.All.Select(x => x.LongName);
Assert.AreEqual(longNames, longNames.Distinct(), "distinct long name
s");
}
[Test]
public void PropertiesHaveTheValueOfTheCorrespondingArguments()
{
InputFileArgument.Value = new FileInfo("inputFileName");
Assert.AreEqual(InputFileArgument.Value, _arguments.InputFile, "Argu
ments.InputFileName");
DictionaryFileArgument.Value = new FileInfo("dictionaryFileName");
Assert.AreEqual(DictionaryFileArgument.Value, _arguments.DictionaryF
ile,
"Arguments.DictionaryFileName");
}
[Test]
public void DictionaryArgumentIsDefaultDictionaryByDedfault()

{
Assert.AreEqual(new FileInfo("defaultDictionary").FullName, Dictiona
ryFileArgument.DefaultValue.FullName,
"DictionaryFileArgument default value");
}
[Test]
public void ReturnsItselfAsOutput()
{
Assert.AreSame(_arguments, _arguments.AsOutput(), "Arguments.AsOutpu
t");
}
private FileArgument DictionaryFileArgument
{
get { return (FileArgument)FindArgument(Arguments.DictionaryLongName
); }
}
private FileArgument InputFileArgument
{
get { return (FileArgument)FindArgument(Arguments.InputFileLongName)
; }
}
}
public interface IArgumentsConfig<T>
{
IEnumerable<Argument> All { get; }
T AsOutput();
}
public interface IArgumentsValues
{
FileInfo InputFile { get; }
FileInfo DictionaryFile { get; }
}
public static class Help
{
internal static readonly string InputFileArgument = Format(
"Input file argument");
internal static readonly string DictionaryFileArgument = Format(
"Dictionary file argument");
private static string Format(params string[] lines)
{
return String.Join("\r\n\t\t", lines);
}
}
}