public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
var template = _templateLocator.Get("EntityServiceBuilder");
var tokens = new TokensBuilder()
.With(nameof(request.EntityName), (Token)request.EntityName)
.With(nameof(request.Directory), (Token)request.Directory)
.Build();
var result = _templateProcessor.Process(template, tokens);
var entityNameSnakeCase = _templateProcessor.Process("{{ entityNameSnakeCase }}", tokens);
var filename = $"{entityNameSnakeCase}.service.ts";
if (_fileSystem.Exists($@"{request.Directory}/{filename}"))
{
if (request.Force)
{
System.IO.File.Delete($@"{request.Directory}/{filename}");
System.IO.File.Delete($@"{request.Directory}/{entityNameSnakeCase}.service.spec.ts");
}
else
{
return(new());
}
}
_commandService.Start($"ng g s {entityNameSnakeCase}", request.Directory);
_fileSystem.WriteAllLines($@"{request.Directory}/{filename}", result);
return(new());
}
public void SolveDoubleHexTest()
{
var lexer = new Mock <ILexer>();
var parser = new Mock <IParser>();
var simplifier = new Mock <ISimplifier>();
var strExp = "1 + 1";
var exp = new Add(new Number(1), new Number(1));
var tokens = new TokensBuilder()
.Number(2)
.Operation(Operations.Addition)
.Number(1)
.Tokens;
lexer.Setup(l => l.Tokenize(strExp)).Returns(() => tokens);
parser.Setup(p => p.Parse(tokens)).Returns(() => exp);
simplifier.Setup(s => s.Analyze(It.IsAny <Add>())).Returns <Add>(e => e);
var processor = new Processor(lexer.Object, parser.Object, simplifier.Object, null)
{
NumeralSystem = NumeralSystem.Hexidecimal
};
var result = processor.Solve <StringResult>(strExp);
lexer.Verify(l => l.Tokenize(It.IsAny <string>()), Times.Once());
parser.Verify(p => p.Parse(It.IsAny <IEnumerable <IToken> >()), Times.Once());
Assert.Equal("0x2", result.Result);
}
public void ParseBoolTest()
{
var lexer = new Mock <ILexer>();
var parser = new Mock <IParser>();
var tokens = new TokensBuilder()
.VariableX()
.Operation(Operations.Addition)
.Number(1)
.Tokens;
lexer.Setup(l => l.Tokenize("x + 1")).Returns(() => tokens);
var exp = new Add(Variable.X, new Number(1));
parser.Setup(p => p.Parse(tokens)).Returns(() => exp);
var processor = new Processor(lexer.Object, parser.Object, null, null);
var result = processor.Parse("x + 1");
lexer.Verify(l => l.Tokenize(It.IsAny <string>()), Times.Once());
parser.Verify(p => p.Parse(It.IsAny <IEnumerable <IToken> >()), Times.Once());
Assert.Equal(exp, result);
}
public void SolveStringTest()
{
var lexer = new Mock <ILexer>();
var parser = new Mock <IParser>();
var simplifier = new Mock <ISimplifier>();
var strExp = "x := 1";
var exp = new Define(Variable.X, new Number(1));
var tokens = new TokensBuilder()
.Function(Functions.Define, 2)
.OpenBracket()
.VariableX()
.Comma()
.Number(1)
.CloseBracket()
.Tokens;
lexer.Setup(l => l.Tokenize(strExp)).Returns(() => tokens);
parser.Setup(p => p.Parse(tokens)).Returns(() => exp);
simplifier.Setup(s => s.Analyze(It.IsAny <Define>())).Returns <Define>(e => e);
var processor = new Processor(lexer.Object, parser.Object, simplifier.Object, null);
var result = processor.Solve <StringResult>(strExp);
lexer.Verify(l => l.Tokenize(It.IsAny <string>()), Times.Once());
parser.Verify(p => p.Parse(It.IsAny <IEnumerable <IToken> >()), Times.Once());
Assert.Equal("The value '1' was assigned to the variable 'x'.", result.Result);
}
public void SolveBoolTest()
{
var lexer = new Mock <ILexer>();
var parser = new Mock <IParser>();
var simplifier = new Mock <ISimplifier>();
var strExp = "true & false";
var exp = new And(new Bool(true), new Bool(false));
var tokens = new TokensBuilder()
.True()
.Operation(Operations.And)
.False()
.Tokens;
lexer.Setup(l => l.Tokenize(strExp)).Returns(() => tokens);
parser.Setup(p => p.Parse(tokens)).Returns(() => exp);
simplifier.Setup(s => s.Analyze(It.IsAny <And>())).Returns <And>(e => e);
var processor = new Processor(lexer.Object, parser.Object, simplifier.Object, null);
var result = processor.Solve <BooleanResult>(strExp);
lexer.Verify(l => l.Tokenize(It.IsAny <string>()), Times.Once());
parser.Verify(p => p.Parse(It.IsAny <IEnumerable <IToken> >()), Times.Once());
Assert.False(result.Result);
}
public void SolveComplexTest()
{
var lexer = new Mock <ILexer>();
var parser = new Mock <IParser>();
var simplifier = new Mock <ISimplifier>();
var strExp = "conjugate(2.3 + 1.4i)";
var complex = new Complex(2.3, 1.4);
var exp = new Conjugate(new ComplexNumber(complex));
var tokens = new TokensBuilder()
.Function(Functions.Conjugate, 1)
.OpenBracket()
.Number(2.3)
.Operation(Operations.Addition)
.Number(1.4)
.Operation(Operations.Multiplication)
.Variable("i")
.CloseBracket()
.Tokens;
lexer.Setup(l => l.Tokenize(strExp)).Returns(() => tokens);
parser.Setup(p => p.Parse(tokens)).Returns(() => exp);
simplifier.Setup(s => s.Analyze(It.IsAny <Conjugate>())).Returns <Conjugate>(e => e);
var processor = new Processor(lexer.Object, parser.Object, simplifier.Object, null);
var result = processor.Solve <ComplexNumberResult>(strExp);
lexer.Verify(l => l.Tokenize(It.IsAny <string>()), Times.Once());
parser.Verify(p => p.Parse(It.IsAny <IEnumerable <IToken> >()), Times.Once());
Assert.Equal(Complex.Conjugate(complex), result.Result);
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
var template = _templateLocator.Get(nameof(IntlBuilder));
var tokens = new TokensBuilder()
.With(nameof(request.Name), (Token)request.Name)
.Build();
var lines = _templateProcessor.Process(template, tokens);
_fileSystem.WriteAllLines($"{request.Directory}{Path.DirectorySeparatorChar}{((Token)request.Name).SnakeCase}-intl.ts", lines);
return(new());
}
public Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
Settings settings = _settingsProvider.Get(request.Directory);
var tokens = new TokensBuilder()
.With(nameof(request.EntityName), (Token)request.EntityName)
.With(nameof(request.Directory), (Token)request.Directory)
.Build();
var result = new List <string>()
{
_templateProcessor.Process("export type {{ entityNamePascalCase }} = {", tokens)
};
var modelsDirectory = $"{settings.DomainDirectory}{Path.DirectorySeparatorChar}Models";
foreach (var path in Directory.GetFiles(modelsDirectory, $"{((Token)request.EntityName).PascalCase}.cs", SearchOption.AllDirectories))
{
foreach (var line in File.ReadAllLines(path))
{
if (line.Contains("public string") || line.Contains("public Guid"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: string,");
}
if (line.Contains("public int") || line.Contains("public double"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: number,");
}
if (line.Contains("public bool"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: boolean,");
}
}
}
result.Add("};");
var filePath = _templateProcessor.Process("{{ directory }}//{{ entityNameSnakeCase }}.ts", tokens);
if (System.IO.File.Exists(filePath) && request.Force == false)
{
return(Task.FromResult(new Unit()));
}
_fileWriter.WriteAllLines(filePath, result.ToArray());
return(Task.FromResult(new Unit()));
}
public void SolveExpTest()
{
var lexer = new Mock <ILexer>();
var parser = new Mock <IParser>();
var simplifier = new Mock <ISimplifier>();
var differentiator = new Mock <IDifferentiator>();
var strExp = "deriv(x)";
var exp = new Derivative(differentiator.Object, simplifier.Object, Variable.X, Variable.X);
var diff = new Number(1);
var tokens = new TokensBuilder()
.Function(Functions.Derivative, 1)
.OpenBracket()
.VariableX()
.CloseBracket()
.Tokens;
lexer.Setup(l => l.Tokenize(strExp)).Returns(() => tokens);
parser.Setup(p => p.Parse(tokens)).Returns(() => exp);
simplifier.Setup(s => s.Analyze(It.IsAny <Number>())).Returns <Number>(e => e);
simplifier.Setup(s => s.Analyze(It.IsAny <Derivative>())).Returns <Derivative>(e => e);
differentiator.Setup(d => d.Analyze(It.IsAny <Derivative>())).Returns(() => diff);
differentiator.SetupProperty(d => d.Variable);
differentiator.SetupProperty(d => d.Parameters);
var processor = new Processor(lexer.Object, parser.Object, simplifier.Object, differentiator.Object);
var result = processor.Solve <ExpressionResult>(strExp);
lexer.Verify(l => l.Tokenize(It.IsAny <string>()), Times.Once());
parser.Verify(p => p.Parse(It.IsAny <IEnumerable <IToken> >()), Times.Once());
Assert.Equal(new Number(1), result.Result);
}
// 解析エラーがある場合は null を返す
// 「null 以外を返す AND 戻り値の Count != 0 ⇔ 正常な Expr である」が成り立っている
public static IReadOnlyList <Tokens.IToken> ToTokens(string text)
{
var tokensBuilder = new TokensBuilder();
foreach (var c in text)
{
if (char.IsWhiteSpace(c))
{
if (!tokensBuilder.TryAddSpace())
{
return(null);
}
continue;
}
if (c == '\r' || c == '\n')
{
if (!tokensBuilder.TryAddLineBreak())
{
return(null);
}
continue;
}
if (c == '+' || c == '＋')
{
if (!tokensBuilder.TryAddPlus())
{
return(null);
}
continue;
}
if (c == '-' || c == '－')
{
if (!tokensBuilder.TryAddMinus())
{
return(null);
}
continue;
}
if (c == 'd' || c == 'D' || c == 'ｄ' || c == 'Ｄ')
{
if (!tokensBuilder.TryAddD())
{
return(null);
}
continue;
}
foreach (var(number, character) in numbers)
{
if (c.ToString() == character.ToString())
{
if (!tokensBuilder.TryAddNumber(number))
{
return(null);
}
goto Continue;
}
}
return(null);
Continue :;
}
return(tokensBuilder.FinishOrDefault());
}
