public FeatureAnalysisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, Pattern<Word, ShapeNode> lhs, RewriteSubrule subrule)
: base(false)
{
var rhsAntiFSs = new List<FeatureStruct>();
foreach (Constraint<Word, ShapeNode> constraint in subrule.Rhs.Children.OfType<Constraint<Word, ShapeNode>>().Where(c => c.Type() == HCFeatureSystem.Segment))
rhsAntiFSs.Add(constraint.FeatureStruct.AntiFeatureStruct());
Pattern.Acceptable = match => IsUnapplicationNonvacuous(match, rhsAntiFSs);
_analysisRhs = new Pattern<Word, ShapeNode>();
int i = 0;
foreach (Tuple<PatternNode<Word, ShapeNode>, PatternNode<Word, ShapeNode>> tuple in lhs.Children.Zip(subrule.Rhs.Children))
{
var lhsConstraint = (Constraint<Word, ShapeNode>) tuple.Item1;
var rhsConstraint = (Constraint<Word, ShapeNode>) tuple.Item2;
if (lhsConstraint.Type() == HCFeatureSystem.Segment && rhsConstraint.Type() == HCFeatureSystem.Segment)
{
var targetConstraint = lhsConstraint.DeepClone();
targetConstraint.FeatureStruct.PriorityUnion(rhsConstraint.FeatureStruct);
targetConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(new Group<Word, ShapeNode>("target" + i) {Children = {targetConstraint}});
FeatureStruct fs = rhsConstraint.FeatureStruct.AntiFeatureStruct();
fs.Subtract(lhsConstraint.FeatureStruct.AntiFeatureStruct());
fs.AddValue(HCFeatureSystem.Type, HCFeatureSystem.Segment);
_analysisRhs.Children.Add(new Constraint<Word, ShapeNode>(fs));
i++;
}
}
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
}
public ComplexConcPatternModel(FdoCache cache, ComplexConcPatternNode root)
{
m_cache = cache;
m_root = root;
m_spanFactory = new ShapeSpanFactory();
m_sda = new ComplexConcPatternSda((ISilDataAccessManaged) cache.DomainDataByFlid, m_root);
}
public SynthesisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative, Pattern<Word, ShapeNode> lhs,
IEnumerable<RewriteSubrule> subrules)
: base(lhs.IsEmpty)
{
Pattern.Acceptable = match => CheckTarget(match, lhs);
if (lhs.IsEmpty)
{
Pattern.Children.Add(new Constraint<Word, ShapeNode>(FeatureStruct.New().Symbol(HCFeatureSystem.Segment, HCFeatureSystem.Anchor).Value));
}
else
{
foreach (Constraint<Word, ShapeNode> constraint in lhs.Children.Cast<Constraint<Word, ShapeNode>>())
{
var newConstraint = constraint.DeepClone();
if (isIterative)
newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(newConstraint);
}
}
Pattern.Freeze();
int i = 0;
foreach (RewriteSubrule subrule in subrules)
{
if (lhs.Children.Count == subrule.Rhs.Children.Count)
SubruleSpecs.Add(new FeatureSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, subrule, i));
else if (lhs.Children.Count > subrule.Rhs.Children.Count)
SubruleSpecs.Add(new NarrowSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, lhs.Children.Count, subrule, i));
else if (lhs.Children.Count == 0)
SubruleSpecs.Add(new EpenthesisSynthesisRewriteSubruleSpec(spanFactory, matcherSettings, isIterative, subrule, i));
i++;
}
}
public override IWordAligner Load(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, CogProject project, XElement elem)
{
var settings = new AlineSettings();
LoadSettings(project.Segmenter, project.FeatureSystem, elem, settings);
XElement relevantFeaturesElem = elem.Element(ConfigManager.Cog + "RelevantFeatures");
Debug.Assert(relevantFeaturesElem != null);
var relevantVowelFeatures = new List<SymbolicFeature>();
var relevantConsFeatures = new List<SymbolicFeature>();
var featureWeights = new Dictionary<SymbolicFeature, int>();
var valueMetrics = new Dictionary<FeatureSymbol, int>();
foreach (XElement featureElem in relevantFeaturesElem.Elements(ConfigManager.Cog + "RelevantFeature"))
{
var feature = project.FeatureSystem.GetFeature<SymbolicFeature>((string) featureElem.Attribute("ref"));
if ((bool?) featureElem.Attribute("vowel") ?? false)
relevantVowelFeatures.Add(feature);
if ((bool?) featureElem.Attribute("consonant") ?? false)
relevantConsFeatures.Add(feature);
featureWeights[feature] = (int) featureElem.Attribute("weight");
foreach (XElement valueElem in featureElem.Elements(ConfigManager.Cog + "RelevantValue"))
{
FeatureSymbol symbol = feature.PossibleSymbols[(string) valueElem.Attribute("ref")];
valueMetrics[symbol] = (int) valueElem.Attribute("metric");
}
}
settings.SoundChangeScoringEnabled = (bool?) elem.Element(ConfigManager.Cog + "SoundChangeScoringEnabled") ?? true;
settings.SyllablePositionCostEnabled = (bool?) elem.Element(ConfigManager.Cog + "SyllablePositionCostEnabled") ?? true;
return new Aline(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics, settings);
}
public NarrowSynthesisRewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative,
int targetCount, RewriteSubrule subrule, int index)
: base(spanFactory, matcherSettings, isIterative, subrule, index)
{
_rhs = subrule.Rhs;
_targetCount = targetCount;
}
public PoorMansAffixIdentifierViewModel(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, IProjectService projectService)
: base("Automatic stemmer", "Input-Settings#automatic-stemmer")
{
_spanFactory = spanFactory;
_segmentPool = segmentPool;
_projectService = projectService;
}
public SynthesisMetathesisRuleSpec(SpanFactory<ShapeNode> spanFactory, Pattern<Word, ShapeNode> pattern, string leftGroupName, string rightGroupName)
{
_spanFactory = spanFactory;
_leftGroupName = leftGroupName;
_rightGroupName = rightGroupName;
_pattern = new Pattern<Word, ShapeNode>();
foreach (PatternNode<Word, ShapeNode> node in pattern.Children)
{
var group = node as Group<Word, ShapeNode>;
if (group != null)
{
var newGroup = new Group<Word, ShapeNode>(group.Name);
foreach (Constraint<Word, ShapeNode> constraint in group.Children.Cast<Constraint<Word, ShapeNode>>())
{
Constraint<Word, ShapeNode> newConstraint = constraint.DeepClone();
newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
newGroup.Children.Add(newConstraint);
}
_pattern.Children.Add(newGroup);
}
else
{
_pattern.Children.Add(node.DeepClone());
}
}
_pattern.Freeze();
}
public AnalysisService(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, IProjectService projectService, IDialogService dialogService, IBusyService busyService)
{
_spanFactory = spanFactory;
_segmentPool = segmentPool;
_projectService = projectService;
_dialogService = dialogService;
_busyService = busyService;
}
protected void End(SpanFactory spanFactory) {
if (HaveContent || !Context.PreviousSpanCanGrow) {
if (Context.InTemporaryBuffer) {
throw new InvalidOperationException(RazorResources.Cannot_Call_EndSpan_From_Temporary_Buffer);
}
End(spanFactory(Context));
}
}
protected SynthesisRewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, bool isIterative,
RewriteSubrule subrule, int index)
: base(spanFactory, matcherSettings, subrule.LeftEnvironment, subrule.RightEnvironment)
{
_isIterative = isIterative;
_subrule = subrule;
_index = index;
}
public HCParser(FdoCache cache)
{
m_cache = cache;
m_spanFactory = new ShapeSpanFactory();
m_traceManager = new FwXmlTraceManager(m_cache);
m_outputDirectory = Path.GetTempPath();
m_changeListener = new ParserModelChangeListener(m_cache);
m_forceUpdate = true;
}
public ProjectService(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, IDialogService dialogService, IBusyService busyService,
ISettingsService settingsService, Lazy<IAnalysisService> analysisService)
{
_spanFactory = spanFactory;
_segmentPool = segmentPool;
_dialogService = dialogService;
_busyService = busyService;
_settingsService = settingsService;
_analysisService = analysisService;
Messenger.Default.Register<DomainModelChangedMessage>(this, HandleDomainModelChanged);
Messenger.Default.Register<ComparisonPerformedMessage>(this, HandleComparisonPerformed);
}
protected void ParseBlockWithOtherParser(SpanFactory previousSpanFactory, bool collectTransitionToken) {
// Capture the current span if we have one
if (TryParseComment(previousSpanFactory)) {
return;
}
Span prev = null;
if (HaveContent) {
prev = previousSpanFactory(Context);
Context.ResetBuffers();
}
// Skip over the switch token if requested
if (collectTransitionToken) {
Context.AcceptCurrent();
}
if (collectTransitionToken && CurrentCharacter == RazorParser.TransitionCharacter) {
// We were told to handle the transition token and found another transition character ==> Escape sequence
// Output the previous content and a hidden token so that the first at of the escape sequence doesn't get rendered
if (prev != null) {
Output(prev);
}
Span span = previousSpanFactory(Context);
Context.ResetBuffers();
span.Hidden = true;
Output(span);
// Now accept the current transition token so it doesn't get treated as a transition and return to the current context
Context.AcceptCurrent();
}
else {
if (prev != null) {
Output(prev);
}
// Switch to the other parser
Context.SwitchActiveParser();
// Have the other parser parse a block starting with the character after the '@'
Context.ActiveParser.ParseBlock();
// Switch back
Context.SwitchActiveParser();
// Once we're done, start a new span
Context.ResetBuffers();
}
}
public NarrowAnalysisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, Pattern<Word, ShapeNode> lhs, RewriteSubrule subrule)
: base(subrule.Rhs.IsEmpty)
{
_analysisRhs = lhs;
_targetCount = subrule.Rhs.Children.Count;
if (subrule.Rhs.IsEmpty)
Pattern.Children.Add(new Constraint<Word, ShapeNode>(FeatureStruct.New().Symbol(HCFeatureSystem.Segment, HCFeatureSystem.Anchor).Value));
else
Pattern.Children.AddRange(subrule.Rhs.Children.DeepClone());
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
}
public EpenthesisAnalysisRewriteRuleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings, RewriteSubrule subrule)
: base(false)
{
Pattern.Acceptable = IsUnapplicationNonvacuous;
_targetCount = subrule.Rhs.Children.Count;
foreach (Constraint<Word, ShapeNode> constraint in subrule.Rhs.Children.Cast<Constraint<Word, ShapeNode>>())
{
var newConstraint = constraint.DeepClone();
newConstraint.FeatureStruct.AddValue(HCFeatureSystem.Modified, HCFeatureSystem.Clean);
Pattern.Children.Add(newConstraint);
}
Pattern.Freeze();
SubruleSpecs.Add(new AnalysisRewriteSubruleSpec(spanFactory, matcherSettings, subrule, Unapply));
}
public CogProject(SpanFactory<ShapeNode> spanFactory)
{
_segmenter = new Segmenter(spanFactory);
_meanings = new KeyedBulkObservableList<string, Meaning>(meaning => meaning.Gloss);
_meanings.CollectionChanged += MeaningsChanged;
_varieties = new KeyedBulkObservableList<string, Variety>(variety => variety.Name);
_varieties.CollectionChanged += VarietiesChanged;
_varietyPairs = new VarietyPairCollection();
_wordAligners = new ObservableDictionary<string, IWordAligner>();
_cognateIdentifiers = new ObservableDictionary<string, ICognateIdentifier>();
_projectProcessors = new ObservableDictionary<string, IProcessor<CogProject>>();
_varietyProcessors = new ObservableDictionary<string, IProcessor<Variety>>();
_varietyPairProcessors = new ObservableDictionary<string, IProcessor<VarietyPair>>();
}
public CogProject(SpanFactory<ShapeNode> spanFactory)
{
_segmenter = new Segmenter(spanFactory);
_meanings = new MeaningCollection();
_meanings.CollectionChanged += MeaningsChanged;
_varieties = new VarietyCollection();
_varieties.CollectionChanged += VarietiesChanged;
_varietyPairs = new VarietyPairCollection();
_cognacyDecisions = new CognacyDecisionCollection();
_wordAligners = new ObservableDictionary<string, IWordAligner>();
_cognateIdentifiers = new ObservableDictionary<string, ICognateIdentifier>();
_projectProcessors = new ObservableDictionary<string, IProcessor<CogProject>>();
_varietyProcessors = new ObservableDictionary<string, IProcessor<Variety>>();
_varietyPairProcessors = new ObservableDictionary<string, IProcessor<VarietyPair>>();
}
public Morpher(SpanFactory<ShapeNode> spanFactory, ITraceManager traceManager, Language lang)
{
_lang = lang;
_traceManager = traceManager;
_allomorphTries = new Dictionary<Stratum, RootAllomorphTrie>();
foreach (Stratum stratum in _lang.Strata)
{
var allomorphs = new HashSet<RootAllomorph>(stratum.Entries.SelectMany(entry => entry.Allomorphs));
var trie = new RootAllomorphTrie(ann => ann.Type() == HCFeatureSystem.Segment);
foreach (RootAllomorph allomorph in allomorphs)
trie.Add(allomorph);
_allomorphTries[stratum] = trie;
}
_analysisRule = lang.CompileAnalysisRule(spanFactory, this);
_synthesisRule = lang.CompileSynthesisRule(spanFactory, this);
MaxStemCount = 2;
LexEntrySelector = entry => true;
RuleSelector = rule => true;
}
public Segmenter(SpanFactory<ShapeNode> spanFactory)
{
_spanFactory = spanFactory;
_vowels = new SymbolCollection();
_vowels.CollectionChanged += SymbolCollectionChanged;
_consonants = new SymbolCollection();
_consonants.CollectionChanged += SymbolCollectionChanged;
_modifiers = new SymbolCollection();
_modifiers.CollectionChanged += SymbolCollectionChanged;
_joiners = new SymbolCollection();
_joiners.CollectionChanged += SymbolCollectionChanged;
_toneLetters = new SymbolCollection();
_toneLetters.CollectionChanged += SymbolCollectionChanged;
_boundaries = new SymbolCollection();
_boundaries.CollectionChanged += SymbolCollectionChanged;
_emptyShape = new Shape(_spanFactory, begin => new ShapeNode(_spanFactory, FeatureStruct.New().Symbol(CogFeatureSystem.AnchorType).Feature(CogFeatureSystem.StrRep).EqualTo("#").Value));
_emptyShape.Freeze();
}
protected RewriteSubruleSpec(SpanFactory<ShapeNode> spanFactory, MatcherSettings<ShapeNode> matcherSettings,
Pattern<Word, ShapeNode> leftEnv, Pattern<Word, ShapeNode> rightEnv)
{
if (leftEnv != null && !leftEnv.IsEmpty)
{
MatcherSettings<ShapeNode> leftEnvMatcherSettings = matcherSettings.DeepClone();
leftEnvMatcherSettings.Direction = Direction.RightToLeft;
leftEnvMatcherSettings.AnchoredToStart = true;
_leftEnvMatcher = new Matcher<Word, ShapeNode>(spanFactory, leftEnv, leftEnvMatcherSettings);
}
if (rightEnv != null && !rightEnv.IsEmpty)
{
MatcherSettings<ShapeNode> rightEnvMatcherSettings = matcherSettings.DeepClone();
rightEnvMatcherSettings.Direction = Direction.LeftToRight;
rightEnvMatcherSettings.AnchoredToStart = true;
_rightEnvMatcher = new Matcher<Word, ShapeNode>(spanFactory, rightEnv, rightEnvMatcherSettings);
}
}
internal static JaegerSpan CreateTestJaegerSpan()
{
return(SpanFactory
.CreateSpan()
.ToJaegerSpan());
}
public void FixtureSetUp()
{
_spanFactory = new IntegerSpanFactory();
}
public override IRule<Word, ShapeNode> CompileSynthesisRule(SpanFactory<ShapeNode> spanFactory, Morpher morpher)
{
return new SynthesisMetathesisRule(spanFactory, morpher, this);
}
private bool HandleTransition(SpanFactory spanFactory, bool acceptOuterTemporaryIfSwitching = false) {
bool isMarkup = false;
using (Context.StartTemporaryBuffer()) {
Context.AcceptWhiteSpace(includeNewLines: true);
Debug.Assert(CurrentCharacter == RazorParser.TransitionCharacter);
Context.AcceptCurrent();
isMarkup = Context.MarkupParser.IsAtTransition();
}
if (isMarkup) {
if (acceptOuterTemporaryIfSwitching) {
// Accept the outer temporary buffer
Context.AcceptTemporaryBuffer();
}
if (DesignTimeMode) {
Context.AcceptWhiteSpace(includeNewLines: true);
}
End(spanFactory);
using (StartBlock(BlockType.Template)) {
ParseBlockWithOtherParser(spanFactory);
}
}
else {
Context.AcceptWhiteSpace(includeNewLines: true);
}
return isMarkup;
}
protected override bool TryRecover(bool allowTransition, SpanFactory previousSpanFactory) {
if (CurrentCharacter == ';') {
return true;
}
if (CurrentCharacter == '{') {
return !BalanceBrackets(allowTransition: allowTransition, spanFactory: previousSpanFactory, appendOuter: true, bracket: null, useTemporaryBuffer: false);
}
return false;
}
public override IRule<Word, ShapeNode> CompileAnalysisRule(SpanFactory<ShapeNode> spanFactory, Morpher morpher)
{
return new AnalysisStratumRule(spanFactory, morpher, this);
}
protected internal override bool HandleTransition(SpanFactory spanFactory) {
return HandleTransition(spanFactory, true);
}
public void ImplicitExpressionAcceptsDotlessCommitInsertionsInStatementBlockAfterIdentifiers()
{
var factory = SpanFactory.CreateCsHtml();
var changed = new StringTextBuffer("@{" + Environment.NewLine
+ " @DateTime." + Environment.NewLine
+ "}");
var old = new StringTextBuffer("@{" + Environment.NewLine
+ " @DateTime" + Environment.NewLine
+ "}");
var textChange = new TextChange(15 + Environment.NewLine.Length, 0, old, 1, changed);
using (var manager = CreateParserManager())
{
Action <TextChange, PartialParseResult, string> applyAndVerifyPartialChange = (changeToApply, expectedResult, expectedCode) =>
{
var result = manager.CheckForStructureChangesAndWait(textChange);
// Assert
Assert.Equal(expectedResult, result);
Assert.Equal(1, manager.ParseCount);
ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree, new MarkupBlock(
factory.EmptyHtml(),
new StatementBlock(
factory.CodeTransition(),
factory.MetaCode("{").Accepts(AcceptedCharacters.None),
factory.Code(Environment.NewLine + " ")
.AsStatement()
.AutoCompleteWith(autoCompleteString: null),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code(expectedCode)
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
.Accepts(AcceptedCharacters.NonWhiteSpace)),
factory.Code(Environment.NewLine).AsStatement(),
factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
factory.EmptyHtml()));
};
manager.InitializeWithDocument(textChange.OldBuffer);
// This is the process of a dotless commit when doing "." insertions to commit intellisense changes.
applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime.");
old = changed;
changed = new StringTextBuffer("@{" + Environment.NewLine
+ " @DateTime.." + Environment.NewLine
+ "}");
textChange = new TextChange(16 + Environment.NewLine.Length, 0, old, 1, changed);
applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime..");
old = changed;
changed = new StringTextBuffer("@{" + Environment.NewLine
+ " @DateTime.Now." + Environment.NewLine
+ "}");
textChange = new TextChange(16 + Environment.NewLine.Length, 0, old, 3, changed);
applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime.Now.");
}
}
public IterativePhonologicalPatternRule(SpanFactory <ShapeNode> spanFactory, IPhonologicalPatternRuleSpec ruleSpec, MatcherSettings <ShapeNode> matcherSettings)
: base(spanFactory, ruleSpec, matcherSettings)
{
}
private bool HandleTransitionCore(SpanFactory spanFactory, bool allowEmbeddedExpression, bool rejectOuterIfSwitching = false) {
if (Context.Peek(RazorParser.StartCommentSequence, caseSensitive: true)) {
Context.AcceptTemporaryBuffer();
Debug.Assert(!InTemporaryBuffer);
End(spanFactory);
ParseComment();
return true;
}
char? next = null;
bool isTemplate = false;
using (Context.StartTemporaryBuffer()) {
Context.AcceptWhiteSpace(includeNewLines: true);
if (CurrentCharacter != RazorParser.TransitionCharacter) {
return false;
}
Context.AcceptCurrent();
next = CurrentCharacter;
if (next == RazorParser.TransitionCharacter) {
isTemplate = true;
Context.AcceptCurrent();
next = CurrentCharacter;
}
}
if (next == '<' || next == ':') {
if (rejectOuterIfSwitching) {
Context.AcceptTemporaryBufferInDesignTimeMode();
}
else {
Context.AcceptTemporaryBuffer();
}
if (isTemplate) {
End(spanFactory);
StartBlock(BlockType.Template);
}
ParseBlockWithOtherParser(previousSpanFactory: spanFactory);
if (isTemplate) {
EndBlock();
}
return true;
}
else if (allowEmbeddedExpression) {
Context.AcceptTemporaryBuffer();
ParseEmbeddedExpression();
return true;
}
return false;
}
protected internal override bool HandleTransition(SpanFactory spanFactory) {
return HandleTransitionCore(spanFactory, allowEmbeddedExpression: false);
}
public async Task ImplicitExpressionProvisionallyAcceptsCaseInsensitiveDotlessCommitInsertions_NewRoslynIntegration()
{
var factory = new SpanFactory();
var original = new StringTextSnapshot("foo @date baz");
var changed = new StringTextSnapshot("foo @date. baz");
var edit = new TestEdit(9, 0, original, 1, changed, ".");
using (var manager = CreateParserManager(original))
{
void ApplyAndVerifyPartialChange(Action applyEdit, string expectedCode)
{
applyEdit();
Assert.Equal(1, manager.ParseCount);
ParserTestBase.EvaluateParseTree(manager.PartialParsingSyntaxTreeRoot, new MarkupBlock(
factory.Markup("foo "),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code(expectedCode).AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharactersInternal.NonWhiteSpace)),
factory.Markup(" baz")));
};
await manager.InitializeWithDocumentAsync(edit.OldSnapshot);
// This is the process of a dotless commit when doing "." insertions to commit intellisense changes.
// @date => @date.
ApplyAndVerifyPartialChange(() => manager.ApplyEdit(edit), "date.");
original = changed;
changed = new StringTextSnapshot("foo @date baz");
edit = new TestEdit(9, 1, original, 0, changed, "");
// @date. => @date
ApplyAndVerifyPartialChange(() => manager.ApplyEdit(edit), "date");
original = changed;
changed = new StringTextSnapshot("foo @DateTime baz");
edit = new TestEdit(5, 4, original, 8, changed, "DateTime");
// @date => @DateTime
ApplyAndVerifyPartialChange(() => manager.ApplyEdit(edit), "DateTime");
original = changed;
changed = new StringTextSnapshot("foo @DateTime. baz");
edit = new TestEdit(13, 0, original, 1, changed, ".");
// @DateTime => @DateTime.
ApplyAndVerifyPartialChange(() => manager.ApplyEdit(edit), "DateTime.");
// Verify the reparse eventually happens
await manager.WaitForReparseAsync();
Assert.Equal(2, manager.ParseCount);
ParserTestBase.EvaluateParseTree(manager.CurrentSyntaxTree.Root, new MarkupBlock(
factory.Markup("foo "),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code("DateTime").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharactersInternal.NonWhiteSpace)),
factory.Markup(". baz")));
}
}
public void SetUp()
{
_spanFactory = new ShapeSpanFactory();
_segmenter = new Segmenter(_spanFactory)
{
Consonants = {"b", "c", "ch", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "sh", "t", "v", "w", "x", "z"},
Vowels = {"a", "e", "i", "o", "u"},
Boundaries = {"-"},
Modifiers = {"\u0303", "\u0308"},
Joiners = {"\u0361"}
};
}
public override IRule <Word, ShapeNode> CompileSynthesisRule(SpanFactory <ShapeNode> spanFactory, Morpher morpher)
{
return(new SynthesisMetathesisRule(spanFactory, morpher, this));
}
public static CogProject GetTestProject(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool)
{
Stream stream = Assembly.GetAssembly(typeof(TestHelpers)).GetManifestResourceStream("SIL.Cog.TestUtils.TestProject.cogx");
return ConfigManager.Load(spanFactory, segmentPool, stream);
}
public override IRule <Word, ShapeNode> CompileAnalysisRule(SpanFactory <ShapeNode> spanFactory, Morpher morpher)
{
return(new AnalysisCompoundingRule(spanFactory, morpher, this));
}