liquid_cms 0.2.0

data/generators/liquid_cms/templates/public/cms/javascripts/cms.js

@@ -0,0 +1,21 @@
+function toggle_component() {
+  $(this).next('ul').toggle();
+}
+
+function asset_preview_toggle() {
+  var previews = $$('.asset_details');
+
+  if (previews.length > 0) {
+    previews.invoke('toggle');
+    jar.put('toggle', {on:previews.first().visible()});
+  }
+}
+
+$(document).observe('dom:loaded', function() {
+  $$('#components .folder').each(function(elem) {
+    elem.observe('click', toggle_component);
+  });
+});
+
+var cookie_expiry = 60 * 60 * 24 * 30; // 1 month
+var jar = new CookieJar({expires:cookie_expiry, path:'/cms'});

data/generators/liquid_cms/templates/public/cms/javascripts/cookiejar.js

@@ -0,0 +1,157 @@
+/**
+ * Javascript code to store data as JSON strings in cookies. 
+ * It uses prototype.js 1.5.1 (http://www.prototypejs.org)
+ * 
+ * Author : Lalit Patel
+ * Website: http://www.lalit.org/lab/jsoncookies
+ * License: Apache Software License 2
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ * Version: 0.5
+ * Updated: Jan 26, 2009 
+ * 
+ * Chnage Log:
+ *   v 0.5
+ *   -  Changed License from CC to Apache 2
+ *   v 0.4
+ *   -  Removed a extra comma in options (was breaking in IE and Opera). (Thanks Jason)
+ *   -  Removed the parameter name from the initialize function
+ *   -  Changed the way expires date was being calculated. (Thanks David)
+ *   v 0.3
+ *   -  Removed dependancy on json.js (http://www.json.org/json.js)
+ *   -  empty() function only deletes the cookies set by CookieJar
+ */
+
+var CookieJar = Class.create();
+
+CookieJar.prototype = {
+
+	/**
+	 * Append before all cookie names to differntiate them.
+	 */
+	appendString: "__CJ_",
+
+	/**
+	 * Initializes the cookie jar with the options.
+	 */
+	initialize: function(options) {
+		this.options = {
+			expires: 3600,		// seconds (1 hr)
+			path: '',			// cookie path
+			domain: '',			// cookie domain
+			secure: ''			// secure ?
+		};
+		Object.extend(this.options, options || {});
+
+		if (this.options.expires != '') {
+			var date = new Date();
+			date = new Date(date.getTime() + (this.options.expires * 1000));
+			this.options.expires = '; expires=' + date.toGMTString();
+		}
+		if (this.options.path != '') {
+			this.options.path = '; path=' + escape(this.options.path);
+		}
+		if (this.options.domain != '') {
+			this.options.domain = '; domain=' + escape(this.options.domain);
+		}
+		if (this.options.secure == 'secure') {
+			this.options.secure = '; secure';
+		} else {
+			this.options.secure = '';
+		}
+	},
+
+	/**
+	 * Adds a name values pair.
+	 */
+	put: function(name, value) {
+		name = this.appendString + name;
+		cookie = this.options;
+		var type = typeof value;
+		switch(type) {
+		  case 'undefined':
+		  case 'function' :
+		  case 'unknown'  : return false;
+		  case 'boolean'  : 
+		  case 'string'   : 
+		  case 'number'   : value = String(value.toString());
+		}
+		var cookie_str = name + "=" + escape(Object.toJSON(value));
+		try {
+			document.cookie = cookie_str + cookie.expires + cookie.path + cookie.domain + cookie.secure;
+		} catch (e) {
+			return false;
+		}
+		return true;
+	},
+
+	/**
+	 * Removes a particular cookie (name value pair) form the Cookie Jar.
+	 */
+	remove: function(name) {
+		name = this.appendString + name;
+		cookie = this.options;
+		try {
+			var date = new Date();
+			date.setTime(date.getTime() - (3600 * 1000));
+			var expires = '; expires=' + date.toGMTString();
+			document.cookie = name + "=" + expires + cookie.path + cookie.domain + cookie.secure;
+		} catch (e) {
+			return false;
+		}
+		return true;
+	},
+
+	/**
+	 * Return a particular cookie by name;
+	 */
+	get: function(name) {
+		name = this.appendString + name;
+		var cookies = document.cookie.match(name + '=(.*?)(;|$)');
+		if (cookies) {
+			return (unescape(cookies[1])).evalJSON();
+		} else {
+			return null;
+		}
+	},
+
+	/**
+	 * Empties the Cookie Jar. Deletes all the cookies.
+	 */
+	empty: function() {
+		keys = this.getKeys();
+		size = keys.size();
+		for(i=0; i<size; i++) {
+			this.remove(keys[i]);
+		}
+	},
+
+	/**
+	 * Returns all cookies as a single object
+	 */
+	getPack: function() {
+		pack = {};
+		keys = this.getKeys();
+
+		size = keys.size();
+		for(i=0; i<size; i++) {
+			pack[keys[i]] = this.get(keys[i]);
+		}
+		return pack;
+	},
+
+	/**
+	 * Returns all keys.
+	 */
+	getKeys: function() {
+		keys = $A();
+		keyRe= /[^=; ]+(?=\=)/g;
+		str  = document.cookie;
+		CJRe = new RegExp("^" + this.appendString);
+		while((match = keyRe.exec(str)) != undefined) {
+			if (CJRe.test(match[0].strip())) {
+				keys.push(match[0].strip().gsub("^" + this.appendString,""));
+			}
+		}
+		return keys;
+	}
+};

data/generators/liquid_cms/templates/public/cms/javascripts/humanmsg.js

@@ -0,0 +1,89 @@
+/*
+  HUMANIZED MESSAGES 1.0
+  idea - http://www.humanized.com/weblog/2006/09/11/monolog_boxes_and_transparent_messages
+  home - http://humanmsg.googlecode.com
+*/
+
+var humanMsg = {
+  setup: function(appendTo, logName, msgOpacity) {
+    humanMsg.msgID = 'humanMsg';
+    humanMsg.logID = 'humanMsgLog';
+
+    appendTo = appendTo || $$('body')[0];
+    logName = logName || 'Message Log';
+
+    humanMsg.msgOpacity = 0.8;
+    if (msgOpacity !== undefined) {
+      humanMsg.msgOpacity = parseFloat(msgOpacity);
+    }
+
+    var myTemplate = new Template(
+      '<div id="#{msgID}" class="humanMsg" style="display:none;">'+
+        '<div class="round"></div>'+
+        '<p></p>'+
+        '<div class="round"></div>'+
+       '</div> '+
+
+      '<div id="#{logID}">'+
+        '<p style="display:none;">#{logName}</p>'+
+        '<ul style="display:none;"></ul>'+
+      '</div>');
+    var show = {msgID: humanMsg.msgID, logID: humanMsg.logID, logName: logName};
+    appendTo.insert(myTemplate.evaluate(show));
+
+    $(humanMsg.logID).down('p').observe('click', function(event) {
+      $(humanMsg.logID).down('ul').toggle('blind');
+    });
+  },
+
+  displayMsg: function(msg, msgClass) {
+
+    if (msg === '') {
+      return;
+    }
+
+    clearTimeout(humanMsg.t2);
+
+    // Inject message
+    var msgElement = $(humanMsg.msgID);
+    var logElement = $(humanMsg.logID);
+    msgElement.down('p').update(msg);
+    logElement.down('ul').insert({ top: '<li>'+msg+'</li>' });
+
+    if (msgClass) {
+      msgElement.toggleClassName(msgClass);
+    }
+
+    msgElement.appear({ duration: 0.2 });
+    logElement.down('p').show().morph('bottom:40px;',
+      { duration: 0.2,
+        afterFinishInternal: function(effect) {
+          effect.element.morph('bottom:0px;', {
+                               duration: 0.3,
+                               transition: Effect.Transitions.spring
+          });
+      }
+    });
+
+    humanMsg.t1 = setTimeout("humanMsg.bindEvents()", 700)
+    humanMsg.t2 = setTimeout("humanMsg.removeMsg()", 5000)
+  },
+
+  // Remove message if mouse is moved or key is pressed
+  bindEvents: function() {
+    document.observe('mousemove', humanMsg.removeMsg)
+            .observe('click', humanMsg.removeMsg)
+            .observe('keypress', humanMsg.removeMsg);
+  },
+
+  // Unbind mouse & keyboard
+  removeMsg: function() {
+    document.stopObserving('mousemove', humanMsg.removeMsg)
+            .stopObserving('click', humanMsg.removeMsg)
+            .stopObserving('keypress', humanMsg.removeMsg);
+
+    $(humanMsg.msgID).fade({ duration: 0.5 });
+  }
+};
+
+document.observe('dom:loaded', function() { humanMsg.setup(); });

data/generators/liquid_cms/templates/public/cms/javascripts/parseliquid.js

@@ -0,0 +1,414 @@
+/* This file defines an XML parser, with a few kludges to make it
+ * useable for HTML. autoSelfClosers defines a set of tag names that
+ * are expected to not have a closing tag, and doNotIndent specifies
+ * the tags inside of which no indentation should happen (see Config
+ * object). These can be disabled by passing the editor an object like
+ * {useHTMLKludges: false} as parserConfig option.
+ */
+
+var LiquidParser = Editor.Parser = (function() {
+  var Kludges = {
+    autoSelfClosers: {"br": true, "img": true, "hr": true, "link": true, "input": true,
+                      "meta": true, "col": true, "frame": true, "base": true, "area": true},
+    doNotIndent: {"pre": true, "!cdata": true}
+  };
+  var NoKludges = {autoSelfClosers: {}, doNotIndent: {"!cdata": true}};
+  var UseKludges = Kludges;
+  var alignCDATA = false;
+    
+  var isQuote = /[\'\"]/;
+  var isWordChar = /[\w\_]/
+  var isPunctuation = /[\.\|\=\:]/;
+  
+  var keywords = {'in': true, 'by': true};
+
+  // Simple stateful tokenizer for XML documents. Returns a
+  // MochiKit-style iterator, with a state property that contains a
+  // function encapsulating the current state. See tokenize.js.
+  var tokenizeXML = (function() {
+    function inText(source, setState) {
+      var ch = source.next();
+      if (ch == "<") {
+        if (source.equals("!")) {
+          source.next();
+          if (source.equals("[")) {
+            if (source.lookAhead("[CDATA[", true)) {
+              setState(inBlock("xml-cdata", "]]>"));
+              return null;
+            }
+            else {
+              return "xml-text";
+            }
+          }
+          else if (source.lookAhead("--", true)) {
+            setState(inBlock("xml-comment", "-->"));
+            return null;
+          }
+          else {
+            return "xml-text";
+          }
+        }
+        else if (source.equals("?")) {
+          source.next();
+          source.nextWhileMatches(/[\w\._\-]/);
+          setState(inBlock("xml-processing", "?>"));
+          return "xml-processing";
+        }
+        else {
+          if (source.equals("/")) source.next();
+          setState(inTag);
+          return "xml-punctuation";
+        }
+      } 
+      else if (ch == "{") {        
+        if (source.equals("{")) {
+          source.next();
+          setState(inLiquidOutput);
+          return 'liquid-start-punctuation';
+        }
+        if (source.equals("%")) {
+          source.next();
+          setState(inLiquidTagName);
+          return 'liquid-start-punctuation';
+        }
+        else {
+          return "xml-text";
+        }
+      }
+      else if (ch == "&") {
+        while (!source.endOfLine()) {
+          if (source.next() == ";")
+            break;
+        }
+        return "xml-entity";
+      }
+      else {
+        source.nextWhileMatches(/[^{&<\n]/);
+        return "xml-text";
+      }
+    }
+
+    function inTag(source, setState) {
+      var ch = source.next();
+      if (ch == ">") {
+        setState(inText);
+        return "xml-punctuation";
+      }
+      else if (/[?\/]/.test(ch) && source.equals(">")) {
+        source.next();
+        setState(inText);
+        return "xml-punctuation";
+      }
+      else if (ch == "=") {
+        return "xml-punctuation";
+      }
+      else if (/[\'\"]/.test(ch)) {
+        setState(inAttribute(ch));
+        return null;
+      }
+      else {
+        source.nextWhileMatches(/[^\s\u00a0=<>\"\'\/?]/);
+        return "xml-name";
+      }
+    }
+
+    function inLiquidOutput(source, setState) {
+      var ch = source.next();
+      if (ch == "}") {
+        if(source.equals("}")) {
+          source.next();
+          setState(inText);
+          return "liquid-end-punctuation";
+        }         
+        else {
+          setState(inText);
+          return "liquid-bad-punctuation";
+        }
+      }
+      else if (isQuote.test(ch)) {
+        setState(inLiquidString(ch, inLiquidOutput));
+        return null;        
+      }
+      else if (isPunctuation.test(ch)) {
+        return "liquid-punctuation";
+      }
+
+      return "liquid-text";
+    }
+    
+    function inLiquidTagName(source, setState) {
+      source.nextWhileMatches(isWordChar);
+      setState(inLiquidTag);
+      return "liquid-tag-name";      
+    }
+
+    function inLiquidTag(source, setState) {
+      var ch = source.next();
+      if (ch == "%") {
+        if(source.equals("}")) {
+          source.next();
+          setState(inText);
+          return "liquid-end-punctuation";
+        }
+        else {
+          setState(inText);
+          return "liquid-bad-punctuation";
+        }
+      }
+      else if (isQuote.test(ch)) {
+        setState(inLiquidString(ch, inLiquidTag));
+        return null;        
+      }
+      else if (isPunctuation.test(ch)) {
+        return "liquid-punctuation";
+      }
+      else {        
+        return readWord(source, keywords)
+      }
+    }
+    
+    function readWord(source, keywords) {
+      source.nextWhileMatches(isWordChar);      
+      var word = source.get();
+            
+      if (keywords && keywords.propertyIsEnumerable(word)) {
+        return {type: "string", style: "liquid-keyword", content: word};
+      }
+      else {
+        return {type: "string", style: "liquid-text", content: word};
+      }
+    }
+    
+    function inLiquidString(quote, outer) {
+      return function(source, setState) {
+        while (!source.endOfLine()) {
+          if (source.next() == quote) {
+            setState(outer);
+            break;
+          }
+        }
+        return "liquid-string";
+      };
+    }
+  
+
+    function inAttribute(quote) {
+      return function(source, setState) {
+        while (!source.endOfLine()) {
+          if (source.next() == quote) {
+            setState(inTag);
+            break;
+          }
+        }
+        return "xml-attribute";
+      };
+    }
+
+    function inBlock(style, terminator) {
+      return function(source, setState) {
+        while (!source.endOfLine()) {
+          if (source.lookAhead(terminator, true)) {
+            setState(inText);
+            break;
+          }
+          source.next();
+        }
+        return style;
+      };
+    }
+
+    return function(source, startState) {
+      return tokenizer(source, startState || inText);
+    };
+  })();
+
+  // The parser. The structure of this function largely follows that of
+  // parseJavaScript in parsejavascript.js (there is actually a bit more
+  // shared code than I'd like), but it is quite a bit simpler.
+  function parseXML(source) {
+    var tokens = tokenizeXML(source);
+    var cc = [base];
+    var tokenNr = 0, indented = 0;
+    var currentTag = null, context = null;
+    var consume, marked;
+    
+    function push(fs) {
+      for (var i = fs.length - 1; i >= 0; i--)
+        cc.push(fs[i]);
+    }
+    function cont() {
+      push(arguments);
+      consume = true;
+    }
+    function pass() {
+      push(arguments);
+      consume = false;
+    }
+
+    function mark(style) {
+      marked = style;
+    }
+    function expect(text) {
+      return function(style, content) {
+        if (content == text) cont();
+        else mark("xml-error") || cont(arguments.callee);
+      };
+    }
+
+    function pushContext(tagname, startOfLine) {
+      var noIndent = UseKludges.doNotIndent.hasOwnProperty(tagname) || (context && context.noIndent);
+      context = {prev: context, name: tagname, indent: indented, startOfLine: startOfLine, noIndent: noIndent};
+    }
+    function popContext() {
+      context = context.prev;
+    }
+    function computeIndentation(baseContext) {
+      return function(nextChars, current) {
+        var context = baseContext;
+        if (context && context.noIndent)
+          return current;
+        if (alignCDATA && /<!\[CDATA\[/.test(nextChars))
+          return 0;
+        if (context && /^<\//.test(nextChars))
+          context = context.prev;
+        while (context && !context.startOfLine)
+          context = context.prev;
+        if (context)
+          return context.indent + indentUnit;
+        else
+          return 0;
+      };
+    }
+
+    function base() {
+      return pass(element, base);
+    }
+    var harmlessTokens = {"xml-text": true, "xml-entity": true, "xml-comment": true, "xml-processing": true};
+    var liquidTokens = {"liquid-punctuation": true, "liquid-bad-punctuation": true, "liquid-keyword": true, "liquid-tag-name": true, "liquid-variable": true, "liquid-text": true, "liquid-string": true};
+    var liquidDelimiterTokens = {"liquid-start-punctuation": true, "liquid-end-punctuation": true};
+    function element(style, content) {
+      if (content == "<" && (!context || context.name != "liquid"))
+        cont(tagname, attributes, endtag(tokenNr == 1));
+      else if (content == "</") cont(closetagname, expect(">"));
+      else if (style == "xml-cdata") {
+        if (!context || context.name != "!cdata") pushContext("!cdata");
+        if (/\]\]>$/.test(content)) popContext();
+        cont();
+      }
+      else if (harmlessTokens.hasOwnProperty(style)) cont();
+      else if (liquidTokens.hasOwnProperty(style)) cont();
+      else if (liquidDelimiterTokens.hasOwnProperty(style)) {
+        if (style == "liquid-start-punctuation")
+          pushContext("liquid");
+        else
+          popContext();
+        cont();
+      }
+      else mark("xml-error") || cont();
+    }
+    function tagname(style, content) {
+      if (style == "xml-name") {
+        currentTag = content.toLowerCase();
+        mark("xml-tagname");
+        cont();
+      }
+      else {
+        currentTag = null;
+        pass();
+      }
+    }
+    function closetagname(style, content) {
+      if (style == "xml-name" && context && content.toLowerCase() == context.name) {
+        popContext();
+        mark("xml-tagname");
+      }
+      else {
+        mark("xml-error");
+      }
+      cont();
+    }
+    function closeliquidtagname(style, content) {
+      if (style == "liquid-tag-name" && context && content.toLowerCase() == context.name) {
+        popContext();
+        mark("xml-tagname");
+      }
+      else {
+        mark("xml-error");
+      }
+      cont();
+    }
+    function endtag(startOfLine) {
+      return function(style, content) {
+        if (content == "/>" || (content == ">" && UseKludges.autoSelfClosers.hasOwnProperty(currentTag))) cont();
+        else if (content == ">") pushContext(currentTag, startOfLine) || cont();
+        else mark("xml-error") || cont(arguments.callee);
+      };
+    }
+    function attributes(style) {
+      if (style == "xml-name") mark("xml-attname") || cont(attribute, attributes);
+      else pass();
+    }
+    function attribute(style, content) {
+      if (content == "=") cont(value);
+      else if (content == ">" || content == "/>") pass(endtag);
+      else pass();
+    }
+    function value(style) {
+      if (style == "xml-attribute") cont(value);
+      else pass();
+    }
+
+    return {
+      indentation: function() {return indented;},
+
+      next: function(){
+        var token = tokens.next();
+        if (token.style == "whitespace" && tokenNr == 0)
+          indented = token.value.length;
+        else
+          tokenNr++;
+        if (token.content == "\n") {
+          indented = tokenNr = 0;
+          token.indentation = computeIndentation(context);
+        }
+
+        if (token.style == "whitespace" || token.type == "xml-comment")
+          return token;
+
+        while(true){
+          consume = marked = false;
+          cc.pop()(token.style, token.content);
+          if (consume){
+            if (marked)
+              token.style = marked;
+            return token;
+          }
+        }
+      },
+
+      copy: function(){
+        var _cc = cc.concat([]), _tokenState = tokens.state, _context = context;
+        var parser = this;
+        
+        return function(input){
+          cc = _cc.concat([]);
+          tokenNr = indented = 0;
+          context = _context;
+          tokens = tokenizeXML(input, _tokenState);
+          return parser;
+        };
+      }
+    };
+  }
+
+  return {
+    make: parseXML,
+    electricChars: "/",
+    configure: function(config) {
+      if (config.useHTMLKludges != null)
+        UseKludges = config.useHTMLKludges ? Kludges : NoKludges;
+      if (config.alignCDATA)
+        alignCDATA = config.alignCDATA;
+    }
+  };
+})();