private bool DoInstructionInternal(IDetailBlockStart blockStart, MetadataContextStack contextStack, List <IDom> newList, ref IDom lastPart) { if (blockStart == null) { return(false); } var match = blockStartMatch.Match(blockStart.Text); if (!match.Success) { return(false); } var varName = match.Groups[varNameKey].Value; var loopOver = match.Groups[loopOverKey].Value; IEnumerable propAsIEnumerable = GetPropList(contextStack, loopOver); var blockContents = blockStart.BlockContents; foreach (var item in propAsIEnumerable) { contextStack.Push(varName, item); Helper.RunOneLoop(blockContents, blockStart, contextStack, newList); contextStack.Pop(); } lastPart = blockStart.BlockEnd; return(true); }
public override void TemplateDone(IRoot sharedRoot, MetadataContextStack contextStack, IEnumerable <IRoot> retList) { foreach (var newRoot in retList) { var blockStart = newRoot .Descendants .OfType <IDetailBlockStart>() .Where(x => x.Text.Contains(Helper.MakeMarker(id))) .FirstOrDefault(); if (blockStart == null) { return; } var blockContents = blockStart.BlockContents; var blockContentsAsStemMembers = blockContents .OfType <IStemMemberAndDetail>() .Select(x => Helper.Copy <IDom>(x)); if (blockContents.Count() != blockContentsAsStemMembers.Count()) { throw new InvalidOperationException(); } newRoot.StemMembersAll.Clear(); newRoot.StemMembersAll .AddOrMoveRange(blockContentsAsStemMembers.OfType <IStemMemberAndDetail>()); } }
public void RunOneLoop(IEnumerable <IDom> blockContents, IDetailBlockStart blockStart, MetadataContextStack contextStack, List <IDom> newList) { var expansionFirstRunner = contextStack.GetValue(Constants.ExpansionFirstRunner) as ExpansionFirstTemplate; var member = blockContents.FirstOrDefault(); var i = 0; while (member != null && blockContents.Contains(member)) { i++; if (i > 1000) { throw new InvalidOperationException("Infinite loop detected"); } var lastMember = member; var copiedMember = member.GetType().GetMethod("Copy").Invoke(member, null) as IDom; var newMembers = expansionFirstRunner.Update(copiedMember, contextStack, ref lastMember); // don't store the end region that matches this block start, because it's being removed newMembers = newMembers .Where(x => { var block = x as IDetailBlockEnd; if (block == null) { return(true); } return(block.GroupGuid != blockStart.GroupGuid); }); newList.AddRange(newMembers); member = lastMember.NextSibling(); } }
private void PushToContext(MetadataContextStack contextStack, string key, object value, bool fullName = false) { if (!fullName) { key = key.SubstringAfter(matchString + "_"); } contextStack.Add(key, value); }
//private Regex matchRegEx = new Regex(@"_xf_(?<part>[_\w]+?)(?<format>_as_\w+)*"); public void DoAlteration(IDom item, MetadataContextStack contextStack) { ReplaceInName(item, contextStack); // TODO: Explore whether to cache this, the same items will be pounded IEnumerable <PropertyInfo> props = item.GetType().GetProperties(); ReplaceInPropertiesNames(item, contextStack, props); ReplaceInText(item, contextStack, props); ReplaceInExpressions(item, contextStack, props); }
private bool HandleAttribute(IAttribute attribute, IHasAttributes item, MetadataContextStack contextStack, List <IDom> newList, ref IDom lastPart) { var value = Helper.GetBestMetadata <CodeFirstMetadata>(attribute, contextStack); var targetHasStructuredDocs = item as IHasStructuredDocumentation; if (value != null && targetHasStructuredDocs != null && !string.IsNullOrWhiteSpace(value.XmlCommentString)) { // targetHasStructuredDocs.StructuredDocumentation = value.XmlCommentString ; } return(false); }
private static IEnumerable GetPropList(MetadataContextStack contextStack, string loopOver) { // TODO: Work out multi-part naming var metaVar = loopOver.SubstringBefore("."); var metaProp = loopOver.SubstringAfter("."); var metaVarValue = contextStack.GetValue(metaVar); var metaPropValue = metaVarValue.GetType().GetProperty(metaProp).GetValue(metaVarValue); var propAsIEnumerable = metaPropValue as IEnumerable; return(propAsIEnumerable); }
public override bool BeforeCopy(IDom sharedPart, MetadataContextStack contextStack, List <IDom> retList, ref IDom lastPart) { blockStartMatch = Helper.BuildSpecificParamRegex(id, loopOverKey, varNameKey); if (DoInstructionInternal(sharedPart as IDetailBlockStart, contextStack, retList, ref lastPart)) { return(true); } return(false); }
private bool DoInstruction(IDom part, MetadataContextStack contextStack, List <IDom> retList, ref IDom lastPart) { // Can't use DoSomeInstruction becuase you can't pass ref to a lambda foreach (var instruction in availableInstructions) { if (instruction.BeforeCopy(part, contextStack, retList, ref lastPart)) { return(true); } } return(false); }
private void HandleAttributes(IHasAttributes newItemHasAttributes, MetadataContextStack contextStack) { if (newItemHasAttributes == null) { return; } var attributes = newItemHasAttributes.Attributes; var xfAttributes = attributes.Where(x => x.Name.StartsWith("_xf_.")).ToList(); foreach (var attribute in xfAttributes) { var name = attribute.Name.SubstringAfter("_xf_."); } }
private bool HandleAttribute(IAttribute attribute, IHasAttributes item, MetadataContextStack contextStack, List <IDom> newList, ref IDom lastPart) { if (item == null) { return(false); } var value = Helper.GetBestMetadata <IHasAttributes>(attribute, contextStack); if (value != null) { item.Attributes.AddOrMoveAttributeRange(value.Attributes); } return(false); }
private void ReplaceInName(IDom item, MetadataContextStack contextStack) { var partHasName = item as IHasName; if (partHasName != null) { var str = ReplacementString(partHasName.Name, contextStack); // don't reset if not needed, because that will enventually invalidate the model if (str != partHasName.Name) { partHasName.Name = str; } } }
private void ReplaceInText(IDom item, MetadataContextStack contextStack, IEnumerable <PropertyInfo> props) { var textProp = props.Where(x => x.Name == "Text").FirstOrDefault(); if (textProp == null) { return; } var startString = textProp.GetValue(item) as string; var str = ReplacementInsideString(startString, contextStack); if (str != startString) { textProp.SetValue(item, str); } }
private void UpdateProperty(MetadataContextStack contextStack, IProperty newProperty) { if (newProperty != null) { // yes, ugly hack IDom dummy = null; if (newProperty.GetAccessor != null) { newProperty.GetAccessor = Update(newProperty.GetAccessor, contextStack, ref dummy).First() as IAccessor; } if (newProperty.SetAccessor != null) { newProperty.SetAccessor = Update(newProperty.SetAccessor, contextStack, ref dummy).First() as IAccessor; } } }
public override bool BeforeCopy(IDom sharedPart, MetadataContextStack contextStack, List <IDom> retList, ref IDom lastPart) { // always return false, even if this does somethign, it doesn't take care of the underlying part var candidates = Helper.GetMatchingAttributes(sharedPart, Id); foreach (var attribute in candidates) { if (HandleAttribute(attribute, sharedPart as IHasAttributes, contextStack, retList, ref lastPart)) { return(false); } } return(false); }
private void ReplaceInPropertiesNames(IDom item, MetadataContextStack contextStack, IEnumerable <PropertyInfo> props) { var filteredProps = props.Where(x => typeof(IHasName).IsAssignableFrom(x.PropertyType)); foreach (var prop in filteredProps) { var propAsHasName = prop.GetValue(item) as IHasName; if (propAsHasName != null) // underlying value can be null { var str = ReplacementString(propAsHasName.Name, contextStack); if (str != propAsHasName.Name) { propAsHasName.Name = str; } } } return; }
private static string GetNewString(string input, MetadataContextStack contextStack, Match match) { if (!match.Success) { return(input); } var format = ""; var replaceWith = match.Groups[1].Value; List <string> replaceParts = replaceWith .Split(new string[] { "_dot_" }, StringSplitOptions.None) .ToList(); if (replaceParts.Last().Contains("_as_")) { var lastPart = replaceParts.Last(); format = lastPart.SubstringAfter("_as_"); lastPart = lastPart.SubstringBefore("_as_"); replaceParts.Remove(replaceParts.Last()); replaceParts.Add(lastPart); } var lookup = contextStack.GetValue(replaceParts.First()); if (lookup == null) { return(input); } replaceParts = replaceParts.Skip(1).ToList(); // get tail foreach (var part in replaceParts) { var lookupProperty = lookup.GetType().GetProperty(part); if (lookupProperty == null) { return(input); } lookup = lookupProperty.GetValue(lookup); if (lookup == null) { return(input); } } return(GetWithFormat(lookup.ToString(), format)); }
private bool DoInstructionInternal(IPublicAnnotation publicAnnotation, MetadataContextStack contextStack, IEnumerable <IDom> newList) { if (publicAnnotation == null) { return(false); } if (!NameMatches(publicAnnotation.Name, true)) { return(false); } foreach (var key in publicAnnotation.Keys) { var value = publicAnnotation.GetValue(key); PushToContext(contextStack, key, value, true); //contextStack.Current.AddValue(key, value); } return(true); }
private void ReplaceInExpressions(IDom item, MetadataContextStack contextStack, IEnumerable <PropertyInfo> props) { var filteredProps = props.Where(x => typeof(IExpression).IsAssignableFrom(x.PropertyType)); foreach (var prop in filteredProps) { var expr = prop.GetValue(item) as IExpression; if (expr == null) { return; // underlying value might be null } // TODO: Allow evaluating expressions in the following using the current language var str = ReplacementInsideString(expr.InitialExpressionString, contextStack); if (str != expr.InitialExpressionString) { expr.InitialExpressionString = str; } } return; }
public override bool BeforeCopy(IDom sharedPart, MetadataContextStack contextStack, List <IDom> retList, ref IDom lastPart) { var ret = new List <IDom>(); // block changes to the passed list if (DoInstructionInternal(sharedPart as IPublicAnnotation, contextStack, ret)) { return(true); } if (DoInstructionInternal(sharedPart as IDeclarationStatement, contextStack, ret)) { return(true); } if (DoInstructionInternal(sharedPart as IField, contextStack, ret)) { return(true); } return(false); }
private void UpdateContainer(MetadataContextStack contextStack, IContainer newContainer) { if (newContainer != null) { var member = newContainer.GetMembers().FirstOrDefault(); var i = 0; var newMemberList = new List <IDom>(); while (member != null) { i++; if (i > 1000) { throw new InvalidOperationException("Infinite loop detected"); } var lastMember = member; newMemberList.AddRange(Update(member, contextStack, ref lastMember)); var nextMember = lastMember.NextSibling(); member = nextMember; } UpdateItem(newContainer, newMemberList); } }
public T GetBestMetadata <T>(IAttribute attribute, MetadataContextStack contextStack) where T : class { var attributeValue = attribute.AttributeValues.FirstOrDefault(); T value = null; if (attributeValue != null) { var metaName = attributeValue.Value.ToString(); value = contextStack.GetValue(metaName) as T; } else { // Convention var tuple = contextStack.RecentOfType <T>(); if (tuple != null) { value = contextStack.RecentOfType <T>().Item2; } } return(value); }
private string ReplacementInsideString(string input, MetadataContextStack contextStack) { var ret = input; var matches = matchRegEx.Matches(input); var replacements = new List <Tuple <int, int, string> >(); for (int i = 0; i < matches.Count; i++) { var match = matches[i]; var str = match.Value; var newStr = GetNewString(str, contextStack, match); replacements.Add(Tuple.Create(match.Index, match.Length, newStr)); //if (newStr != str) ret = ret.Replace(str, newStr); } replacements.Reverse(); foreach (var replacement in replacements) { var start = ret.Substring(0, replacement.Item1); var end = ret.Substring(replacement.Item1 + replacement.Item2); ret = start + replacement.Item3 + end; } return(ret); }
private bool DoInstructionInternal(IDeclarationStatement declaration, MetadataContextStack contextStack, IEnumerable <IDom> newList) { if (declaration == null) { return(false); } if (!NameMatches(declaration.Name)) { return(false); } var name = declaration.Name; object value = null; if (declaration.Initializer != null) { // TODO: Allow evaluating expressions in the following using the current language value = declaration.Initializer.InitialExpressionString.ToString(); } PushToContext(contextStack, name, value); //contextStack.Current.AddValue(name, value); return(true); }
internal IEnumerable <IDom> Update(IDom part, MetadataContextStack contextStack, ref IDom lastPart) { var newItem = helper.Copy <IDom>(part); // Returning true from DoInstruction means the part is fully handled and no more should be done { var newMemberList = new List <IDom>(); if (DoInstruction(part, contextStack, newMemberList, ref lastPart)) { return(newMemberList.OfType <IDom>()); } } // TODO: I'm not convinced there are three actions, it may be 3 instructions. DoReplacements(newItem, contextStack); DoAfterCopy(newItem); HandleAttributes(newItem as IHasAttributes, contextStack); // Manage children. Property has a special case of multiple children. Events may be the same. UpdateProperty(contextStack, newItem as IProperty); UpdateContainer(contextStack, newItem as IContainer); return(new IDom[] { newItem }); }
public virtual bool BeforeCopy(IDom sharedPart, MetadataContextStack contextStack, List <IDom> retList, ref IDom lastPart) { return(false); }
public string PushToContext(string key, object value, MetadataContextStack contextStack) { contextStack.Current.AddValue(key, value); return(key); }
public virtual void AfterCopy(IDom newPart, MetadataContextStack contextStack) { }
private string ReplacementString(string input, MetadataContextStack contextStack) { var match = matchRegEx.Match(input); return(GetNewString(input, contextStack, match)); }
private void DoReplacements <T>(T newItem, MetadataContextStack metaContextStack) where T : IDom { replacementAlteration.DoAlteration(newItem, metaContextStack); // TODO: Do Replacements }