/// <summary> /// Initializes a new instance of the <see cref="AssetResolver" /> class. /// </summary> /// <param name="containsLocation">The delegate used to check if an asset location is already used.</param> /// <param name="containsAssetWithId">The delegate used to check if an asset identifier is already used.</param> public AssetResolver(NamingHelper.ContainsLocationDelegate containsLocation, ContainsAssetWithIdDelegate containsAssetWithId) { ExistingIds = new HashSet<AssetId>(); ExistingLocations = new HashSet<string>(StringComparer.OrdinalIgnoreCase); ContainsLocation = containsLocation; ContainsAssetWithId = containsAssetWithId; }
/// <summary> /// Initializes a new instance of the <see cref="AssetResolver" /> class. /// </summary> /// <param name="containsLocation">The delegate used to check if an asset location is already used.</param> /// <param name="containsAssetWithId">The delegate used to check if an asset identifier is already used.</param> public AssetResolver(NamingHelper.ContainsLocationDelegate containsLocation, ContainsAssetWithIdDelegate containsAssetWithId) { existingIds = new HashSet<Guid>(); existingLocations = new HashSet<string>(StringComparer.OrdinalIgnoreCase); ContainsLocation = containsLocation; ContainsAssetWithId = containsAssetWithId; this.containsLocation = DefaultContainsLocation; containsId = DefaultContainsId; }
public override void Visit(AccessColumnNode node) { if (_aliases.ContainsKey(node.Alias)) { base.Visit(new AccessColumnNode(NamingHelper.ToColumnName(node.Alias, node.Name), _aliases[node.Alias], node.ReturnType, TextSpan.Empty)); } else { base.Visit(node); } }
public static string DefaultScalarFieldTypeMapping(GraphQlType baseType, string valueName) { var propertyName = NamingHelper.ToPascalCase(valueName); if (propertyName == "From" || propertyName == "ValidFrom" || propertyName == "CreatedAt" || propertyName == "To" || propertyName == "ValidTo" || propertyName == "ModifiedAt" || propertyName.EndsWith("Timestamp")) { return("DateTimeOffset?"); } return("string"); }
public static MessageDescription CreateEmptyMessageDescription(OperationDescription operation, bool isResponse, MessageDirection direction, string overridingAction) { string action = overridingAction ?? NamingHelper.GetMessageAction(operation, isResponse); MessageDescription result = new MessageDescription(action, direction); // Clear message wrapper result.Body.WrapperName = null; result.Body.WrapperNamespace = null; return(result); }
public static MessageDescription CreateFromMessageContract(OperationDescription operation, bool isResponse, MessageDirection direction, string overridingAction, Type messageContractType) { string action = overridingAction ?? NamingHelper.GetMessageAction(operation, isResponse); // TypeLoader typeLoader = new TypeLoader(); return(typeLoader.CreateTypedMessageDescription(messageContractType, null, null, operation.DeclaringContract.Namespace, action, direction)); }
public void GetUniqueName_EmptyCollection_ReturnNameBase() { // Setup const string nameBase = "The basic name"; IEnumerable <ObjectWithName> existingObjects = Enumerable.Empty <ObjectWithName>(); // Call string name = NamingHelper.GetUniqueName(existingObjects, nameBase, namedObject => namedObject.Name); // Assert Assert.AreEqual(nameBase, name); }
public static FaultDescription CreateFaultDescription(OperationDescription operation, Type faultType, string overridingAction) { string name = NamingHelper.TypeName(faultType) + "Fault"; string action = overridingAction ?? (NamingHelper.GetMessageAction(operation, false) + name); FaultDescription description = new FaultDescription(action) { Namespace = operation.DeclaringContract.Namespace, DetailType = faultType }; description.SetNameOnly(new System.ServiceModel.Description.XmlName(name)); return(description); }
private static void AssertMetaData(IEnumerable <HydraulicBoundaryLocationCalculation> calculations, HydraulicBoundaryLocation hydraulicBoundaryLocation, MapFeature mapFeature, double targetProbability, string displayName, List <string> presentedMetaDataItems) { string uniqueName = NamingHelper.GetUniqueName( presentedMetaDataItems, string.Format(displayName, ProbabilityFormattingHelper.Format(targetProbability)), v => v); MapFeaturesMetaDataTestHelper.AssertMetaData( GetExpectedResult(calculations, hydraulicBoundaryLocation), mapFeature, uniqueName); presentedMetaDataItems.Add(uniqueName); }
protected override void Initialize(ParameterLoadingAnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var eventDeclaration = (EventStatementSyntax)c.Node; if (!NamingHelper.IsRegexMatch(eventDeclaration.Identifier.ValueText, Pattern)) { c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, eventDeclaration.Identifier.GetLocation(), Pattern)); } }, SyntaxKind.EventStatement); }
public static FaultDescription CreateFaultDescription(OperationDescription operation, Type faultType, string overridingAction) { string name = NamingHelper.TypeName(faultType) + TypeLoader.FaultSuffix; string action = overridingAction ?? NamingHelper.GetMessageAction(operation, false) + name; FaultDescription result = new FaultDescription(action) { Namespace = operation.DeclaringContract.Namespace, DetailType = faultType }; result.SetNameOnly(new XmlName(name)); return(result); }
public static void AddMessagePartDescription(OperationDescription operation, bool isResponse, MessageDescription message, Type type, SerializerOption serializerOption) { if (type != null) { string partName; string partNamespace; if (serializerOption == SerializerOption.DataContractSerializer) { XmlQualifiedName xmlQualifiedName = XsdDataContractExporter.GetRootElementName(type); if (xmlQualifiedName == null) { xmlQualifiedName = XsdDataContractExporter.GetSchemaTypeName(type); } if (!xmlQualifiedName.IsEmpty) { partName = xmlQualifiedName.Name; partNamespace = xmlQualifiedName.Namespace; } else { // For anonymous type, we assign CLR type name and contract namespace to MessagePartDescription partName = type.Name; partNamespace = operation.DeclaringContract.Namespace; } } else { XmlTypeMapping xmlTypeMapping = XmlReflectionImporter.ImportTypeMapping(type); partName = xmlTypeMapping.ElementName; partNamespace = xmlTypeMapping.Namespace; } MessagePartDescription messagePart = new MessagePartDescription(NamingHelper.XmlName(partName), partNamespace) { Index = 0, Type = type // We do not infer MessagePartDescription.ProtectionLevel }; message.Body.Parts.Add(messagePart); } if (isResponse) { SetReturnValue(message, operation); } }
private static string CreateParameterName(ITypeSymbol typeSymbol, SemanticModel semanticModel) { string name = NamingHelper.CreateIdentifierName( typeSymbol, firstCharToLower: true); if (!string.IsNullOrEmpty(name) && !string.Equals(typeSymbol.Name, name, StringComparison.Ordinal)) { return(name); } return(null); }
/// <summary> /// Returns initialized <see cref="SearchServiceClient"/> based on index name "sample-dancinggoat-coffee-azure". /// </summary> private ISearchIndexClient GetSearchClient() { var indexName = NamingHelper.GetValidIndexName("sample-dancinggoat-coffee-azure"); var indexInfo = SearchIndexInfoProvider.GetSearchIndexInfo(indexName); if (indexInfo == null) { return(null); } var serviveClient = new SearchServiceClient(indexInfo.IndexSearchServiceName, new SearchCredentials(indexInfo.IndexAdminKey)); return(serviveClient.Indexes.GetClient(indexName)); }
protected override void Initialize(ParameterLoadingAnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var parameterDeclaration = (ParameterSyntax)c.Node; if (parameterDeclaration.Identifier != null && !NamingHelper.IsRegexMatch(parameterDeclaration.Identifier.Identifier.ValueText, Pattern)) { c.ReportDiagnostic(Diagnostic.Create(Rule, parameterDeclaration.Identifier.Identifier.GetLocation(), Pattern)); } }, SyntaxKind.Parameter); }
private static void AddWaveConditionsCalculation(WaveImpactAsphaltCoverCalculationGroupContext nodeData) { var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation { Name = NamingHelper.GetUniqueName(nodeData.WrappedData.Children, RiskeerCommonDataResources.Calculation_DefaultName, c => c.Name) }; WaveConditionsInputHelper.SetWaterLevelType(calculation.InputParameters, nodeData.AssessmentSection.FailureMechanismContribution.NormativeProbabilityType); nodeData.WrappedData.Children.Add(calculation); nodeData.WrappedData.NotifyObservers(); }
private void GenerateWrapperClassDestructors(NodeJSTypeReference classToWrapTypeReference) { Class classToWrap = classToWrapTypeReference.Declaration as Class; string classNameWrap = NamingHelper.GenerateClassWrapName(classToWrap.Name); string classNameWrapperMember = NamingHelper.GenerateClassWrapperMember(classToWrap.Name); // Destructor for wrapped class PushBlock(BlockKind.Method); WriteLine("{0}::~{0}()", classNameWrap); WriteStartBraceIndent(); WriteLine("delete {0};", classNameWrapperMember); WriteCloseBraceIndent(); PopBlock(NewLineKind.BeforeNextBlock); }
public void TestNamespace() { Assert.True(NamingHelper.IsValidNamespace("a")); Assert.True(NamingHelper.IsValidNamespace("aThisIsOk")); Assert.True(NamingHelper.IsValidNamespace("aThis._IsOk")); Assert.True(NamingHelper.IsValidNamespace("a.b.c")); Assert.False(NamingHelper.IsValidNamespace("")); Assert.False(NamingHelper.IsValidNamespace("a . w")); Assert.False(NamingHelper.IsValidNamespace("a e zaThis._IsOk")); Assert.False(NamingHelper.IsValidNamespace("9.b.c")); Assert.False(NamingHelper.IsValidNamespace("a.b.")); Assert.False(NamingHelper.IsValidNamespace(".a.")); }
public override void Visit(DotNode node) { if (!(node.Root is DotNode) && node.Root is AccessColumnNode column) { Nodes.Pop(); Nodes.Pop(); var name = $"{NamingHelper.ToColumnName(column.Alias, column.Name)}.{node.Expression.ToString()}"; Nodes.Push(new AccessColumnNode(name, string.Empty, node.ReturnType, TextSpan.Empty)); return; } base.Visit(node); }
protected override void Initialize(ParameterLoadingAnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var typeParameter = (TypeParameterSyntax)c.Node; if (!NamingHelper.IsRegexMatch(typeParameter.Identifier.ValueText, Pattern)) { c.ReportDiagnostic(Diagnostic.Create(rule, typeParameter.Identifier.GetLocation(), typeParameter.Identifier.ValueText, Pattern)); } }, SyntaxKind.TypeParameter); }
private void WriteTransitionProperty(IAttribute attribute) { cw.BeginProperty(AccessLevel.Public, VirtualisationLevel.None, interfacesEnvironment.ToTypeName(attribute, true), NamingHelper.ToDTOPropertyName(attribute)); cw.WritePropertyGet("return this.{0}.{1};", NamingHelper.PropertyName_AdapterDTO, NamingHelper.ToDTOPropertyName(attribute)); cw.WritePropertySet("this.{0}.{1} = value; NotifyPropertyChanged(\"{1}\");", NamingHelper.PropertyName_AdapterDTO, NamingHelper.ToDTOPropertyName(attribute)); cw.EndProperty(); }
private bool ExportCalculationGroup(CalculationGroup nestedGroup, string currentFolderPath, List <string> exportedGroups) { string uniqueGroupName = NamingHelper.GetUniqueName(exportedGroups, nestedGroup.Name, group => group); bool exportSucceeded = ExportCalculationItemsRecursively(nestedGroup, Path.Combine(currentFolderPath, uniqueGroupName)); if (!exportSucceeded) { return(false); } exportedGroups.Add(uniqueGroupName); return(true); }
public void GetUniqueName() { var item1 = mocks.Stub <INameable>(); var item2 = mocks.Stub <INameable>(); var item3 = mocks.Stub <INameable>(); item1.Name = "one (1)"; item2.Name = "one"; item3.Name = "INameable1"; var namedItems = new List <INameable>(new[] { item1, item2, item3 }); Assert.AreEqual("INameable2", NamingHelper.GetUniqueName(null, namedItems, typeof(INameable))); Assert.AreEqual("one (2)", NamingHelper.GetUniqueName("one ({0})", namedItems, typeof(INameable))); }
/// <summary> /// Formats the name of a database constraint according to the naming conventions configuration /// </summary> /// <param name="constraint">The constraint</param> /// <returns>The formatted constraint name</returns> public string ToConstraintName(string constraint) { string result = null; switch (namingConventions.ConstraintNamingConvention) { case ConstraintNamingConvention.Default: result = constraint; break; case ConstraintNamingConvention.Lowercase: result = NamingHelper.ToLowercase(constraint); break; case ConstraintNamingConvention.Uppercase: result = NamingHelper.ToUppercase(constraint); break; } return(result); }
protected override void Initialize(ParameterLoadingAnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var declaration = (NamespaceStatementSyntax)c.Node; var declarationName = declaration.Name?.ToString(); if (declarationName != null && !NamingHelper.IsRegexMatch(declarationName, Pattern)) { c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, declaration.Name.GetLocation(), Pattern)); } }, SyntaxKind.NamespaceStatement); }
protected override void Initialize(ParameterLoadingAnalysisContext context) { context.RegisterSyntaxNodeActionInNonGenerated( c => { var methodDeclaration = (MethodStatementSyntax)c.Node; if (!NamingHelper.IsRegexMatch(methodDeclaration.Identifier.ValueText, Pattern) && IsEventHandler(methodDeclaration, c.SemanticModel)) { c.ReportDiagnosticWhenActive(Diagnostic.Create(rule, methodDeclaration.Identifier.GetLocation(), methodDeclaration.Identifier.ValueText, Pattern)); } }, SyntaxKind.SubStatement); }
public void TestCamelCase() { { var s = NamingHelper.CamelCaseFromString(" hello world, this is some long string "); Assert.AreEqual("HelloWorldThisIsSomeLongString", s); } { var s = NamingHelper.CamelCaseFromString("HelloWorld"); Assert.AreEqual("HelloWorld", s); } { var s = NamingHelper.CamelCaseFromString("hi SQL world"); Assert.AreEqual("HiSQLWorld", s); } }
public void GetUniqueName_CollectionWithNamedObjectMatchingNameBase_ReturnNameBaseAppendedWithPostfixIncrement() { // Setup const string nameBase = "The basic name"; var existingObjects = new[] { new ObjectWithName(nameBase) }; // Call string name = NamingHelper.GetUniqueName(existingObjects, nameBase, namedObject => namedObject.Name); // Assert Assert.AreEqual(nameBase + " (1)", name); }
public static ClassDeclarationSyntax ClassWithInjected<TInjected>(string className) { var (typeName, variableName) = NamingHelper.GetNames<TInjected>(); var classCode = $@"class {className} {{ private readonly {typeName} _{variableName}; public {className}( {typeName} {variableName}) {{ _{variableName} = {variableName}; }} }}"; return ParseClass(classCode); }
public ManyToOneRelation NewManyToOneRelation(ModelClass pkClass, ModelClass fkClass, string fkColumn) { ManyToOneRelation relation = new ManyToOneRelation(fkClass, pkClass); // TODO: Disabled to test server explorer drag drop bug of DeviceBuffer /*Log( * String.Format("Relation: Type=ManyToOne, PKClass={0}, FKClass={1}, Column={2}", pkClass.Name, * fkClass.Name, fkColumn));*/ relation.SourceColumn = fkColumn; relation.TargetColumnKey = fkColumn; relation.TargetTable = fkClass.Table; relation.TargetPropertyName = NamingHelper.GetPlural(fkClass.Name); return(relation); }
public ScalarFieldTypeDescription GetCustomScalarFieldType(GraphQlGeneratorConfiguration configuration, GraphQlType baseType, GraphQlTypeBase valueType, string valueName) { valueName = NamingHelper.ToPascalCase(valueName); if (valueName == "From" || valueName == "ValidFrom" || valueName == "To" || valueName == "ValidTo" || valueName == "CreatedAt" || valueName == "UpdatedAt" || valueName == "ModifiedAt" || valueName == "DeletedAt" || valueName.EndsWith("Timestamp")) { return new ScalarFieldTypeDescription { NetTypeName = "DateTimeOffset?" } } ; return(GetFallbackFieldType(configuration, valueType)); }
public void GetUniqueName_CollectionWithNamedObjectNotMatchingNameBase_ReturnNameBase() { // Setup const string nameBase = "The basic name"; var existingObjects = new[] { new ObjectWithName("Something original!") }; // Call string name = NamingHelper.GetUniqueName(existingObjects, nameBase, namedObject => namedObject.Name); // Assert Assert.AreEqual(nameBase, name); }