pages_core 3.4.3 → 3.5.1

data/app/assets/javascripts/pages/admin/features/rich_text.es6.jsx

@@ -0,0 +1,124 @@
+class TextileDecorator {
+  blockquote(str) { return ["bq. ", str, ""]; }
+  bold(str) { return ["<b>", str, "</b>"]; }
+  emphasis(str) { return ["<i>", str, "</i>"]; }
+  h1(str) { return ["h1. ", str, ""]; }
+  h2(str) { return ["h2. ", str, ""]; }
+  h3(str) { return ["h3. ", str, ""]; }
+  h4(str) { return ["h4. ", str, ""]; }
+  h5(str) { return ["h5. ", str, ""]; }
+  h6(str) { return ["h6. ", str, ""]; }
+  link(url, name) { return ["\"", name, `\":${url}`]; }
+  email(address, name) { return ["\"", name, `\":mailto:${address}`]; }
+
+  list(str) {
+    return ["", str.split("\n").map(l => "* " + l).join("\n"), ""];
+  }
+
+  orderedList(str) {
+    return ["", str.split("\n").map(l => "# " + l).join("\n"), ""];
+  }
+}
+
+class RichTextArea {
+  constructor(textarea) {
+    this.textarea = textarea;
+    this.decorator = new TextileDecorator();
+    this.toolbar = $("<ul class=\"rich-text-toolbar\"></ul>")
+                      .insertBefore(this.textarea);
+    this.addButtons();
+  }
+
+  adjustSelection(callback) {
+    let length = this.getSelection().length;
+    let [start, end] = this.getSelectionRange();
+    let [replacementLength, prefixLength] = callback();
+    let newEnd = (end + (replacementLength - length) + prefixLength);
+    let newStart = start === end ? newEnd : (start + prefixLength);
+    return this.setSelectionRange(newStart, newEnd);
+  };
+
+  getSelection() {
+    return $(this.textarea).getSelection().text;
+  }
+
+  getSelectionRange() {
+    if (typeof this.textarea.selectionStart !== "undefined") {
+      return [this.textarea.selectionStart, this.textarea.selectionEnd];
+    } else {
+      return [0, 0];
+    }
+  };
+
+  replaceSelection(prefix, replacement, postfix) {
+    return this.adjustSelection(() => {
+      $(this.textarea).replaceSelection(prefix + replacement + postfix);
+      $(this.textarea).focus();
+      return [replacement.length, prefix.length];
+    });
+  };
+
+  // Sets a new selection range for object
+  setSelectionRange(start, end) {
+    if (typeof this.textarea.setSelectionRange !== "undefined") {
+      return this.textarea.setSelectionRange(start, end);
+    }
+  };
+
+  addButton(name, className, callback) {
+    var link = $(
+      `<a title=\"${name}\" class=\"${className}\">` +
+      `<i class=\"fa fa-${className}\"></i></a>`
+    );
+
+    link.click(() => {
+      let [prefix, replacement, postfix] = callback(this.getSelection());
+      this.replaceSelection(prefix, replacement, postfix);
+    });
+
+    $("<li class=\"button\"></li>").append(link).appendTo(this.toolbar);
+  };
+
+  addButtons() {
+    // Bold button
+    this.addButton("Bold", "bold", s => this.decorator.bold(s));
+
+    // Italic button
+    this.addButton("Italics", "italic", s => this.decorator.emphasis(s));
+
+    // Heading buttons
+    this.addButton("Heading 2", "header h2", s => this.decorator.h2(s));
+    this.addButton("Heading 3", "header h3", s => this.decorator.h3(s));
+    this.addButton("Heading 4", "header h4", s => this.decorator.h4(s));
+
+    // Block Quote
+    this.addButton("Block Quote", "quote-left", s => this.decorator.blockquote(s))
+
+    // List
+    this.addButton("List", "list-ul", s => this.decorator.list(s));
+
+    // Ordered list
+    this.addButton("Ordered list", "list-ol", s => this.decorator.orderedList(s));
+
+    // Link button
+    this.addButton("Link", "link", selection => {
+      let name = selection.length > 0 ? selection : "Link text";
+      var url = prompt("Enter link URL", "");
+      url = url.length > 0 ? url : "http://example.com/";
+      url = url.replace(/^(?!(f|ht)tps?:\/\/)/, 'http://');
+      return this.decorator.link(url, name);
+    });
+
+    // Email button
+    this.addButton("Email link", "envelope", selection => {
+      let name = selection.length > 0 ? selection : "Link text";
+      var address = prompt("Enter email address", "");
+      address = address.length > 0 ? address : "example@example.com";
+      return this.decorator.email(address, name);
+    });
+  }
+}
+
+$(function() {
+  $('textarea.rich').each(function() { new RichTextArea(this); });
+});

data/app/assets/javascripts/pages/admin/features/tag_editor.es6.jsx

@@ -0,0 +1,160 @@
+var TagEditor = function(container) {
+  this.initialize(container);
+};
+
+$.extend(TagEditor.prototype, {
+  initialize: function(container) {
+    var tagEditor = this;
+    tagEditor.container = container;
+    tagEditor.tags = Array();
+    tagEditor.serializeField = $(tagEditor.container).find('.serialized_tags').get(0);
+    tagEditor.findTags(true);
+
+    tagEditor.inputField = $(tagEditor.container).find('.add-tag').get(0);
+    $(tagEditor.container).find('.add-tag-button').click(function() {
+      tagEditor.addTag();
+      $(tagEditor.container).find('.add-tag').blur();
+      return false;
+    });
+    $(tagEditor.container).find('.add-tag').keydown(function(event) {
+      if (event.which === 13) {
+        tagEditor.addTag();
+        return false;
+      }
+    });
+
+    $(tagEditor.container).find('.add-tag').each(function(){
+      var field = this;
+      field.exampleText = $(field).val();
+      $(field).addClass('example');
+      $(field).focus(function(event){
+        $(tagEditor.container).find('.add-tag-button').fadeIn('fast');
+        $(field).removeClass('example');
+        if ($(field).val() === field.exampleText) {
+          $(field).val('');
+        }
+      });
+      $(field).blur(function(event) {
+        $(tagEditor.container).find('.add-tag-button').fadeOut('fast');
+        if (!$(field).val() || $(field).val() === field.exampleText) {
+          $(field).addClass('example').val(field.exampleText);
+        }
+      });
+    });
+    $(tagEditor.container).find('.add-tag-button').hide();
+  },
+
+  addTag: function() {
+    var tagEditor = this;
+    var tagName = $(tagEditor.inputField).val().replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+    if (tagName) {
+      if (this.hasTag(tagName)) {
+        this.enable(this.getTagByName(tagName));
+      } else {
+        $(tagEditor.container).find('.tags').append('<span class="tag"><input type="checkbox" name="tag-'+tagName+'" value="1" checked="checked"><span class="name">'+tagName+'</span></span>');
+        tagEditor.findTags();
+      }
+    }
+    $(tagEditor.inputField).val('');
+  },
+
+  findTags: function(permanentize) {
+    var tagEditor = this;
+    $(this.container).find('.tag').each(function () {
+      var tag = this;
+      if (!tag.tagEditorApplied) {
+        tag.checkBox = $(tag).find('input[type=checkbox]').get(0);
+        tag.name = $(tag).find('.name').text();
+        if(tagEditor.isChecked(tag)){
+          tag.enabled = true;
+          $(tag).addClass('enabled');
+        } else {
+          tag.enabled = false;
+        }
+        $(tag).click(function () {
+          tagEditor.toggle(tag);
+        });
+        tagEditor.tags[tagEditor.tags.length] = tag;
+        tag.tagEditorApplied = true;
+      }
+    });
+    tagEditor.serializeTags();
+  },
+
+  hasTag: function(tagName) {
+    var hasTag = false;
+    $(this.tags).each(function () {
+      if (tagName.toLowerCase() === this.name.toLowerCase()) {
+        hasTag = true;
+      }
+    });
+    return hasTag;
+  },
+
+  setEnabled: function(tag, enabled) {
+    tag.enabled = enabled;
+    if (tag.enabled) {
+      $(tag).addClass('enabled');
+    } else {
+      $(tag).removeClass('enabled');
+    }
+    $(tag.checkBox).attr('checked', tag.enabled);
+    this.serializeTags();
+  },
+
+  toggle: function(tag) {
+    if (tag.enabled) {
+      this.disable(tag);
+    } else {
+      this.enable(tag);
+    }
+  },
+
+  enable: function(tag) {
+    this.setEnabled(tag, true);
+  },
+
+  disable: function(tag) {
+    this.setEnabled(tag, false);
+  },
+
+  getTagByName: function(tagName) {
+    var tag = null;
+    $(this.tags).each(function(){
+      if (this.name.toLowerCase() === tagName.toLowerCase()) {
+        tag = this;
+      }
+    });
+    return tag;
+  },
+
+  isChecked: function(tag) {
+    return $(tag.checkBox).attr('checked');
+  },
+
+  enabledTags: function() {
+    var enabledTags = Array();
+    $(this.tags).each(function() {
+      if (this.enabled) {
+        enabledTags[enabledTags.length] = this;
+      }
+    });
+    return enabledTags;
+  },
+
+  serializeTags: function() {
+    var tagNames = Array();
+    $(this.enabledTags()).each(function() {
+      tagNames[tagNames.length] = '"' + this.name.replace('"', '\\"') + '"';
+    });
+    $(this.serializeField).val('['+tagNames.join(', ')+']');
+    $(this.container).find('.add-tag').attr('disabled', false);
+  }
+});
+
+// Apply the tag editor to each instance
+$(function() {
+  $('.tag-editor').each(function() {
+    this.tagEditor = new TagEditor(this);
+  });
+});

data/app/assets/javascripts/pages/admin/lib/ajax_extensions.es6.jsx

@@ -0,0 +1,21 @@
+(function () {
+  let _ajax_request = function(url, data, callback, type, method) {
+    if ($.isFunction(data)) {
+      callback = data;
+      data = {};
+    }
+    return $.ajax({
+      type: method,
+      url: url,
+      data: data,
+      success: callback,
+      dataType: type
+    });
+  };
+
+  jQuery.extend({
+    put: function(url, data, callback, type) {
+      return _ajax_request(url, data, callback, type, "PUT");
+    }
+  });
+})();

data/app/assets/javascripts/pages/admin/lib/center_on_screen.es6.jsx

@@ -0,0 +1,22 @@
+jQuery.fn.centerOnScreen = function() {
+  this.css("position", "absolute");
+  this.css("z-index", 1000 + (Math.round(Math.random() * 5000)));
+
+  var x = (($(window).width() / 2) - (this.width() / 2)) +
+          $(window).scrollLeft();
+
+  var y = (($(window).height() / 2) - (this.height() / 2)) +
+          $(window).scrollTop();
+
+  if (x < 0) {
+    x = 0;
+  }
+
+  if (y < 0) {
+    y = 0;
+  }
+
+  this.css({left: x + "px", top: y + "px"});
+
+  return this;
+};

data/app/assets/javascripts/pages/admin/lib/tree.es6.jsx

@@ -0,0 +1,294 @@
+/*
+   Based on
+
+   js-tree by Wang Zuo
+   https://github.com/wangzuo/js-tree
+
+   react-ui-tree
+   https://github.com/pqx/react-ui-tree
+
+   The MIT License (MIT)
+
+   Copyright (c) 2015 Wang Zuo
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+
+   Copyright (c) 2015 pqx Limited
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+ */
+class Tree {
+  constructor(obj) {
+    this.cnt = 1;
+    this.obj = obj || { children: [] };
+    this.indexes = {};
+    this.build(this.obj);
+  }
+
+  build(obj) {
+    var indexes = this.indexes;
+    var startId = this.cnt;
+    var self = this;
+
+    var index = { id: startId, node: obj };
+    indexes[this.cnt + ''] = index;
+    this.cnt++;
+
+    if (obj.children && obj.children.length) {
+      walk(obj.children, index);
+    }
+
+    function walk(objs, parent) {
+      var children = [];
+      objs.forEach(function(obj, i) {
+        var index = {};
+        index.id = self.cnt;
+        index.node = obj;
+
+        if (parent) {
+          index.parent = parent.id;
+        }
+
+        indexes[self.cnt + ''] = index;
+        children.push(self.cnt);
+        self.cnt++;
+
+        if (obj.children && obj.children.length) {
+          walk(obj.children, index);
+        }
+      });
+      parent.children = children;
+
+      children.forEach(function(id, i) {
+        var index = indexes[id + ''];
+        if (i > 0) {
+          index.prev = children[i - 1];
+        }
+        if (i < children.length-1) {
+          index.next = children[i+1];
+        }
+      });
+    }
+
+    return index;
+  }
+
+  getIndex(id) {
+    var index = this.indexes[id + ''];
+    if (index) {
+      return index;
+    }
+  }
+
+  removeIndex(index) {
+    var self = this;
+    del(index);
+
+    function del(index) {
+      delete self.indexes[index.id + ''];
+      if (index.children && index.children.length) {
+        index.children.forEach(function(child) {
+          del(self.getIndex(child));
+        });
+      }
+    }
+  }
+
+  get(id) {
+    var index = this.getIndex(id);
+    if (index && index.node) {
+      return index.node;
+    }
+    return null;
+  }
+
+  remove(id) {
+    var index = this.getIndex(id);
+    var node = this.get(id);
+    var parentIndex = this.getIndex(index.parent);
+    var parentNode = this.get(index.parent);
+    parentNode.children.splice(parentNode.children.indexOf(node), 1);
+    parentIndex.children.splice(parentIndex.children.indexOf(id), 1);
+    this.removeIndex(index);
+    this.updateChildren(parentIndex.children);
+
+    return node;
+  }
+
+  updateChildren(children) {
+    children.forEach(function(id, i) {
+      var index = this.getIndex(id);
+      index.prev = index.next = null;
+      if (i > 0) {
+        index.prev = children[i-1];
+      }
+      if (i < children.length-1) {
+        index.next = children[i+1];
+      }
+    }.bind(this));
+  }
+
+  insert(obj, parentId, i) {
+    var parentIndex = this.getIndex(parentId);
+    var parentNode = this.get(parentId);
+
+    var index = this.build(obj);
+    index.parent = parentId;
+
+    parentNode.children = parentNode.children || [];
+    parentIndex.children = parentIndex.children || [];
+
+    parentNode.children.splice(i, 0, obj);
+    parentIndex.children.splice(i, 0, index.id);
+
+    this.updateChildren(parentIndex.children);
+    if (parentIndex.parent) {
+      this.updateChildren(this.getIndex(parentIndex.parent).children);
+    }
+
+    return index;
+  }
+
+  insertBefore(obj, destId) {
+    var destIndex = this.getIndex(destId);
+    var parentId = destIndex.parent;
+    var i = this.getIndex(parentId).children.indexOf(destId);
+    return this.insert(obj, parentId, i);
+  }
+
+  insertAfter(obj, destId) {
+    var destIndex = this.getIndex(destId);
+    var parentId = destIndex.parent;
+    var i = this.getIndex(parentId).children.indexOf(destId);
+    return this.insert(obj, parentId, i+1);
+  }
+
+  prepend(obj, destId) {
+    return this.insert(obj, destId, 0);
+  }
+
+  append(obj, destId) {
+    var destIndex = this.getIndex(destId);
+    destIndex.children = destIndex.children || [];
+    return this.insert(obj, destId, destIndex.children.length);
+  }
+
+  // react-ui-tree methods
+
+  updateNodesPosition() {
+    var top = 1;
+    var left = 1;
+    var root = this.getIndex(1);
+    var self = this;
+
+    root.top = top++;
+    root.left = left++;
+
+    if (root.children && root.children.length) {
+      walk(root.children, root, left, root.node.collapsed);
+    }
+
+    function walk(children, parent, left, collapsed) {
+      var height = 1;
+      children.forEach(function(id) {
+        var node = self.getIndex(id);
+        if (collapsed) {
+          node.top = null;
+          node.left = null;
+        } else {
+          node.top = top++;
+          node.left = left;
+        }
+
+        if (node.children && node.children.length) {
+          height += walk(
+            node.children,
+            node,
+            left+1,
+            collapsed || node.node.collapsed
+          );
+        } else {
+          node.height = 1;
+          height += 1;
+        }
+      });
+
+      if(parent.node.collapsed) parent.height = 1;
+      else parent.height = height;
+      return parent.height;
+    }
+  }
+
+  move(fromId, toId, placement) {
+    if (fromId === toId || toId === 1) {
+      return;
+    }
+
+    var obj = this.remove(fromId);
+    var index = null;
+
+    if (placement === 'before') {
+      index = this.insertBefore(obj, toId);
+    } else if (placement === 'after') {
+      index = this.insertAfter(obj, toId);
+    } else if(placement === 'prepend') {
+      index = this.prepend(obj, toId);
+    } else if(placement === 'append') {
+      index = this.append(obj, toId);
+    }
+
+    // todo: perf
+    this.updateNodesPosition();
+    return index;
+  }
+
+  getParent(id) {
+    var indexes = this.indexes;
+    if (indexes.hasOwnProperty(id)) {
+      return this.getIndex(indexes[id].parent);
+    }
+  }
+
+  getNodeByTop(top) {
+    var indexes = this.indexes;
+    for(var id in indexes) {
+      if (indexes.hasOwnProperty(id)) {
+        if(indexes[id].top === top) {
+          return indexes[id];
+        }
+      }
+    }
+  }
+}