private void Load()
{
// Pre clean up
_directoryChangeNotifier.ClearListeners();
var configData = Config.Load(DTE.Solution.GetDirectory());
foreach (var settingData in configData?.TriggerGroups)
{
string generatorPath = configData.GetGeneratorPath(settingData.GeneratorName);
AssemblyExtensions.CopyDlls(generatorPath, DTE.Solution.GetDirectory());
if (settingData.Triggers.Count == 0)
{
continue;
}
Project project = DTE.Solution.FindProject(settingData.UniqueProjectName);
var directoryChangeListener = FactoryMethods.GetRelativeDirectoryChangeListener(project.GetDirectory());
var generatorRunner = new GeneratorRunner(generatorPath,
settingData.UniqueProjectName, settingData.EntitasCfgPath, settingData.EntitasUserCfgPath);
directoryChangeListener.Add(settingData.Triggers.ToArray());
directoryChangeListener.Changed += () => generatorRunner.Run();
_directoryChangeNotifier.AddListener(directoryChangeListener);
}
}
public override bool Execute(string[] arguments)
{
const string url = "http://localhost:8082/";
BookGenArgumentBase args = new BookGenArgumentBase();
if (!ArgumentParser.ParseArguments(arguments, args))
{
return(false);
}
using (var server = HttpServerFactory.CreateServerForPreview(CurrentState.Log, CurrentState.ServerLog, args.Directory))
{
server.Start();
CurrentState.Log.Info("-------------------------------------------------");
CurrentState.Log.Info("Test server running on: {0}", url);
CurrentState.Log.Info("Serving from: {0}", args.Directory);
if (Program.AppSetting.AutoStartWebserver)
{
GeneratorRunner.StartUrl(url);
}
Console.WriteLine(GeneratorRunner.ExitString);
Console.ReadLine();
server.Stop();
}
return(true);
}
public void GenerateParserConfig()
{
var errorReporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".table")).Returns("Buffalo.Core.Parser.Configuration.AutoConfigParser.table");
GeneratorRunner.Run <ParserGenerator>(ParserTestFiles.Parser(), errorReporter.Object, environment.Object);
}
public void UnknownVisibility()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns((string)null);
reporter.Setup(x => x.AddError(3, 14, 3, 16, "'BOB' is not a valid visibility.")).Verifiable();
GeneratorRunner.Run <LexerGenerator>(
LexerTestFiles.UnknownVisibility(),
reporter.Object,
environment.Object);
}
public void UnknownOption()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(1, 1, 1, 8, "'Disarray' is not a recognised option.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.UnknownOption(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void UndefinedProduction()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(1, 9, 1, 11, "The non-terminal <B> is not defined.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.UndefinedProduction(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void ReduceReduceConflict()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(10, 1, 10, 3, "<B> -> causes a reduce-reduce conflict with <A> -> a.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.ReduceReduceConflict(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void ReduceAcceptConflict()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(6, 6, 6, 8, "<A> -> <A> causes a reduce-accept conflict.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.ReduceAcceptConflict(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void PseudoReachable()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(1, 1, 1, 1, "All accept actions were optomised away.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.ParserPseudoReachable(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public MainViewModel(GeneratorRunner runner)
{
_runner = runner;
WorkDirectory = _runner.WorkDirectory;
ValidateConfigCommand = new DelegateCommand(this, () => _runner.Initialize());
CleanOutDirCommand = new DelegateCommand(this, () => _runner.InitializeAndExecute(x => x.DoClean()));
BuildTestCommand = new DelegateCommand(this, () => _runner.InitializeAndExecute(x => x.DoTest()));
BuildReleaseCommand = new DelegateCommand(this, () => _runner.InitializeAndExecute(x => x.DoBuild()));
BuildPrintCommand = new DelegateCommand(this, () => _runner.InitializeAndExecute(x => x.DoPrint()));
BuildEpubCommand = new DelegateCommand(this, () => _runner.InitializeAndExecute(x => x.DoEpub()));
BuildWordpressCommand = new DelegateCommand(this, () => _runner.InitializeAndExecute(x => x.DoWordpress()));
HelpCommand = new DelegateCommand(this, () => _runner.RunHelp());
ExitCommand = new DelegateCommand(() => View?.ExitApp());
}
public void InvalidProductionArg()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(6, 15, 6, 16, "Invalid argument reference")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.InvalidProductionArg(),
reporter.Object,
environment.Object);
reporter.Verify();
}
private static void OnParseSuccess(Options options)
{
var generatorRunner = new GeneratorRunner(options);
// TODO: enable nullable
if (options.Exercise == null)
{
generatorRunner.RegenerateAllExercises();
}
else
{
generatorRunner.RegenerateSingleExercise(options.Exercise);
}
}
public void NoProductions()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(1, 1, 1, 1, "No productions defined.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.NoProductions(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void NoStates()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns((string)null);
reporter.Setup(x => x.AddError(1, 1, 1, 1, "No states defined.")).Verifiable();
GeneratorRunner.Run <LexerGenerator>(
LexerTestFiles.NoStates(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void DuplicatedSetting()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns((string)null);
reporter.Setup(x => x.AddWarning(3, 1, 3, 4, "Name has already been defined.")).Verifiable();
GeneratorRunner.Run <LexerGenerator>(
LexerTestFiles.DuplicatedSetting(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void UnknownSetting()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns((string)null);
reporter.Setup(x => x.AddError(3, 1, 3, 8, "'Disarray' is not a recognised option.")).Verifiable();
GeneratorRunner.Run <LexerGenerator>(
LexerTestFiles.UnknownSetting(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void MatchEmptyString()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns((string)null);
reporter.Setup(x => x.AddWarning(6, 2, 6, 5, "This regular expression claims to match the empty string, this is not supported and usually indicates a typeo in the regular expression")).Verifiable();
GeneratorRunner.Run <LexerGenerator>(
LexerTestFiles.MatchEmptyString(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void ReErrors()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns((string)null);
reporter.Setup(x => x.AddError(6, 2, 6, 4, "unexpected char '{' at position 0")).Verifiable();
GeneratorRunner.Run <LexerGenerator>(
LexerTestFiles.ReErrors(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void NoRules()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns((string)null);
reporter.Setup(x => x.AddError(4, 7, 4, 13, "The state 'INITIAL' does not define any rules.")).Verifiable();
GeneratorRunner.Run <LexerGenerator>(
LexerTestFiles.NoRules(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void DuplicateEntryPoints()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddWarning(2, 7, 2, 9, "The non-terminal <A> is already an entry point.")).Verifiable();
environment.Setup(x => x.GetResourceName(".table")).Returns((string)null);
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.DuplicateEntryPoints(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void ReDefinedDifferentType()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
reporter.Setup(x => x.AddError(8, 16, 8, 16, "This type conflicts with a previous definition of <NonTerminal>.")).Verifiable();
reporter.Setup(x => x.AddWarning(8, 1, 8, 13, "The non-terminal <NonTerminal> has already been defined.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.ReDefinedDifferentType(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void UnreachableNonTerminal()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".table")).Returns((string)null);
reporter.Setup(x => x.AddWarning(6, 1, 6, 3, "The non-terminal <B> is not reachable.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.UnreachableNonTerminal(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void DuplicateProduction()
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
environment.Setup(x => x.GetResourceName(".table")).Returns((string)null);
reporter.Setup(x => x.AddWarning(6, 1, 6, 3, "The non-terminal <A> has already been defined.")).Verifiable();
GeneratorRunner.Run <ParserGenerator>(
ParserTestFiles.DuplicateProduction(),
reporter.Object,
environment.Object);
reporter.Verify();
}
public void Generate(string setName)
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
var set = ParserTestFiles.GetNamedResourceSet(setName);
var builder = new StringBuilder("Buffalo.Core.Test.Parser.Generation.");
builder.Append(set.Code.ResourceName, ParserTestFiles.Namespace.Length, set.Code.ResourceName.Length - ParserTestFiles.Namespace.Length - 5);
builder.Append(".table");
environment.Setup(x => x.GetResourceName(".table")).Returns(builder.ToString());
GeneratorRunner.Run <ParserGenerator>(set, reporter.Object, environment.Object);
}
public override bool Execute(string[] arguments)
{
BookGenArgumentBase args = new BookGenArgumentBase();
if (!ArgumentParser.ParseArguments(arguments, args))
{
return(false);
}
GeneratorRunner runner = Program.CreateRunner(args.Verbose, args.Directory);
if (runner.Initialize(false))
{
runner.DoEditor();
return(true);
}
return(false);
}
public static void AssertGeneration(ResourceSet set, bool embedTable)
{
var reporter = new Mock <IErrorReporter>(MockBehavior.Strict);
var environment = new Mock <ICodeGeneratorEnv>(MockBehavior.Strict);
string expectedResourceName;
if (embedTable)
{
var builder = new StringBuilder("Buffalo.Core.Test.Lexer.Generation.");
builder.Append(set.Code.ResourceName, LexerTestFiles.Namespace.Length, set.Code.ResourceName.Length - LexerTestFiles.Namespace.Length - 5);
builder.Append(".{0}.table");
expectedResourceName = builder.ToString();
}
else
{
expectedResourceName = null;
}
environment.Setup(x => x.GetResourceName(".{0}.table")).Returns(expectedResourceName);
GeneratorRunner.Run <LexerGenerator>(set, reporter.Object, environment.Object);
}
