private NextSection AddDeclaration(NextSection current, Action <Declaration> mutator = null)
{
current.Section.Should().Be(Sections.Declaration);
return(NextSection(current.Section, () => new AddDeclaration {
FormId = current.Id, Declaration = DeclarationBuilder.NewValid(mutator)
}.Execute()));
}
public BestStartGrantBuilder WithCompletedSections(bool markAsCompleted = true)
{
With(f => f.Consent, ConsentBuilder.NewValid());
With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid());
With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid());
With(f => f.ExistingChildren, ExistingChildrenBuilder.NewValid());
With(f => f.ApplicantBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.PartnerBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.GuardianBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.GuardianPartnerBenefits, BenefitsBuilder.NewWithBenefit());
With(f => f.PartnerDetails, RelationDetailsBuilder.NewValid("partner"));
With(f => f.GuardianDetails, RelationDetailsBuilder.NewValid("guardian"));
With(f => f.GuardianPartnerDetails, RelationDetailsBuilder.NewValid("guardian partner"));
With(f => f.HealthProfessional, HealthProfessionalBuilder.NewValid());
With(f => f.PaymentDetails, PaymentDetailsBuilder.NewValid());
With(f => f.Evidence, EvidenceBuilder.NewValid());
With(f => f.Declaration, DeclarationBuilder.NewValid());
With(f => f.Started, DomainRegistry.NowUtc() - TimeSpan.FromHours(24));
With(f => f.Completed, DomainRegistry.NowUtc());
With(f => f.UserId, _instance.ApplicantDetails?.EmailAddress);
VerifyConsistent(_instance);
if (!markAsCompleted)
{
With(f => f.Completed, null);
}
return(this);
}
protected static BsgDetail NewBsgDetail(string formId, int childCount = 2)
{
var detail = new BsgDetail
{
Id = formId,
Consent = ConsentBuilder.NewValid(),
ApplicantDetails = ApplicantDetailsBuilder.NewValid(),
ExpectedChildren = ExpectedChildrenBuilder.NewValid(),
ExistingChildren = ExistingChildrenBuilder.NewValid(childCount),
ApplicantBenefits = BenefitsBuilder.NewWithBenefit(),
PartnerBenefits = BenefitsBuilder.NewWithBenefit(),
GuardianBenefits = BenefitsBuilder.NewWithBenefit(),
GuardianPartnerBenefits = BenefitsBuilder.NewWithBenefit(),
PartnerDetails = RelationDetailsBuilder.NewValid("partner"),
GuardianDetails = RelationDetailsBuilder.NewValid("guardian"),
GuardianPartnerDetails = RelationDetailsBuilder.NewValid("guardian partner"),
HealthProfessional = HealthProfessionalBuilder.NewValid(),
PaymentDetails = PaymentDetailsBuilder.NewValid(),
Evidence = EvidenceBuilder.NewValid(),
Declaration = DeclarationBuilder.NewValid(),
};
return(detail);
}
public ChangeOfCircsBuilder WithCompletedSections(bool markAsCompleted = true, bool excludeOptionalSections = false)
{
With(f => f.Consent, ConsentBuilder.NewValid());
With(f => f.UserId, "*****@*****.**");
With(f => f.ExistingApplicantDetails, ApplicantDetailsBuilder.NewValid(ad => ad.Address = AddressBuilder.NewValid("existing")));
With(f => f.ExistingPaymentDetails, PaymentDetailsBuilder.NewValid());
With(f => f.Options, OptionsBuilder.NewValid());
if (!excludeOptionalSections)
{
With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid());
With(f => f.ExpectedChildren, ExpectedChildrenBuilder.NewValid());
With(f => f.HealthProfessional, HealthProfessionalBuilder.NewValid());
With(f => f.PaymentDetails, PaymentDetailsBuilder.NewValid());
}
With(f => f.Evidence, EvidenceBuilder.NewValid());
With(f => f.Declaration, DeclarationBuilder.NewValid());
With(f => f.Started, DomainRegistry.NowUtc() - TimeSpan.FromHours(24));
With(f => f.Completed, DomainRegistry.NowUtc());
VerifyConsistent(_instance);
if (!markAsCompleted)
{
With(f => f.Completed, null);
}
return(this);
}
public void TestDeclarationBuilderCanBuildDeclarations()
{
// Given
var declaration = new DeclarationBuilder()
.WithName("$myVar")
.WithDescription("my description")
.WithImplicit(false)
.WithSourceFileName("MyFile.yarn")
.WithSourceNodeName("Test")
.WithRange(new Yarn.Compiler.Range(0, 0, 0, 10))
.WithType(BuiltinTypes.String)
.Declaration;
var expectedDeclaration = new Declaration
{
Name = "$myVar",
Description = "my description",
IsImplicit = false,
SourceFileName = "MyFile.yarn",
SourceNodeName = "Test",
Range = new Yarn.Compiler.Range(0, 0, 0, 10),
Type = BuiltinTypes.String
};
// Then
Assert.Equal(expectedDeclaration, declaration);
}
private static FixedList <DeclarationIL> BuildIL(Package package)
{
var ilFactory = new ILFactory();
var declarationBuilder = new DeclarationBuilder(ilFactory);
declarationBuilder.Build(package.AllDeclarations, package.SymbolTree);
return(declarationBuilder.AllDeclarations.ToFixedList());
}
public override string Declaration_ComputeProperty_FullName(DeclarationBuilder _this)
{
if (_this.Namespace == null)
{
return(_this.Name);
}
else
{
return(_this.Namespace.FullName + "." + _this.Name);
}
}
public void Complete_SetsCompletionDate()
{
var form = new ChangeOfCircsBuilder("form")
.WithCompletedSections(markAsCompleted: false)
.With(f => f.Declaration, null)
.Insert();
var next = form.AddDeclaration(DeclarationBuilder.NewValid());
next.Section.Should().BeNull("this should be the last section that is filled out");
form.Completed.Should().Be(TestNowUtc.Value);
}
public Package Analyze(
PackageSyntax packageSyntax,
FixedDictionary <string, Package> references)
{
// First pull over all the lexer and parser errors from the compilation units
var diagnostics = AllDiagnostics(packageSyntax);
var scopesBuilder = new LexicalScopesBuilder(diagnostics, packageSyntax, references);
scopesBuilder.BuildScopesInPackage(packageSyntax);
// Make a list of all the member declarations (i.e. not namespaces)
var memberDeclarations = packageSyntax.CompilationUnits
.SelectMany(cu => cu.AllMemberDeclarations).ToFixedList();
// TODO we can't do full type checking without some IL gen and code execution, how to handle that?
// Do type checking
TypeResolver.Check(memberDeclarations, diagnostics);
#if DEBUG
TypeResolutionValidator.Validate(memberDeclarations);
// TODO validate that all ReferencedSymbols lists have a single value non-errored code
#endif
MoveChecker.Check(memberDeclarations, diagnostics);
ShadowChecker.Check(memberDeclarations, diagnostics);
// TODO we need to check definite assignment as part of this
BindingMutabilityChecker.Check(memberDeclarations, diagnostics);
// --------------------------------------------------
// This is where the representation transitions to IR
ControlFlowAnalyzer.BuildGraphs(memberDeclarations);
// --------------------------------------------------
var liveness = LivenessAnalyzer.Analyze(memberDeclarations);
DeleteInserter.Transform(memberDeclarations, liveness);
BorrowChecker.Check(memberDeclarations, diagnostics);
// Build final declaration objects and find the entry point
var declarationBuilder = new DeclarationBuilder();
var declarations = declarationBuilder.Build(memberDeclarations);
var entryPoint = DetermineEntryPoint(declarations, diagnostics);
return(new Package(packageSyntax.Name, diagnostics.Build(), references, declarations, entryPoint));
}
public void NextSectionClearsSkippedSections()
{
var form = new BestStartGrantBuilder("form")
.With(f => f.ApplicantDetails, ApplicantDetailsBuilder.NewValid(ad => ad.Under16(TestNowUtc.Value)))
.With(f => f.ApplicantBenefits, BenefitsBuilder.NewWithBenefit())
.With(f => f.Declaration, DeclarationBuilder.NewValid())
.Insert();
form.AddExistingChildren(ExistingChildrenBuilder.NewValid());
form = Repository.Load <BestStartGrant>(form.Id);
form.Declaration.Should().NotBeNull("should not be overwritten by moving to the next section");
form.ApplicantBenefits.Should().BeNull("intermediate 'ApplicantBenefits' section should be cleared based on answers");
}
public override void Declaration(DeclarationBuilder _this)
{
base.Declaration(_this);
_this.FullNameLazy =
() =>
{
if (_this.Namespace == null)
{
return(_this.Name);
}
else
{
return(_this.Namespace.FullName + "." + _this.Name);
}
};
}
private static void RemoveTypes(SoalImporter importer)
{
foreach (var type in importer.typesToRemove)
{
DeclarationBuilder decl = type as DeclarationBuilder;
if (decl != null)
{
int count = 0;
importer.referenceCounter.TryGetValue(type, out count);
if (count <= 0)
{
decl.Namespace = null;
importer.Model.RemoveSymbol(decl);
}
}
}
}
protected static CocDetail NewCocDetail(string formId)
{
var detail = new CocDetail
{
Id = formId,
Consent = ConsentBuilder.NewValid(),
Identity = "*****@*****.**",
Options = OptionsBuilder.NewValid(),
ApplicantDetails = ApplicantDetailsBuilder.NewValid(),
ExpectedChildren = ExpectedChildrenBuilder.NewValid(),
HealthProfessional = HealthProfessionalBuilder.NewValid(),
PaymentDetails = PaymentDetailsBuilder.NewValid(),
Evidence = EvidenceBuilder.NewValid(),
Declaration = DeclarationBuilder.NewValid(),
};
return(detail);
}
public Package Build()
{
var diagnostics = new DiagnosticsBuilder(packageSyntax.Diagnostics);
var package = new Package(packageSyntax);
var references = GetPackageReferences(package);
package.Add(references);
var globalDeclarations = new DeclarationBuilder(packageSyntax).Build();
BuildDeclarations(package.GlobalNamespace, globalDeclarations);
package.FindEntities();
package.FindEntryPoints();
var binders = new BindersBuilder(package).Build(diagnostics);
// TODO resolve entity types
Resolve(package, binders); // use binders to resolve rest of semantic model
// TODO type check
// TODO borrow check
package.Set(diagnostics);
return package;
}
public void Execute_StoresDeclaration()
{
var existingForm = new ChangeOfCircsBuilder("form123")
.Insert();
existingForm.Declaration.Should().BeNull("no data stored before executing command");
var cmd = new AddDeclaration
{
FormId = "form123",
Declaration = DeclarationBuilder.NewValid(),
};
cmd.Execute();
var updatedForm = Repository.Load <ChangeOfCircs>("form123");
updatedForm.Declaration.Should().NotBeNull();
updatedForm.Declaration.AgreedToLegalStatement.Should().Be(cmd.Declaration.AgreedToLegalStatement);
}
public Package Build()
{
var diagnostics = new DiagnosticsBuilder(packageSyntax.Diagnostics);
var package = new Package(packageSyntax);
var references = GetPackageReferences(package);
package.Add(references);
var globalDeclarations = new DeclarationBuilder(packageSyntax).Build();
BuildDeclarations(package.GlobalNamespace, globalDeclarations);
package.FindEntities();
package.FindEntryPoints();
var binders = new BindersBuilder(package).Build(diagnostics);
// TODO resolve entity types
Resolve(package, binders); // use binders to resolve rest of semantic model
// TODO type check
// TODO borrow check
package.Set(diagnostics);
return(package);
}
protected void DeclarationShouldBeInvalid(BestStartGrant form, Action <Declaration> mutator)
{
ShouldBeInvalid(() => form.AddDeclaration(DeclarationBuilder.NewValid(mutator)));
}
public override void Declaration(DeclarationBuilder _this)
{
base.Declaration(_this);
}
protected void DeclarationShouldBeInvalid(ChangeOfCircs form, Action <Declaration> mutator)
{
ShouldBeInvalid(() => form.AddDeclaration(DeclarationBuilder.NewValid(mutator)));
}
