liquid_cms 0.2.0.11 → 0.2.0.12

data/generators/liquid_cms/templates/public/cms/codemirror/js/unittests.js

@@ -0,0 +1,44 @@
+/**
+ * Test Harness for CodeMirror
+ * JS-unit compatible tests here.  The two available assertions are
+ * assertEquals (strict equality) and assertEquivalent (looser equivalency).
+ *
+ * 'editor' is a global object for the CodeMirror editor shared between all
+ * tests.  After manipulating it in each test, try to restore it to
+ * approximately its original state.
+ */
+
+function testSetGet() {
+  var code = 'It was the best of times.\nIt was the worst of times.';
+  editor.setCode(code);
+  assertEquals(code, editor.getCode());
+  editor.setCode('');
+  assertEquals('', editor.getCode());
+}
+
+function testSetStylesheet() {
+  function cssStatus() {
+    // Returns a list of tuples, for each CSS link return the filename and
+    // whether it is enabled.
+    links = editor.win.document.getElementsByTagName('link');
+    css = [];
+    for (var x = 0, link; link = links[x]; x++) {
+      if (link.rel.indexOf("stylesheet") !== -1) {
+        css.push([link.href.substring(link.href.lastIndexOf('/') + 1),
+                 !link.disabled])
+      }
+    }
+    return css;
+  }
+  assertEquivalent([], cssStatus());
+  editor.setStylesheet('css/jscolors.css');
+  assertEquivalent([['jscolors.css', true]], cssStatus());
+  editor.setStylesheet(['css/csscolors.css', 'css/xmlcolors.css']);
+  assertEquivalent([['jscolors.css', false], ['csscolors.css', true], ['xmlcolors.css', true]], cssStatus());
+  editor.setStylesheet([]);
+  assertEquivalent([['jscolors.css', false], ['csscolors.css', false], ['xmlcolors.css', false]], cssStatus());
+}
+
+// Update this list of tests as new ones are added.
+var tests = ['testSetGet', 'testSetStylesheet'];
+

data/generators/liquid_cms/templates/public/cms/codemirror/js/util.js

@@ -34,12 +34,15 @@ function matcher(regexp){
   return function(value){return regexp.test(value);};
 }
 
-// Test whether a DOM node has a certain CSS class. Much faster than
-// the MochiKit equivalent, for some reason.
-function hasClass(element, className){
+// Test whether a DOM node has a certain CSS class.
+function hasClass(element, className) {
   var classes = element.className;
   return classes && new RegExp("(^| )" + className + "($| )").test(classes);
 }
+function removeClass(element, className) {
+  element.className = element.className.replace(new RegExp(" " + className + "\\b", "g"), "");
+  return element;
+}
 
 // Insert a DOM node after another node.
 function insertAfter(newNode, oldNode) {

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

@@ -1,5 +1,19 @@
+// set or delete a cookie value to remember the folders view state
+function set_component_view_state(elem) {
+  var key = elem.getAttribute('id');
+  var current_folders = jar.get('component_folders') || {};
+  
+  if (elem.next('ul').visible())
+    current_folders[key] = true;
+  else
+    delete current_folders[key];
+
+  jar.put('component_folders', current_folders);
+}
+
 function toggle_component() {
   $(this).next('ul').toggle();
+  set_component_view_state(this);
 }
 
 function asset_preview_toggle() {
@@ -17,5 +31,5 @@ $(document).observe('dom:loaded', function() {
   });
 });
 
-var cookie_expiry = 60 * 60 * 24 * 30; // 1 month
+var cookie_expiry = 60 * 60 * 24 * 30 * 3; // 3 months
 var jar = new CookieJar({expires:cookie_expiry, path:'/cms'});

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

@@ -0,0 +1,181 @@
+/**
+ * @author Ryan Johnson <http://syntacticx.com/>
+ * @copyright 2008 PersonalGrid Corporation <http://personalgrid.com/>
+ * @package LivePipe UI
+ * @license MIT
+ * @url http://livepipe.net/core
+ * @require prototype.js
+ */
+
+if(typeof(Control) == 'undefined')
+    Control = {};
+    
+var $proc = function(proc){
+    return typeof(proc) == 'function' ? proc : function(){return proc};
+};
+
+var $value = function(value){
+    return typeof(value) == 'function' ? value() : value;
+};
+
+Object.Event = {
+    extend: function(object){
+        object._objectEventSetup = function(event_name){
+            this._observers = this._observers || {};
+            this._observers[event_name] = this._observers[event_name] || [];
+        };
+        object.observe = function(event_name,observer){
+            if(typeof(event_name) == 'string' && typeof(observer) != 'undefined'){
+                this._objectEventSetup(event_name);
+                if(!this._observers[event_name].include(observer))
+                    this._observers[event_name].push(observer);
+            }else
+                for(var e in event_name)
+                    this.observe(e,event_name[e]);
+        };
+        object.stopObserving = function(event_name,observer){
+            this._objectEventSetup(event_name);
+            if(event_name && observer)
+                this._observers[event_name] = this._observers[event_name].without(observer);
+            else if(event_name)
+                this._observers[event_name] = [];
+            else
+                this._observers = {};
+        };
+        object.observeOnce = function(event_name,outer_observer){
+            var inner_observer = function(){
+                outer_observer.apply(this,arguments);
+                this.stopObserving(event_name,inner_observer);
+            }.bind(this);
+            this._objectEventSetup(event_name);
+            this._observers[event_name].push(inner_observer);
+        };
+        object.notify = function(event_name){
+            this._objectEventSetup(event_name);
+            var collected_return_values = [];
+            var args = $A(arguments).slice(1);
+            try{
+                for(var i = 0; i < this._observers[event_name].length; ++i)
+                    collected_return_values.push(this._observers[event_name][i].apply(this._observers[event_name][i],args) || null);
+            }catch(e){
+                if(e == $break)
+                    return false;
+                else
+                    throw e;
+            }
+            return collected_return_values;
+        };
+        if(object.prototype){
+            object.prototype._objectEventSetup = object._objectEventSetup;
+            object.prototype.observe = object.observe;
+            object.prototype.stopObserving = object.stopObserving;
+            object.prototype.observeOnce = object.observeOnce;
+            object.prototype.notify = function(event_name){
+                if(object.notify){
+                    var args = $A(arguments).slice(1);
+                    args.unshift(this);
+                    args.unshift(event_name);
+                    object.notify.apply(object,args);
+                }
+                this._objectEventSetup(event_name);
+                var args = $A(arguments).slice(1);
+                var collected_return_values = [];
+                try{
+                    if(this.options && this.options[event_name] && typeof(this.options[event_name]) == 'function')
+                        collected_return_values.push(this.options[event_name].apply(this,args) || null);
+                    var callbacks_copy = this._observers[event_name]; // since original array will be modified after observeOnce calls
+                    for(var i = 0; i < callbacks_copy.length; ++i)
+                        collected_return_values.push(callbacks_copy[i].apply(callbacks_copy[i],args) || null);
+                }catch(e){
+                    if(e == $break)
+                        return false;
+                    else
+                        throw e;
+                }
+                return collected_return_values;
+            };
+        }
+    }
+};
+
+/* Begin Core Extensions */
+
+//Element.observeOnce
+Element.addMethods({
+    observeOnce: function(element,event_name,outer_callback){
+        var inner_callback = function(){
+            outer_callback.apply(this,arguments);
+            Element.stopObserving(element,event_name,inner_callback);
+        };
+        Element.observe(element,event_name,inner_callback);
+    }
+});
+
+//mouse:wheel
+(function(){
+    function wheel(event){
+        var delta, element, custom_event;
+        // normalize the delta
+        if (event.wheelDelta) { // IE & Opera
+            delta = event.wheelDelta / 120;
+        } else if (event.detail) { // W3C
+            delta =- event.detail / 3;
+        }
+        if (!delta) { return; }
+        element = Event.extend(event).target;
+        element = Element.extend(element.nodeType === Node.TEXT_NODE ? element.parentNode : element);
+        custom_event = element.fire('mouse:wheel',{ delta: delta });
+        if (custom_event.stopped) {
+            Event.stop(event);
+            return false;
+        }
+    }
+    document.observe('mousewheel',wheel);
+    document.observe('DOMMouseScroll',wheel);
+})();
+
+/* End Core Extensions */
+
+//from PrototypeUI
+var IframeShim = Class.create({
+    initialize: function() {
+        this.element = new Element('iframe',{
+            style: 'position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);display:none',
+            src: 'javascript:void(0);',
+            frameborder: 0 
+        });
+        $(document.body).insert(this.element);
+    },
+    hide: function() {
+        this.element.hide();
+        return this;
+    },
+    show: function() {
+        this.element.show();
+        return this;
+    },
+    positionUnder: function(element) {
+        var element = $(element);
+        var offset = element.cumulativeOffset();
+        var dimensions = element.getDimensions();
+        this.element.setStyle({
+            left: offset[0] + 'px',
+            top: offset[1] + 'px',
+            width: dimensions.width + 'px',
+            height: dimensions.height + 'px',
+            zIndex: element.getStyle('zIndex') - 1
+        }).show();
+        return this;
+    },
+    setBounds: function(bounds) {
+        for(prop in bounds)
+            bounds[prop] += 'px';
+        this.element.setStyle(bounds);
+        return this;
+    },
+    destroy: function() {
+        if(this.element)
+            this.element.remove();
+        return this;
+    }
+});

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

@@ -0,0 +1,149 @@
+/**
+ * @author Ryan Johnson <http://syntacticx.com/>
+ * @copyright 2008 PersonalGrid Corporation <http://personalgrid.com/>
+ * @package LivePipe UI
+ * @license MIT
+ * @url http://livepipe.net/control/tabs
+ * @require prototype.js, livepipe.js
+ */
+
+/*global window, document, Prototype, $, $A, $H, $break, Class, Element, Event, Control */
+
+if(typeof(Prototype) == "undefined") {
+    throw "Control.Tabs requires Prototype to be loaded."; }
+if(typeof(Object.Event) == "undefined") {
+    throw "Control.Tabs requires Object.Event to be loaded."; }
+
+Control.Tabs = Class.create({
+    initialize: function(tab_list_container,options){
+        if(!$(tab_list_container)) {
+            throw "Control.Tabs could not find the element: " + tab_list_container; }
+        this.activeContainer = false;
+        this.activeLink = false;
+        this.containers = $H({});
+        this.links = [];
+        Control.Tabs.instances.push(this);
+        this.options = {
+            beforeChange: Prototype.emptyFunction,
+            afterChange: Prototype.emptyFunction,
+            hover: false,
+            linkSelector: 'li a',
+            setClassOnContainer: false,
+            activeClassName: 'active',
+            defaultTab: 'first',
+            autoLinkExternal: true,
+            targetRegExp: /#(.+)$/,
+            showFunction: Element.show,
+            hideFunction: Element.hide
+        };
+        Object.extend(this.options,options || {});
+        (typeof(this.options.linkSelector == 'string') ? 
+            $(tab_list_container).select(this.options.linkSelector) : 
+            this.options.linkSelector($(tab_list_container))
+        ).findAll(function(link){
+            return (/^#/).exec((Prototype.Browser.WebKit ? decodeURIComponent(link.href) : link.href).replace(window.location.href.split('#')[0],''));
+        }).each(function(link){
+            this.addTab(link);
+        }.bind(this));
+        this.containers.values().each(Element.hide);
+        if(this.options.defaultTab == 'first') {
+            this.setActiveTab(this.links.first());
+        } else if(this.options.defaultTab == 'last') {
+            this.setActiveTab(this.links.last());
+        } else {
+            this.setActiveTab(this.options.defaultTab); }
+        var targets = this.options.targetRegExp.exec(window.location);
+        if(targets && targets[1]){
+            targets[1].split(',').each(function(target){
+                this.setActiveTab(this.links.find(function(link){
+                    return link.key == target;
+                }));
+            }.bind(this));
+        }
+        if(this.options.autoLinkExternal){
+            $A(document.getElementsByTagName('a')).each(function(a){
+                if(!this.links.include(a)){
+                    var clean_href = a.href.replace(window.location.href.split('#')[0],'');
+                    if(clean_href.substring(0,1) == '#'){
+                        if(this.containers.keys().include(clean_href.substring(1))){
+                            $(a).observe('click',function(event,clean_href){
+                                this.setActiveTab(clean_href.substring(1));
+                            }.bindAsEventListener(this,clean_href));
+                        }
+                    }
+                }
+            }.bind(this));
+        }
+    },
+    addTab: function(link){
+        this.links.push(link);
+        link.key = link.getAttribute('href').replace(window.location.href.split('#')[0],'').split('#').last().replace(/#/,'');
+        var container = $(link.key);
+        if(!container) {
+            throw "Control.Tabs: #" + link.key + " was not found on the page."; }
+        this.containers.set(link.key,container);
+        link[this.options.hover ? 'onmouseover' : 'onclick'] = function(link){
+            if(window.event) {
+                Event.stop(window.event); }
+            this.setActiveTab(link);
+            return false;
+        }.bind(this,link);
+    },
+    setActiveTab: function(link){
+        if(!link && typeof(link) == 'undefined') {
+            return; }
+        if(typeof(link) == 'string'){
+            this.setActiveTab(this.links.find(function(_link){
+                return _link.key == link;
+            }));
+        }else if(typeof(link) == 'number'){
+            this.setActiveTab(this.links[link]);
+        }else{
+            if(this.notify('beforeChange',this.activeContainer,this.containers.get(link.key)) === false) {
+                return; }
+            if(this.activeContainer) {
+                this.options.hideFunction(this.activeContainer); }
+            this.links.each(function(item){
+                (this.options.setClassOnContainer ? $(item.parentNode) : item).removeClassName(this.options.activeClassName);
+            }.bind(this));
+            (this.options.setClassOnContainer ? $(link.parentNode) : link).addClassName(this.options.activeClassName);
+            this.activeContainer = this.containers.get(link.key);
+            this.activeLink = link;
+            this.options.showFunction(this.containers.get(link.key));
+            this.notify('afterChange',this.containers.get(link.key));
+        }
+    },
+    next: function(){
+        this.links.each(function(link,i){
+            if(this.activeLink == link && this.links[i + 1]){
+                this.setActiveTab(this.links[i + 1]);
+                throw $break;
+            }
+        }.bind(this));
+    },
+    previous: function(){
+        this.links.each(function(link,i){
+            if(this.activeLink == link && this.links[i - 1]){
+                this.setActiveTab(this.links[i - 1]);
+                throw $break;
+            }
+        }.bind(this));
+    },
+    first: function(){
+        this.setActiveTab(this.links.first());
+    },
+    last: function(){
+        this.setActiveTab(this.links.last());
+    }
+});
+Object.extend(Control.Tabs,{
+    instances: [],
+    findByTabId: function(id){
+        return Control.Tabs.instances.find(function(tab){
+            return tab.links.find(function(link){
+                return link.key == id;
+            });
+        });
+    }
+});
+Object.Event.extend(Control.Tabs);

data/generators/liquid_cms/templates/public/cms/stylesheets/ie9.css

@@ -0,0 +1,4 @@
+form.simple_form .buttons input,
+form.simple_form a.cancel {
+  line-height: 1.5em;
+}

data/generators/liquid_cms/templates/public/cms/stylesheets/sidebar.css

@@ -0,0 +1,132 @@
+#sidebar {
+  background-color: #CFCFCF;
+  float: left;
+  padding: 0 0.5em 0.5em;
+  margin-left: 1em;
+  width: 19em;
+}
+#sidebar h2 {
+  font-size: 12pt;
+  padding: 0.2em;
+  margin: 0;
+  text-align: center;
+}
+#sidebar form {
+  margin-top: 0.5em;
+}
+#sidebar ul {
+  list-style-type: none;
+  margin: 0;
+  padding: 0;
+}
+#sidebar #assets li {
+  border: 1px solid #AAA;
+  padding: 0.3em 0.4em;
+  margin-bottom: 0.3em;
+}
+#sidebar #assets li:hover {
+  background-color: #BFD6FF !important;
+}
+#sidebar #assets li.light {
+  background-color: #DDD;
+}
+#sidebar .asset_details {
+  margin-top: 0.5em;
+}
+#sidebar .asset_image {
+  margin: 0 1.5em 0;
+}
+#sidebar .asset_image {
+  float: left;
+}
+#sidebar .asset_size {
+  font-size: 8pt;
+  float: right;
+}
+#sidebar #components form {
+  margin-bottom: 0.5em;
+}
+#sidebar #components ul ul {
+  margin-left: 0.5em;
+}
+#sidebar .documentation {
+  text-align: center;
+  margin-bottom: 0;
+}
+
+#sidebar ul.tabs {
+  display: block;
+  margin: 1em 0 0.5em 0;
+  padding: 0;
+  text-align: center;
+}
+#sidebar ul.tabs li {
+  display: inline;
+}
+#sidebar ul.tabs a {
+  -moz-border-radius: 0.4em 0.4em 0 0;
+  -webkit-border-radius: 0.4em 0.4em 0 0;
+  border-radius: 0.4em 0.4em 0 0;
+  background-color: #333;
+  color: #CCC;
+  font-size: 9pt;
+  font-weight: bold;
+  margin: 0;
+  padding: 0.5em 0.5em;
+  padding-right: 0.5em;
+  text-align: center;
+  text-shadow: -1px -1px 1px #000000;
+  text-decoration: none;
+}
+#sidebar ul.tabs a.active,
+#sidebar ul.tabs a:hover {
+  text-shadow: none;
+}
+#sidebar ul.tabs a:hover {
+  background-color: #777;
+}
+#sidebar ul.tabs a.active {
+  background-color: #666;
+}
+
+#tab_container {
+  border: 2px groove #CCC;
+  padding: 0.2em 0.5em;
+}
+#tab_container p {
+  background: none repeat scroll 0 0 #E5E5E5;
+  font-size: 8pt;
+  margin: 0 0 0.5em;
+  padding: 0.5em 0;
+  text-align: center;
+}
+#tab_container p:first-child {
+  background: #777;
+  background: -moz-linear-gradient(270deg, #666 0%, #888 100%) repeat scroll 0 0 transparent;
+  background: -webkit-gradient(linear, left top, left bottom, color-stop(0,#666), color-stop(1.0,#888));
+}
+#tab_container p:first-child a {
+  color: #EEE;
+  font-weight: bold;
+  text-decoration: none;
+  text-shadow: -1px -1px 1px #333;
+}
+#tab_container p:first-child a:hover {
+  text-decoration: underline;
+}
+
+#cms ul.tree { list-style-type: none; background: url(/cms/images/tree/vline.png) repeat-y; margin: 0; padding: 0; }
+#cms ul.tree ul { margin-left: 10px; }
+#cms ul.tree li { margin: 0; padding: 0 0px 0 12px; line-height: 20px; background: url(/cms/images/tree/node.png) no-repeat; color: #369; font-weight: bold; } 
+#cms ul.tree li:last-child { background: url(/cms/images/tree/lastnode.png) no-repeat; }
+
+#cms ul.tree, #sidebar #assets ul {
+  margin-bottom: 0.5em;
+}
+#cms ul.tree ul {
+  margin-left: 15px;
+}
+#cms ul.tree li img.folder:hover {
+  cursor: pointer;
+}
+