public virtual void Execute(XmlNode node) { var reportNodes = node.SelectNodes("./Report"); foreach (XmlNode reportNode in reportNodes) { var name = reportNode.Attributes["Name"].Value; var path = reportNode.SelectSingleNode("./Path")?.InnerXml; path = path ?? $"{NamingConvention.Apply(name)}.rdl"; if (!Path.IsPathRooted(path)) { path = Path.Combine(RootPath ?? string.Empty, path); } var description = reportNode.SelectSingleNode("./Description")?.InnerXml; var hidden = bool.Parse(reportNode.Attributes["Hidden"]?.Value ?? bool.FalseString); reportService.Create(name, ParentPath, path, description, hidden, Root?.DataSources, Root?.SharedDatasets); foreach (var childParser in ChildrenParsers) { childParser.ParentPath = $"{ParentPath}/{name}"; childParser.Execute(reportNode); } } }
private ScriptableObjectBinder(Type type, JSBindingOptions options, NamingConvention namingConvention) { if (type == null) throw new ArgumentNullException("type"); if (!type.IsClass && !type.IsInterface) throw new ArgumentException("The type must be a class or interface."); this.type = type; var attr = GetJSObjectAttribute(this.type); if (attr != null) { if (options == JSBindingContext.DefaultOptions) { this.options = attr.Options; } } else { this.options = options; } this.namingConvention = namingConvention; this.Create(); Debug.Assert(this.dispatchTable != null); Debug.Assert(this.propertyDispatchTable != null); if ((this.options & JSBindingOptions.LazyCompile) == 0) { this.Compile(); } }
public bool IsNamingConventionType(NamingConvention namingConvention, string value) { switch (namingConvention) { case NamingConvention.CamelCase: return(!value.Contains(" ") && !value.Contains("-") && char.IsLower(value.First())); case NamingConvention.PascalCase: return(!value.Contains(" ") && !value.Contains("-") && char.IsUpper(value.First())); case NamingConvention.TitleCase: return(!value.Contains("-") && char.IsUpper(value.First())); case NamingConvention.SnakeCase: return(!value.Contains(" ") && !value.Any(c => char.IsUpper(c))); } throw new NotImplementedException(); }
private static Boolean KawigiEdit_RunTest(int testNum, string p0, Boolean hasAnswer, string p1) { Console.Write("Test " + testNum + ": [" + "\"" + p0 + "\""); Console.WriteLine("]"); NamingConvention obj; string answer; obj = new NamingConvention(); DateTime startTime = DateTime.Now; answer = obj.toCamelCase(p0); DateTime endTime = DateTime.Now; Boolean res; res = true; Console.WriteLine("Time: " + (endTime - startTime).TotalSeconds + " seconds"); if (hasAnswer) { Console.WriteLine("Desired answer:"); Console.WriteLine("\t" + "\"" + p1 + "\""); } Console.WriteLine("Your answer:"); Console.WriteLine("\t" + "\"" + answer + "\""); if (hasAnswer) { res = answer == p1; } if (!res) { Console.WriteLine("DOESN'T MATCH!!!!"); } else if ((endTime - startTime).TotalSeconds >= 2) { Console.WriteLine("FAIL the timeout"); res = false; } else if (hasAnswer) { Console.WriteLine("Match :-)"); } else { Console.WriteLine("OK, but is it right?"); } Console.WriteLine(""); return res; }
public void TestConvert() { string name1 = "_DFC.EntityType__Root_SUFFIX_term10"; string name2 = "_DFC_ENTITY_Type_Root_SUFFIX_TERM10"; string name3 = "_Dfc_Entity_type_RootSuffix_term10"; NamingConvention c = new NamingConvention(NamingStyle.LowerCase); string nameLC = "_dfc_entity_type_root_suffix_term10"; Assert.AreEqual(nameLC, c.Convert(name1)); Assert.AreEqual(nameLC, c.Convert(name2)); Assert.AreEqual(nameLC, c.Convert(name3)); c = new NamingConvention(NamingStyle.UpperCase); string nameUC = "_DFC_ENTITY_TYPE_ROOT_SUFFIX_TERM10"; Assert.AreEqual(nameUC, c.Convert(name1)); Assert.AreEqual(nameUC, c.Convert(name2)); Assert.AreEqual(nameUC, c.Convert(name3)); c = new NamingConvention(NamingStyle.CamelCase); string nameCC = "DfcEntityTypeRootSuffixTerm10"; Assert.AreEqual(nameCC, c.Convert(name1)); Assert.AreEqual(nameCC, c.Convert(name2)); Assert.AreEqual(nameCC, c.Convert(name3)); }
public async Task <Document> ScaffoldAsync(SyntaxNode syntax, NamingConvention naming) { var name = syntax.DescendantNodes().OfType <ClassDeclarationSyntax>() .Select(x => x.Identifier.ToString()) .FirstOrDefault() ?? "Avatar"; var document = project.AddDocument(nameof(AvatarScaffold), // NOTE: if we don't force re-parsing in the context of our own // project, nested types can't be resolved, for some reason :/ syntax.NormalizeWhitespace().ToFullString(), folders: naming.RootNamespace.Split('.'), filePath: name); foreach (var refactoring in refactorings) { document = await document.ApplyCodeActionAsync(refactoring, cancellationToken : context.CancellationToken); } foreach (var codeFix in codeFixes) { document = await document.ApplyCodeFixAsync(codeFix, cancellationToken : context.CancellationToken); } return(document); }
public JsonDeserializer(NamingConvention namingConvention = NamingConvention.CamelHump) { _jsonSettings = new JsonSerializerSettings(); NamingStrategy selectedNamingStrategy; switch (namingConvention) { case NamingConvention.CamelHump: selectedNamingStrategy = new CamelCaseNamingStrategy(true, false); break; case NamingConvention.SnakeCase: selectedNamingStrategy = new SnakeCaseNamingStrategy(true, false); break; default: selectedNamingStrategy = new DefaultNamingStrategy(); break; } _jsonSettings.ContractResolver = new PrivateSetterContractResolver { NamingStrategy = selectedNamingStrategy }; }
public virtual Database LinkTables() { foreach (var table in Tables) { foreach (var column in table.Columns) { if (table.PrimaryKey?.Key.Count == 1 && table.PrimaryKey.Key.Contains(column.Name)) { continue; } foreach (var parentTable in Tables) { if (table.FullName == parentTable.FullName) { continue; } if (parentTable.PrimaryKey != null && parentTable.PrimaryKey.Key.Contains(column.Name)) { table.ForeignKeys.Add(new ForeignKey(column.Name) { ConstraintName = NamingConvention.GetForeignKeyConstraintName(table, new string[] { column.Name }, parentTable), References = string.Format("{0}.{1}", Name, parentTable.FullName), Child = table.FullName }); } } } } return(this); }
public LoadDriver(IDockerNetwork network, NamingConvention namingConvention, TestConfig testConfig) { _network = network ?? throw new ArgumentNullException(nameof(network)); if (namingConvention == null) { throw new ArgumentNullException(nameof(namingConvention)); } if (testConfig == null) { throw new ArgumentNullException(nameof(testConfig)); } _logStream = File.Create(Path.Combine(namingConvention.ContainerLogs, "k6.txt")); _resultStream = File.Create(Path.Combine(namingConvention.AgentResults, K6ResultsFile)); _hostScriptPath = Path.Combine(Directory.GetCurrentDirectory(), "K6", "basic.js"); _container = new TestcontainersBuilder <TestcontainersContainer>() .WithImage(LoadDriveImageName) .WithName($"{OverheadTest.Prefix}-k6-load") .WithNetwork(_network) .WithCommand("run", "-u", testConfig.ConcurrentConnections.ToString(), "-e", $"ESHOP_HOSTNAME={EshopApp.ContainerName}", "-i", testConfig.Iterations.ToString(), "--rps", testConfig.MaxRequestRate.ToString(), ContainerScriptPath, "--summary-export", ContainerResultsPath) .WithBindMount(_hostScriptPath, ContainerScriptPath) .WithOutputConsumer(Consume.RedirectStdoutAndStderrToStream(_logStream, _logStream)) .Build(); }
public static SerializerBuilder WithNamingConvention(this SerializerBuilder serializerBuilder, NamingConvention namingConvention) { var target = GetNamingConvention(namingConvention); return(serializerBuilder.WithNamingConvention(target)); }
public void Can_create_configuration_report() { var sut = ConfigurationReporter.CreateDefault(); new ConfigurationBuilder(ConfigurationKeys("key1", "key2"), None) .WithConfigurationSource(new ConfigurationSourceStub( ("KEY2", "value") )) .WithConfigurations(new Dictionary <string, string> { { "key3", "value" } }) .WithNamingConventions(NamingConvention.Default, NamingConvention.UseCustom(x => x.ToUpper())) .WithConfigurationReporter(sut) .Build(); var report = sut.Report(); _output.WriteLine(report); Assert.Equal(expected: $"{NL}" + $"key source value keys{NL}" + $"-----------------------------------------------{NL}" + $"key3 MANUAL value {NL}" + $"key1 ConfigurationSourceStub MISSING key1, KEY1{NL}" + $"key2 ConfigurationSourceStub value KEY2{NL}", report); }
private static INamingConvention GetNamingConvention(NamingConvention namingConvention) { INamingConvention target; switch (namingConvention) { case NamingConvention.Camel: target = new CamelCaseNamingConvention(); break; case NamingConvention.Hyphenated: target = new HyphenatedNamingConvention(); break; case NamingConvention.Pascal: target = new PascalCaseNamingConvention(); break; case NamingConvention.Underscored: target = new UnderscoredNamingConvention(); break; case NamingConvention.Null: target = new NullNamingConvention(); break; default: throw new NotImplementedException(namingConvention.ToString()); } return(target); }
public void SetConsumerName_Works(Type eventType, Type consumerType, bool useFullTypeNames, string prefix, bool suffixEventName, ConsumerNameSource consumerNameSource, NamingConvention namingConvention, string expected) { var environment = new FakeHostEnvironment("app1"); var options = new EventBusOptions { }; options.Naming.Convention = namingConvention; options.Naming.UseFullTypeNames = useFullTypeNames; options.Naming.ConsumerNameSource = consumerNameSource; options.Naming.ConsumerNamePrefix = prefix; options.Naming.SuffixConsumerName = suffixEventName; var registration = new EventRegistration(eventType); registration.Consumers.Add(new EventConsumerRegistration(consumerType)); var creg = Assert.Single(registration.Consumers); registration.SetEventName(options.Naming) .SetConsumerNames(options.Naming, environment); Assert.Equal(expected, creg.ConsumerName); }
public override SyntaxNode CreateSyntax(NamingConvention naming, INamedTypeSymbol[] symbols) { var name = naming.GetName(symbols); var imports = new HashSet <string>(); var(baseType, implementedInterfaces) = symbols.ValidateGeneratorTypes(); if (baseType != null) { AddImports(imports, baseType); } foreach (var iface in implementedInterfaces) { AddImports(imports, iface); } return(CompilationUnit() .WithUsings( List( imports.Select(ns => UsingDirective(ParseName(ns))))) .WithMembers( SingletonList <MemberDeclarationSyntax>( NamespaceDeclaration(ParseName(naming.GetNamespace(symbols))) .WithMembers( SingletonList <MemberDeclarationSyntax>( ClassDeclaration(name) .WithModifiers(TokenList(Token(SyntaxKind.PartialKeyword))) .WithBaseList( BaseList( SeparatedList <BaseTypeSyntax>( symbols.Select(AsTypeSyntax).Select(t => SimpleBaseType(t)))))))))); }
/// <summary>Converts this object to a convention.</summary> /// <exception cref="ArgumentNullException">Thrown when one or more required arguments are null.</exception> /// <exception cref="ArgumentException"> Thrown when one or more arguments have unsupported or /// illegal values.</exception> /// <param name="name"> The value.</param> /// <param name="path"> Full pathname of the file.</param> /// <param name="convention"> The convention.</param> /// <param name="concatenatePath"> (Optional) True to concatenate path.</param> /// <param name="concatenationDelimiter">(Optional) The concatenation delimiter.</param> /// <returns>The given data converted to a string.</returns> public static string ToConvention( string name, string path, NamingConvention convention, bool concatenatePath = false, string concatenationDelimiter = "") { string value = name; if (concatenatePath && (!string.IsNullOrEmpty(path))) { value = path; } if (string.IsNullOrEmpty(value)) { throw new ArgumentNullException(nameof(name)); } switch (convention) { case NamingConvention.FhirDotNotation: return(value); case NamingConvention.PascalDotNotation: { string[] components = ToPascal(value.Split('.')); return(string.Join(".", components)); } case NamingConvention.PascalCase: { string[] components = ToPascal(value.Split('.')); return(string.Join(concatenationDelimiter, components)); } case NamingConvention.CamelCase: { string[] components = ToCamel(value.Split('.')); return(string.Join(concatenationDelimiter, components)); } case NamingConvention.UpperCase: { string[] components = ToUpperInvariant(value.Split('.')); return(string.Join(concatenationDelimiter, components)); } case NamingConvention.LowerCase: { string[] components = ToLowerInvariant(value.Split('.')); return(string.Join(concatenationDelimiter, components)); } case NamingConvention.None: default: throw new ArgumentException($"Invalid Naming Convention: {convention}"); } }
protected SqlServerBase(NamingConvention namingConvention) { if (namingConvention == null) { throw new ArgumentNullException(nameof(namingConvention)); } Stream = File.Create(Path.Combine(namingConvention.ContainerLogs, "sqlserver.txt")); }
protected override NamingConvention CreateNamingConvention() { var namingConvension = new NamingConvention { LetterCasePolicy = LetterCasePolicy.Default }; return(namingConvension); }
public IActionResult Index([FromQuery] NamingConvention conv) { ViewData["conv"] = Helper.NamingConventionList(conv); ViewData["root"] = Helper.Notes[conv]; ViewData["type"] = Helper.ChordTypeList; return(View()); }
public void Can_use_environment_style_naming_convention_with_prefix() { var sut = NamingConvention.UseEnvironmentStyle("DEFAULT_KAFKA"); var result = sut.GetKey("group.id"); Assert.Equal("DEFAULT_KAFKA_GROUP_ID", result); }
public void Can_use_environment_style_naming_convention() { var sut = NamingConvention.UseEnvironmentStyle(); var result = sut.GetKey("group.id"); Assert.Equal("GROUP_ID", result); }
public void Can_use_custom_naming() { var sut = NamingConvention.UseCustom(s => s.ToUpper()); var result = sut.GetKey("group.id"); Assert.Equal("GROUP.ID", result); }
public void Using_custom_toupper_with_turkish_culture_will_fail() { var sut = NamingConvention.UseCustom(s => s.ToUpper()); var result = sut.GetKey("group.id"); Assert.NotEqual("GROUP.ID", result); }
protected override NamingConvention CreateNamingConvention() { var namingConvention = new NamingConvention { LetterCasePolicy = LetterCasePolicy.Lowercase }; return(namingConvention); }
/// <summary> /// Converts the value of a type specified by a generic type parameter into a YAML-formatted array of UTF-8 /// encoded bytes. /// </summary> /// <param name="value">The object to parse to YAML.</param> /// <param name="compressionType">The type of compression to use.</param> /// <param name="namingConvention">The naming convention to use.</param> /// <returns>A YAML-formatted UTF-8 encoded array of bytes, parsed from the given object.</returns> public static async Task <byte[]> GetBytesAsync(object value, NamingConvention namingConvention, CompressionType compressionType) { var bytes = await GetBytesAsync(namingConvention).ConfigureAwait(false); return(compressionType == CompressionType.None ? bytes : await Utility.CompressHelperAsync(bytes, compressionType).ConfigureAwait(false)); }
/// <summary> /// Converts the value of a type specified by a generic type parameter into a JSON-formatted array of UTF-8 /// encoded bytes. /// </summary> /// <param name="value">The object to parse to JSON.</param> /// <param name="namingConvention">The naming convention to write in.</param> /// <returns>A JSON-formatted UTF-8 encoded array of bytes, parsed from the given object.</returns> public static MemoryStream GetStream(object value, NamingConvention namingConvention) { var stream = new MemoryStream(); Serialise_Internal(stream, value, namingConvention); return(stream); }
private void CheckNaming(SyntaxToken currentIdentifier, string memberType, NamingConvention convention, SyntaxNodeAnalysisContext context) { var conventionedIdentifier = currentIdentifier.WithConvention(convention); if (conventionedIdentifier.Text != currentIdentifier.Text) { context.ReportDiagnostic(Diagnostic.Create(Rule, currentIdentifier.GetLocation(), memberType, currentIdentifier.Text, conventionedIdentifier.Text)); } }
/// <summary> /// Converts the element to a native configuration object it corresponds to - /// i.e. to a <see cref="DomainConfiguration"/> object. /// </summary> /// <returns>The result of conversion.</returns> public DomainConfiguration ToNative() { var config = new DomainConfiguration { Name = Name, ConnectionInfo = ConnectionInfoParser.GetConnectionInfo(CurrentConfiguration, ConnectionUrl, Provider, ConnectionString), NamingConvention = NamingConvention.ToNative(), KeyCacheSize = KeyCacheSize, KeyGeneratorCacheSize = KeyGeneratorCacheSize, QueryCacheSize = QueryCacheSize, RecordSetMappingCacheSize = RecordSetMappingCacheSize, DefaultSchema = DefaultSchema, DefaultDatabase = DefaultDatabase, UpgradeMode = ParseEnum <DomainUpgradeMode>(UpgradeMode), ForeignKeyMode = ParseEnum <ForeignKeyMode>(ForeignKeyMode), SchemaSyncExceptionFormat = ParseEnum <SchemaSyncExceptionFormat>(SchemaSyncExceptionFormat), Options = ParseEnum <DomainOptions>(Options), ServiceContainerType = ServiceContainerType.IsNullOrEmpty() ? null : Type.GetType(ServiceContainerType), IncludeSqlInExceptions = IncludeSqlInExceptions, BuildInParallel = BuildInParallel, AllowCyclicDatabaseDependencies = AllowCyclicDatabaseDependencies, ForcedServerVersion = ForcedServerVersion, Collation = Collation, ConnectionInitializationSql = ConnectionInitializationSql, MultidatabaseKeys = MultidatabaseKeys, ShareStorageSchemaOverNodes = ShareStorageSchemaOverNodes, EnsureConnectionIsAlive = EnsureConnectionIsAlive, FullTextChangeTrackingMode = ParseEnum <FullTextChangeTrackingMode>(FullTextChangeTrackingMode), VersioningConvention = VersioningConvention.ToNative() }; foreach (var element in Types) { config.Types.Register(element.ToNative()); } foreach (var element in Sessions) { config.Sessions.Add(element.ToNative()); } foreach (var element in MappingRules) { config.MappingRules.Add(element.ToNative()); } foreach (var element in Databases) { config.Databases.Add(element.ToNative()); } foreach (var element in KeyGenerators) { config.KeyGenerators.Add(element.ToNative()); } foreach (var element in IgnoreRules) { config.IgnoreRules.Add(element.ToNative()); } return(config); }
public void ReturnsRightResultForConventionWithSingleConstantWithoutViewPostfix() { string viewName = "ExampleVW"; string convention = string.Format("ViewModels.{0}ViewModel", NamingConvention.ViewName); string result = NamingConvention.ResolveViewModelByViewName("MyProject.MyAssembly", viewName, convention); Assert.AreEqual("ViewModels.ExampleVWViewModel", result); }
public void ReturnsRightResultForConventionWithMultipleConstants() { string viewName = "ExampleView"; string convention = string.Format("{0}.ViewModels.{1}ViewModel", NamingConvention.Assembly, NamingConvention.ViewName); string result = NamingConvention.ResolveViewModelByViewName("MyProject.MyAssembly", viewName, convention); Assert.AreEqual("MyProject.MyAssembly.ViewModels.ExampleViewModel", result); }
public void ReturnsRightResultForConventionWithSingleConstant() { string viewModelName = "ExampleViewModel"; string convention = string.Format("/Views/{0}View.xaml", NamingConvention.ViewModelName); string result = NamingConvention.ResolveViewByViewModelName("MyProject.MyAssembly", viewModelName, convention); Assert.AreEqual("/Views/ExampleView.xaml", result); }
public void ReturnsRightResultForConventionWithoutConstant() { string viewName = "ExampleView"; string convention = "ViewModels.TestViewModel"; string result = NamingConvention.ResolveViewModelByViewName("MyProject.MyAssembly", viewName, convention); Assert.AreEqual("ViewModels.TestViewModel", result); }
public void TestCamelCase() { Assert.True(NamingConvention.GetCamelCase("FOO") == "foo"); Assert.True(NamingConvention.GetCamelCase("Bar") == "bar"); Assert.True(NamingConvention.GetCamelCase("zaz") == "zaz"); Assert.True(NamingConvention.GetCamelCase("FooBarZaz") == "fooBarZaz"); Assert.True(NamingConvention.GetCamelCase("foo bar zaz") == "fooBarZaz"); Assert.True(NamingConvention.GetCamelCase("foo_bar_zaz") == "fooBarZaz"); }
private JSObjectBinder(Type type, JSBindingOptions options, NamingConvention namingConvention) { if (type == null) throw new ArgumentNullException("type"); if (!type.IsInterface) throw new ArgumentException("Only interface type allowed.", "type"); this.type = type; this.options = options; this.namingConvention = namingConvention; this.proxyType = JSObjectTypeBuilder.Create(type, options, namingConvention); }
public static string ConvertIdentifier(string name, NamingConvention namingConvention) { // TODO: complete this... if (namingConvention == NamingConvention.None) return name; if (char.IsUpper(name[0])) { return char.ToLowerInvariant(name[0]) + name.Substring(1); } return name; }
public static string ConvertMemberName(string name, NamingConvention namingConvention) { // it allow names like Some.Member.Access // TODO: check for incorrect symbols if (!name.Contains('.')) return ConvertIdentifier(name, namingConvention); var parts = name.Split('.'); for (var i = 0; i < parts.Length; i++) { if (string.IsNullOrEmpty(parts[i])) throw new ArgumentException("name"); parts[i] = ConvertIdentifier(parts[i], namingConvention); } return string.Join(".", parts); }
public static INamingConvention Create(NamingConvention convention) { var formatter = new Formatter(DefaultFormatter); switch (convention) { case NamingConvention.None: break; case NamingConvention.PascalCased: formatter = Inflector.Pascalize; break; case NamingConvention.CamelCased: formatter = Inflector.Camelize; break; case NamingConvention.Underscored: formatter = Inflector.Underscore; break; } return new InflectorNamingConvention(formatter); }
public static Type Create(Type targetType, JSBindingOptions options, NamingConvention namingConvention) { Initialize(); // create the type TypeBuilder type = module.DefineType( string.Format("{0}.{1}Proxy", namespaceName, targetType.FullName), TypeAttributes.Public | TypeAttributes.Sealed, typeof(JSObjectBase), new Type[] { targetType } ); // TODO: properties // create members foreach (var method in targetType.GetMethods()) { // explicit interface implementation MethodBuilder mb = type.DefineMethod( targetType.Name + "." + method.Name, MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, method.ReturnType, method.GetParameters().Select(_ => _.ParameterType).ToArray() ); type.DefineMethodOverride(mb, method); var emit = new EmitHelper(mb.GetILGenerator()); emit.LdArg(1) .Ret() ; } return type.CreateType(); }
private static string FormatName(string name, NamingConvention naming) { switch (naming) { case NamingConvention.Pascal: return char.ToUpper(name[0], CultureInfo.InvariantCulture) + name.Substring(1); case NamingConvention.Camel: return char.ToLower(name[0], CultureInfo.InvariantCulture) + name.Substring(1); case NamingConvention.Upper: return name.ToUpper(CultureInfo.InvariantCulture); case NamingConvention.Lower: return name.ToLower(CultureInfo.InvariantCulture); default: return name; } }
internal static SyntaxToken WithConvention(this SyntaxToken identifier, NamingConvention namingConvention) { // int @class = 5; if (identifier.IsVerbatimIdentifier()) { return identifier; } // int cl\u0061ss = 5; if (identifier.Text.Contains("\\")) { return identifier; } var originalValue = identifier.ValueText; string newValue; switch (namingConvention) { case NamingConvention.LowerCamelCase: newValue = GetLowerCamelCaseIdentifier(originalValue); break; case NamingConvention.UpperCamelCase: newValue = GetUpperCamelCaseIdentifier(originalValue); break; case NamingConvention.UnderscoreLowerCamelCase: newValue = GetUnderscoreLowerCamelCaseIdentifier(originalValue); break; case NamingConvention.InterfacePrefixUpperCamelCase: newValue = GetInterfacePrefixUpperCamelCaseIdentifier(originalValue); break; default: throw new ArgumentException(nameof(namingConvention)); } return SyntaxFactory.Identifier(identifier.LeadingTrivia, newValue, identifier.TrailingTrivia); }
public JsonMemberNamingConventionAttribute(NamingConvention convention) : this(convention, UnderscoreConvention.None) { }
internal static NamingStrategy GetStrategy(NamingConvention convention) { switch (convention) { case NamingConvention.Default: return Default; case NamingConvention.LowerCase: return LowerCase; case NamingConvention.CamelCase: return CamelCase; case NamingConvention.UpperCase: return UpperCase; default: throw new NotSupportedException ("NamingConvention " + convention.ToString () + " is not supported."); } }
public JsonMemberNamingConventionAttribute(NamingConvention convention) { _convention = convention; }
/// <summary> /// Specify options as enum. /// </summary> /// <param name="namingConvention"></param> /// <param name="compareMethod"></param> public NotifyAttribute(NamingConvention namingConvention = default(NamingConvention), CompareMethod compareMethod = default(CompareMethod)) { }
public JsonMemberNamingConventionAttribute(NamingConvention naming, UnderscoreConvention underscores) { _convention = naming; _underscores = underscores; }
public JSBindAttribute(NamingConvention namingConvention) : this(true, namingConvention) { }
private static void TestNamingCase(string baseName, NamingConvention testCase, string expected) { JsonMemberNamingConventionAttribute attribute = new JsonMemberNamingConventionAttribute(testCase); TestPropertyDescriptor property = CreateTestProperty(baseName); IPropertyDescriptorCustomization customization = attribute; customization.Apply(property); Assert.AreEqual(expected, property.CustomizedName); }
public JSBindAttribute(bool visible, NamingConvention namingConvention) { this.visible = visible; this.namingConvention = namingConvention; }
public void Render(object data, TextWriter writer, TemplateLocator templateLocator, NamingConvention namingConvention) { Render(data, writer, templateLocator, NamingConventionFactory.Create(namingConvention)); }