spontaneous 0.1.0.alpha1

data/application/css/variables.scss

@@ -0,0 +1,80 @@
+$blue: #10b2fe;
+$white: white;
+$top_bar_height: 40px;
+$side_bar_width: 0px;
+$chrome_color: #222222;
+
+$white: white;
+$level1: rgb(224, 224, 224);
+$level2: $level1 - #090909;
+$level3: $level2 - #090909;
+$level4: $level3 - #090909;
+$level5: $level4 - #090909;
+$level6: $level5 - #090909;
+$level7: $level6 - #090909;
+
+$bar-height: 34px;
+$padding: 10px;
+
+$line-height: 12px;
+$font-size: 11px;
+
+@mixin rounded($radius: 5px) {
+  -webkit-border-radius: $radius;
+  -moz-border-radius: $radius;
+  border-radius: $radius; }
+
+@mixin rounded-left($radius: 5px) {
+  -webkit-border-top-left-radius: $radius;
+  -moz-border-radius-topleft: $radius;
+  border-top-left-radius: $radius;
+  -webkit-border-bottom: $radius;
+  -moz-border-radius-bottomleft: $radius;
+  border-bottom-left-radius: $radius; }
+
+@mixin rounded-right($radius: 5px) {
+  -webkit-border-top-right-radius: $radius;
+  -moz-border-radius-topright: $radius;
+  border-top-right-radius: $radius;
+  -webkit-border-bottom: $radius;
+  -moz-border-radius-bottomright: $radius;
+  border-bottom-right-radius: $radius; }
+
+@mixin rounded-top($radius: 5px) {
+  -webkit-border-top-right-radius: $radius;
+  -moz-border-radius-topright: $radius;
+  border-top-right-radius: $radius;
+  -webkit-border-top-left-radius: $radius;
+  -moz-border-radius-topleft: $radius;
+  border-top-left-radius: $radius; }
+
+@mixin rounded-bottom($radius: 5px) {
+  -webkit-border-bottom-right-radius: $radius;
+  -moz-border-radius-bottomright: $radius;
+  border-bottom-right-radius: $radius;
+  -webkit-border-bottom-left-radius: $radius;
+  -moz-border-radius-bottomleft: $radius;
+  border-bottom-left-radius: $radius; }
+
+@mixin rounded-top-left($radius: 5px) {
+  -webkit-border-top-left-radius: $radius;
+  -moz-border-radius-topleft: $radius;
+  border-top-left-radius: $radius; }
+
+.clearfix:after {
+  content: ".";
+  display: block;
+  height: 0;
+  clear: both;
+  visibility: hidden; }
+
+$bar-padding: ($bar-height - $line-height) / 2;
+
+.bar {
+  height: $bar-height - $bar-padding;
+  padding-top: $bar-padding; }
+
+.border-box {
+  -webkit-box-sizing: border-box;
+  -mox-box-sizing: border-box;
+  box-sizing: border-box; }

data/application/js/add_alias_dialogue.js

@@ -0,0 +1,59 @@
+
+Spontaneous.AddAliasDialogue = (function($, S) {
+	var dom = S.Dom, Dialogue = Spontaneous.Dialogue;
+
+	var AddAliasDialogue = new JS.Class(Dialogue, {
+		initialize: function(box_view, type) {
+			this.box_view = box_view;
+			this.box_view.bind('entry_added', this.alias_added.bind(this))
+			this.type = type;
+		},
+		title: function() {
+			return 'Add alias to “' + this.box_view.name() + '”';
+		},
+		buttons: function() {
+			var btns = {};
+			btns["Add"] = this.add_alias.bind(this);
+			return btns;
+		},
+
+		uid: function() {
+			return this.content.uid() + '!add-alias';
+		},
+		add_alias: function() {
+			if (this.target) {
+				this.box_view.add_alias(this.target.id, this.type)
+			}
+		},
+		alias_added: function() {
+			this.close();
+		},
+		select_target: function(target) {
+			this.target = target;
+		},
+		body: function() {
+			var editing = dom.div('#add-alias-dialogue'), outer = dom.div(), instructions = dom.p('.instructions'),
+				targets = this.targets, __dialogue = this;
+			instructions.html("Choose a target:")
+			editing.append(instructions, outer)
+			Spontaneous.Ajax.get(['/targets', this.type.schema_id].join('/'), this.targets_loaded.bind(this));
+			this._outer = outer;
+			return editing;
+		},
+		targets_loaded: function(targets) {
+			var outer = this._outer, __dialogue = this;
+			this.targets = targets;
+			$.each(targets, function(i, target) {
+				var d = dom.div('.type').text(target.title).click(function() {
+					$('.type', outer).removeClass('selected');
+					__dialogue.select_target(target);
+					$(this).addClass('selected');;
+				});
+				outer.append(d)
+			});
+
+		}
+	});
+	return AddAliasDialogue;
+})(jQuery, Spontaneous);
+

data/application/js/add_home_dialogue.js

@@ -0,0 +1,59 @@
+
+Spontaneous.AddHomeDialogue = (function($, S) {
+	var dom = S.Dom, Dialogue = Spontaneous.Dialogue;
+
+	var AddHomeDialogue = new JS.Class(Dialogue, {
+		initialize: function(types) {
+			this.types = types;
+		},
+		title: function() {
+			return "Create site home page";
+		},
+		width: function() {
+			return '50%';
+		},
+		buttons: function() {
+			var btns = {};
+			btns["Create"] = this.create_home.bind(this);
+			return btns;
+		},
+
+		uid: function() {
+			return this.content.uid() + '!editing';
+		},
+		create_home: function() {
+			if (this.type) {
+				S.Ajax.post('/root', {'type':this.type.schema_id}, this.home_created.bind(this));
+			}
+		},
+		home_created: function(data) {
+			window.location.href = S.Ajax.namespace
+		},
+		select_type: function(type) {
+			this.type = type;
+		},
+		body: function() {
+			var editing = dom.div('#create-home-dialogue'), outer = dom.div(), instructions = dom.p('.instructions'),
+				types = this.types, __dialogue = this;
+			instructions.html("You don't have a home page. Please choose a type below and hit <span class=\"button\">Create</span> to add one")
+			$.each(types, function(i, type) {
+				if (type.is_page()) {
+					var d = dom.div('.type').text(type.title).click(function() {
+						$('.type', outer).removeClass('selected');
+						__dialogue.select_type(type);
+						$(this).addClass('selected');;
+					});
+					outer.append(d)
+				}
+			});
+			editing.append(instructions, outer)
+			return editing;
+		},
+		cancel_button: function() {
+			return false;
+		},
+	});
+	return AddHomeDialogue;
+})(jQuery, Spontaneous);
+
+

data/application/js/ajax.js

@@ -0,0 +1,99 @@
+// console.log("Loading Ajax...");
+
+Spontaneous.Ajax = (function($, S) {
+	$.ajaxSetup({
+		'async': true,
+		'cache': false,
+		'dataType': 'json',
+		'ifModified': true
+	});
+	return {
+		namespace: "/@spontaneous",
+		get: function(url, callback) {
+			var handle_response = function(data, textStatus, xhr) {
+				if (textStatus !== 'success') {
+					xhr = data;
+					data = {};
+				}
+				callback(data, textStatus, xhr);
+			};
+			$.ajax({
+				'url': this.request_url(url),
+				'success': handle_response,
+				'data': this.api_access_key(),
+				'error': handle_response // pass the error to the handler too
+			});
+		},
+		post: function(url, post_data, callback) {
+			var success = function(data, textStatus, XMLHttpRequest) {
+				callback(data, textStatus, XMLHttpRequest);
+			};
+			var error = function(XMLHttpRequest, textStatus, error_thrown) {
+				var data = false;
+				try {
+					data = $.parseJSON(XMLHttpRequest.responseText);
+				} catch (e) { }
+				callback(data, textStatus, XMLHttpRequest);
+			};
+			post_data = $.extend(post_data, this.api_access_key());
+			$.ajax({
+				'url': this.request_url(url),
+				'type': 'post',
+				'data': post_data,
+				'success': success,
+				'error': error
+			});
+		},
+		test_field_versions: function(target, fields, success, failure) {
+			var version_data = {}, modified = 0;
+			for (var i = 0, ii = fields.length; i < ii; i++) {
+				var field = fields[i], key = "[fields]["+field.schema_id()+"]";
+				if (field.is_modified()) {
+					version_data[key] = field.version();
+					modified++;
+				}
+			}
+			if (modified === 0) { success(); }
+
+			this.post(['/version', target.id()].join('/'), version_data, function(data, textStatus, xhr) {
+				if (textStatus === 'success') {
+					success();
+				} else {
+					if (xhr.status === 409) {
+						var field_map = {};
+						for (var i = 0, ii = fields.length; i < ii; i++) {
+							var f = fields[i];
+							field_map[f.schema_id()] = f;
+						}
+						var conflicted_fields = [];
+						for (var sid in data) {
+							if (data.hasOwnProperty(sid)) {
+								var values = data[sid], field = field_map[sid];
+								conflicted_fields.push({
+									field:field,
+									version: values[0],
+									values: {
+										server_original: values[1],
+										local_edited:  field.edited_value(),
+										local_original:  field.original_value()
+									}
+								});
+							}
+						}
+						failure(conflicted_fields)
+					}
+				}
+			});
+		},
+		api_access_key: function() {
+			return {'__key':Spontaneous.Auth.Key.load(S.site_id)}
+		},
+		request_url: function(url, needs_key) {
+			var path = this.namespace + url;
+			if (needs_key) {
+				path += "?"+$.param(this.api_access_key())
+			}
+			return path
+		}
+	};
+}(jQuery, Spontaneous));

data/application/js/authentication.js

@@ -0,0 +1,22 @@
+// console.log('Loading Authentication...')
+
+Spontaneous.Auth = (function($, S) {
+	return {
+		Key: {
+			key: function(site) {
+				return site + '_api_key'
+			},
+			save: function(site, key) {
+				localStorage.setItem(this.key(site), key);
+			},
+			load: function(site) {
+				return localStorage.getItem(this.key(site));
+			},
+			remove: function(site) {
+				localStorage.removeItem(this.key(site));
+				return false;
+			}
+		}
+	};
+}(jQuery, Spontaneous));
+

data/application/js/box.js

@@ -0,0 +1,104 @@
+// console.log('Loading Box...')
+
+Spontaneous.Box = (function($, S) {
+	var dom = S.Dom;
+
+	var Box = new JS.Class(Spontaneous.Content, {
+
+		initialize: function(content, container) {
+			this.callSuper(content);
+			this.container = container;
+		},
+
+		name: function() {
+			return this.type().title;
+		},
+
+		type: function() {
+			if (!this._type) {
+				this._type = this.container.type().box_prototype(this.content.id)
+			}
+			return this._type;
+		},
+
+		id: function() {
+			return this.container.id() + "/" + this.schema_id();
+		},
+
+		schema_id: function() {
+			return this.type().data.id;
+		},
+
+		depth: function() {
+			return 'box';
+		},
+
+		mouseover: function() {
+			if (this.fields_preview) {
+				this.fields_preview.addClass('hover');
+			}
+		},
+		mouseout: function() {
+			if (this.fields_preview) {
+				this.fields_preview.removeClass('hover');
+			}
+		},
+
+		re_sort: function(item) {
+			var order = this._entry_container.sortable('toArray'), css_id = item.attr('id'), position = 0;
+			for (var i = 0, ii = order.length; i < ii; i++) {
+				if (order[i] === css_id) { position = i; break; }
+			}
+			var id = css_id.split('-')[1], entry;
+
+			for (var i = 0, entries = this.entries(), ii = entries.length; i < ii; i++) {
+				if (entries[i].id() == id) { entry = entries[i]; break; }
+			}
+			entry.reposition(position, function(entry) {
+				this.sorted(entry)
+			}.bind(this));
+		},
+		sorted: function(entry) {
+		},
+		upload_complete: function(values) {
+			this.insert_entry(this.wrap_entry(values.entry), values.position);
+		},
+		upload_progress: function(position, total) {
+		},
+
+		entry_id: function(entry) {
+			return "entry-" + entry.id();
+		},
+
+		entry_class: function() {
+			return 'container-'+this.schema_id();
+		},
+
+		add_entry: function(type, position) {
+			Spontaneous.Ajax.post(['/add', this.id(), type.schema_id].join('/'), {}, this.entry_added.bind(this));
+		},
+
+		add_alias: function(alias_target_id, type) {
+			S.Ajax.post(["/alias", this.id()].join("/"), {'alias_id':type.schema_id, 'target_id':alias_target_id}, this.entry_added.bind(this));
+		},
+
+		entry_added: function(result) {
+			var position = result.position, e = result.entry, entry = this.wrap_entry(e);
+			this.content.entries.splice(position, 0, e);
+			this.entries().splice(position, 0, entry);
+			var page = S.Editing.get('page');
+			page.trigger('entry_added', entry, position);
+			this.trigger('entry_added', entry, position);
+		},
+
+		save_path: function() {
+			return ['/savebox', this.id()].join('/');
+		},
+		entry_wrappers: function() {
+			return this._entry_container.find('> .'+this.entry_class())
+		}
+	});
+
+	return Box;
+
+})(jQuery, Spontaneous);

data/application/js/box_container.js

@@ -0,0 +1,82 @@
+// console.log('Loading BoxContainer...')
+
+Spontaneous.BoxContainer = (function($, S) {
+	var dom = S.Dom;
+
+	var BoxContainer = new JS.Class(S.Views.View, {
+
+		initialize: function(content, wrap_id) {
+			this.callSuper(content);
+			this.wrap_id = wrap_id;
+			this.box_content_container = dom.div();
+		},
+
+		panel: function() {
+			var wrapper = dom.div([dom.id(this.wrap_id), 'slots']);
+
+			wrapper.append(this.tab_bar());
+			wrapper.append(this.box_content_container);
+			var s = Spontaneous.State.active_box(this.content);
+			this.activate_id(s);
+			return wrapper;
+		},
+		tab_bar: function() {
+			if (this.boxes().length === 0) { return ''; }
+			if (!this._tab_bar) {
+				var bar = dom.ul('.slot-tabs');
+				for (var i = 0, boxes = this.boxes(), ii = boxes.length; i < ii; i++) {
+					var box = boxes[i];
+					var li = dom.li();
+					li.text(box.name())
+					li.append(dom.span('.down'));
+					var click = function(index) {
+						this.activate(index, true);
+					}.bind(this, i);
+					li.click(click);
+					bar.append(li);
+				}
+				this._tab_bar = bar;
+			}
+			return this._tab_bar;
+		},
+		activate: function(box_index, manually) {
+			var box = this.boxes()[box_index];
+			if (box === this._active_box) { return; }
+			$('li', this.tab_bar()).removeClass('active');
+			$('li:nth-child('+(box_index+1)+')', this.tab_bar()).addClass('active')
+			box.activate();
+			this._active_box = box;
+			if (manually) {
+				Spontaneous.State.activate_box(this.content, box);
+				this.content.set('box', box);
+			}
+		},
+		activate_id: function(id) {
+			if (id) {
+				for (var i = 0, ss = this.boxes(), ii = ss.length; i < ii; i++) {
+					var s = ss[i];
+					if (ss[i].id() === id) {
+						this.activate(i);
+						return;
+					}
+				}
+			}
+			// just in case
+			this.activate(0);
+		},
+		boxes: function() {
+			if (!this._boxes) {
+				var _boxes = [], content_container = this.box_content_container;
+				var f = function(i, box) {
+					_boxes.push(new Spontaneous.Views.BoxView(box, content_container))
+				}.bind(this);
+				$.each(this.content.boxes(), f);
+				this._boxes = _boxes;
+			}
+			return this._boxes;
+		}
+	});
+	return BoxContainer;
+})(jQuery, Spontaneous);
+
+

data/application/js/compatibility.js

@@ -0,0 +1,132 @@
+
+// Parts copyright Modernizr:
+// * @author        Faruk Ates
+// * @author        Paul Irish
+// * @copyright     (c) 2009-2011 Faruk Ates.
+// * @contributor   Ben Alman
+
+// many thanks to modernizer for working a lot of this out
+// should probably just use it instead...
+(function() {
+	var _window = window, _document = document;
+	var prefixes = ' -webkit- -moz- -o- -ms- -khtml- '.split(' ');
+	try {
+
+		///////////////////////////// Flexible Box model
+		function set_prefixed_property_css(element, property, value, extra) {
+			element.style.cssText = prefixes.join(property + ':' + value + ';') + (extra || '');
+		}
+
+		function set_prefixed_value_css(element, property, value, extra) {
+			property += ':';
+			element.style.cssText = (property + prefixes.join(value + ';' + property)).slice(0, -property.length) + (extra || '');
+		}
+
+		var docElement = _document.documentElement,
+		c = _document.createElement('div'),
+		elem = _document.createElement('div'),
+		w;
+
+		set_prefixed_value_css(c, 'display', 'box', 'width:42px;padding:0;');
+		set_prefixed_property_css(elem, 'box-flex', '1', 'width:10px;');
+
+		c.appendChild(elem);
+		docElement.appendChild(c);
+		w = elem.offsetWidth
+		c.removeChild(elem);
+		docElement.removeChild(c);
+
+		if (w !== 42) {
+			// console.error(w)
+			throw (w) + " Flexible Box Model not supported"
+		}
+
+		///////////////////////////// XHR Uploads
+		var xhr = new XMLHttpRequest();
+		if (!xhr.upload) {
+			throw "XMLHttpRequestUpload not supported";
+		}
+
+		///////////////////////////// FormData
+		try {
+			var f = new FormData();
+		} catch (e) {
+			throw "FormData not supported";
+		}
+
+		///////////////////////////// File API / File objects
+		if (!_window.File) {
+			throw "File API not supported";
+		}
+
+		///////////////////////////// File API / objectURLs
+		// provide consistent API for creating blob/object URLs
+		var createObjectURL = 'createObjectURL', revokeObjectURL = 'revokeObjectURL';
+		if (!_window.URL) {
+			if (_window.webkitURL) {
+				_window.URL = _window.webkitURL;
+			} else {
+				_window.URL = {};
+				if (_window.createBlobURL) {
+					_window.URL[createObjectURL] = function(file) {
+						return _window.createBlobURL(file);
+					};
+				} else if (_window[createObjectURL]) {
+					_window.URL[createObjectURL] = function(file) {
+						return _window[createObjectURL](file);
+					};
+				} else {
+					//// Dont fail this because it's not absolutely essential
+					//// & fails iOS devices (though that might be a good thing in some ways, it
+					//// would seriously limit users ability to make quick changes on the go, for instance)
+					_window.URL[createObjectURL] = function(file) {
+						return '';
+					}
+					// throw "File API not supported";
+				}
+				if (_window.revokeBlobURL) {
+					_window.URL[revokeObjectURL] = function(file) {
+						return _window.revokeBlobURL(file);
+					};
+				} else if (_window[revokeObjectURL]) {
+					_window.URL[revokeObjectURL] = function(file) {
+						return _window[revokeObjectURL](file);
+					};
+				} else {
+					//// Dont fail this because it's not absolutely essential
+					//// & fails iOS devices (though that might be a good thing in some ways, it
+					//// would seriously limit users ability to make quick changes on the go, for instance)
+					_window.URL[revokeObjectURL] = function(file) {
+						return '';
+					}
+					// throw "File API not supported";
+				}
+			}
+		}
+		///////////////////////////// File API / slices
+		// normalise access to the File#slice method
+		var proto = _window.File.prototype;
+		if (!proto.slice) {
+			var methods = ['webkitSlice', 'mozSlice'];
+			for (var i = 0, ii = methods.length; i < ii; i++) {
+				var method = methods[i];
+				if (proto[method]) { proto.slice = proto[method]; }
+			}
+			if (!proto.slice) {
+				// not supporting slice just means we can't use the sharded uploader
+			}
+		}
+
+
+
+		///////////////////////////// localStorage
+		try {
+			var i = localStorage.getItem;
+		} catch(e) {
+			throw "Local Storage not supported"
+		}
+
+	} catch (e) {
+		_window.location.href = "/@spontaneous/unsupported?msg=" + _window.encodeURI(e);
+	}
+}());