SQL Operations Studio Public Preview 1 (0.23) release source code

src/vs/base/test/node/extfs/extfs.test.ts

@@ -0,0 +1,268 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import assert = require('assert');
+import os = require('os');
+
+import path = require('path');
+import fs = require('fs');
+
+import uuid = require('vs/base/common/uuid');
+import strings = require('vs/base/common/strings');
+import extfs = require('vs/base/node/extfs');
+import { onError } from 'vs/base/test/common/utils';
+
+suite('Extfs', () => {
+
+	test('mkdirp', function (done: () => void) {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+
+		extfs.mkdirp(newDir, 493, (error) => {
+			if (error) {
+				return onError(error, done);
+			}
+
+			assert.ok(fs.existsSync(newDir));
+
+			extfs.del(parentDir, os.tmpdir(), () => { }, done);
+		}); // 493 = 0755
+	});
+
+	test('delSync - swallows file not found error', function () {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+
+		extfs.delSync(newDir);
+
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('delSync - simple', function (done: () => void) {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+
+		extfs.mkdirp(newDir, 493, (error) => {
+			if (error) {
+				return onError(error, done);
+			}
+
+			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+			fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+			extfs.delSync(newDir);
+
+			assert.ok(!fs.existsSync(newDir));
+			done();
+		}); // 493 = 0755
+	});
+
+	test('delSync - recursive folder structure', function (done: () => void) {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+
+		extfs.mkdirp(newDir, 493, (error) => {
+			if (error) {
+				return onError(error, done);
+			}
+
+			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+			fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+			fs.mkdirSync(path.join(newDir, 'somefolder'));
+			fs.writeFileSync(path.join(newDir, 'somefolder', 'somefile.txt'), 'Contents');
+
+			extfs.delSync(newDir);
+
+			assert.ok(!fs.existsSync(newDir));
+			done();
+		}); // 493 = 0755
+	});
+
+	test('copy, move and delete', function (done: () => void) {
+		const id = uuid.generateUuid();
+		const id2 = uuid.generateUuid();
+		const sourceDir = require.toUrl('./fixtures');
+		const parentDir = path.join(os.tmpdir(), 'vsctests', 'extfs');
+		const targetDir = path.join(parentDir, id);
+		const targetDir2 = path.join(parentDir, id2);
+
+		extfs.copy(sourceDir, targetDir, (error) => {
+			if (error) {
+				return onError(error, done);
+			}
+
+			assert.ok(fs.existsSync(targetDir));
+			assert.ok(fs.existsSync(path.join(targetDir, 'index.html')));
+			assert.ok(fs.existsSync(path.join(targetDir, 'site.css')));
+			assert.ok(fs.existsSync(path.join(targetDir, 'examples')));
+			assert.ok(fs.statSync(path.join(targetDir, 'examples')).isDirectory());
+			assert.ok(fs.existsSync(path.join(targetDir, 'examples', 'small.jxs')));
+
+			extfs.mv(targetDir, targetDir2, (error) => {
+				if (error) {
+					return onError(error, done);
+				}
+
+				assert.ok(!fs.existsSync(targetDir));
+				assert.ok(fs.existsSync(targetDir2));
+				assert.ok(fs.existsSync(path.join(targetDir2, 'index.html')));
+				assert.ok(fs.existsSync(path.join(targetDir2, 'site.css')));
+				assert.ok(fs.existsSync(path.join(targetDir2, 'examples')));
+				assert.ok(fs.statSync(path.join(targetDir2, 'examples')).isDirectory());
+				assert.ok(fs.existsSync(path.join(targetDir2, 'examples', 'small.jxs')));
+
+				extfs.mv(path.join(targetDir2, 'index.html'), path.join(targetDir2, 'index_moved.html'), (error) => {
+					if (error) {
+						return onError(error, done);
+					}
+
+					assert.ok(!fs.existsSync(path.join(targetDir2, 'index.html')));
+					assert.ok(fs.existsSync(path.join(targetDir2, 'index_moved.html')));
+
+					extfs.del(parentDir, os.tmpdir(), (error) => {
+						if (error) {
+							return onError(error, done);
+						}
+					}, (error) => {
+						if (error) {
+							return onError(error, done);
+						}
+						assert.ok(!fs.existsSync(parentDir));
+						done();
+					});
+				});
+			});
+		});
+	});
+
+	test('readdir', function (done: () => void) {
+		if (strings.canNormalize && typeof process.versions['electron'] !== 'undefined' /* needs electron */) {
+			const id = uuid.generateUuid();
+			const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+			const newDir = path.join(parentDir, 'extfs', id, 'öäü');
+
+			extfs.mkdirp(newDir, 493, (error) => {
+				if (error) {
+					return onError(error, done);
+				}
+
+				assert.ok(fs.existsSync(newDir));
+
+				extfs.readdir(path.join(parentDir, 'extfs', id), (error, children) => {
+					assert.equal(children.some(n => n === 'öäü'), true); // Mac always converts to NFD, so
+
+					extfs.del(parentDir, os.tmpdir(), () => { }, done);
+				});
+			}); // 493 = 0755
+		} else {
+			done();
+		}
+	});
+
+	test('writeFileAndFlush', function (done: () => void) {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+		const testFile = path.join(newDir, 'flushed.txt');
+
+		extfs.mkdirp(newDir, 493, (error) => {
+			if (error) {
+				return onError(error, done);
+			}
+
+			assert.ok(fs.existsSync(newDir));
+
+			extfs.writeFileAndFlush(testFile, 'Hello World', null, (error) => {
+				if (error) {
+					return onError(error, done);
+				}
+
+				assert.equal(fs.readFileSync(testFile), 'Hello World');
+
+				const largeString = (new Array(100 * 1024)).join('Large String\n');
+
+				extfs.writeFileAndFlush(testFile, largeString, null, (error) => {
+					if (error) {
+						return onError(error, done);
+					}
+
+					assert.equal(fs.readFileSync(testFile), largeString);
+
+					extfs.del(parentDir, os.tmpdir(), () => { }, done);
+				});
+			});
+		});
+	});
+
+	test('realcase', (done) => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+
+		extfs.mkdirp(newDir, 493, (error) => {
+
+			// assume case insensitive file system
+			if (process.platform === 'win32' || process.platform === 'darwin') {
+				const upper = newDir.toUpperCase();
+				const real = extfs.realcaseSync(upper);
+
+				if (real) { // can be null in case of permission errors
+					assert.notEqual(real, upper);
+					assert.equal(real.toUpperCase(), upper);
+					assert.equal(real, newDir);
+				}
+			}
+
+			// linux, unix, etc. -> assume case sensitive file system
+			else {
+				const real = extfs.realcaseSync(newDir);
+				assert.equal(real, newDir);
+			}
+
+			extfs.del(parentDir, os.tmpdir(), () => { }, done);
+		});
+	});
+
+	test('realpath', (done) => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+
+		extfs.mkdirp(newDir, 493, (error) => {
+
+			extfs.realpath(newDir, (error, realpath) => {
+				assert.ok(realpath);
+				assert.ok(!error);
+
+				extfs.del(parentDir, os.tmpdir(), () => { }, done);
+			});
+		});
+	});
+
+	test('realpathSync', (done) => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+
+		extfs.mkdirp(newDir, 493, (error) => {
+			let realpath: string;
+			try {
+				realpath = extfs.realpathSync(newDir);
+			} catch (error) {
+				assert.ok(!error);
+			}
+			assert.ok(realpath);
+
+			extfs.del(parentDir, os.tmpdir(), () => { }, done);
+		});
+	});
+});

src/vs/base/test/node/extfs/fixtures/examples/company.jxs

@@ -0,0 +1,23 @@
+'use strict';
+/// <reference path="employee.ts" />
+var Workforce;
+(function (Workforce_1) {
+    var Company = (function () {
+        function Company() {
+        }
+        return Company;
+    })();
+    (function (property, Workforce, IEmployee) {
+        if (property === void 0) { property = employees; }
+        if (IEmployee === void 0) { IEmployee = []; }
+        property;
+        calculateMonthlyExpenses();
+        {
+            var result = 0;
+            for (var i = 0; i < employees.length; i++) {
+                result += employees[i].calculatePay();
+            }
+            return result;
+        }
+    });
+})(Workforce || (Workforce = {}));

src/vs/base/test/node/extfs/fixtures/examples/conway.jxs

@@ -0,0 +1,117 @@
+'use strict';
+var Conway;
+(function (Conway) {
+    var Cell = (function () {
+        function Cell() {
+        }
+        return Cell;
+    })();
+    (function (property, number, property, number, property, boolean) {
+        if (property === void 0) { property = row; }
+        if (property === void 0) { property = col; }
+        if (property === void 0) { property = live; }
+    });
+    var GameOfLife = (function () {
+        function GameOfLife() {
+        }
+        return GameOfLife;
+    })();
+    (function () {
+        property;
+        gridSize = 50;
+        property;
+        canvasSize = 600;
+        property;
+        lineColor = '#cdcdcd';
+        property;
+        liveColor = '#666';
+        property;
+        deadColor = '#eee';
+        property;
+        initialLifeProbability = 0.5;
+        property;
+        animationRate = 60;
+        property;
+        cellSize = 0;
+        property;
+        context: ICanvasRenderingContext2D;
+        property;
+        world = createWorld();
+        circleOfLife();
+        function createWorld() {
+            return travelWorld(function (cell) {
+                cell.live = Math.random() < initialLifeProbability;
+                return cell;
+            });
+        }
+        function circleOfLife() {
+            world = travelWorld(function (cell) {
+                cell = world[cell.row][cell.col];
+                draw(cell);
+                return resolveNextGeneration(cell);
+            });
+            setTimeout(function () { circleOfLife(); }, animationRate);
+        }
+        function resolveNextGeneration(cell) {
+            var count = countNeighbors(cell);
+            var newCell = new Cell(cell.row, cell.col, cell.live);
+            if (count < 2 || count > 3)
+                newCell.live = false;
+            else if (count == 3)
+                newCell.live = true;
+            return newCell;
+        }
+        function countNeighbors(cell) {
+            var neighbors = 0;
+            for (var row = -1; row <= 1; row++) {
+                for (var col = -1; col <= 1; col++) {
+                    if (row == 0 && col == 0)
+                        continue;
+                    if (isAlive(cell.row + row, cell.col + col)) {
+                        neighbors++;
+                    }
+                }
+            }
+            return neighbors;
+        }
+        function isAlive(row, col) {
+            // todo - need to guard with world[row] exists?
+            if (row < 0 || col < 0 || row >= gridSize || col >= gridSize)
+                return false;
+            return world[row][col].live;
+        }
+        function travelWorld(callback) {
+            var result = [];
+            for (var row = 0; row < gridSize; row++) {
+                var rowData = [];
+                for (var col = 0; col < gridSize; col++) {
+                    rowData.push(callback(new Cell(row, col, false)));
+                }
+                result.push(rowData);
+            }
+            return result;
+        }
+        function draw(cell) {
+            if (context == null)
+                context = createDrawingContext();
+            if (cellSize == 0)
+                cellSize = canvasSize / gridSize;
+            context.strokeStyle = lineColor;
+            context.strokeRect(cell.row * cellSize, cell.col * cellSize, cellSize, cellSize);
+            context.fillStyle = cell.live ? liveColor : deadColor;
+            context.fillRect(cell.row * cellSize, cell.col * cellSize, cellSize, cellSize);
+        }
+        function createDrawingContext() {
+            var canvas = document.getElementById('conway-canvas');
+            if (canvas == null) {
+                canvas = document.createElement('canvas');
+                canvas.id = "conway-canvas";
+                canvas.width = canvasSize;
+                canvas.height = canvasSize;
+                document.body.appendChild(canvas);
+            }
+            return canvas.getContext('2d');
+        }
+    });
+})(Conway || (Conway = {}));
+var game = new Conway.GameOfLife();

src/vs/base/test/node/extfs/fixtures/examples/employee.jxs

@@ -0,0 +1,38 @@
+'use strict';
+var Workforce;
+(function (Workforce) {
+    var Employee = (function () {
+        function Employee() {
+        }
+        return Employee;
+    })();
+    (property);
+    name: string, property;
+    basepay: number;
+    implements;
+    IEmployee;
+    {
+        name;
+        basepay;
+    }
+    var SalesEmployee = (function () {
+        function SalesEmployee() {
+        }
+        return SalesEmployee;
+    })();
+    ();
+    Employee(name, basepay);
+    {
+        function calculatePay() {
+            var multiplier = (document.getElementById("mult")), as = any, value;
+            return _super.calculatePay.call(this) * multiplier + bonus;
+        }
+    }
+    var employee = new Employee('Bob', 1000);
+    var salesEmployee = new SalesEmployee('Jim', 800, 400);
+    salesEmployee.calclatePay(); // error: No member 'calclatePay' on SalesEmployee
+})(Workforce || (Workforce = {}));
+extern;
+var $;
+var s = Workforce.salesEmployee.calculatePay();
+$('#results').text(s);

src/vs/base/test/node/extfs/fixtures/examples/small.jxs

@@ -0,0 +1,24 @@
+'use strict';
+var M;
+(function (M) {
+    var C = (function () {
+        function C() {
+        }
+        return C;
+    })();
+    (function (x, property, number) {
+        if (property === void 0) { property = w; }
+        var local = 1;
+        // unresolved symbol because x is local
+        //self.x++; 
+        self.w--; // ok because w is a property
+        property;
+        f = function (y) {
+            return y + x + local + w + self.w;
+        };
+        function sum(z) {
+            return z + f(z) + w + self.w;
+        }
+    });
+})(M || (M = {}));
+var c = new M.C(12, 5);

src/vs/base/test/node/extfs/fixtures/index.html

@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+<html>
+<head id='headID'>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <title>Strada </title>
+    <link href="site.css" rel="stylesheet" type="text/css" />
+    <script src="jquery-1.4.1.js"></script>
+    <script src="../compiler/dtree.js" type="text/javascript"></script>
+    <script src="../compiler/typescript.js" type="text/javascript"></script>
+    <script type="text/javascript">
+
+    // Compile strada source into resulting javascript
+    function compile(prog, libText) {
+        var outfile = {
+          source: "",
+          Write: function (s) { this.source += s; },
+          WriteLine: function (s) { this.source += s + "\r"; },
+        }
+
+        var parseErrors = []
+
+        var compiler=new Tools.TypeScriptCompiler(outfile,true);
+        compiler.setErrorCallback(function(start,len, message) { parseErrors.push({start:start, len:len, message:message}); });
+        compiler.addUnit(libText,"lib.ts");
+        compiler.addUnit(prog,"input.ts");
+        compiler.typeCheck();
+        compiler.emit();
+
+        if(parseErrors.length > 0 ) {
+          //throw new Error(parseErrors);
+        }
+
+	while(outfile.source[0] == '/' && outfile.source[1] == '/' && outfile.source[2] == ' ') {
+            outfile.source = outfile.source.slice(outfile.source.indexOf('\r')+1);
+        }
+        var errorPrefix = "";
+	for(var i = 0;i<parseErrors.length;i++) {
+          errorPrefix += "// Error: (" + parseErrors[i].start + "," + parseErrors[i].len + ") " + parseErrors[i].message + "\r";
+        }
+
+        return errorPrefix + outfile.source;
+    }
+    </script>
+    <script type="text/javascript">
+	
+        var libText = "";
+        $.get("../compiler/lib.ts", function(newLibText) {
+            libText = newLibText;
+        });	
+        
+
+        // execute the javascript in the compiledOutput pane
+        function execute() {
+          $('#compilation').text("Running...");
+          var txt = $('#compiledOutput').val();
+          var res;
+          try {
+             var ret = eval(txt);
+             res = "Ran successfully!";
+          } catch(e) { 
+             res = "Exception thrown: " + e;
+          }
+          $('#compilation').text(String(res));
+        }
+
+        // recompile the stradaSrc and populate the compiledOutput pane
+        function srcUpdated() {
+            var newText = $('#stradaSrc').val();
+            var compiledSource;
+            try {
+                compiledSource = compile(newText, libText);
+            } catch (e) {
+                compiledSource = "//Parse error"
+                for(var i in e) 
+                  compiledSource += "\r// " + e[i];
+            }
+            $('#compiledOutput').val(compiledSource);
+        }
+
+        // Populate the stradaSrc pane with one of the built in samples
+        function exampleSelectionChanged() {
+            var examples = document.getElementById('examples');
+            var selectedExample = examples.options[examples.selectedIndex].value;
+            if (selectedExample != "") {
+                $.get('examples/' + selectedExample, function (srcText) {
+                    $('#stradaSrc').val(srcText);
+                    setTimeout(srcUpdated,100);
+                }, function (err) {
+                    console.log(err);
+                });
+            }
+        }
+
+    </script>
+</head>
+<body>
+    <h1>TypeScript</h1>
+    <br />
+    <select id="examples" onchange='exampleSelectionChanged()'>
+        <option value="">Select...</option>
+        <option value="small.ts">Small</option>
+        <option value="employee.ts">Employees</option>
+        <option value="conway.ts">Conway Game of Life</option>
+        <option value="typescript.ts">TypeScript Compiler</option>
+    </select>
+
+    <div>
+        <textarea id='stradaSrc' rows='40' cols='80' onchange='srcUpdated()' onkeyup='srcUpdated()' spellcheck="false">
+//Type your TypeScript here...
+      </textarea>
+      <textarea id='compiledOutput' rows='40' cols='80' spellcheck="false">
+//Compiled code will show up here...
+      </textarea>
+      <br />
+      <button onclick='execute()'/>Run</button> 
+      <div id='compilation'>Press 'run' to execute code...</div>
+      <div id='results'>...write your results into #results...</div>
+    </div>
+    <div id='bod' style='display:none'></div>
+</body>
+</html>

src/vs/base/test/node/extfs/fixtures/site.css

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------
+The base color for this template is #5c87b2. If you'd like
+to use a different color start by replacing all instances of
+#5c87b2 with your new color.
+----------------------------------------------------------*/
+body
+{
+    background-color: #5c87b2;
+    font-size: .75em;
+    font-family: Segoe UI, Verdana, Helvetica, Sans-Serif;
+    margin: 8px;
+    padding: 0;
+    color: #696969;
+}
+
+h1, h2, h3, h4, h5, h6
+{
+    color: #000;
+    font-size: 40px;
+    margin: 0px;
+}
+
+textarea
+{
+   font-family: Consolas
+}
+
+#results
+{
+    margin-top: 2em;
+    margin-left: 2em;
+    color: black;
+    font-size: medium;
+}
+