spontaneous 0.1.0.alpha1

data/application/js/require.js

@@ -0,0 +1,129 @@
+Spontaneous.Require = {
+	pending: [],
+	current: false,
+	_completed: [],
+	position: 0,
+	async: true,
+	init: function(asynchronous) {
+		this.async = asynchronous;
+		var body = document.body;
+		var splash = document.createElement('div');
+		splash.id = "script-load-splash";
+			var progress_outer = document.createElement('div');
+			progress_outer.id = "script-load-progress";
+		if (this.async) {
+			var progress_inner = document.createElement('div');
+			progress_outer.appendChild(progress_inner);
+			this.bar = progress_inner;
+			this.progress(0);
+		} else {
+			progress_outer.className = "synchronous";
+			progress_outer.innerHTML = "Loading...";
+		}
+		splash.appendChild(progress_outer);
+		body.appendChild(splash);
+		this.container = splash
+	},
+	remove: function() {
+		document.body.removeChild(this.container);
+	},
+	progress: function(position) {
+		this.position = position;
+		var percent = ((this.completed()/this.total()) * 100);
+		if (isNaN(percent)) { percent = 0; }
+		this.bar.style.width = percent + '%';
+	},
+	completed: function() {
+		var total = 0;
+		for (var i = 0, ii = this._completed.length; i < ii; i++) {
+			total += this._completed[i][1];
+		}
+		total += this.position;
+		return total;
+	},
+	total: function() {
+		var total = 0;
+		for (var i = 0, ii = this.pending.length; i < ii; i++) {
+			total += this.pending[i][1];
+		}
+		if (this.current) {
+			total += this.current[1];
+		}
+		for (var i = 0, ii = this._completed.length; i < ii; i++) {
+			total += this._completed[i][1];
+		}
+		return total;
+	},
+	add: function(script) {
+		this.pending.push(script)
+		if (!this.current) { this.next(); }
+	},
+	script_url: function(src) {
+		var url = src;
+		if (Spontaneous.development) {
+			url += "?"+(new Date()).valueOf();
+		}
+		return url;
+	},
+	next: function() {
+		if (this.pending.length === 0) {
+			this.container.className = 'loaded';
+			this.remove();
+			Spontaneous.onload();
+			return;
+		}
+		var s = this.pending.shift();
+		this.current = s;
+		if (this.async) {
+			var xhr = new XMLHttpRequest();
+			xhr.open("GET", this.script_url(s[0]), true);
+			var onprogress = (function(req) {
+				return function(event) {
+					req.onprogress(event);
+				}
+			})(this);
+			var onreadystatechange = (function(req) {
+				return function(event) {
+					req.onreadystatechange(event);
+				}
+			})(this);
+			xhr.onprogress = onprogress;
+			xhr.onreadystatechange = onreadystatechange;
+			xhr.send();
+		} else {
+			var body = document.body;
+			var script = document.createElement('script');
+			script.type = 'text/javascript';
+			script.src = this.script_url(this.current[0]);
+			var onload = (function(req) {
+				return function() {
+					req._completed.push(req.current);
+					req.current = false;
+					req.next();
+				};
+			})(this);
+			script.onload = onload;
+			body.appendChild(script);
+			// this.current = false;
+		}
+	},
+	onprogress: function(event) {
+		this.progress(event.position);
+	},
+	onreadystatechange: function(event) {
+		var xhr = event.currentTarget;
+		if (xhr.readyState == 4 && xhr.status === 200) {
+			var body = document.body;
+			var script = document.createElement('script');
+			script.type = 'text/javascript';
+			script.text = xhr.responseText;
+			body.appendChild(script)
+			this._completed.push(this.current);
+			this.position = 0;
+			this.next();
+		}
+	}
+};
+Spontaneous.require = function(script) {
+	Spontaneous.Require.add(script)
+}

data/application/js/sharded_upload.js

@@ -0,0 +1,206 @@
+// console.log("Loading ShardedUpload...");
+
+
+Spontaneous.ShardedUpload = (function($, S) {
+	var dom = S.Dom;
+	var upload_id = (new Date()).valueOf();
+	var Shard = new JS.Class({
+		initialize: function(uploader, index, blob) {
+			this.uploader = uploader;
+			this.index = index;
+			this.blob = blob;
+			this.progress = 0;
+			this.size = this.blob.size;
+		},
+		start: function() {
+			var reader = new FileReader();
+			reader.onload = function(event) {
+				this.compute_hash(reader.result);
+			}.bind(this);
+			reader.onerror = function(event) {
+				console.error('error', event);
+			};
+			reader.readAsArrayBuffer(this.blob);
+		},
+
+		// callback from reader
+		compute_hash: function(array_buffer) {
+			var bytes = new Uint8Array(array_buffer);
+			var sha = Crypto.SHA1(bytes);
+			this.hash = sha
+			this.begin_upload();
+			this.failure_count = 0;
+		},
+		remote_path: function() {
+			return S.Ajax.request_url(['shard', this.hash].join('/'), true);
+		},
+		begin_upload: function() {
+			// test for existance of shard on server
+			S.Ajax.get(['/shard', this.hash].join('/'), this.status_complete.bind(this));
+		},
+		status_complete: function(data, status, xhr) {
+			if (status === "success") {
+				// we're actually done
+				this.complete();
+			} else {
+				this.upload();
+			}
+		},
+		retry: function() {
+			if (this.hash) {
+				this.upload();
+			} else {
+				this.start();
+			}
+		},
+		upload: function() {
+			// create the form and post it using the calculated hash
+			// assigning the callbacks to myself.
+
+			var form = new FormData(),
+				path = S.Ajax.request_url(['/shard', this.hash].join('/'), true);
+			form.append('file', this.blob);
+			var xhr = new XMLHttpRequest(), upload = xhr.upload;
+			xhr.open("POST", path, true);
+			upload.onprogress = this.onprogress.bind(this);
+			upload.onload = this.onload.bind(this);
+			upload.onloadend = this.onloadend.bind(this);
+			upload.onerror = this.onerror.bind(this);
+			xhr.onreadystatechange = this.onreadystatechange.bind(this);
+			this.started = (new Date()).valueOf();
+			xhr.send(form);
+		},
+
+		complete: function() {
+			this.blob = null;
+			this.uploader.shard_complete(this);
+		},
+		failed: function() {
+			this.failure_count += 1;
+			this.uploader.shard_failed(this);
+		},
+		onprogress: function(event) {
+			var progress = event.position;
+			this.progress = progress;
+			this.time = (new Date()).valueOf() - this.started;
+			this.uploader.upload_progress(this);
+		},
+		onload: function(event) {
+		},
+		onloadend: function(event) {
+			console.error('Shard#onloadend: shard upload failed', event);
+		},
+		onreadystatechange: function(event) {
+			var xhr = event.currentTarget;
+			if (xhr.readyState == 4) {
+				if (xhr.status === 200) {
+					this.complete();
+				} else {
+					this.failed();
+				}
+			}
+		},
+
+		onerror: function(event) {
+			console.error('Shard#onerror: shard upload error', event);
+		}
+	});
+
+	var ShardedUpload = new JS.Class(Spontaneous.Upload, {
+		slice_size: 524288,
+		initialize: function(manager, target, file) {
+			this.callSuper();
+			this.completed = [];
+			this.failed = [];
+			this.current = null;
+		},
+		start: function() {
+			this.started = (new Date()).valueOf();
+			this.start_with_index(0);
+		},
+		start_with_index: function(index) {
+			if (index < this.shard_count()) {
+				var shard = new Shard(this, index, this.slice(index));
+				this.current = shard;
+				shard.start();
+			} else {
+				if (this.failed.length === 0) {
+					this.finalize();
+				} else {
+					var shard = this.failed.pop();
+					console.warn('retrying failed shard', shard)
+					this.current = shard;
+					shard.retry();
+				}
+			}
+		},
+		finalize: function() {
+			var form = new FormData();
+			form.append('field', this.field_name);
+			form.append('version', this.target_version);
+			form.append('shards', this.hashes().join(','));
+			form.append('mime_type', this.mime_type());
+			form.append('filename', this.file.fileName);
+			this.post(this.path(), form);
+		},
+		path: function() {
+			return ["/shard/replace", this.target_id].join('/');
+		},
+		hashes: function() {
+			var hashes = [];
+			for (var i = 0, ii = this.completed.length; i < ii; i++) {
+				hashes.push(this.completed[i].hash);
+			}
+			return hashes;
+		},
+		upload_progress: function(shard) {
+			this.time = (new Date()).valueOf() - this.started;
+			this.manager.upload_progress(this);
+		},
+		position: function() {
+			var _position = 0;
+			for (var i = 0, cc = this.completed, ii = cc.length; i < ii; i++) {
+				if (cc[i]) { // failed shards will leave a blank space
+					_position += cc[i].size;
+				}
+			}
+			_position += this.current.progress;
+			_position = Math.min(_position, this.total());
+			return _position;
+		},
+		mime_type: function() {
+			return this.file.type;
+		},
+		total: function() {
+			return this.file.size;
+		},
+		shard_complete: function(shard) {
+			// update the progress
+			// and launch the next shard
+			this.manager.upload_progress(this);
+			this.completed[shard.index] = shard;
+			this.start_with_index(shard.index + 1);
+		},
+		shard_failed: function(shard) {
+			console.error('shard failed', shard, shard.index);
+			this.failed.push(shard);
+			this.start_with_index(shard.index + 1);
+		},
+		shard_count: function() {
+			return Math.ceil(this.file.size / this.slice_size);
+		},
+		slice: function(n) {
+			// file slicing methods have been normalised by compatibility.js
+			return this.file.slice(n * this.slice_size, (n+1) * this.slice_size);
+		}
+
+	});
+	ShardedUpload.extend({
+		supported: function() {
+			return ((typeof window.File.prototype.slice === 'function') &&
+				(typeof window.FileReader !== 'undefined') &&
+				(typeof window.Uint8Array !== 'undefined'));
+		}
+	});
+	return ShardedUpload;
+}(jQuery, Spontaneous));

data/application/js/side_bar.js

@@ -0,0 +1,30 @@
+// console.log('Loading Side Bar...')
+
+Spontaneous.SideBar = (function($, S) {
+	var dom = S.Dom, Page = S.Page;
+
+	var side_bar = {
+		panel: function() {
+			this.panel = dom.div('#side-bar');
+			this.logo_panel = dom.div('#logo')
+			this.page_info_panel = dom.div('.page-info')
+			this.user_panel = dom.div('#user')
+			this.panel.append(this.logo_panel).append(this.page_info_panel).append(this.user_panel);
+			return this.panel;
+		},
+		location_changed: function(location) {
+			console.log('page-loaded', location)
+			this.page_info_panel.text(location.url);
+		},
+		spinner: function() {
+			if (!this._spinner) {
+				this._spinner = Spontaneous.Progress(this.logo_panel[0], 48, {
+					spinner_fg_color: "#fff",
+					period: 850
+				});
+			}
+			return this._spinner;
+		}
+	};
+	return side_bar;
+})(jQuery, Spontaneous);

data/application/js/spontaneous.js

@@ -0,0 +1,6 @@
+// console.log('Loading Spontaneous...')
+
+Spontaneous.page = function() {
+	return Spontaneous.Editing.get('page');
+}
+

data/application/js/state.js

@@ -0,0 +1,64 @@
+// console.log("Loading State...")
+
+Spontaneous.State = (function($, S) {
+	var ajax = S.Ajax;
+
+	var ContentState = new JS.Class({
+		initialize: function(content) {
+			this.content = content;
+			this.state = this.load();
+		},
+		load: function() {
+			var s = (localStorage.getItem(this.storage_key()) || '{}');
+			try {
+				return JSON.parse(s);
+			} catch (e) { return {}; }
+		},
+		save: function() {
+			localStorage.setItem(this.storage_key(), this.toString());
+		},
+		storage_key: function() {
+			return 'content-state-'+this.content.id();
+		},
+		activate_box: function(box) {
+			this.state.box = box.id();
+		},
+		active_box: function() {
+			return this.state.box;
+		},
+		activate_slot: function(slot) {
+			this.state.slot = slot.id();
+		},
+		active_slot: function() {
+			return this.state.slot;
+		},
+		toString: function() {
+			return JSON.stringify(this.state);
+		}
+	});
+	var State = new JS.Singleton({
+		get: function(content) {
+			var s = new ContentState(content);
+			return s;
+		},
+		activate_box: function(content, box) {
+			var s = this.get(content);
+			s.activate_box(box);
+			s.save();
+		},
+		active_box: function(content) {
+			var s = this.get(content);
+			return s.active_box();
+		},
+		activate_slot: function(content, slot) {
+			var s = this.get(content);
+			s.activate_slot(slot);
+			s.save();
+		},
+		active_slot: function(content) {
+			var s = this.get(content);
+			return s.active_slot();
+		}
+	});
+	return State;
+}(jQuery, Spontaneous));

data/application/js/status_bar.js

@@ -0,0 +1,47 @@
+// console.log("Loading StatusBar...");
+
+
+Spontaneous.StatusBar = (function($, S) {
+	var dom = S.Dom;
+
+	var StatusBar = {
+		showing: false,
+		init: function() {
+			this.container = dom.div('#status-bar').hide();
+			S.UploadManager.init(this);
+			// window.setTimeout(function() {this.hide();}.bind(this), 1000);
+			return this.container;
+		},
+		hide: function() {
+			if (!this.showing) { return; }
+			this.showing = false;
+			var duration = 200;
+			window.setTimeout(function() {
+				// S.ContentArea.wrap.animate({'bottom': 0}, duration);
+				// S.Dialogue.overlay().animate({'bottom': 0}, duration);
+				this.container.animate({'height': 0}, duration, function() { /* this.container.hide() */ }.bind(this));
+			}.bind(this), 500);
+		},
+		show: function() {
+			if (this.showing) { return; }
+			this.showing = true;
+			var duration = 200, height = 32;
+			// S.ContentArea.wrap.animate({'bottom': height}, duration);
+			// S.Dialogue.overlay().animate({'bottom': height}, duration);
+			this.container.css('height', 0+'px');
+			this.container.show();
+			this.container.animate({'height': height}, duration);
+		},
+		progress_container: function() {
+			if (!this._progress_container) {
+				var c = dom.div('#progress-container');
+				this.container.append(c);
+				this._progress_container = c;
+			}
+			return this._progress_container;
+		}
+	};
+	return StatusBar;
+})(jQuery, Spontaneous);
+
+