kopia lustrzana https://github.com/c9/core
509 wiersze
18 KiB
JavaScript
509 wiersze
18 KiB
JavaScript
var bar; // Intended global
|
|
|
|
require([
|
|
"lib/chai/chai",
|
|
"text!plugins/c9.ide.layout.classic/skins.xml",
|
|
"events",
|
|
"text!/static/standalone/skin/default/dark.css"
|
|
], function (chai, skin, events, theme) {
|
|
"use strict";
|
|
var expect = chai.expect;
|
|
var EventEmitter = events.EventEmitter;
|
|
|
|
function html(path, message) {
|
|
var htmlNode;
|
|
if (typeof path != "object" || !(path instanceof HTMLElement))
|
|
htmlNode = html.constr(path);
|
|
else
|
|
htmlNode = path;
|
|
var not = false;
|
|
|
|
function testOk(value) {
|
|
if (not)
|
|
expect(value, message || path).not.ok;
|
|
else
|
|
expect(value, message || path).ok;
|
|
not = false;
|
|
}
|
|
|
|
var obj = {
|
|
get is(){ return obj; },
|
|
get has(){ return obj; },
|
|
get have(){ return obj; },
|
|
get and(){ return obj; },
|
|
get to(){ return obj; },
|
|
get not(){ not = true; return obj; },
|
|
|
|
get ok(){ testOk(htmlNode); return obj; },
|
|
get exists(){ testOk(htmlNode); return obj; },
|
|
get exist(){ testOk(htmlNode); return obj; },
|
|
get node(){ return htmlNode },
|
|
|
|
get visible() {
|
|
testOk(htmlNode && (htmlNode.offsetWidth || htmlNode.offsetHeight));
|
|
return obj;
|
|
},
|
|
|
|
text: function(text) {
|
|
testOk(htmlNode.textContent.match(text));
|
|
return obj;
|
|
},
|
|
|
|
icon: function(icon) {
|
|
testOk(htmlNode.innerHTML.indexOf(icon) > -1);
|
|
return obj;
|
|
},
|
|
|
|
className: function(name) {
|
|
testOk(htmlNode.className.indexOf(name) > -1);
|
|
return obj;
|
|
},
|
|
child: function(query) {
|
|
if (typeof query == "number") {
|
|
if (query < 0)
|
|
query = htmlNode.children.length + query;
|
|
htmlNode = htmlNode.children[query];
|
|
} else {
|
|
htmlNode = htmlNode.querySelector(query);
|
|
}
|
|
return obj;
|
|
}
|
|
};
|
|
return obj;
|
|
}
|
|
expect.html = html;
|
|
expect.html.setConstructor = function(fn) {
|
|
html.constr = fn;
|
|
};
|
|
|
|
expect.html.mocked = function(options, imports, register) {
|
|
register(null, {
|
|
c9 : (function(){
|
|
var x = new EventEmitter();
|
|
x.location = "";
|
|
x.has = function(){ return false; };
|
|
x.toInternalPath = x.toExternalPath = function(p) {
|
|
return p;
|
|
};
|
|
x.connected = true;
|
|
return x;
|
|
})(),
|
|
vfs: (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
anims: (function(){
|
|
var x = new EventEmitter();
|
|
x.animateSplitBoxNode = function(node, opt) {
|
|
node.setAttribute("height", parseInt(opt.height, 10));
|
|
};
|
|
return x;
|
|
})(),
|
|
watcher: (function(){
|
|
var x = new EventEmitter();
|
|
x.watch = function(){};
|
|
x.unwatch = function(){};
|
|
x.check = function(){};
|
|
return x;
|
|
})(),
|
|
save: (function(){
|
|
var x = new EventEmitter();
|
|
x.saveAll = function(c){ c(); };
|
|
x.getSavingState = function(tab) { return "saved"; };
|
|
return x;
|
|
})(),
|
|
findreplace: {
|
|
|
|
},
|
|
ace: (function() {
|
|
var x = new EventEmitter();
|
|
x.getElement = function(){};
|
|
return x;
|
|
})(),
|
|
css: {
|
|
get packed() { return true; },
|
|
get packedThemes() { return true; },
|
|
defineLessLibrary: function(){},
|
|
insert: function() {},
|
|
insertLess: function() {}
|
|
},
|
|
settings: (function(){
|
|
var obj = new EventEmitter();
|
|
obj.save = function(){};
|
|
obj.set = function(){};
|
|
obj.get = function(){};
|
|
obj.getNumber = function() {};
|
|
obj.emit("read", {});
|
|
return obj;
|
|
})(),
|
|
fs: (function(){
|
|
var obj = new EventEmitter();
|
|
obj.writeFile = function(){};
|
|
obj.watch = function(){};
|
|
return obj;
|
|
})(),
|
|
tooltip: {
|
|
add: function(){}
|
|
},
|
|
clipboard: (function(){
|
|
var cb = new EventEmitter();
|
|
cb.registerHandler = function(){};
|
|
return cb;
|
|
})(),
|
|
preferences: (function(){
|
|
var prefs = new EventEmitter();
|
|
prefs.add = function(){};
|
|
return prefs;
|
|
})(),
|
|
commands: (function(){
|
|
var commands = {};
|
|
|
|
if (typeof apf != "undefined") {
|
|
apf.button.prototype.$propHandlers["command"] =
|
|
apf.item.prototype.$propHandlers["command"] = function(value) {
|
|
this.onclick = function(){
|
|
commands[value].exec(
|
|
apf.getPlugin("tabManager").focussedPage.editor
|
|
);
|
|
};
|
|
};
|
|
}
|
|
|
|
var c = new EventEmitter();
|
|
|
|
c.commands = commands;
|
|
c.addCommands = function(a, b, c) {
|
|
a.forEach(function(o) {
|
|
commands[o.name] = o;
|
|
});
|
|
};
|
|
c.addCommand = function(o) {
|
|
commands[o.name] = o;
|
|
};
|
|
c.removeCommand = function(o) {
|
|
delete commands[o.name];
|
|
};
|
|
c.exec = function(name) {
|
|
commands[name].exec();
|
|
};
|
|
c.getExceptionList = function(){ return []; };
|
|
|
|
return c;
|
|
})(),
|
|
log: {},
|
|
http: {},
|
|
api: {
|
|
stats: {
|
|
post: function(type, message, cb) {
|
|
cb && cb();
|
|
}
|
|
}
|
|
},
|
|
layout: (function(){
|
|
// Load the skin
|
|
if (imports.ui) {
|
|
var plugin = new imports.Plugin();
|
|
|
|
imports.ui.insertCss(theme, false, plugin);
|
|
|
|
imports.ui.insertSkin({
|
|
"data" : skin,
|
|
"media-path" : "plugins/c9.ide.layout.classic/images/",
|
|
"icon-path" : "plugins/c9.ide.layout.classic/icons/"
|
|
}, {addElement: function(){}});
|
|
|
|
document.documentElement.style.background = "white";
|
|
}
|
|
|
|
var layout = plugin || new EventEmitter();
|
|
|
|
layout.initMenus = function() {};
|
|
layout.findParent = function(){
|
|
if (!bar || bar.$amlDestroyed) {
|
|
bar = apf.document.documentElement.appendChild(
|
|
new imports.ui.bar());
|
|
bar.$ext.style.position = "fixed";
|
|
bar.$ext.style.left = "20px";
|
|
bar.$ext.style.right = "320px";
|
|
bar.$ext.style.bottom = "20px";
|
|
bar.$ext.style.height = "200px";
|
|
bar.$ext.style.minHeight = "200px";
|
|
plugin.addElement(bar);
|
|
}
|
|
bar.setAttribute("resizable", true);
|
|
|
|
return bar;
|
|
};
|
|
layout.getElement = function(){
|
|
return new apf.bar();
|
|
};
|
|
layout.setFindArea = function(active, callback, isDefault) {
|
|
// callback();
|
|
};
|
|
layout.proposeLayoutChange = function(){};
|
|
return layout;
|
|
})(),
|
|
panels: (function(){
|
|
var panel, column;
|
|
|
|
var api = {
|
|
register: function(p, o) {
|
|
if (!column) {
|
|
column = apf.document.documentElement.appendChild(
|
|
new imports.ui.bar({style:"background : #303130;"}));
|
|
column.$ext.style.position = "fixed";
|
|
column.$ext.style.top = "75px";
|
|
column.$ext.style.right = "20px";
|
|
column.$ext.style.left = "";
|
|
column.$ext.style.bottom = "20px";
|
|
column.$ext.style.width = "300px";
|
|
column.$ext.style.height = "";
|
|
}
|
|
|
|
panel = p;
|
|
p.draw({container: column.$ext, aml: column});
|
|
},
|
|
isActive: function() { return false; },
|
|
unregister: function(){},
|
|
activate: function(){
|
|
// panel.panel.show()
|
|
},
|
|
deactivate: function(){
|
|
// panel.panel.hide()
|
|
},
|
|
on: function(){
|
|
|
|
}
|
|
};
|
|
if (imports.Plugin) {
|
|
var plugin = new imports.Plugin();
|
|
plugin.freezePublicAPI(api);
|
|
return plugin;
|
|
} else {
|
|
return api;
|
|
}
|
|
})(),
|
|
Panel: function(developer, deps, options) {
|
|
var plugin = new imports.Plugin(developer, deps);
|
|
var emit = plugin.getEmitter();
|
|
var drawn = false;
|
|
var where;
|
|
plugin.on("load", function(){
|
|
where = options.where || "left";
|
|
var panels = apf.getPlugin("panels");
|
|
panels.register(plugin);
|
|
});
|
|
plugin.freezePublicAPI.baseclass();
|
|
plugin.freezePublicAPI({
|
|
get autohide(){ return false; },
|
|
get width(){ return options.width; },
|
|
get minWidth(){ return options.minWidth; },
|
|
get aml(){ return plugin.getElement(options.elementName); },
|
|
get area(){ return ""; },
|
|
get where(){ return where; },
|
|
setCommand: function(){},
|
|
attachTo: function(){},
|
|
detach: function(){},
|
|
emit: emit,
|
|
show: function(){ emit("show"); },
|
|
hide: function(){ emit("hide"); },
|
|
draw: function draw(area) {
|
|
if (drawn) return false;
|
|
drawn = true;
|
|
|
|
emit.sticky("draw", {
|
|
html: area.container,
|
|
aml: area.aml
|
|
});
|
|
|
|
return true;
|
|
}
|
|
});
|
|
|
|
return plugin;
|
|
},
|
|
tree: (function(){
|
|
var tree = new EventEmitter();
|
|
tree.createFolder = function(){};
|
|
tree.getElement = function(){};
|
|
tree.getAllExpanded = function(){ return []; };
|
|
return tree;
|
|
})(),
|
|
"tree.favorites" : (function(){
|
|
var tree = new EventEmitter();
|
|
tree.addFavorites = function(){};
|
|
tree.getFavoritePaths = function(){ return [] };
|
|
return tree;
|
|
})(),
|
|
tabManager: (function(){
|
|
var tabManager = new EventEmitter();
|
|
tabManager.open = function(){ tabManager.emit("open") };
|
|
tabManager.openFile = function(){ tabManager.emit("open") };
|
|
tabManager.findPage = function(){};
|
|
tabManager.getPanes = function(){ return [] };
|
|
tabManager.checkAllTabs = function(){};
|
|
return tabManager;
|
|
})(),
|
|
tabbehavior: (function(){
|
|
var x = new EventEmitter();
|
|
x.getElement = function(){};
|
|
return x;
|
|
})(),
|
|
menus: (function(){
|
|
var menus = new EventEmitter();
|
|
menus.addItemByPath = function(x, aml, y, plugin) {
|
|
aml && (plugin || y).addElement(aml);
|
|
return aml;
|
|
};
|
|
menus.addItemToMenu = menus.addItemByPath;
|
|
menus.get = function(){return {}};
|
|
menus.remove = function(){};
|
|
menus.enableItem = function(){};
|
|
menus.disableItem = function(){};
|
|
return menus;
|
|
})(),
|
|
util: {
|
|
alert: function() {},
|
|
escapeXml: function(s) { return s; }
|
|
},
|
|
gotoline: {
|
|
toggle: function(){ }
|
|
},
|
|
"auth.bootstrap": {
|
|
login: function(callback) { callback(); }
|
|
},
|
|
"auth": {},
|
|
"info": {
|
|
getUser: function(callback) {
|
|
var user = { id: 1 };
|
|
return callback ? callback(null, user) : user;
|
|
},
|
|
getWorkspace: function(callback) {
|
|
var ws = { id: 2 };
|
|
return callback ? callback(null, ws) : ws;
|
|
}
|
|
},
|
|
"ace.gotoline": {},
|
|
"ace.stripws": {
|
|
disable: function(){},
|
|
enable: function(){}
|
|
},
|
|
"dialog.alert": {show: function() { console.log(console, Array.prototype.slice.apply(arguments)); }},
|
|
"dialog.confirm": {show: function() {}},
|
|
"dialog.question": {show: function() {}},
|
|
"dialog.file": {show: function() {}},
|
|
"dialog.fileremove": {show: function() {}},
|
|
"dialog.fileoverwrite": {show: function() {}},
|
|
"dialog.error": {
|
|
showError: function(msg) {
|
|
console.warn(msg);
|
|
}
|
|
},
|
|
"run.gui": { getElement : function(){} },
|
|
"debugger": {debug: function() {}, stop: function(){}},
|
|
"focusManager": {
|
|
focus: function() {
|
|
|
|
}
|
|
},
|
|
error_handler: {reportError: function(){}},
|
|
installer: {
|
|
show: function(){}
|
|
},
|
|
proc: {
|
|
execFile: function() {},
|
|
spawn: function() {}
|
|
},
|
|
threewaymerge: {
|
|
patchAce: function(oldVal, newVal, doc) {
|
|
if (doc == undefined) {
|
|
doc = newVal;
|
|
newVal = oldVal;
|
|
}
|
|
doc.setValue(newVal);
|
|
}
|
|
},
|
|
metadata: (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
editors: (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
timeslider: (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
OTDocument: (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
"notification.bubble": (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
"collab": (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
"collab.connect": (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
"collab.workspace": (function(){
|
|
var x = new EventEmitter();
|
|
x.users = [];
|
|
return x;
|
|
})(),
|
|
"collab.util": (function(){
|
|
var x = new EventEmitter();
|
|
return x;
|
|
})(),
|
|
});
|
|
};
|
|
|
|
expect.setupArchitectTest = function(config, architect, options) {
|
|
if (options && options.mockPlugins) {
|
|
config.push({
|
|
consumes: [],
|
|
provides: options.mockPlugins,
|
|
setup: expect.html.mocked
|
|
});
|
|
}
|
|
architect.resolveConfig(config, function(err, config) {
|
|
/*global describe it before after = */
|
|
if (err) throw err;
|
|
var app = window.app = architect.createApp(config, function(err, app) {
|
|
if (err && err.unresolved && !config.unresolved) {
|
|
console.warn("Adding mock services for " + err.unresolved);
|
|
config.unresolved = err.unresolved;
|
|
expect.setupArchitectTest(config, architect, {
|
|
mockPlugins: config.unresolved
|
|
});
|
|
return;
|
|
}
|
|
|
|
describe('app', function() {
|
|
it('should load test app', function(done) {
|
|
expect(err).not.ok;
|
|
done();
|
|
});
|
|
});
|
|
|
|
onload && onload();
|
|
|
|
});
|
|
if (app) {
|
|
app.on("service", function(name, plugin) {
|
|
if (!plugin.name && typeof plugin != "function")
|
|
plugin.name = name;
|
|
});
|
|
app.rerun = function() {
|
|
expect.setupArchitectTest(config, architect);
|
|
};
|
|
}
|
|
});
|
|
};
|
|
|
|
}); |