Beispiel #1
0
        public void TranslateReturnsInputIfNoSettings()
        {
            var input  = "MyNamespace.Test";
            var actual = NamespaceTranslator.Translate(input, new List <NamespaceSettings>());

            Assert.That(actual, Is.EqualTo(input));
        }
        public TypescriptInterface Convert(Type type)
        {
            if (!type.IsClass && !type.IsInterface && !type.IsStruct())
            {
                throw new ArgumentException($"Type '{type.FullName}' is neither a class, struct nor an interface");
            }

            var effectiveType = type;

            if (type.IsGenericType)
            {
                effectiveType = type.GetGenericTypeDefinition();
            }
            var typescriptProperties = effectiveType.GetProperties()
                                       .Where(ShouldIncludeProperty)
                                       .Select(propertyConverter.Convert)
                                       .ToList();

            var dependencies = typescriptProperties
                               .SelectMany(x => x.Dependencies)
                               .ToList();
            var translatedNamespace = NamespaceTranslator.Translate(effectiveType.Namespace, namespaceSettings);
            var typeName            = type.IsGenericType ? GetGenericTypeName(type) : type.Name;

            return(new TypescriptInterface(
                       effectiveType.Namespace,
                       translatedNamespace,
                       typeName, // TODO: Apply transforms
                       typescriptProperties,
                       dependencies,
                       settings.Modifiers));
        }
Beispiel #3
0
        public void TranslateOnlyReplacesLeadingPart()
        {
            var input       = "MyNamespace.MyNamespace.Test";
            var translation = "Models";
            var settings    = new NamespaceSettings("MyNamespace")
            {
                Translation = translation
            };
            var actual = NamespaceTranslator.Translate(input, new List <NamespaceSettings> {
                settings
            });

            Assert.That(actual, Is.EqualTo("Models.MyNamespace.Test"));
        }
Beispiel #4
0
        public void TranslateReturnsTranslatedForExactMatch()
        {
            var input       = "MyNamespace.Test";
            var translation = "Models";
            var settings    = new NamespaceSettings(input)
            {
                Translation = translation
            };
            var actual = NamespaceTranslator.Translate(input, new List <NamespaceSettings> {
                settings
            });

            Assert.That(actual, Is.EqualTo(translation));
        }
        public TypescriptEnum Convert(Type type)
        {
            if (!type.IsEnum)
            {
                throw new ArgumentException($"Type '{type.FullName}' is not an enum");
            }

            var translatedNamespace = settings.EnumsIntoSeparateFile
                ? "Enums"
                : NamespaceTranslator.Translate(type.Namespace, namespaceSettings);

            return(new TypescriptEnum(
                       type.Namespace,
                       translatedNamespace,
                       type.Name, // TODO: Apply transforms
                       settings.Modifiers,
                       Enum.GetNames(type).ToList()));
        }
Beispiel #6
0
        public void TranslateReturnsNullForNull()
        {
            var actual = NamespaceTranslator.Translate(null, new List <NamespaceSettings>());

            Assert.That(actual, Is.Null);
        }
Beispiel #7
0
        public TypeDeterminerResult Determine(Type propertyType)
        {
            var typeAttribute = propertyType.GetCustomAttribute <TypescriptTypeAttribute>();

            if (typeAttribute != null)
            {
                return(new TypeDeterminerResult(typeAttribute.TypeString, typeAttribute.Dependencies));
            }
            var matchingTypeConverter = settings.TypeConverters.FirstOrDefault(x => x.IsMatchingType(propertyType));

            if (matchingTypeConverter != null)
            {
                return(new TypeDeterminerResult(matchingTypeConverter.Convert(propertyType), new List <Type>()));
            }
            if (propertyType.IsNullable())
            {
                var underlyingType       = Nullable.GetUnderlyingType(propertyType);
                var underlyingTypeResult = Determine(underlyingType);
                return(new TypeDeterminerResult(
                           $"{underlyingTypeResult.FormattedType} | null",
                           underlyingTypeResult.Dependencies));
            }
            if (propertyType.IsGenericParameter)
            {
                return(new TypeDeterminerResult(propertyType.Name, new List <Type>()));
            }
            if (IsPrimitiveType(propertyType))
            {
                return(new TypeDeterminerResult(PrimitiveTypes[propertyType], new List <Type>()));
            }
            if (propertyType.IsEnum && enumSettings.EnumsIntoSeparateFile)
            {
                return(new TypeDeterminerResult("Enums." + propertyType.Name, new List <Type> {
                    propertyType
                }));
            }

            if (propertyType.IsDictionary(out var keyType, out var valueType))
            {
                var keyTypeResult   = Determine(keyType);
                var valueTypeResult = Determine(valueType);
                return(new TypeDeterminerResult(
                           $"{{ [key: {keyTypeResult.FormattedType}]: {valueTypeResult.FormattedType} }}",
                           keyTypeResult.Dependencies.Concat(valueTypeResult.Dependencies).ToList()
                           ));
            }
            if (propertyType.IsCollection(out var itemType))
            {
                var itemTypeResult          = Determine(itemType);
                var formattedCollectionType = itemTypeResult.FormattedType.Contains('|')
                    ? $"({itemTypeResult.FormattedType})[]"
                    : $"{itemTypeResult.FormattedType}[]";
                return(new TypeDeterminerResult(
                           formattedCollectionType,
                           itemTypeResult.Dependencies
                           ));
            }
            var translatedNamespace = NamespaceTranslator.Translate(propertyType.Namespace, namespaceSettings);

            if (propertyType.IsGenericType)
            {
                var genericResults = propertyType.GetGenericArguments()
                                     .Select(Determine)
                                     .ToList();
                var generics = $"<{string.Join(",", genericResults.Select(x => x.FormattedType))}>";
                return(new TypeDeterminerResult(
                           $"{translatedNamespace}.{propertyType.Name.StripGenericTypeSuffix()}{generics}",
                           genericResults.SelectMany(x => x.Dependencies).Concat(new [] { propertyType.GetGenericTypeDefinition() }).ToList()
                           ));
            }
            return(new TypeDeterminerResult(
                       $"{translatedNamespace}.{propertyType.Name}",
                       new List <Type> {
                propertyType
            }
                       ));
        }