private void SetWalkStartFor(CodeRegion region, int outputLineCnt) { _walkthroughRanges[region.Name] = new LinesRange { Start = outputLineCnt + 1 }; }
private void ExecuteTest(CodeRegion models, CodeRegion input, CodeRegion expected, Location location, string message) { var inputCode = string.Join("\r\n", models.Lines.AddRange(input.Lines)); var expectedCode = string.Join("\r\n", models.Lines.AddRange(expected.Lines)); var offsetLocation = new Location(location.Line + models.Lines.Count, location.Column); var expectedDiagnostic = new DiagnosticResult { Id = NotAutoMapperAnalyzer.DiagnosticId, Message = message, Severity = Microsoft.CodeAnalysis.DiagnosticSeverity.Info, Locations = new[] { new DiagnosticResultLocation ( path: "Test0.cs", line: offsetLocation.Line, column: offsetLocation.Column ) } }; VerifyCSharpDiagnostic ( source: inputCode, expected: expectedDiagnostic ); VerifyCSharpFix ( oldSource: inputCode, newSource: expectedCode, allowNewCompilerDiagnostics: true ); }
public void TestSourceFiles() { var files = Directory.EnumerateFiles("TestCases", "*.cs"); foreach (var f in files) { var content = File.ReadAllLines(f); var topComments = content.TakeWhile(x => Regex.IsMatch(x, "^//.*$")).ToImmutableList(); var location = Location.FromComments(topComments); var message = MessageFromComments(topComments); var regions = CodeRegion.FromSource(content.ToImmutableList()); var models = regions.Where(x => x.Name.Equals("Models", StringComparison.OrdinalIgnoreCase)).ToImmutableList(); var expected = regions.Single(x => x.Name.Equals("Expected", StringComparison.OrdinalIgnoreCase)); var inputs = regions.Where(x => x.Name.Equals("Input", StringComparison.OrdinalIgnoreCase)).ToImmutableList(); foreach (var model in models) { foreach (var input in inputs) { ExecuteTest(model, input, expected, location, message); } } } }
public void ReportLookupTypeError(CodeRegion environment, string name, Type new_type, Type existing_type) { if (existing_type == 0) { Console.Error.WriteLine("{0}:{1}:{2}-{3}:{4}: No possible type for “{5}”. Expression should have types: {6}.", environment.FileName, environment.StartRow, environment.StartColumn, environment.EndRow, environment.EndColumn, name, new_type); } else { Console.Error.WriteLine("{0}:{1}:{2}-{3}:{4}: Lookup for “{5}” has conflicting types: {6} versus {7}.", environment.FileName, environment.StartRow, environment.StartColumn, environment.EndRow, environment.EndColumn, name, new_type, existing_type); } }
public void ReportExpressionTypeError(CodeRegion where, Type new_type, Type existing_type) { if (existing_type == 0) { Console.Error.WriteLine("{0}:{1}:{2}-{3}:{4}: No possible type for {5}. Expression should have types: {6}.", where.FileName, where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, where.PrettyName, new_type); } else { Console.Error.WriteLine("{0}:{1}:{2}-{3}:{4}: Conflicting types for {5}: {6} versus {7}.", where.FileName, where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, where.PrettyName, new_type, existing_type); } }
public void ReportExpressionTypeError(CodeRegion where, Type new_type, Type existing_type) { MakeDirty(); if (existing_type == 0) { buffer.Write("<tr><td>{0}:{1}-{2}:{3}</td><td>No possible type for {4}. Expression should have types: {5}.</td></tr>", where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, where.PrettyName, new_type); } else { buffer.Write("<tr><td>{0}:{1}-{2}:{3}</td><td>Conflicting types for {4}: {5} versus {6}.</td></tr>", where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, where.PrettyName, new_type, existing_type); } }
public override void VisitRegionDirectiveTrivia(RegionDirectiveTriviaSyntax node) { var region = new CodeRegion { StartIndex = node.FullSpan.Start, Name = ParseRegionName(node) }; _stack.Push(region); base.VisitRegionDirectiveTrivia(node); }
public void ReportLookupTypeError(CodeRegion environment, string name, Type new_type, Type existing_type) { MakeDirty(); if (existing_type == 0) { buffer.Write("<tr><td>{0}:{1}-{2}:{3}</td><td>No possible type for “{4}”. Expression should have types: {5}.</td></tr>", environment.StartRow, environment.StartColumn, environment.EndRow, environment.EndColumn, name, new_type); } else { buffer.Write("<tr><td>{0}:{1}-{2}:{3}</td><td>Lookup for “{4}” has conflicting types: {5} versus {6}.</td></tr>", environment.StartRow, environment.StartColumn, environment.EndRow, environment.EndColumn, name, new_type, existing_type); } }
public ApiGenerator CreateChild(string name, CodeRegion region, Type type, bool informative) { var node = Document.CreateElement("o_0:attr", Document.DocumentElement.NamespaceURI); node.SetAttribute("name", name); node.SetAttribute("startline", region.StartRow.ToString()); node.SetAttribute("startcol", region.StartColumn.ToString()); node.SetAttribute("endline", region.EndRow.ToString()); node.SetAttribute("endcol", region.EndColumn.ToString()); node.SetAttribute("informative", informative ? "true" : "false"); this.node.AppendChild(node); string base_name = name; var it = 0; do { var def_node = Document.CreateElement("o_0:def", Document.DocumentElement.NamespaceURI); def_node.AppendChild(Document.CreateTextNode(base_name)); node.AppendChild(def_node); if (it < names.Length) { base_name = names[it] + "." + base_name; } } while (it++ < names.Length); string[] new_names; if ((type & Type.Template) != 0) { new_names = new string[0]; } else { new_names = new string[names.Length + 1]; names.CopyTo(new_names, 0); new_names[names.Length] = name; } if (type != NameInfo.AnyType) { foreach (var t in Enum.GetValues(typeof(Type)).Cast <Type>()) { if ((type & t) == 0) { continue; } var type_node = Document.CreateElement("o_0:type", Document.DocumentElement.NamespaceURI); type_node.AppendChild(Document.CreateTextNode(t == Type.Unit ? "Null" : t.ToString())); node.AppendChild(type_node); } } return(new ApiGenerator(Document, node, new_names)); }
private void AppendDemoRegion(CodeRegion demoRegion) { var demoCode = CodeSlicer.CopyCodeWithWalkthroughs(new CodeSlicer.CodeWithWalkthroughsInput { Start = demoRegion.LineStart, End = demoRegion.LineEnd, LineCountOffset = _lineCountOffset }); _outputCode.Append(demoCode.Code); _lineCountOffset += demoCode.LineCount; CopyWalkthroughs(demoCode.WalkthroughRanges); }
public IEnumerable <ICodeRegion> GetRegions(string src) { var ret = new List <ICodeRegion>(); var lines = src.Split(new char[] { '\n' }); CodeRegion currentCodeRegion = null; var regionStack = new Stack <CodeRegion>(); int lineNumber = 0; foreach (var line in lines) { if (line.Contains("#region")) { // start a new region var start = line.IndexOf("#region") + "#region".Length; var name = line.Substring(start).Trim(); currentCodeRegion = new CodeRegion(); currentCodeRegion.Name = name; currentCodeRegion.LineStart = lineNumber; // add as child of the last item in the stack if (regionStack.Count > 0 && regionStack.Peek() != null) { regionStack.Peek().Add(currentCodeRegion); } else { ret.Add(currentCodeRegion); } regionStack.Push(currentCodeRegion); } if (line.Contains("#endregion")) { if (regionStack.Peek() != null) { var c = regionStack.Pop(); c.LineEnd = lineNumber; } } lineNumber++; } return(ret); }
public void ReportForbiddenNameAccess(CodeRegion environment, string name) { Console.Error.WriteLine("{0}:{1}:{2}-{3}:{4}: Lookup for “{5}” is forbidden.", environment.FileName, environment.StartRow, environment.StartColumn, environment.EndRow, environment.EndColumn, name); }
public void ReportRawError(CodeRegion where, string message) { MakeDirty(); buffer.Write("<tr><td>{0}:{1}-{2}:{3}</td><td>{4}</td></tr>", where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, message); }
public void ReportExpressionTypeError(CodeRegion where, Type new_type, Type existing_type) { AnalyseDirty = true; }
public void ReportLookupTypeError(CodeRegion environment, string name, Type new_type, Type existing_type) { AnalyseDirty = true; }
public void ReportRawError(CodeRegion where, string message) { AnalyseDirty = true; }
public void ReportSingleTypeError(CodeRegion where, Type type) { Console.Error.WriteLine("{0}:{1}:{2}-{3}:{4}: The expression has types {5}, but it must only have one.", where.FileName, where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, type); }
protected override void Visit(CodeRegion region) { VisitList(region.Members); }
public void ReportSingleTypeError(CodeRegion where, Type type) { MakeDirty(); buffer.Write("<tr><td>{0}:{1}-{2}:{3}</td><td>The expression has types {4}, but it must only have one.</td></tr>", where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, type); }
internal RegionBuilder(CodeRegion region) { Region = region; }
public void ReportRawError(CodeRegion where, string message) { Console.Error.WriteLine("{0}:{1}:{2}-{3}:{4}: {5}", where.FileName, where.StartRow, where.StartColumn, where.EndRow, where.EndColumn, message); }
public void ReportSingleTypeError(CodeRegion where, Type type) { AnalyseDirty = true; }
public void ReportForbiddenNameAccess(CodeRegion environment, string name) { AnalyseDirty = true; }
public void ReportForbiddenNameAccess(CodeRegion environment, string name) { MakeDirty(); buffer.Write("<tr><td>{0}:{1}-{2}:{3}</td><td>Lookup for “{4}” is forbidden.<td></tr>", environment.StartRow, environment.StartColumn, environment.EndRow, environment.EndColumn, name); }
//获得单一变量 private CodeObject GetOneObject() { CodeObject ret = null; Token token = ReadToken(); bool not = false; bool minus = false; bool negative = false; CALC calc = CALC.NONE; while (true) { if (token.Type == TokenType.Not) { not = true; } else if (token.Type == TokenType.Minus) { minus = true; } else if (token.Type == TokenType.Negative) { negative = true; } else { break; } token = ReadToken(); } if (token.Type == TokenType.Increment) { calc = CALC.PRE_INCREMENT; token = ReadToken(); } else if (token.Type == TokenType.Decrement) { calc = CALC.PRE_DECREMENT; token = ReadToken(); } switch (token.Type) { case TokenType.Identifier: ret = new CodeMember((string)token.Lexeme); break; case TokenType.Function: UndoToken(); ret = new CodeFunction(ParseFunctionDeclaration(false)); break; case TokenType.LeftPar: ret = new CodeRegion(GetObject()); ReadRightParenthesis(); break; case TokenType.LeftBracket: UndoToken(); ret = GetArray(); break; case TokenType.LeftBrace: UndoToken(); ret = GetTable(); break; case TokenType.Eval: ret = GetEval(); break; case TokenType.Null: ret = new CodeScriptObject(m_script, null); break; case TokenType.Boolean: case TokenType.Number: case TokenType.String: case TokenType.SimpleString: ret = new CodeScriptObject(m_script, token.Lexeme); break; default: throw new ParserException("Object起始关键字错误 ", token); } ret.StackInfo = new StackInfo(m_strBreviary, token.SourceLine); ret = GetVariable(ret); ret.Not = not; ret.Minus = minus; ret.Negative = negative; if (ret is CodeMember) { if (calc != CALC.NONE) { ((CodeMember)ret).Calc = calc; } else { Token peek = ReadToken(); if (peek.Type == TokenType.Increment) { calc = CALC.POST_INCREMENT; } else if (peek.Type == TokenType.Decrement) { calc = CALC.POST_DECREMENT; } else { UndoToken(); } if (calc != CALC.NONE) { ((CodeMember)ret).Calc = calc; } } } else if (calc != CALC.NONE) { throw new ParserException("++ 或者 -- 只支持变量的操作", token); } return(ret); }
ScriptObject ParseRegion(CodeRegion region) { return(ResolveOperand(region.Context)); }
static void Main(string[] args) { Console.WriteLine("Entity Frameworks CodeGenerationTools Demo Program.\n"); //I had problems with accessing Dictionary by [] index, so quickly used these //to check in normal C# usage. //var tc = new TestCollections(); //tc.TestCollections2(); try { //As this program only reads and interprets the XML within the EDMX, //there is no need for a ConnectionString in the App.Config and //no connection is made to a database. //Since this is a test program, let's assume you are executing from .\bin\Debug var currentdirectory = Environment.CurrentDirectory; var inputFile = @"..\..\Model1.edmx"; inputFile = Path.Combine(currentdirectory, inputFile); //Demo 1 //EFFluentUtility is from //http://visualstudiogallery.msdn.microsoft.com/5d663b99-ed3b-481d-b7bc-b947d2457e3c //By opening the VSIX (DbContextFluentTemplate_V50, which is a ZIP) I've taken a //copy of "CSharpDbContextFluent.Mapping.tt" from the ItemTemplate. //Then copied the supporting classes from the template and //entered here in the CodeGenerationToolsLibrary project as a .Net Class here. //I've used the Mapping.tt because it is the most complex, //and shows how to obtain the Mapping info used to //create the EntityConfiguration from the EDMX. // // See PropertyToColumnMapping and ManyToManyMappings from // MetadataLoadResult // EF5FluentUtility efu = new EF5FluentUtility(); MetadataLoadResult mlr = efu.LoadMetadata(inputFile); var a = mlr.EdmItems; var b = mlr.ManyToManyMappings; var c = mlr.PropertyToColumnMapping; var d = mlr.TphMappings; //Obtain the EntityContainer from the ItemsCollection var container = mlr.EdmItems.GetItems <EntityContainer>()[0]; //Iterate all the EntitySets and Properties //EntitySet are as in "People", where the EntityType is "Person" foreach (var entityset in container.BaseEntitySets.OfType <EntitySet>().OrderBy(e => e.Name)) { var entitysetname = entityset.Name; var entityname = entityset.ElementType.Name; var entitytype = entityset.ElementType; var declaringtype = entityset.ElementType.NavigationProperties[0].DeclaringType; //Navigation Properties for a particular Entity var collectionNavigations1 = entityset.ElementType.NavigationProperties.Where(np => np.DeclaringType == entityset.ElementType); // Find m:m relationshipsto configure for a particular Entity var manyManyRelationships = entityset.ElementType.NavigationProperties .Where(np => //np.DeclaringType is EntityType && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many && np.FromEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many // Ensures we only configure from one end. // Convention is to have source on the left, as it would be diagrammatically. && np.RelationshipType.RelationshipEndMembers.First() == np.FromEndMember) .ToArray(); //Now process the M:Ms foreach (var navProperty in manyManyRelationships) { var otherNavProperty = navProperty.ToEndMember.GetEntityType().NavigationProperties.Where(n => n.RelationshipType == navProperty.RelationshipType && n != navProperty).Single(); var association = (AssociationType)navProperty.RelationshipType; //This did not work in the T4 Template. var mapping1 = mlr.ManyToManyMappings[association]; var mapping2 = mlr.ManyToManyMappings.Where(m => m.Key.Name == association.Name).FirstOrDefault().Value; var item1 = mapping1.Item1; //This did not work in the T4 Template. var leftKeyMappings1 = mapping1.Item2[navProperty.ToEndMember]; var leftKeyMappings2 = mapping1.Item2.Where(np => np.Key.Name == navProperty.ToEndMember.Name).FirstOrDefault().Value; // Need to ensure that FKs are declared in the same order as the PK properties on each principal type var leftType = (EntityType)navProperty.DeclaringType; var rightType = (EntityType)otherNavProperty.DeclaringType; //Access using Index [navProperty.FromEndMember] did not work within template. var leftKeyMappings = mapping1.Item2.Where(np => np.Key.Name == navProperty.FromEndMember.Name).FirstOrDefault().Value; //[navProperty.FromEndMember]; var rightKeyMappings = mapping1.Item2.Where(np => np.Key.Name == otherNavProperty.FromEndMember.Name).FirstOrDefault().Value; //[otherNavProperty.FromEndMember]; var left = leftKeyMappings.Where(km => km.Key.Name == "PersonID"); var right = rightType.KeyMembers.Select(m => "\"" + rightKeyMappings.Where(km => km.Key.Name == m.Name).FirstOrDefault().Value + "\"").FirstOrDefault(); } //Dual OrderBy to bring Keys to top of list //Iterate all properties for this particular Entity. var properties = entityset.ElementType.Properties.OrderBy(s => s.Name).OrderBy(p => entityset.ElementType.KeyMembers.Contains(p) == false).ToArray(); foreach (var property in properties) { var propertyname = property.Name; //This did not work in the T4 Template. var mapping1 = mlr.PropertyToColumnMapping[entityset.ElementType]; //PropertyToColumnMapping is a collection for ALL Entities, so here the particular Entity needs to be filtered out. //Mapping returned is a complex generic Dictionary. var mapping2 = mlr.PropertyToColumnMapping.Where(k => k.Key == entityset.ElementType).FirstOrDefault().Value; var mapping3 = mlr.PropertyToColumnMapping.Where(k => k.Key.FullName == entityset.ElementType.FullName).FirstOrDefault().Value; var mapping4 = mapping3.Item2.Where(p => p.Key.Name == property.Name).FirstOrDefault().Value; var i1 = mapping1.Item1; var i2 = mapping1.Item2; var mapright = i2[property]; } } //******************************************************************************** //Demo 2 //This takes EF.Utility.CS.ttinclude and receates as //.net Classes. // MyTextTransformation tt = new MyTextTransformation(); CodeGenerationTools code = new CodeGenerationTools(tt); CodeRegion cregion = new CodeRegion(tt, 1); MetadataTools mtool = new MetadataTools(tt); MetadataLoader mloader = new MetadataLoader(tt); var ItemCollection = mloader.CreateEdmItemCollection(inputFile); var Container = ItemCollection.GetItems <EntityContainer>()[0]; Console.WriteLine(String.Format("Container Name: {0}", Container.Name)); Console.WriteLine(String.Format("Model Namespace: {0}", mloader.GetModelNamespace(inputFile))); Console.WriteLine(String.Format("No Of Items in ItemsCollection: {0}\n", ItemCollection.Count)); Console.WriteLine("Press any key to continue.\n"); Console.ReadKey(); foreach (var i in ItemCollection) { Console.WriteLine(String.Format("Item: {0}, {1}", i.ToString(), i.BuiltInTypeKind.ToString())); } Console.WriteLine("Press any key to continue.\n"); Console.ReadKey(); EdmItemCollection edmItemCollection = null;; var ret = mloader.TryCreateEdmItemCollection(inputFile, out edmItemCollection); StoreItemCollection storeItemCollection = null; ret = mloader.TryCreateStoreItemCollection(inputFile, out storeItemCollection); StorageMappingItemCollection storageMappingItemCollection = null; ret = mloader.TryCreateStorageMappingItemCollection(inputFile, edmItemCollection, storeItemCollection, out storageMappingItemCollection); foreach (var i in storageMappingItemCollection) { Console.WriteLine(String.Format("Item: {0}, {1}", i.ToString(), i.BuiltInTypeKind.ToString())); } DataSpace ds = storageMappingItemCollection.DataSpace; MetadataWorkspace metadataWorkspace = null; ret = mloader.TryLoadAllMetadata(inputFile, out metadataWorkspace); //Get the schema "dbo" from a particular Entity. EntityContainer ec = storeItemCollection.GetItems <EntityContainer>().First(); EntitySet eset = ec.GetEntitySetByName(code.Escape("People"), true); string schemaName1 = eset.MetadataProperties["Schema"].Value.ToString(); //Get the schema "dbo" from any Entity. I guess the schema will be same for all?! EntitySetBase fes = ec.BaseEntitySets.FirstOrDefault(); string schemaName2 = fes.MetadataProperties["Schema"].Value.ToString(); var edmxSchema = EDMXchema.GetSchemaElement(inputFile); Console.WriteLine("Press any key to continue.\n"); Console.ReadKey(); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.WriteLine("Press any key to quit."); Console.ReadKey(); // var loadResult = LoadMetadata(inputFile); }
private void SetWalkEndFor(CodeRegion region, int outputLineCnt) { _walkthroughRanges[region.Name].End = outputLineCnt; }
private CodeObject GetOneObject() { CodeObject parent = null; Token token = this.ReadToken(); bool flag = false; bool flag2 = false; bool flag3 = false; CALC nONE = CALC.NONE; while (true) { if (token.Type == Scorpio.Compiler.TokenType.Not) { flag = true; } else if (token.Type == Scorpio.Compiler.TokenType.Minus) { flag2 = true; } else { if (token.Type != Scorpio.Compiler.TokenType.Negative) { break; } flag3 = true; } token = this.ReadToken(); } if (token.Type == Scorpio.Compiler.TokenType.Increment) { nONE = CALC.PRE_INCREMENT; token = this.ReadToken(); } else if (token.Type == Scorpio.Compiler.TokenType.Decrement) { nONE = CALC.PRE_DECREMENT; token = this.ReadToken(); } switch (token.Type) { case Scorpio.Compiler.TokenType.LeftBrace: this.UndoToken(); parent = this.GetTable(); break; case Scorpio.Compiler.TokenType.LeftPar: parent = new CodeRegion(this.GetObject()); this.ReadRightParenthesis(); break; case Scorpio.Compiler.TokenType.LeftBracket: this.UndoToken(); parent = this.GetArray(); break; case Scorpio.Compiler.TokenType.Function: this.UndoToken(); parent = new CodeFunction(this.ParseFunctionDeclaration(false)); break; case Scorpio.Compiler.TokenType.Boolean: case Scorpio.Compiler.TokenType.Number: case Scorpio.Compiler.TokenType.String: case Scorpio.Compiler.TokenType.SimpleString: parent = new CodeScriptObject(this.m_script, token.Lexeme); break; case Scorpio.Compiler.TokenType.Null: parent = new CodeScriptObject(this.m_script, null); break; case Scorpio.Compiler.TokenType.Eval: parent = this.GetEval(); break; case Scorpio.Compiler.TokenType.Identifier: parent = new CodeMember((string)token.Lexeme); break; default: throw new ParserException("Object起始关键字错误 ", token); } parent.StackInfo = new StackInfo(this.m_strBreviary, token.SourceLine); parent = this.GetVariable(parent); parent.Not = flag; parent.Minus = flag2; parent.Negative = flag3; if (parent is CodeMember) { if (nONE != CALC.NONE) { ((CodeMember)parent).Calc = nONE; return(parent); } Token token2 = this.ReadToken(); if (token2.Type == Scorpio.Compiler.TokenType.Increment) { nONE = CALC.POST_INCREMENT; } else if (token2.Type == Scorpio.Compiler.TokenType.Decrement) { nONE = CALC.POST_DECREMENT; } else { this.UndoToken(); } if (nONE != CALC.NONE) { ((CodeMember)parent).Calc = nONE; } return(parent); } if (nONE != CALC.NONE) { throw new ParserException("++ 或者 -- 只支持变量的操作", token); } return(parent); }