spontaneous 0.1.0.alpha1

data/application/js/conflicted_field_dialogue.js

@@ -0,0 +1,92 @@
+
+Spontaneous.ConflictedFieldDialogue = (function($, S) {
+	var dom = S.Dom, Dialogue = Spontaneous.Dialogue;
+
+	var ConflictedFieldDialogue = new JS.Class(Dialogue, {
+		initialize: function(parent_view, conflicted_fields) {
+			this.parent_view = parent_view;
+			this.conflicted_fields = conflicted_fields;
+			this.active_conflict = 0;
+			this.wrap = dom.div('#conflicted-fields-dialogue');
+		},
+		title: function() {
+			return "Conflicted Fields";
+		},
+		width: function() {
+			return '90%';
+		},
+		buttons: function() {
+			var btns = {};
+			btns["Use"] = this.conflict_resolved.bind(this);
+			return btns;
+		},
+
+		resolve_value: function(conflict, value) {
+			conflict.value = value;
+		},
+		conflict_resolved: function() {
+			var conflict = this.current_conflict();
+			// conflict.value = this.conflict_view.use_value;
+			// this.parent_view.conflict_resolved(conflict, this.conflict_view.use_value)
+			if (conflict && conflict.value) {
+				this.show_next_conflict();
+			}
+		},
+		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;
+		},
+		current_conflict: function() {
+			return this.conflicted_fields[this.active_conflict];
+		},
+
+		next_conflict: function() {
+			this.active_conflict += 1;
+			return this.current_conflict();
+		},
+		conflict_panel: function(outer) {
+			outer.empty();
+			var conflict = this.current_conflict(),
+			field = conflict.field,
+			instructions = dom.p('.instructions');
+			instructions.html("The field '"+field.label()+"' has been modified by another person. Please select which version you want to use.")
+			var view = field.conflict_view(this, conflict);
+			outer.append(instructions);
+			outer.append(view.panel());
+			this.conflict_view = view;
+			return outer;
+		},
+
+		body: function() {
+			panel = this.conflict_panel(this.wrap);
+			return this.wrap;
+		},
+		show_next_conflict: function() {
+			var conflict = this.next_conflict();
+			if (conflict) {
+				this.conflict_panel(this.wrap);
+			} else {
+				console.log('closing conflict view', this.conflicted_fields);
+				this.parent_view.conflicts_resolved(this.conflicted_fields);
+				this.close();
+			}
+		},
+		cancel_button: function() {
+			return false;
+		},
+	});
+	return ConflictedFieldDialogue;
+})(jQuery, Spontaneous);
+
+
+

data/application/js/content.js

@@ -0,0 +1,224 @@
+// console.log('Loading Content...')
+
+Spontaneous.Content = (function($, S) {
+	var dom = S.Dom;
+
+	var Content = new JS.Class({
+		include: Spontaneous.Properties,
+
+		initialize: function(content) {
+			this.content = content;
+		},
+
+		uid: function() {
+			return (this.container ? this.container.uid() : '') + '/' + this.content.id;
+		},
+		id: function() {
+			return this.content.id;
+		},
+		is_page: function() {
+			return this.type().is_page();
+		},
+
+		target: function() {
+			return this.content.target;
+		},
+		developer_description: function() {
+			return this.type().type + "["+this.id()+']'
+		},
+		developer_edit_url: function() {
+			return this.type().edit_url();
+		},
+		type: function() {
+			return S.Types.type(this.content.type);
+		}.cache(),
+
+		constantize: function(type) {
+			var parts = type.split(/\./), obj = window;
+			for (var i = 0, ii = parts.length; i < ii; i++) {
+				obj = obj[parts[i]];
+			}
+			return obj;
+		},
+
+		unload: function() {
+			$.each(this.field_list(), function(i, f) { f.unload(); });
+			$.each(this.entries(), function(i, e) { e.unload(); });
+		},
+
+		field_list: function() {
+			var type = this.type(), prototypes = type.field_prototypes, names = type.field_names;
+			var fields = this.fields(), list = [];
+			for (var i = 0, ii = names.length; i < ii; i++) {
+				list.push(fields[names[i]]);
+			}
+			return list;
+		}.cache(),
+
+		text_fields: function() {
+			var fields = [], all_fields = this.field_list();
+			for (var i = 0, ii = all_fields.length; i < ii; i++) {
+				var f = all_fields[i];
+				if (!f.is_image()) {
+					fields.push(f);
+				}
+			}
+			return fields;
+		},
+		image_fields: function() {
+			var fields = [], all_fields = this.field_list();
+			for (var i = 0, ii = all_fields.length; i < ii; i++) {
+				var f = all_fields[i];
+				if (f.is_image()) {
+					fields.push(f);
+				}
+			}
+			return fields;
+		},
+		file_fields: function() {
+			var fields = [], all_fields = this.field_list();
+			for (var i = 0, ii = all_fields.length; i < ii; i++) {
+				var f = all_fields[i];
+				if (f.is_file()) {
+					fields.push(f);
+				}
+			}
+			return fields;
+		},
+		fields: function() {
+			var fields = {}, type = this.type(), prototypes = type.field_prototypes;
+
+			for (var i = 0, ii = this.content.fields.length; i < ii; i++) {
+				var f = this.content.fields[i],
+				prototype = prototypes[f.name],
+				type_class = this.constantize(prototype.type)
+				if (!type_class) {
+					console.warn(
+						"Content#fields:",
+						"Field has invalid type", prototype.type,
+						"content_id:", this.content.id,
+						"type:", "'"+type.title+"'",
+						"field_name:", f.name
+					);
+					type_class = Spontaneous.FieldTypes.StringField;
+				}
+				var field = new type_class(this, f);
+				// field.watch('value', this.field_updated.bind(this, field));
+				fields[f.name] = field;
+			};
+			return fields;
+		}.cache(),
+
+		field: function(name) {
+			return this.fields()[name];
+		},
+		field_updated: function(field, value) {
+			this.save_field(field);
+		},
+
+		save_field: function(field) {
+			var params = { field: {} };
+			params.field[field.name] = {value: field.value()};
+			Spontaneous.Ajax.post(this.save_path(), params, this.save_complete.bind(this));
+		},
+
+		save_path: function() {
+			return ['/save', this.content.id].join('/');
+		},
+
+		save_complete: function(response) {
+			if (response) {
+				var fields = response.fields;
+				for (var i = 0, ii = fields.length; i < ii; i++) {
+					var values = fields[i], field = this.field(values.name);
+					field.update(values);
+				}
+			}
+		},
+
+		has_fields: function() {
+			return (this.content.fields.length > 0)
+		},
+
+		title: function() {
+			return this.title_field().value();
+		},
+
+		title_field: function() {
+			return this.fields()[this.type().title_field_name];
+		},
+
+		hidden: function() {
+			return this.content.hidden;
+		},
+
+		entries: function() {
+			if (!this.content.entries) {
+				return [];
+			}
+			var _entries = [];
+			for (var i = 0, ee = this.content.entries, ii = ee.length; i < ii; i++) {
+				var entry = this.wrap_entry(ee[i]);
+				_entries.push(entry);
+			}
+			return _entries;
+		}.cache(),
+
+		boxes: function() {
+			var _boxes = [];
+			if (this.content.boxes) {
+				for (var i = 0, ee = this.content.boxes, ii = ee.length; i < ii; i++) {
+					_boxes.push(new S.Box(ee[i], this));
+				}
+			}
+			return _boxes;
+		}.cache(),
+
+		has_boxes: function() {
+			return (this.boxes().length > 0)
+		},
+
+		wrap_entry: function(entry) {
+			var entry_class = Spontaneous.Entry;
+			if (entry.is_page) {
+				entry_class = Spontaneous.PageEntry;
+			}
+			return new entry_class(entry, this);
+		},
+
+		allowed_types: function() {
+			return this.type().allowed_types();
+		},
+
+		depth: function() {
+			return this.content.depth;
+		},
+
+		destroy: function() {
+			Spontaneous.Ajax.post(['/destroy', this.content.id].join('/'), {}, this.destroyed.bind(this));
+		},
+		toggle_visibility: function() {
+			Spontaneous.Ajax.post(['/toggle', this.content.id].join('/'), {}, this.visibility_toggled.bind(this));
+		},
+		visibility_toggled: function(result) {
+			console.log('visibility_toggled', result)
+			this.set('hidden', result.hidden);
+			// this.trigger('visibility_toggled', result);
+		},
+		destroyed: function() {
+			var page = S.Editing.get('page');
+			this.trigger('destroyed', this);
+			page.trigger('removed_entry', this);
+		},
+		reposition: function(position) {
+			Spontaneous.Ajax.post(['/content', this.content.id, 'position', position].join('/'), {}, function() {
+				this.repositioned();
+			}.bind(this));
+		},
+		repositioned: function() {
+			this.trigger('repositioned');
+		}
+	});
+
+	return Content;
+}(jQuery, Spontaneous));

data/application/js/content_area.js

@@ -0,0 +1,44 @@
+// console.log('Loading Content Area...')
+
+Spontaneous.ContentArea = (function($, S) {
+	var dom = S.Dom;
+	var ContentArea = new JS.Singleton({
+		include: Spontaneous.Properties,
+
+		wrap: null,
+		preview: null,
+		editing: null,
+		mode: 'edit',
+
+		init: function() {
+			this.wrap = dom.div('#content');
+			this.preview = S.Preview.init(this.wrap);
+			this.editing = S.Editing.init(this.wrap);
+			return this.wrap;
+		},
+
+		location_changed: function(location) {
+			this.goto_page(location);
+		},
+		display: function(mode) {
+			this.mode = mode;
+			this.current().display(S.Location.location());
+		},
+		current: function() {
+			if (this.mode === 'preview') {
+				this.editing.hide();
+				this.preview.show();
+				return this.preview;
+			} else if (this.mode === 'edit') {
+				this.preview.hide();
+				this.editing.show();
+				return this.editing;
+			}
+		},
+		goto_page: function(page) {
+			this.current().goto_page(page);
+		}
+	});
+	return ContentArea;
+})(jQuery, Spontaneous);
+

data/application/js/dialogue.js

@@ -0,0 +1,196 @@
+// console.log('Loading Dialogue...')
+
+Spontaneous.Dialogue = (function($, S) {
+	var dom = S.Dom;
+
+
+	var Button = new JS.Class({
+		initialize: function(label, action, is_default) {
+			this.label = label;
+			this.action = action;
+			this.is_default = is_default;
+			this.disabled = false;
+		},
+
+		html: function() {
+			var el = dom.a(this.css_class()).html(this.label);
+			if (typeof this.action === 'function') {
+				var __button = this;
+				el.click(function() {
+					if (!__button.disabled) { __button.action(); }
+					return false;
+				});
+			}
+			this.button = el;
+			return el;
+		},
+		css_class: function() {
+			return ['button', (this.is_default ? 'default' : ''), this.label.toLowerCase().split(' ')[0]].join(' ');
+		},
+		disable: function() {
+			this.set_disabled(true)
+		},
+		enable: function() {
+			this.set_disabled(false)
+		},
+		set_disabled: function(state) {
+			this.disabled = state;
+			this.button.removeClass('disabled');
+			if (this.disabled) {
+				this.button.addClass('disabled')
+			}
+		}
+	});
+	var CancelButton = new JS.Class(Button, {
+		initialize: function(label, is_default) {
+			this.callSuper(label + ' <span class="key-combo">(Esc)</span>', function() {
+				Spontaneous.Dialogue.cancel();
+			}, is_default);
+		},
+		css_class: function() {
+			return this.callSuper().replace(' cancel', '') + ' cancel';
+		}
+	});
+	var Dialogue = new JS.Class({
+		open: function() {
+			Spontaneous.Dialogue.open(this);
+		},
+		close: function() {
+			Spontaneous.Dialogue.close(this);
+		},
+		width: function() {
+			return '50%';
+		},
+		title: function() {
+			return "Dialogue";
+		},
+		class_name: function() {
+			return '';
+		},
+		buttons: function() {
+			// return a
+			//   { label : action }
+			// or
+			//   { label : [action, is_default ]}
+			// set to define non-cancel action buttons
+			// for this dialogue
+		},
+		cleanup: function() {
+			// over-ride if you need to do anything before the dialogue is closed
+			// (either by cancel or through other actions)
+		},
+		cancel_button: function() {
+			return new CancelButton(this.cancel_label());
+		},
+		cancel_label: function() {
+			return 'Cancel';
+		},
+		disable_button: function(button_name) {
+			Spontaneous.Dialogue.disable_button(button_name);
+		}
+	});
+
+	Dialogue.extend({
+		_overlay: false,
+		_open: false,
+		_z_index: 1000,
+		_instance: false,
+
+		open: function(instance) {
+			if (this._open || !instance) { return; }
+			this._instance = instance;
+			$('body').css("overflow", "hidden");
+			this.overlay().fadeIn(200);
+			var c = this.container(), a = this._actions, b;
+			var buttons = instance.buttons(), button_map = {};
+			a.empty().append(dom.div('.spacer'));
+			b = instance.cancel_button();
+			if (b) {
+				button_map['cancel'] = b;
+				button_map[instance.cancel_label().toLowerCase()] = b;
+				a.append(b.html());
+				$(document).bind('keydown.dialogue', function(event) {
+					if (event.keyCode === 27) { // escape key
+						this.cancel();
+					}
+				}.bind(this));
+			}
+			if (buttons) {
+				$.each(buttons, function(label, params) {
+					var action, is_default = false;
+					if (typeof params === 'function') {
+						action = params;
+					} else if ($.isArray(params)) {
+						action = params[0];
+						is_default = params[1];
+					} else {
+						action = params.action;
+						is_default = params.is_default;
+					}
+					b = new Button(label, action, is_default);
+					a.append(b.html());
+					button_map[label.toLowerCase()] = b;
+				});
+			}
+			this.button_map = button_map;
+			this._body.empty().append(instance.body());
+			c.fadeIn(200);
+			this._open = true;
+		},
+
+		disable_button: function(button_name) {
+			var button = this.button_map[button_name.toLowerCase()]
+			button.disable();
+		},
+		close: function() {
+			if (!this._instance || !this._open) { return; }
+			this._instance.cleanup();
+			this.container().remove();
+			this.overlay().fadeOut(200, function() {
+				$('body').css("overflow", "auto");
+			});
+			this._instance = this._container = this._open = false;
+			$(document).unbind('keydown.dialogue');
+		},
+		cancel: function() {
+			return this.close();
+		},
+		container: function() {
+			if (!this._container) {
+				var instance = this._instance;
+				var wrap = dom.div('#dialogue-wrap').css('z-index', this.z_index()).hide();
+				var outline = dom.div('#dialogue-outer').css('width', instance.width()).addClass(instance.class_name());
+				var controls_wrap = dom.div('#dialogue-control-wrap');
+				var controls = dom.div('#dialogue-controls');
+				var actions = dom.div('.dialogue-actions');
+				var body = dom.div('#dialogue-body');
+				var title = dom.div('#dialogue-title').append(instance.title());
+
+				controls.append(actions);
+				controls_wrap.append(controls);
+				outline.append(title);
+				outline.append(body);
+				outline.append(controls_wrap);
+				wrap.append(outline)
+				$('#content').append(wrap);
+				this._actions = actions;
+				this._title = title;
+				this._container = wrap;
+				this._body = body;
+			}
+			return this._container;
+		},
+		overlay: function() {
+			if (!this._overlay) {
+				var o = dom.div('#dialogue-overlay').css('z-index', this.z_index()).hide();
+				$('#content').append(o)
+				this._overlay = o;
+			}
+			return this._overlay;
+		},
+		z_index: function() {
+			return ++this._z_index;
+		}
+	});
+	return Dialogue;
+})(jQuery, Spontaneous);

data/application/js/dom.js

@@ -0,0 +1,71 @@
+// console.log('Loading DOM...');
+
+Spontaneous.Dom = (function($, S) {
+	var tags = 'div p iframe a span img select option label ul li dl dt dd table tr td h1 h2 h3 h4 header input button form textarea'.split(' ');
+	var Dom = {
+		body: function() {
+			return $(document.body);
+		},
+		id: function(name) {
+			return '#'+name;
+		},
+		px: function(dim) {
+			return dim + 'px';
+		},
+		cmd_key_label: function(text, key) {
+			var cmd = ((window.navigator.platform.indexOf("Mac") === 0) ? "Cmd" : "Ctrl");
+			// var alt =  '<span class="key-combo">(' + cmd  + "+"+key+')</span>';
+			return this.key_label(text, cmd  + "+" +key);
+		},
+		key_label: function(text, key) {
+			var alt =  '<span class="key-combo">('+key+')</span>';
+			return text + " " + alt;
+		},
+		parse_selector: function(selector) {
+			var p, id = '', classes = [], result = {};
+			selector = selector || '';
+			if (typeof selector === 'string') {
+				p = selector.split('.')
+			} else if ($.isArray(selector)) {
+				p = selector;
+			}
+			for (var i = 0, ii = p.length; i < ii; i++) {
+				var part = p[i];
+				if (part === '') {
+				} else if (part.indexOf('#') === 0) {
+					id = part.substr(1);
+				} else if (part.indexOf('.') === 0) {
+					var r = this.parse_selector(part);
+					classes.push(r['class']);
+				} else {
+					classes.push(part);
+				}
+			}
+			if (id !== '') {
+				result['id'] = id;
+			}
+			if (classes.length > 0) {
+				result['class'] = classes.join(' ')
+			}
+			return result;
+		}
+	};
+	var generate = function(tag_name) {
+		var tag = '<'+tag_name+'/>';
+		return function(selector, params) {
+			if (typeof selector === 'object') {
+				if (!$.isArray(selector)) {
+					params = selector;
+					selector = '';
+				}
+			}
+			var attrs = $.extend((params || {}), Dom.parse_selector(selector));
+			return $(tag, attrs);
+		};
+	};
+	for (var i = 0, ii = tags.length; i < ii; i++) {
+		Dom[tags[i]] = generate(tags[i]);
+	}
+	return Dom;
+})(jQuery, Spontaneous);
+