1163 lines
34 KiB
JavaScript
1163 lines
34 KiB
JavaScript
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
var createIwcConnector;
|
|
|
|
createIwcConnector = function(callback) {
|
|
var IwcConnector, duiClient, get_root_intent, init, iwcHandler, received_HB, root_element;
|
|
iwcHandler = {};
|
|
duiClient = new DUIClient();
|
|
duiClient.connect((function(_this) {
|
|
return function(intent) {
|
|
var _ref;
|
|
console.log("intent received iwc: " + (JSON.stringify(intent)));
|
|
console.log("" + (JSON.stringify(_this.iwcHandler)));
|
|
return (_ref = iwcHandler[intent.action]) != null ? _ref.map(function(f) {
|
|
return setTimeout(function() {
|
|
return f(intent);
|
|
}, 0);
|
|
}) : void 0;
|
|
};
|
|
})(this));
|
|
duiClient.initOK();
|
|
root_element = null;
|
|
received_HB = null;
|
|
IwcConnector = (function() {
|
|
function IwcConnector(engine, HB, execution_listener, yatta) {
|
|
var receive_, sendRootElement, send_;
|
|
this.engine = engine;
|
|
this.HB = HB;
|
|
this.execution_listener = execution_listener;
|
|
this.yatta = yatta;
|
|
this.duiClient = duiClient;
|
|
this.iwcHandler = iwcHandler;
|
|
send_ = (function(_this) {
|
|
return function(o) {
|
|
return _this.send(o);
|
|
};
|
|
})(this);
|
|
this.execution_listener.push(send_);
|
|
receive_ = (function(_this) {
|
|
return function(intent) {
|
|
var o;
|
|
o = intent.extras;
|
|
return _this.receive(o);
|
|
};
|
|
})(this);
|
|
this.iwcHandler["Yatta_new_operation"] = [receive_];
|
|
if (root_element != null) {
|
|
this.engine.applyOps(received_HB);
|
|
}
|
|
sendRootElement = (function(_this) {
|
|
return function() {
|
|
var json;
|
|
json = {
|
|
root_element: _this.yatta.getRootElement(),
|
|
HB: _this.yatta.getHistoryBuffer().toJson()
|
|
};
|
|
return _this.sendIwcIntent("Yatta_push_root_element", json);
|
|
};
|
|
})(this);
|
|
this.iwcHandler["Yatta_get_root_element"] = [sendRootElement];
|
|
}
|
|
|
|
IwcConnector.prototype.getRootElement = function() {
|
|
return root_element;
|
|
};
|
|
|
|
IwcConnector.prototype.send = function(o) {
|
|
if (o.uid.creator === this.HB.getUserId() && (typeof o.uid.op_number !== "string")) {
|
|
return this.sendIwcIntent("Yatta_new_operation", o);
|
|
}
|
|
};
|
|
|
|
IwcConnector.prototype.receive = function(o) {
|
|
if (o.uid.creator !== this.HB.getUserId()) {
|
|
return this.engine.applyOp(o);
|
|
}
|
|
};
|
|
|
|
IwcConnector.prototype.sendIwcIntent = function(action_name, content) {
|
|
var intent;
|
|
intent = {
|
|
action: action_name,
|
|
component: "",
|
|
data: "",
|
|
dataType: "",
|
|
extras: content
|
|
};
|
|
return this.duiClient.publishToUser(intent);
|
|
};
|
|
|
|
IwcConnector.prototype.sync = function() {
|
|
throw new Error("Can't use this a.t.m.");
|
|
};
|
|
|
|
return IwcConnector;
|
|
|
|
})();
|
|
get_root_intent = {
|
|
action: "Yatta_get_root_element",
|
|
component: "",
|
|
data: "",
|
|
dataType: "",
|
|
extras: {}
|
|
};
|
|
init = function() {
|
|
var is_initialized, receiveRootElement;
|
|
duiClient.publishToUser(get_root_intent);
|
|
is_initialized = false;
|
|
receiveRootElement = function(json) {
|
|
root_element = json != null ? json.extras.root_element : void 0;
|
|
received_HB = json != null ? json.extras.HB : void 0;
|
|
if (!is_initialized) {
|
|
is_initialized = true;
|
|
return callback(IwcConnector);
|
|
}
|
|
};
|
|
iwcHandler["Yatta_push_root_element"] = [receiveRootElement];
|
|
return setTimeout(receiveRootElement, 3000);
|
|
};
|
|
setTimeout(init, 10);
|
|
return void 0;
|
|
};
|
|
|
|
module.exports = createIwcConnector;
|
|
|
|
if (typeof window !== "undefined" && window !== null) {
|
|
window.createIwcConnector = createIwcConnector;
|
|
}
|
|
|
|
|
|
},{}],2:[function(require,module,exports){
|
|
var Engine;
|
|
|
|
Engine = (function() {
|
|
function Engine(HB, parser) {
|
|
this.HB = HB;
|
|
this.parser = parser;
|
|
this.unprocessed_ops = [];
|
|
}
|
|
|
|
Engine.prototype.parseOperation = function(json) {
|
|
var typeParser;
|
|
typeParser = this.parser[json.type];
|
|
if (typeParser != null) {
|
|
return typeParser(json);
|
|
} else {
|
|
throw new Error("You forgot to specify a parser for type " + json.type + ". The message is " + (JSON.stringify(json)) + ".");
|
|
}
|
|
};
|
|
|
|
Engine.prototype.applyOps = function(ops_json) {
|
|
var o, ops, _i, _j, _k, _len, _len1, _len2;
|
|
ops = [];
|
|
for (_i = 0, _len = ops_json.length; _i < _len; _i++) {
|
|
o = ops_json[_i];
|
|
ops.push(this.parseOperation(o));
|
|
}
|
|
for (_j = 0, _len1 = ops.length; _j < _len1; _j++) {
|
|
o = ops[_j];
|
|
this.HB.addOperation(o);
|
|
}
|
|
for (_k = 0, _len2 = ops.length; _k < _len2; _k++) {
|
|
o = ops[_k];
|
|
if (!o.execute()) {
|
|
this.unprocessed_ops.push(o);
|
|
}
|
|
}
|
|
return this.cleanUp();
|
|
};
|
|
|
|
Engine.prototype.cleanUp = function() {
|
|
var old_length, op, unprocessed, _i, _len, _ref, _results;
|
|
_results = [];
|
|
while (true) {
|
|
old_length = this.unprocessed_ops.length;
|
|
unprocessed = [];
|
|
_ref = this.unprocessed_ops;
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
op = _ref[_i];
|
|
if (!op.execute()) {
|
|
unprocessed.push(op);
|
|
}
|
|
}
|
|
this.unprocessed_ops = unprocessed;
|
|
if (this.unprocessed_ops.length === old_length) {
|
|
break;
|
|
} else {
|
|
_results.push(void 0);
|
|
}
|
|
}
|
|
return _results;
|
|
};
|
|
|
|
Engine.prototype.applyOp = function(op_json) {
|
|
var o;
|
|
o = this.parseOperation(op_json);
|
|
this.HB.addOperation(o);
|
|
if (!o.execute()) {
|
|
this.unprocessed_ops.push(o);
|
|
}
|
|
return this.cleanUp();
|
|
};
|
|
|
|
return Engine;
|
|
|
|
})();
|
|
|
|
module.exports = Engine;
|
|
|
|
|
|
},{}],3:[function(require,module,exports){
|
|
var Engine, HistoryBuffer, JsonYatta, json_types_uninitialized;
|
|
|
|
json_types_uninitialized = require("../Types/JsonTypes.coffee");
|
|
|
|
HistoryBuffer = require("../HistoryBuffer.coffee");
|
|
|
|
Engine = require("../Engine.coffee");
|
|
|
|
JsonYatta = (function() {
|
|
function JsonYatta(user_id, Connector) {
|
|
var first_word, json_types, root_elem;
|
|
this.HB = new HistoryBuffer(user_id);
|
|
json_types = json_types_uninitialized(this.HB);
|
|
this.engine = new Engine(this.HB, json_types.parser);
|
|
this.connector = new Connector(this.engine, this.HB, json_types.execution_listener, this);
|
|
root_elem = this.connector.getRootElement();
|
|
if (root_elem == null) {
|
|
first_word = new json_types.types.JsonType(this.HB.getNextOperationIdentifier());
|
|
this.HB.addOperation(first_word);
|
|
first_word.execute();
|
|
this.root_element = first_word;
|
|
} else {
|
|
this.root_element = this.HB.getOperation(root_elem);
|
|
}
|
|
}
|
|
|
|
JsonYatta.prototype.getRootElement = function() {
|
|
return this.root_element;
|
|
};
|
|
|
|
JsonYatta.prototype.getEngine = function() {
|
|
return this.engine;
|
|
};
|
|
|
|
JsonYatta.prototype.getConnector = function() {
|
|
return this.connector;
|
|
};
|
|
|
|
JsonYatta.prototype.getHistoryBuffer = function() {
|
|
return this.HB;
|
|
};
|
|
|
|
JsonYatta.prototype.getUserId = function() {
|
|
return this.HB.getUserId();
|
|
};
|
|
|
|
JsonYatta.prototype.val = function(name, content) {
|
|
return this.root_element.val(name, content);
|
|
};
|
|
|
|
return JsonYatta;
|
|
|
|
})();
|
|
|
|
if (typeof window !== "undefined" && window !== null) {
|
|
window.JsonYatta = JsonYatta;
|
|
}
|
|
|
|
module.exports = JsonYatta;
|
|
|
|
|
|
},{"../Engine.coffee":2,"../HistoryBuffer.coffee":4,"../Types/JsonTypes.coffee":6}],4:[function(require,module,exports){
|
|
var HistoryBuffer;
|
|
|
|
HistoryBuffer = (function() {
|
|
function HistoryBuffer(user_id) {
|
|
this.user_id = user_id;
|
|
this.operation_counter = {};
|
|
this.buffer = {};
|
|
this.change_listeners = [];
|
|
}
|
|
|
|
HistoryBuffer.prototype.getUserId = function() {
|
|
return this.user_id;
|
|
};
|
|
|
|
HistoryBuffer.prototype.getOperationCounter = function() {
|
|
var ctn, res, user, _ref;
|
|
res = {};
|
|
_ref = this.operation_counter;
|
|
for (user in _ref) {
|
|
ctn = _ref[user];
|
|
res[user] = ctn;
|
|
}
|
|
return res;
|
|
};
|
|
|
|
HistoryBuffer.prototype.toJson = function() {
|
|
var json, o, o_number, u_name, user, _ref;
|
|
json = [];
|
|
_ref = this.buffer;
|
|
for (u_name in _ref) {
|
|
user = _ref[u_name];
|
|
for (o_number in user) {
|
|
o = user[o_number];
|
|
if (!isNaN(parseInt(o_number))) {
|
|
json.push(o.toJson());
|
|
}
|
|
}
|
|
}
|
|
return json;
|
|
};
|
|
|
|
HistoryBuffer.prototype.getNextOperationIdentifier = function(user_id) {
|
|
var uid;
|
|
if (user_id == null) {
|
|
user_id = this.user_id;
|
|
}
|
|
if (this.operation_counter[user_id] == null) {
|
|
this.operation_counter[user_id] = 0;
|
|
}
|
|
uid = {
|
|
'creator': user_id,
|
|
'op_number': this.operation_counter[user_id]
|
|
};
|
|
this.operation_counter[user_id]++;
|
|
return uid;
|
|
};
|
|
|
|
HistoryBuffer.prototype.getOperation = function(uid) {
|
|
var _ref;
|
|
if (uid instanceof Object) {
|
|
return (_ref = this.buffer[uid.creator]) != null ? _ref[uid.op_number] : void 0;
|
|
} else if (uid == null) {
|
|
|
|
} else {
|
|
throw new Error("This type of uid is not defined!");
|
|
}
|
|
};
|
|
|
|
HistoryBuffer.prototype.addOperation = function(o) {
|
|
if (this.buffer[o.creator] == null) {
|
|
this.buffer[o.creator] = {};
|
|
}
|
|
if (this.operation_counter[o.creator] == null) {
|
|
this.operation_counter[o.creator] = 0;
|
|
}
|
|
if (this.buffer[o.creator][o.op_number] != null) {
|
|
throw new Error("You must not overwrite operations!");
|
|
}
|
|
this.buffer[o.creator][o.op_number] = o;
|
|
if (typeof o.op_number === 'number' && o.creator !== this.getUserId()) {
|
|
this.operation_counter[o.creator]++;
|
|
}
|
|
return o;
|
|
};
|
|
|
|
return HistoryBuffer;
|
|
|
|
})();
|
|
|
|
module.exports = HistoryBuffer;
|
|
|
|
|
|
},{}],5:[function(require,module,exports){
|
|
var __hasProp = {}.hasOwnProperty,
|
|
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
|
|
|
|
module.exports = function(HB) {
|
|
var Delete, Delimiter, Insert, Operation, execution_listener, parser;
|
|
parser = {};
|
|
execution_listener = [];
|
|
Operation = (function() {
|
|
function Operation(_arg) {
|
|
this.creator = _arg['creator'], this.op_number = _arg['op_number'];
|
|
}
|
|
|
|
Operation.prototype.getUid = function() {
|
|
return {
|
|
'creator': this.creator,
|
|
'op_number': this.op_number
|
|
};
|
|
};
|
|
|
|
Operation.prototype.execute = function() {
|
|
var l, _i, _len;
|
|
this.is_executed = true;
|
|
for (_i = 0, _len = execution_listener.length; _i < _len; _i++) {
|
|
l = execution_listener[_i];
|
|
l(this.toJson());
|
|
}
|
|
return this;
|
|
};
|
|
|
|
Operation.prototype.saveOperation = function(name, op) {
|
|
if ((op != null ? op.execute : void 0) != null) {
|
|
return this[name] = op;
|
|
} else if (op != null) {
|
|
if (this.unchecked == null) {
|
|
this.unchecked = {};
|
|
}
|
|
return this.unchecked[name] = op;
|
|
}
|
|
};
|
|
|
|
Operation.prototype.validateSavedOperations = function() {
|
|
var name, op, op_uid, success, uninstantiated, _ref;
|
|
uninstantiated = {};
|
|
success = this;
|
|
_ref = this.unchecked;
|
|
for (name in _ref) {
|
|
op_uid = _ref[name];
|
|
op = HB.getOperation(op_uid);
|
|
if (op) {
|
|
this[name] = op;
|
|
} else {
|
|
uninstantiated[name] = op_uid;
|
|
success = false;
|
|
}
|
|
}
|
|
delete this.unchecked;
|
|
if (!success) {
|
|
this.unchecked = uninstantiated;
|
|
}
|
|
return success;
|
|
};
|
|
|
|
return Operation;
|
|
|
|
})();
|
|
Delete = (function(_super) {
|
|
__extends(Delete, _super);
|
|
|
|
function Delete(uid, deletes) {
|
|
this.saveOperation('deletes', deletes);
|
|
Delete.__super__.constructor.call(this, uid);
|
|
}
|
|
|
|
Delete.prototype.toJson = function() {
|
|
return {
|
|
'type': "Delete",
|
|
'uid': this.getUid(),
|
|
'deletes': this.deletes.getUid()
|
|
};
|
|
};
|
|
|
|
Delete.prototype.execute = function() {
|
|
if (this.validateSavedOperations()) {
|
|
this.deletes.applyDelete(this);
|
|
Delete.__super__.execute.apply(this, arguments);
|
|
return this;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
return Delete;
|
|
|
|
})(Operation);
|
|
parser['Delete'] = function(_arg) {
|
|
var deletes_uid, uid;
|
|
uid = _arg['uid'], deletes_uid = _arg['deletes'];
|
|
return new Delete(uid, deletes_uid);
|
|
};
|
|
Insert = (function(_super) {
|
|
__extends(Insert, _super);
|
|
|
|
function Insert(uid, prev_cl, next_cl, origin) {
|
|
this.saveOperation('prev_cl', prev_cl);
|
|
this.saveOperation('next_cl', next_cl);
|
|
if (origin != null) {
|
|
this.saveOperation('origin', origin);
|
|
} else {
|
|
this.saveOperation('origin', prev_cl);
|
|
}
|
|
Insert.__super__.constructor.call(this, uid);
|
|
}
|
|
|
|
Insert.prototype.applyDelete = function(o) {
|
|
if (this.deleted_by == null) {
|
|
this.deleted_by = [];
|
|
}
|
|
return this.deleted_by.push(o);
|
|
};
|
|
|
|
Insert.prototype.isDeleted = function() {
|
|
var _ref;
|
|
return ((_ref = this.deleted_by) != null ? _ref.length : void 0) > 0;
|
|
};
|
|
|
|
Insert.prototype.getDistanceToOrigin = function() {
|
|
var d, o;
|
|
d = 0;
|
|
o = this.prev_cl;
|
|
while (true) {
|
|
if (this.origin === o) {
|
|
break;
|
|
}
|
|
d++;
|
|
if (this === this.prev_cl) {
|
|
throw new Error("this should not happen ;) ");
|
|
}
|
|
o = o.prev_cl;
|
|
}
|
|
return d;
|
|
};
|
|
|
|
Insert.prototype.update_sl = function() {
|
|
var o;
|
|
o = this.prev_cl;
|
|
({
|
|
update: function(dest_cl, dest_sl) {
|
|
var _results;
|
|
_results = [];
|
|
while (true) {
|
|
if (o.isDeleted()) {
|
|
_results.push(o = o[dest_cl]);
|
|
} else {
|
|
this[dest_sl] = o;
|
|
break;
|
|
}
|
|
}
|
|
return _results;
|
|
}
|
|
});
|
|
update("prev_cl", "prev_sl");
|
|
return update("next_cl", "prev_sl");
|
|
};
|
|
|
|
Insert.prototype.execute = function() {
|
|
var distance_to_origin, i, o, _ref, _ref1;
|
|
if (this.is_executed != null) {
|
|
return this;
|
|
}
|
|
if (!this.validateSavedOperations()) {
|
|
return false;
|
|
} else {
|
|
if (((_ref = this.prev_cl) != null ? _ref.validateSavedOperations() : void 0) && ((_ref1 = this.next_cl) != null ? _ref1.validateSavedOperations() : void 0) && this.prev_cl.next_cl !== this) {
|
|
distance_to_origin = 0;
|
|
o = this.prev_cl.next_cl;
|
|
i = 0;
|
|
while (true) {
|
|
if (o == null) {
|
|
console.log(JSON.stringify(this.prev_cl.getUid()));
|
|
console.log(JSON.stringify(this.next_cl.getUid()));
|
|
}
|
|
if (o !== this.next_cl) {
|
|
if (o.getDistanceToOrigin() === i) {
|
|
if (o.creator < this.creator) {
|
|
this.prev_cl = o;
|
|
distance_to_origin = i + 1;
|
|
} else {
|
|
|
|
}
|
|
} else if (o.getDistanceToOrigin() < i) {
|
|
if (i - distance_to_origin <= o.getDistanceToOrigin()) {
|
|
this.prev_cl = o;
|
|
distance_to_origin = i + 1;
|
|
} else {
|
|
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
i++;
|
|
o = o.next_cl;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
this.next_cl = this.prev_cl.next_cl;
|
|
this.prev_cl.next_cl = this;
|
|
this.next_cl.prev_cl = this;
|
|
}
|
|
Insert.__super__.execute.apply(this, arguments);
|
|
return this;
|
|
}
|
|
};
|
|
|
|
Insert.prototype.val = function() {
|
|
throw new Error("Implement this function!");
|
|
};
|
|
|
|
return Insert;
|
|
|
|
})(Operation);
|
|
Delimiter = (function(_super) {
|
|
__extends(Delimiter, _super);
|
|
|
|
function Delimiter() {
|
|
return Delimiter.__super__.constructor.apply(this, arguments);
|
|
}
|
|
|
|
Delimiter.prototype.isDeleted = function() {
|
|
return false;
|
|
};
|
|
|
|
Delimiter.prototype.getDistanceToOrigin = function() {
|
|
return 0;
|
|
};
|
|
|
|
Delimiter.prototype.execute = function() {
|
|
var l, _i, _len;
|
|
if (this.validateSavedOperations()) {
|
|
for (_i = 0, _len = execution_listener.length; _i < _len; _i++) {
|
|
l = execution_listener[_i];
|
|
l(this.toJson());
|
|
}
|
|
return this;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
Delimiter.prototype.toJson = function() {
|
|
var _ref, _ref1;
|
|
return {
|
|
'type': "Delimiter",
|
|
'uid': this.getUid(),
|
|
'prev': (_ref = this.prev_cl) != null ? _ref.getUid() : void 0,
|
|
'next': (_ref1 = this.next_cl) != null ? _ref1.getUid() : void 0
|
|
};
|
|
};
|
|
|
|
return Delimiter;
|
|
|
|
})(Insert);
|
|
parser['Delimiter'] = function(json) {
|
|
var next, prev, uid;
|
|
uid = json['uid'], prev = json['prev'], next = json['next'];
|
|
return new Delimiter(uid, prev, next);
|
|
};
|
|
return {
|
|
'types': {
|
|
'Delete': Delete,
|
|
'Insert': Insert,
|
|
'Delimiter': Delimiter,
|
|
'Operation': Operation
|
|
},
|
|
'parser': parser,
|
|
'execution_listener': execution_listener
|
|
};
|
|
};
|
|
|
|
|
|
},{}],6:[function(require,module,exports){
|
|
var text_types_uninitialized,
|
|
__hasProp = {}.hasOwnProperty,
|
|
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
|
|
|
|
text_types_uninitialized = require("./TextTypes.coffee");
|
|
|
|
module.exports = function(HB) {
|
|
var JsonType, parser, text_types, types;
|
|
text_types = text_types_uninitialized(HB);
|
|
types = text_types.types;
|
|
parser = text_types.parser;
|
|
JsonType = (function(_super) {
|
|
__extends(JsonType, _super);
|
|
|
|
function JsonType(uid, initial_value) {
|
|
var name, o;
|
|
JsonType.__super__.constructor.call(this, uid);
|
|
if (initial_value != null) {
|
|
if (typeof initial_value !== "object") {
|
|
throw new Error("The initial value of JsonTypes must be of type Object! (current type: " + (typeof initial_value) + ")");
|
|
}
|
|
for (name in initial_value) {
|
|
o = initial_value[name];
|
|
this.val(name, o);
|
|
}
|
|
}
|
|
}
|
|
|
|
JsonType.prototype.val = function(name, content) {
|
|
var json, word;
|
|
if ((name != null) && (content != null)) {
|
|
if (typeof content === 'string') {
|
|
word = HB.addOperation(new types.Word(HB.getNextOperationIdentifier(), content)).execute();
|
|
JsonType.__super__.val.call(this, name, word);
|
|
return content;
|
|
} else if (typeof content === 'object') {
|
|
json = HB.addOperation(JsonType(HB.getNextOperationIdentifier(), content)).execute();
|
|
JsonType.__super__.val.call(this, name, json);
|
|
return content;
|
|
} else {
|
|
throw new Error("You must not set " + (typeof content) + "-types in collaborative Json-objects!");
|
|
}
|
|
} else {
|
|
return JsonType.__super__.val.call(this, name, content);
|
|
}
|
|
};
|
|
|
|
JsonType.prototype.toJson = function() {
|
|
return {
|
|
'type': "JsonType",
|
|
'uid': this.getUid()
|
|
};
|
|
};
|
|
|
|
return JsonType;
|
|
|
|
})(types.MapManager);
|
|
parser['JsonType'] = function(json) {
|
|
var uid;
|
|
uid = json['uid'];
|
|
return new JsonType(uid);
|
|
};
|
|
types['JsonType'] = JsonType;
|
|
return text_types;
|
|
};
|
|
|
|
|
|
},{"./TextTypes.coffee":8}],7:[function(require,module,exports){
|
|
var basic_types_uninitialized,
|
|
__hasProp = {}.hasOwnProperty,
|
|
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
|
|
|
|
basic_types_uninitialized = require("./BasicTypes.coffee");
|
|
|
|
module.exports = function(HB) {
|
|
var AddName, ListManager, MapManager, ReplaceManager, Replaceable, basic_types, parser, types;
|
|
basic_types = basic_types_uninitialized(HB);
|
|
types = basic_types.types;
|
|
parser = basic_types.parser;
|
|
MapManager = (function(_super) {
|
|
__extends(MapManager, _super);
|
|
|
|
function MapManager(uid) {
|
|
this.map = {};
|
|
MapManager.__super__.constructor.call(this, uid);
|
|
}
|
|
|
|
MapManager.prototype.val = function(name, content) {
|
|
var o, result, _ref, _ref1;
|
|
if (content != null) {
|
|
if (this.map[name] == null) {
|
|
HB.addOperation(new AddName(HB.getNextOperationIdentifier(), this, name)).execute();
|
|
}
|
|
return this.map[name].replace(content);
|
|
} else if (name != null) {
|
|
return (_ref = this.map[name]) != null ? _ref.val() : void 0;
|
|
} else {
|
|
result = {};
|
|
_ref1 = this.map;
|
|
for (name in _ref1) {
|
|
o = _ref1[name];
|
|
result[name] = o.val();
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
return MapManager;
|
|
|
|
})(types.Operation);
|
|
AddName = (function(_super) {
|
|
__extends(AddName, _super);
|
|
|
|
function AddName(uid, map_manager, name) {
|
|
this.name = name;
|
|
this.saveOperation('map_manager', map_manager);
|
|
AddName.__super__.constructor.call(this, uid);
|
|
}
|
|
|
|
AddName.prototype.execute = function() {
|
|
var beg, end, uid_beg, uid_end, uid_r;
|
|
if (!this.validateSavedOperations()) {
|
|
return false;
|
|
} else {
|
|
uid_r = this.map_manager.getUid();
|
|
uid_r.op_number = "_" + uid_r.op_number + "_RM_" + this.name;
|
|
if (HB.getOperation(uid_r) == null) {
|
|
uid_beg = this.map_manager.getUid();
|
|
uid_beg.op_number = "_" + uid_beg.op_number + "_RM_" + this.name + "_beginning";
|
|
uid_end = this.map_manager.getUid();
|
|
uid_end.op_number = "_" + uid_end.op_number + "_RM_" + this.name + "_end";
|
|
beg = HB.addOperation(new types.Delimiter(uid_beg, void 0, uid_end));
|
|
end = HB.addOperation(new types.Delimiter(uid_end, beg, void 0)).execute();
|
|
beg.execute();
|
|
this.map_manager.map[this.name] = HB.addOperation(new ReplaceManager(void 0, uid_r, beg, end)).execute();
|
|
}
|
|
return AddName.__super__.execute.apply(this, arguments);
|
|
}
|
|
};
|
|
|
|
AddName.prototype.toJson = function() {
|
|
return {
|
|
'type': "AddName",
|
|
'uid': this.getUid(),
|
|
'map_manager': this.map_manager.getUid(),
|
|
'name': this.name
|
|
};
|
|
};
|
|
|
|
return AddName;
|
|
|
|
})(types.Operation);
|
|
parser['AddName'] = function(json) {
|
|
var map_manager, name, uid;
|
|
map_manager = json['map_manager'], uid = json['uid'], name = json['name'];
|
|
return new AddName(uid, map_manager, name);
|
|
};
|
|
ListManager = (function(_super) {
|
|
__extends(ListManager, _super);
|
|
|
|
function ListManager(uid, beginning, end, prev, next, origin) {
|
|
if ((beginning != null) && (end != null)) {
|
|
this.saveOperation('beginning', beginning);
|
|
this.saveOperation('end', end);
|
|
} else {
|
|
this.beginning = HB.addOperation(new types.Delimiter(HB.getNextOperationIdentifier(), void 0, void 0));
|
|
this.end = HB.addOperation(new types.Delimiter(HB.getNextOperationIdentifier(), this.beginning, void 0));
|
|
this.beginning.next_cl = this.end;
|
|
this.beginning.execute();
|
|
this.end.execute();
|
|
}
|
|
ListManager.__super__.constructor.call(this, uid, prev, next, origin);
|
|
}
|
|
|
|
ListManager.prototype.getLastOperation = function() {
|
|
return this.end.prev_cl;
|
|
};
|
|
|
|
ListManager.prototype.getFirstOperation = function() {
|
|
return this.beginning.next_cl;
|
|
};
|
|
|
|
ListManager.prototype.toArray = function() {
|
|
var o, result;
|
|
o = this.beginning.next_cl;
|
|
result = [];
|
|
while (o !== this.end) {
|
|
result.push(o);
|
|
o = o.next_cl;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
ListManager.prototype.getOperationByPosition = function(position) {
|
|
var o;
|
|
o = this.beginning.next_cl;
|
|
if (position > 0) {
|
|
while (true) {
|
|
o = o.next_cl;
|
|
if (!o.isDeleted()) {
|
|
position -= 1;
|
|
}
|
|
if (position === 0) {
|
|
break;
|
|
}
|
|
if (o instanceof types.Delimiter) {
|
|
throw new Error("position parameter exceeded the length of the document!");
|
|
}
|
|
}
|
|
}
|
|
return o;
|
|
};
|
|
|
|
return ListManager;
|
|
|
|
})(types.Insert);
|
|
ReplaceManager = (function(_super) {
|
|
__extends(ReplaceManager, _super);
|
|
|
|
function ReplaceManager(initial_content, uid, beginning, end, prev, next, origin) {
|
|
ReplaceManager.__super__.constructor.call(this, uid, beginning, end, prev, next, origin);
|
|
if (initial_content != null) {
|
|
this.replace(initial_content);
|
|
}
|
|
}
|
|
|
|
ReplaceManager.prototype.replace = function(content) {
|
|
var o, op;
|
|
o = this.getLastOperation();
|
|
op = new Replaceable(content, this, HB.getNextOperationIdentifier(), o, o.next_cl);
|
|
return HB.addOperation(op).execute();
|
|
};
|
|
|
|
ReplaceManager.prototype.val = function() {
|
|
var o;
|
|
o = this.getLastOperation();
|
|
if (o instanceof types.Delimiter) {
|
|
throw new Error("dtrn");
|
|
}
|
|
return o.val();
|
|
};
|
|
|
|
ReplaceManager.prototype.toJson = function() {
|
|
var json;
|
|
json = {
|
|
'type': "ReplaceManager",
|
|
'uid': this.getUid(),
|
|
'beginning': this.beginning.getUid(),
|
|
'end': this.end.getUid()
|
|
};
|
|
if ((this.prev_cl != null) && (this.next_cl != null)) {
|
|
json['prev'] = this.prev_cl.getUid();
|
|
json['next'] = this.next_cl.getUid();
|
|
}
|
|
if ((this.origin != null) && this.origin !== this.prev_cl) {
|
|
json["origin"] = this.origin.getUid();
|
|
}
|
|
return json;
|
|
};
|
|
|
|
return ReplaceManager;
|
|
|
|
})(ListManager);
|
|
parser["ReplaceManager"] = function(json) {
|
|
var beginning, content, end, next, origin, prev, uid;
|
|
content = json['content'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'], beginning = json['beginning'], end = json['end'];
|
|
return new ReplaceManager(content, uid, beginning, end, prev, next, origin);
|
|
};
|
|
Replaceable = (function(_super) {
|
|
__extends(Replaceable, _super);
|
|
|
|
function Replaceable(content, parent, uid, prev, next, origin) {
|
|
this.saveOperation('content', content);
|
|
this.saveOperation('parent', parent);
|
|
if (!((prev != null) && (next != null) && (content != null))) {
|
|
throw new Error("You must define content, prev, and next for Replaceable-types!");
|
|
}
|
|
Replaceable.__super__.constructor.call(this, uid, prev, next, origin);
|
|
}
|
|
|
|
Replaceable.prototype.val = function() {
|
|
return this.content;
|
|
};
|
|
|
|
Replaceable.prototype.replace = function(content) {
|
|
return this.parent.replace(content);
|
|
};
|
|
|
|
Replaceable.prototype.execute = function() {
|
|
var _base;
|
|
if (!this.validateSavedOperations()) {
|
|
return false;
|
|
} else {
|
|
if (typeof (_base = this.content).setReplaceManager === "function") {
|
|
_base.setReplaceManager(this.parent);
|
|
}
|
|
Replaceable.__super__.execute.apply(this, arguments);
|
|
return this;
|
|
}
|
|
};
|
|
|
|
Replaceable.prototype.toJson = function() {
|
|
var json;
|
|
json = {
|
|
'type': "Replaceable",
|
|
'content': this.content.getUid(),
|
|
'ReplaceManager': this.parent.getUid(),
|
|
'prev': this.prev_cl.getUid(),
|
|
'next': this.next_cl.getUid(),
|
|
'uid': this.getUid()
|
|
};
|
|
if ((this.origin != null) && this.origin !== this.prev_cl) {
|
|
json["origin"] = this.origin.getUid();
|
|
}
|
|
return json;
|
|
};
|
|
|
|
return Replaceable;
|
|
|
|
})(types.Insert);
|
|
parser["Replaceable"] = function(json) {
|
|
var content, next, origin, parent, prev, uid;
|
|
content = json['content'], parent = json['ReplaceManager'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'];
|
|
return new Replaceable(content, parent, uid, prev, next, origin);
|
|
};
|
|
types['ListManager'] = ListManager;
|
|
types['MapManager'] = MapManager;
|
|
types['ReplaceManager'] = ReplaceManager;
|
|
types['Replaceable'] = Replaceable;
|
|
return basic_types;
|
|
};
|
|
|
|
|
|
},{"./BasicTypes.coffee":5}],8:[function(require,module,exports){
|
|
var structured_types_uninitialized,
|
|
__hasProp = {}.hasOwnProperty,
|
|
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
|
|
|
|
structured_types_uninitialized = require("./StructuredTypes.coffee");
|
|
|
|
module.exports = function(HB) {
|
|
var TextDelete, TextInsert, Word, parser, structured_types, types;
|
|
structured_types = structured_types_uninitialized(HB);
|
|
types = structured_types.types;
|
|
parser = structured_types.parser;
|
|
TextDelete = (function(_super) {
|
|
__extends(TextDelete, _super);
|
|
|
|
function TextDelete() {
|
|
return TextDelete.__super__.constructor.apply(this, arguments);
|
|
}
|
|
|
|
return TextDelete;
|
|
|
|
})(types.Delete);
|
|
parser["TextDelete"] = parser["Delete"];
|
|
TextInsert = (function(_super) {
|
|
__extends(TextInsert, _super);
|
|
|
|
function TextInsert(content, uid, prev, next, origin) {
|
|
this.content = content;
|
|
if (!((prev != null) && (next != null))) {
|
|
throw new Error("You must define prev, and next for TextInsert-types!");
|
|
}
|
|
TextInsert.__super__.constructor.call(this, uid, prev, next, origin);
|
|
}
|
|
|
|
TextInsert.prototype.getLength = function() {
|
|
if (this.isDeleted()) {
|
|
return 0;
|
|
} else {
|
|
return this.content.length;
|
|
}
|
|
};
|
|
|
|
TextInsert.prototype.val = function(current_position) {
|
|
if (this.isDeleted()) {
|
|
return "";
|
|
} else {
|
|
return this.content;
|
|
}
|
|
};
|
|
|
|
TextInsert.prototype.toJson = function() {
|
|
var json;
|
|
json = {
|
|
'type': "TextInsert",
|
|
'content': this.content,
|
|
'uid': this.getUid(),
|
|
'prev': this.prev_cl.getUid(),
|
|
'next': this.next_cl.getUid()
|
|
};
|
|
if ((this.origin != null) && this.origin !== this.prev_cl) {
|
|
json["origin"] = this.origin.getUid();
|
|
}
|
|
return json;
|
|
};
|
|
|
|
return TextInsert;
|
|
|
|
})(types.Insert);
|
|
parser["TextInsert"] = function(json) {
|
|
var content, next, origin, prev, uid;
|
|
content = json['content'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'];
|
|
return new TextInsert(content, uid, prev, next, origin);
|
|
};
|
|
Word = (function(_super) {
|
|
__extends(Word, _super);
|
|
|
|
function Word(uid, initial_content, beginning, end, prev, next, origin) {
|
|
Word.__super__.constructor.call(this, uid, beginning, end, prev, next, origin);
|
|
if (initial_content != null) {
|
|
this.insertText(0, initial_content);
|
|
}
|
|
}
|
|
|
|
Word.prototype.insertText = function(position, content) {
|
|
var c, o, op, _i, _len, _results;
|
|
o = this.getOperationByPosition(position);
|
|
_results = [];
|
|
for (_i = 0, _len = content.length; _i < _len; _i++) {
|
|
c = content[_i];
|
|
op = new TextInsert(c, HB.getNextOperationIdentifier(), o.prev_cl, o);
|
|
_results.push(HB.addOperation(op).execute());
|
|
}
|
|
return _results;
|
|
};
|
|
|
|
Word.prototype.deleteText = function(position, length) {
|
|
var d, i, o, _i, _results;
|
|
o = this.getOperationByPosition(position);
|
|
_results = [];
|
|
for (i = _i = 0; 0 <= length ? _i < length : _i > length; i = 0 <= length ? ++_i : --_i) {
|
|
d = HB.addOperation(new TextDelete(HB.getNextOperationIdentifier(), o)).execute();
|
|
o = o.next_cl;
|
|
while (o.isDeleted()) {
|
|
if (o instanceof types.Delimiter) {
|
|
throw new Error("You can't delete more than there is..");
|
|
}
|
|
o = o.next_cl;
|
|
}
|
|
_results.push(d.toJson());
|
|
}
|
|
return _results;
|
|
};
|
|
|
|
Word.prototype.replaceText = function(text) {
|
|
var word;
|
|
if (this.replace_manager != null) {
|
|
word = HB.addOperation(new Word(HB.getNextOperationIdentifier())).execute();
|
|
word.insertText(0, text);
|
|
return this.replace_manager.replace(word);
|
|
} else {
|
|
throw new Error("This type is currently not maintained by a ReplaceManager!");
|
|
}
|
|
};
|
|
|
|
Word.prototype.val = function() {
|
|
var c, o;
|
|
c = (function() {
|
|
var _i, _len, _ref, _results;
|
|
_ref = this.toArray();
|
|
_results = [];
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
o = _ref[_i];
|
|
if (o.val != null) {
|
|
_results.push(o.val());
|
|
} else {
|
|
_results.push("");
|
|
}
|
|
}
|
|
return _results;
|
|
}).call(this);
|
|
return c.join('');
|
|
};
|
|
|
|
Word.prototype.setReplaceManager = function(op) {
|
|
this.saveOperation('replace_manager', op);
|
|
return this.validateSavedOperations;
|
|
};
|
|
|
|
Word.prototype.toJson = function() {
|
|
var json;
|
|
json = {
|
|
'type': "Word",
|
|
'uid': this.getUid(),
|
|
'beginning': this.beginning.getUid(),
|
|
'end': this.end.getUid()
|
|
};
|
|
if (this.prev_cl != null) {
|
|
json['prev'] = this.prev_cl.getUid();
|
|
}
|
|
if (this.next_cl != null) {
|
|
json['next'] = this.next_cl.getUid();
|
|
}
|
|
if ((this.origin != null) && this.origin !== this.prev_cl) {
|
|
json["origin"] = this.origin.getUid();
|
|
}
|
|
return json;
|
|
};
|
|
|
|
return Word;
|
|
|
|
})(types.ListManager);
|
|
parser['Word'] = function(json) {
|
|
var beginning, end, next, origin, prev, uid;
|
|
uid = json['uid'], beginning = json['beginning'], end = json['end'], prev = json['prev'], next = json['next'], origin = json['origin'];
|
|
return new Word(uid, void 0, beginning, end, prev, next, origin);
|
|
};
|
|
types['TextInsert'] = TextInsert;
|
|
types['TextDelete'] = TextDelete;
|
|
types['Word'] = Word;
|
|
return structured_types;
|
|
};
|
|
|
|
|
|
},{"./StructuredTypes.coffee":7}]},{},[3,1]); |