public void TestCompilationUnit(string csharpText, string expectedTypeScriptText)
{
var actual = TypeScriptTranslator.TranslateCompilationUnit(csharpText, s_References);
CheckSucceeds(actual, expectedTypeScriptText);
TypeScriptValidator.Validate(actual.Text);
}
public void TestType(string csharpType, string expectedTypeScriptType)
{
var actual = TypeScriptTranslator.TranslateType(csharpType, s_References);
CheckSucceeds(actual, expectedTypeScriptType);
TypeScriptValidator.Validate(actual + "v = null;");
}
public void TestStatement(string csharpStatement, string expectedTypeScriptStatement)
{
var actual = TypeScriptTranslator.TranslateStatement(csharpStatement, s_References);
CheckSucceeds(actual, expectedTypeScriptStatement);
TypeScriptValidator.Validate(actual.Text);
}
public void TestExpression(string csharpExpression, string expectedTypeScriptExpression)
{
var actual = TypeScriptTranslator.TranslateExpression(csharpExpression, s_References);
CheckSucceeds(actual, expectedTypeScriptExpression);
TypeScriptValidator.Validate("var v = " + actual.Text + ";");
}
public void SaveTranslation(string path)
{
IAsset file = new Asset(path);
TypeScriptTranslator translator = new TypeScriptTranslator();
var compiled = translator.Translate(file);
var normalScript = path.Replace("." + FileExtension, ".js");
using (var compiledScript = File.CreateText(HostingEnvironment.MapPath(normalScript)))
{
compiledScript.Write(compiled.Content);
compiledScript.Close();
}
}
public IEnumerable <Exception> ValidateTranslation(string path)
{
var retVal = new List <Exception>();
try
{
IAsset file = new Asset(path);
TypeScriptTranslator translator = new TypeScriptTranslator();
translator.Translate(file);
}
catch (AssetTranslationException ex)
{
retVal.Add(ex);
}
return(retVal);
}
static void Main(string[] args)
{
var workspace = new AdhocWorkspace(DesktopMefHostServices.DefaultServices);
var projectInfo = CommandLineProject.CreateProjectInfo("cs2ts", LanguageNames.CSharp, args, Environment.CurrentDirectory, workspace);
var project = workspace.AddProject(projectInfo);
var compilation = (CSharpCompilation)project.GetCompilationAsync().GetAwaiter().GetResult();
var result = TypeScriptTranslator.Translate(compilation);
if (result.Diagnostics.Count > 0)
{
foreach (var dx in result.Diagnostics)
{
Console.Out.WriteLine(dx);
}
}
else
{
Console.Out.Write(result.Text);
}
}
public void FillingOfDependenciesIsCorrect()
{
// Arrange
var virtualFileSystemMock = new Mock <IVirtualFileSystemWrapper>();
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath("~/"))
.Returns("/")
;
string testTypeScriptTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"TestTypeScript.ts");
virtualFileSystemMock
.Setup(fs => fs.ToAbsolutePath(testTypeScriptTsAssetVirtualPath))
.Returns(testTypeScriptTsAssetVirtualPath)
;
virtualFileSystemMock
.Setup(fs => fs.FileExists(testTypeScriptTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(testTypeScriptTsAssetVirtualPath))
.Returns(@"/// <reference path=""ColoredTranslatorBadge.ts"" />
module TranslatorBadges {
var TS_BADGE_TEXT: string = ""TypeScript"";
var TS_BADGE_COLOR: string = ""#0074C1"";
export function createTsTranslatorBadge() {
var tsBadge: IColoredTranslatorBadge = new ColoredTranslatorBadge(""ts"");
tsBadge.setText(TS_BADGE_TEXT);
tsBadge.setTextColor(TS_BADGE_COLOR);
tsBadge.setBorderColor(TS_BADGE_COLOR);
tsBadge.show();
}
}
TranslatorBadges.createTsTranslatorBadge();")
;
string jqueryTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"jquery.d.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(jqueryTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(jqueryTsAssetVirtualPath))
.Returns(Utils.GetResourceAsString("BundleTransformer.Tests.Resources.jquery.d.ts", GetType().Assembly))
;
string iTranslatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"ITranslatorBadge.d.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(iTranslatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(iTranslatorBadgeTsAssetVirtualPath))
.Returns(@"interface ITranslatorBadge {
getText(): string;
setText(text: string): void;
show(): void;
hide(): void;
isVisible(): boolean;
}")
;
string translatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"TranslatorBadge.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(translatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(translatorBadgeTsAssetVirtualPath))
.Returns(@"/// <reference path=""jquery.d.ts"" />
/// <reference path=""ITranslatorBadge.d.ts"" />
module TranslatorBadges {
export class TranslatorBadge implements ITranslatorBadge {
$badgeElem: JQuery;
$linkElem: JQuery;
constructor (public elementId: string) {
this.$badgeElem = jQuery(""#"" + elementId);
this.$linkElem = this.$badgeElem.find(""A:first"");
}
public getText(): string {
return this.$linkElem.text();
}
public setText(text: string): void {
this.$linkElem.text(text);
}
public show(): void {
this.$badgeElem.show(0);
}
public hide(): void {
this.$badgeElem.hide(0);
}
public isVisible() : boolean {
return this.$badgeElem.is("":visible"");
}
}
}")
;
string iColoredTranslatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"IColoredTranslatorBadge.d.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(iColoredTranslatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(iColoredTranslatorBadgeTsAssetVirtualPath))
.Returns(@"/// <reference path=""ITranslatorBadge.d.ts"" />
interface IColoredTranslatorBadge extends ITranslatorBadge {
getTextColor(): string;
setTextColor(color: string): void;
getBorderColor(): string;
setBorderColor(color: string): void;
}")
;
string coloredTranslatorBadgeTsAssetVirtualPath = UrlHelpers.Combine(SCRIPTS_DIRECTORY_VIRTUAL_PATH,
"ColoredTranslatorBadge.ts");
virtualFileSystemMock
.Setup(fs => fs.FileExists(coloredTranslatorBadgeTsAssetVirtualPath))
.Returns(true)
;
virtualFileSystemMock
.Setup(fs => fs.GetFileTextContent(coloredTranslatorBadgeTsAssetVirtualPath))
.Returns(@"/// <reference path=""jquery.d.ts"" />
/// <reference path=""./IColoredTranslatorBadge.d.ts"" />
/// <reference path=""TranslatorBadge.ts"" />
module TranslatorBadges {
export class ColoredTranslatorBadge
extends TranslatorBadge
{
public getTextColor(): string {
return this.$linkElem.css(""color"");
}
public setTextColor(color: string): void {
this.$linkElem.css(""color"", color);
}
public getBorderColor(): string {
return this.$badgeElem.css(""border-color"");
}
public setBorderColor(color: string): void {
this.$badgeElem.css(""border-color"", color);
}
}
}")
;
Func <IJsEngine> createJsEngineInstance =
() => JsEngineSwitcher.Current.CreateDefaultEngine();
IVirtualFileSystemWrapper virtualFileSystemWrapper = virtualFileSystemMock.Object;
var tsConfig = new TypeScriptSettings();
var tsTranslator = new TypeScriptTranslator(createJsEngineInstance, virtualFileSystemWrapper,
tsConfig);
IAsset asset = new Asset(testTypeScriptTsAssetVirtualPath, virtualFileSystemWrapper);
// Act
asset = tsTranslator.Translate(asset);
IList <string> dependencies = asset.VirtualPathDependencies;
// Assert
Assert.Equal(5, dependencies.Count);
Assert.Equal(coloredTranslatorBadgeTsAssetVirtualPath, dependencies[0]);
Assert.Equal(jqueryTsAssetVirtualPath, dependencies[1]);
Assert.Equal(iColoredTranslatorBadgeTsAssetVirtualPath, dependencies[2]);
Assert.Equal(iTranslatorBadgeTsAssetVirtualPath, dependencies[3]);
Assert.Equal(translatorBadgeTsAssetVirtualPath, dependencies[4]);
}
public static void RegisterBundles(BundleCollection bundles)
{
// bundles.IgnoreList.Clear();
// AddDefaultIgnorePatterns(bundles.IgnoreList);
//NOTE: it's bundles.DirectoryFilter in Microsoft.AspNet.Web.Optimization.1.1.3 and not bundles.IgnoreList
var engine = new V8JsEngine();
var uglySettings = new UglifySettings();
uglySettings.Js.CodeGeneration.Beautify = true;
bundles.UseCdn = false;
var uglifyJsMinifier = new UglifyJsMinifier(() => engine, uglySettings)
{
CompressionOptions = { Angular = true },
ParsingOptions = new ParsingOptions {
Strict = true
},
CodeGenerationOptions = new CodeGenerationOptions()
};
var lessTranslator = new LessTranslator();
var cssTransformer = new CssTransformer(new CleanCssMinifier(), new ITranslator[] { lessTranslator });
var tsTranslater = new TypeScriptTranslator();
var jsTransformer = new JsTransformer(uglifyJsMinifier, new List <ITranslator> {
tsTranslater
});
var jsBundle = new CustomScriptBundle("~/bundles/js");
jsBundle.IncludeDirectory("~/scripts", "*.js", true);
jsBundle.IncludeDirectory("~/scripts", "*.map", true);
bundles.IgnoreList.Ignore("angular-mocks.js");
bundles.IgnoreList.Ignore("angular-scenario.js");
// jsBundle.IncludeDirectory("~/scripts/angular-dialog-service-5.1.2", "*.js", true);
jsBundle.Builder = new DefaultBundleBuilder();
jsBundle.Orderer = new JsBundlerOrderer();
jsBundle.Transforms.Add(jsTransformer);
bundles.Add(jsBundle);
var typeScriptBundle = new CustomScriptBundle("~/bundles/ts"); //// Typescript generatred locally via visual studio and checked in - not done on the fly
typeScriptBundle.IncludeDirectory("~/app", "*.js", true);
typeScriptBundle.Transforms.Add(jsTransformer);
typeScriptBundle.Builder = new DefaultBundleBuilder();
typeScriptBundle.Orderer = new JsBundlerOrderer();
bundles.Add(typeScriptBundle);
var lessCssBundle = new Bundle("~/bundles/less");
lessCssBundle.Include("~/Content/bootstrap/bootstrap.less");
lessCssBundle.Builder = new DefaultBundleBuilder();
lessCssBundle.Transforms.Add(cssTransformer);
lessCssBundle.Orderer = new DefaultBundleOrderer();
bundles.Add(lessCssBundle);
var cssBundle = new StyleBundle("~/bundles/css");
cssBundle.IncludeDirectory("~/Content/Bootstrap", "*.css", false);
cssBundle.IncludeDirectory("~/Content/", "*.css", false);
cssBundle.IncludeDirectory("~/Content/css", "*.css", false);
cssBundle.Builder = new DefaultBundleBuilder();
cssBundle.Transforms.Add(cssTransformer);
cssBundle.Orderer = new PushToTopOrderer("bootstrap");
bundles.Add(cssBundle);
var publicCssBundle = new StyleBundle("~/bundles/public/css");
publicCssBundle.IncludeDirectory("~/Content/public", "*.css", true);
publicCssBundle.Builder = new DefaultBundleBuilder();
publicCssBundle.Transforms.Add(cssTransformer);
publicCssBundle.Orderer = new PushToTopOrderer("bootstrap");
bundles.Add(publicCssBundle);
}
public void TestCompilationUnitFails(string csharpText, params DiagnosticDescriptor[] diagnostics)
{
CheckFails(TypeScriptTranslator.TranslateCompilationUnit(csharpText, s_References), diagnostics);
}
public void TestTypeFails(string csharpType, params DiagnosticDescriptor[] diagnostics)
{
CheckFails(TypeScriptTranslator.TranslateType(csharpType, s_References), diagnostics);
}
public void TestStatementFails(string csharpStatement, params DiagnosticDescriptor[] diagnostics)
{
CheckFails(TypeScriptTranslator.TranslateStatement(csharpStatement, s_References), diagnostics);
}
public void TestExpressionFails(string csharpExpression, params DiagnosticDescriptor[] expectedDiagnostics)
{
CheckFails(TypeScriptTranslator.TranslateExpression(csharpExpression, s_References), expectedDiagnostics);
}
