/// <summary>
/// constructor
/// </summary>
/// <param name="parser">the file parser</param>
public Script(IFileParser parser)
: base(parser)
{
CurrentLineNumber = 0;
ActionLines = new List<ActionLine>();
Parser.WorkingDir = Parser.WorkingDir + Constants.Directory.ScriptDir;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="parser">the file parser</param>
public Interface(IFileParser parser)
: base(parser)
{
Properties = new Dictionary<string, string>();
Controls = new Dictionary<string, Dictionary<string, string>>();
Parser.WorkingDir = Parser.WorkingDir + Constants.Directory.InterfaceDir;
}
public Program(CommandLineArgs arguments, Configuration configuration, IFileParser fileParser, IApplicationType applicationType)
{
Arguments = arguments;
Configuration = configuration;
FileParser = fileParser;
ApplicationType = applicationType;
}
public bool ProcessLine(IFileParser parser, FileParserContext context, string line, bool isBeforeCode)
{
if (!IsDirective(line)) return false;
if (!isBeforeCode && IgnoreAfterCode) return true;
return ProcessLine(parser, context, line);
}
/// <summary>
/// construct an Automation Engine
/// </summary>
/// <param name="parser">the file parser</param>
/// <param name="workingDir">the working directory</param>
public Automation(IFileParser parser, IReporter reporter, string workingDir = "")
: this(workingDir)
{
Parser = parser;
Parser.WorkingDir = WorkingDir;
Reporter = reporter;
Reporter.WorkingDir = WorkingDir;
}
public ConsoleApp(CommandLineArgs arguments, Config configuration, IFileParser fileParser, IDrawer drawer,
IWordPreparer wordPreparer, ISaver imageSaver)
{
_args = arguments;
_config = configuration;
_parser = fileParser;
_drawer = drawer;
_wordPreparer = wordPreparer;
_imageSaver = imageSaver;
}
public void ShouldReturnTrueOnReferenceLine(IFileParser parser, ReferenceLineProcessor processor)
{
// Arrange
const string Line = @"#r ""MyDll.dll""";
// Act
var result = processor.ProcessLine(parser, new FileParserContext(), Line, true);
// Assert
result.ShouldBeTrue();
}
public void SetUp()
{
_fileSystemService = MockRepository.GenerateMock<IFileSystemService>();
_fileParser = new FileParser(_fileSystemService);
_files = new List<string>
{
"file1",
"file2"
};
}
public void ShouldReturnFalseOtherwise(IFileParser parser, UsingLineProcessor processor)
{
// Arrange
const string UsingLine = @"using (var x = new Disposable())";
// Act
var result = processor.ProcessLine(parser, new FileParserContext(), UsingLine, true);
// Assert
result.ShouldBeFalse();
}
public void ShouldReturnTrueOnUsingLine(IFileParser parser, UsingLineProcessor processor)
{
// Arrange
const string UsingLine = @"using ""System.Data"";";
// Act
var result = processor.ProcessLine(parser, new FileParserContext(), UsingLine, true);
// Assert
result.ShouldBeTrue();
}
public void ShouldIgnoreAliases(IFileParser parser, UsingLineProcessor processor)
{
// Arrange
const string UsingLine = @"using Path = ""System.IO.Path"";";
// Act
var result = processor.ProcessLine(parser, new FileParserContext(), UsingLine, true);
// Assert
result.ShouldBeFalse();
}
public void ShouldReturnFalseOtherwise(IFileParser parser, ShebangLineProcessor processor)
{
// Arrange
const string Line = @"var x = new Test();";
// Act
var result = processor.ProcessLine(parser, new FileParserContext(), Line, true);
// Assert
result.ShouldBeFalse();
}
public void ShouldReturnTrueOnLoadLine(IFileParser parser, LoadLineProcessor processor)
{
// Arrange
const string Line = @"#load ""script.csx""";
// Act
var result = processor.ProcessLine(parser, new FileParserContext(), Line, true);
// Assert
result.ShouldBeTrue();
}
public void ShouldReturnTrueOnShebangLine(IFileParser parser, ShebangLineProcessor processor)
{
// Arrange
const string Line = @"#!/usr/bin/env scriptcs";
// Act
var result = processor.ProcessLine(parser, new FileParserContext(), Line, true);
// Assert
result.ShouldBeTrue();
}
protected override bool ProcessLine(IFileParser parser, FileParserContext context, string line)
{
var url = GetDirectiveArgument(line);
var client = new HttpClient();
var response = client.GetStringAsync(url).Result;
parser.ParseScript(response.Split(Environment.NewLine.ToCharArray()).ToList(), context);
return true;
}
public void SetUp()
{
_splitter = new Mock<ISegmentSplitter>();
_documentParser = new Mock<IDocumentParser>();
_docsRepo = new Mock<IIncomingDocumentsRepository>();
_resolver = new Mock<IBusinessPartnerSpecificServiceResolver>();
_reader = new Mock<IEdiFileReader>();
_generator = new Mock<IMessageGenerator>();
_reader.Setup(r => r.Read(It.IsAny<EdiSegmentCollection>())).Returns(new EdiFileInfo(null));
_sut = new FedexFileParser(_splitter.Object, _reader.Object, _generator.Object);
}
public void ShouldAddNamespaceToContext(IFileParser parser, UsingLineProcessor processor)
{
// Arrange
const string UsingLine = @"using ""System.Data"";";
var context = new FileParserContext();
// Act
processor.ProcessLine(parser, context, UsingLine, true);
// Assert
context.Namespaces.Count.ShouldEqual(1);
}
public bool ProcessLine(IFileParser parser, FileParserContext context, string line, bool isBeforeCode)
{
if (!IsUsingLine(line)) return false;
var @namespace = GetNamespace(line);
if (!context.Namespaces.Contains(@namespace))
{
context.Namespaces.Add(@namespace);
}
return true;
}
protected override bool ProcessLine(IFileParser parser, FileParserContext context, string line)
{
var gistId = GetDirectiveArgument(line);
var files = _Downloader.DownloadGistFiles(gistId);
foreach (var file in files)
{
parser.ParseFile(file, context);
}
return true;
}
protected override bool ProcessLine(IFileParser parser, FileParserContext context, string line)
{
var argument = GetDirectiveArgument(line);
var assemblyPath = Environment.ExpandEnvironmentVariables(argument);
var referencePath = _fileSystem.GetFullPath(assemblyPath);
if (!string.IsNullOrWhiteSpace(referencePath) && !context.References.Contains(referencePath))
{
context.References.Add(referencePath);
}
return true;
}
/// <summary>
/// Gets the text file using a file parser.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="parser">The parser.</param>
/// <returns></returns>
public static string GetTextFile(string path, IFileParser parser)
{
if (Exists(path))
{
return Get(path).ToString();
}
else
{
string data = parser.Parse(path);
Add(data, path);
return data;
}
}
protected override bool ProcessLine(IFileParser parser, FileParserContext context, string line)
{
var argument = GetDirectiveArgument(line);
var filePath = Environment.ExpandEnvironmentVariables(argument);
var fullPath = _fileSystem.GetFullPath(filePath);
if (!string.IsNullOrWhiteSpace(fullPath))
{
parser.ParseFile(fullPath, context);
}
return true;
}
public CalculatorService(IFile file, IFileParser parser, ICruncherAutomator automator)
{
if (file == null)
throw new ArgumentNullException(nameof(file));
if (parser == null)
throw new ArgumentNullException(nameof(parser));
if (automator == null)
throw new ArgumentNullException(nameof(automator));
_file = file;
_parser = parser;
_automator = automator;
}
public void ShouldExpandEnvironmentVariables(
[Frozen] Mock<IFileSystem> fileSystem,
LoadLineProcessor processor,
IFileParser parser)
{
// Arrange
var context = new FileParserContext();
var line = string.Format("#load %{0}%", EnvVarKey);
// Act
processor.ProcessLine(parser, context, line, true);
// Assert
fileSystem.Verify(x => x.GetFullPath(EnvVarValue));
}
public void ShouldThrowExceptionIfAfterCode(
[Frozen] Mock<IFileSystem> fileSystem,
ReferenceLineProcessor processor,
IFileParser parser)
{
// Arrange
var context = new FileParserContext();
const string RelativePath = "..\\script.csx";
const string Line = @"#r " + RelativePath;
const string FullPath = "C:\\script.csx";
fileSystem.Setup(x => x.GetFullPath(RelativePath)).Returns(FullPath);
// Act / Assert
Assert.Throws(typeof(InvalidDirectiveUseException), () => processor.ProcessLine(parser, context, Line, false));
}
public bool ProcessLine(IFileParser parser, FileParserContext context, string line, bool isBeforeCode)
{
Guard.AgainstNullArgument("context", context);
if (!IsUsingLine(line))
{
return false;
}
var @namespace = GetNamespace(line);
if (!context.Namespaces.Contains(@namespace))
{
context.Namespaces.Add(@namespace);
}
return true;
}
public bool ProcessLine(IFileParser parser, FileParserContext context, string line, bool isBeforeCode)
{
if (context == null) throw new ArgumentNullException("context");
if (!IsUsingLine(line))
{
return false;
}
var @namespace = GetNamespace(line);
if (!context.Namespaces.Contains(@namespace))
{
context.Namespaces.Add(@namespace);
}
return true;
}
public void ShouldAddReferenceToContext(
[Frozen] Mock<IFileSystem> fileSystem,
ReferenceLineProcessor processor,
IFileParser parser)
{
// Arrange
var context = new FileParserContext();
const string RelativePath = "..\\Assembly.dll";
const string Line = @"#r " + RelativePath;
const string FullPath = "C:\\Assembly.dll";
fileSystem.Setup(x => x.GetFullPath(RelativePath)).Returns(FullPath);
// Act
processor.ProcessLine(parser, context, Line, true);
// Assert
context.References.Count.ShouldEqual(1);
}
public bool ProcessLine(IFileParser parser, FileParserContext context, string line, bool isBeforeCode)
{
if (!Matches(line))
{
return false;
}
if (!isBeforeCode)
{
if (BehaviorAfterCode == Contracts.BehaviorAfterCode.Throw)
{
throw new InvalidDirectiveUseException(string.Format("Encountered directive '{0}' after the start of code. Please move this directive to the beginning of the file.", DirectiveString));
}
else if (BehaviorAfterCode == Contracts.BehaviorAfterCode.Ignore)
{
return true;
}
}
return ProcessLine(parser, context, line);
}
public void ShouldAddReferenceByNameFromGACIfLocalFileDoesntExist(
[Frozen] Mock<IFileSystem> fileSystem,
ReferenceLineProcessor processor,
IFileParser parser)
{
// Arrange
var context = new FileParserContext();
var name = "script.csx";
var line = @"#r " + name;
var fullPath = "C:\\script.csx";
fileSystem.Setup(x => x.GetFullPath(name)).Returns(fullPath);
fileSystem.Setup(x => x.FileExists(fullPath)).Returns(false);
// Act
var result = processor.ProcessLine(parser, context, line, true);
// Assert
context.References.Count(x => x == name).ShouldEqual(1);
}
