blogelator 0.1.0 → 0.1.1

data/vendor/assets/javascripts/codemirror/xml.js

@@ -0,0 +1,333 @@
+CodeMirror.defineMode("xml", function(config, parserConfig) {
+  var indentUnit = config.indentUnit;
+  var multilineTagIndentFactor = parserConfig.multilineTagIndentFactor || 1;
+  var multilineTagIndentPastTag = parserConfig.multilineTagIndentPastTag;
+  if (multilineTagIndentPastTag == null) multilineTagIndentPastTag = true;
+
+  var Kludges = parserConfig.htmlMode ? {
+    autoSelfClosers: {'area': true, 'base': true, 'br': true, 'col': true, 'command': true,
+                      'embed': true, 'frame': true, 'hr': true, 'img': true, 'input': true,
+                      'keygen': true, 'link': true, 'meta': true, 'param': true, 'source': true,
+                      'track': true, 'wbr': true},
+    implicitlyClosed: {'dd': true, 'li': true, 'optgroup': true, 'option': true, 'p': true,
+                       'rp': true, 'rt': true, 'tbody': true, 'td': true, 'tfoot': true,
+                       'th': true, 'tr': true},
+    contextGrabbers: {
+      'dd': {'dd': true, 'dt': true},
+      'dt': {'dd': true, 'dt': true},
+      'li': {'li': true},
+      'option': {'option': true, 'optgroup': true},
+      'optgroup': {'optgroup': true},
+      'p': {'address': true, 'article': true, 'aside': true, 'blockquote': true, 'dir': true,
+            'div': true, 'dl': true, 'fieldset': true, 'footer': true, 'form': true,
+            'h1': true, 'h2': true, 'h3': true, 'h4': true, 'h5': true, 'h6': true,
+            'header': true, 'hgroup': true, 'hr': true, 'menu': true, 'nav': true, 'ol': true,
+            'p': true, 'pre': true, 'section': true, 'table': true, 'ul': true},
+      'rp': {'rp': true, 'rt': true},
+      'rt': {'rp': true, 'rt': true},
+      'tbody': {'tbody': true, 'tfoot': true},
+      'td': {'td': true, 'th': true},
+      'tfoot': {'tbody': true},
+      'th': {'td': true, 'th': true},
+      'thead': {'tbody': true, 'tfoot': true},
+      'tr': {'tr': true}
+    },
+    doNotIndent: {"pre": true},
+    allowUnquoted: true,
+    allowMissing: true
+  } : {
+    autoSelfClosers: {},
+    implicitlyClosed: {},
+    contextGrabbers: {},
+    doNotIndent: {},
+    allowUnquoted: false,
+    allowMissing: false
+  };
+  var alignCDATA = parserConfig.alignCDATA;
+
+  // Return variables for tokenizers
+  var tagName, type, setStyle;
+
+  function inText(stream, state) {
+    function chain(parser) {
+      state.tokenize = parser;
+      return parser(stream, state);
+    }
+
+    var ch = stream.next();
+    if (ch == "<") {
+      if (stream.eat("!")) {
+        if (stream.eat("[")) {
+          if (stream.match("CDATA[")) return chain(inBlock("atom", "]]>"));
+          else return null;
+        } else if (stream.match("--")) {
+          return chain(inBlock("comment", "-->"));
+        } else if (stream.match("DOCTYPE", true, true)) {
+          stream.eatWhile(/[\w\._\-]/);
+          return chain(doctype(1));
+        } else {
+          return null;
+        }
+      } else if (stream.eat("?")) {
+        stream.eatWhile(/[\w\._\-]/);
+        state.tokenize = inBlock("meta", "?>");
+        return "meta";
+      } else {
+        var isClose = stream.eat("/");
+        tagName = "";
+        var c;
+        while ((c = stream.eat(/[^\s\u00a0=<>\"\'\/?]/))) tagName += c;
+        if (!tagName) return "tag error";
+        type = isClose ? "closeTag" : "openTag";
+        state.tokenize = inTag;
+        return "tag";
+      }
+    } else if (ch == "&") {
+      var ok;
+      if (stream.eat("#")) {
+        if (stream.eat("x")) {
+          ok = stream.eatWhile(/[a-fA-F\d]/) && stream.eat(";");
+        } else {
+          ok = stream.eatWhile(/[\d]/) && stream.eat(";");
+        }
+      } else {
+        ok = stream.eatWhile(/[\w\.\-:]/) && stream.eat(";");
+      }
+      return ok ? "atom" : "error";
+    } else {
+      stream.eatWhile(/[^&<]/);
+      return null;
+    }
+  }
+
+  function inTag(stream, state) {
+    var ch = stream.next();
+    if (ch == ">" || (ch == "/" && stream.eat(">"))) {
+      state.tokenize = inText;
+      type = ch == ">" ? "endTag" : "selfcloseTag";
+      return "tag";
+    } else if (ch == "=") {
+      type = "equals";
+      return null;
+    } else if (ch == "<") {
+      state.tokenize = inText;
+      state.state = baseState;
+      state.tagName = state.tagStart = null;
+      var next = state.tokenize(stream, state);
+      return next ? next + " error" : "error";
+    } else if (/[\'\"]/.test(ch)) {
+      state.tokenize = inAttribute(ch);
+      state.stringStartCol = stream.column();
+      return state.tokenize(stream, state);
+    } else {
+      stream.eatWhile(/[^\s\u00a0=<>\"\']/);
+      return "word";
+    }
+  }
+
+  function inAttribute(quote) {
+    var closure = function(stream, state) {
+      while (!stream.eol()) {
+        if (stream.next() == quote) {
+          state.tokenize = inTag;
+          break;
+        }
+      }
+      return "string";
+    };
+    closure.isInAttribute = true;
+    return closure;
+  }
+
+  function inBlock(style, terminator) {
+    return function(stream, state) {
+      while (!stream.eol()) {
+        if (stream.match(terminator)) {
+          state.tokenize = inText;
+          break;
+        }
+        stream.next();
+      }
+      return style;
+    };
+  }
+  function doctype(depth) {
+    return function(stream, state) {
+      var ch;
+      while ((ch = stream.next()) != null) {
+        if (ch == "<") {
+          state.tokenize = doctype(depth + 1);
+          return state.tokenize(stream, state);
+        } else if (ch == ">") {
+          if (depth == 1) {
+            state.tokenize = inText;
+            break;
+          } else {
+            state.tokenize = doctype(depth - 1);
+            return state.tokenize(stream, state);
+          }
+        }
+      }
+      return "meta";
+    };
+  }
+
+  function Context(state, tagName, startOfLine) {
+    this.prev = state.context;
+    this.tagName = tagName;
+    this.indent = state.indented;
+    this.startOfLine = startOfLine;
+    if (Kludges.doNotIndent.hasOwnProperty(tagName) || (state.context && state.context.noIndent))
+      this.noIndent = true;
+  }
+  function popContext(state) {
+    if (state.context) state.context = state.context.prev;
+  }
+  function maybePopContext(state, nextTagName) {
+    var parentTagName;
+    while (true) {
+      if (!state.context) {
+        return;
+      }
+      parentTagName = state.context.tagName.toLowerCase();
+      if (!Kludges.contextGrabbers.hasOwnProperty(parentTagName) ||
+          !Kludges.contextGrabbers[parentTagName].hasOwnProperty(nextTagName)) {
+        return;
+      }
+      popContext(state);
+    }
+  }
+
+  function baseState(type, stream, state) {
+    if (type == "openTag") {
+      state.tagName = tagName;
+      state.tagStart = stream.column();
+      return attrState;
+    } else if (type == "closeTag") {
+      var err = false;
+      if (state.context) {
+        if (state.context.tagName != tagName) {
+          if (Kludges.implicitlyClosed.hasOwnProperty(state.context.tagName.toLowerCase()))
+            popContext(state);
+          err = !state.context || state.context.tagName != tagName;
+        }
+      } else {
+        err = true;
+      }
+      if (err) setStyle = "error";
+      return err ? closeStateErr : closeState;
+    } else {
+      return baseState;
+    }
+  }
+  function closeState(type, _stream, state) {
+    if (type != "endTag") {
+      setStyle = "error";
+      return closeState;
+    }
+    popContext(state);
+    return baseState;
+  }
+  function closeStateErr(type, stream, state) {
+    setStyle = "error";
+    return closeState(type, stream, state);
+  }
+
+  function attrState(type, _stream, state) {
+    if (type == "word") {
+      setStyle = "attribute";
+      return attrEqState;
+    } else if (type == "endTag" || type == "selfcloseTag") {
+      var tagName = state.tagName, tagStart = state.tagStart;
+      state.tagName = state.tagStart = null;
+      if (type == "selfcloseTag" ||
+          Kludges.autoSelfClosers.hasOwnProperty(tagName.toLowerCase())) {
+        maybePopContext(state, tagName.toLowerCase());
+      } else {
+        maybePopContext(state, tagName.toLowerCase());
+        state.context = new Context(state, tagName, tagStart == state.indented);
+      }
+      return baseState;
+    }
+    setStyle = "error";
+    return attrState;
+  }
+  function attrEqState(type, stream, state) {
+    if (type == "equals") return attrValueState;
+    if (!Kludges.allowMissing) setStyle = "error";
+    return attrState(type, stream, state);
+  }
+  function attrValueState(type, stream, state) {
+    if (type == "string") return attrContinuedState;
+    if (type == "word" && Kludges.allowUnquoted) {setStyle = "string"; return attrState;}
+    setStyle = "error";
+    return attrState(type, stream, state);
+  }
+  function attrContinuedState(type, stream, state) {
+    if (type == "string") return attrContinuedState;
+    return attrState(type, stream, state);
+  }
+
+  return {
+    startState: function() {
+      return {tokenize: inText,
+              state: baseState,
+              indented: 0,
+              tagName: null, tagStart: null,
+              context: null};
+    },
+
+    token: function(stream, state) {
+      if (!state.tagName && stream.sol())
+        state.indented = stream.indentation();
+
+      if (stream.eatSpace()) return null;
+      tagName = type = null;
+      var style = state.tokenize(stream, state);
+      if ((style || type) && style != "comment") {
+        setStyle = null;
+        state.state = state.state(type || style, stream, state);
+        if (setStyle)
+          style = setStyle == "error" ? style + " error" : setStyle;
+      }
+      return style;
+    },
+
+    indent: function(state, textAfter, fullLine) {
+      var context = state.context;
+      // Indent multi-line strings (e.g. css).
+      if (state.tokenize.isInAttribute) {
+        return state.stringStartCol + 1;
+      }
+      if (context && context.noIndent) return CodeMirror.Pass;
+      if (state.tokenize != inTag && state.tokenize != inText)
+        return fullLine ? fullLine.match(/^(\s*)/)[0].length : 0;
+      // Indent the starts of attribute names.
+      if (state.tagName) {
+        if (multilineTagIndentPastTag)
+          return state.tagStart + state.tagName.length + 2;
+        else
+          return state.tagStart + indentUnit * multilineTagIndentFactor;
+      }
+      if (alignCDATA && /<!\[CDATA\[/.test(textAfter)) return 0;
+      if (context && /^<\//.test(textAfter))
+        context = context.prev;
+      while (context && !context.startOfLine)
+        context = context.prev;
+      if (context) return context.indent + indentUnit;
+      else return 0;
+    },
+
+    electricChars: "/",
+    blockCommentStart: "<!--",
+    blockCommentEnd: "-->",
+
+    configuration: parserConfig.htmlMode ? "html" : "xml",
+    helperType: parserConfig.htmlMode ? "html" : "xml"
+  };
+});
+
+CodeMirror.defineMIME("text/xml", "xml");
+CodeMirror.defineMIME("application/xml", "xml");
+if (!CodeMirror.mimeModes.hasOwnProperty("text/html"))
+  CodeMirror.defineMIME("text/html", {name: "xml", htmlMode: true});

data/vendor/assets/javascripts/codemirror/yaml.js

@@ -0,0 +1,97 @@
+CodeMirror.defineMode("yaml", function() {
+
+  var cons = ['true', 'false', 'on', 'off', 'yes', 'no'];
+  var keywordRegex = new RegExp("\\b(("+cons.join(")|(")+"))$", 'i');
+
+  return {
+    token: function(stream, state) {
+      var ch = stream.peek();
+      var esc = state.escaped;
+      state.escaped = false;
+      /* comments */
+      if (ch == "#" && (stream.pos == 0 || /\s/.test(stream.string.charAt(stream.pos - 1)))) {
+        stream.skipToEnd(); return "comment";
+      }
+      if (state.literal && stream.indentation() > state.keyCol) {
+        stream.skipToEnd(); return "string";
+      } else if (state.literal) { state.literal = false; }
+      if (stream.sol()) {
+        state.keyCol = 0;
+        state.pair = false;
+        state.pairStart = false;
+        /* document start */
+        if(stream.match(/---/)) { return "def"; }
+        /* document end */
+        if (stream.match(/\.\.\./)) { return "def"; }
+        /* array list item */
+        if (stream.match(/\s*-\s+/)) { return 'meta'; }
+      }
+      /* inline pairs/lists */
+      if (stream.match(/^(\{|\}|\[|\])/)) {
+        if (ch == '{')
+          state.inlinePairs++;
+        else if (ch == '}')
+          state.inlinePairs--;
+        else if (ch == '[')
+          state.inlineList++;
+        else
+          state.inlineList--;
+        return 'meta';
+      }
+
+      /* list seperator */
+      if (state.inlineList > 0 && !esc && ch == ',') {
+        stream.next();
+        return 'meta';
+      }
+      /* pairs seperator */
+      if (state.inlinePairs > 0 && !esc && ch == ',') {
+        state.keyCol = 0;
+        state.pair = false;
+        state.pairStart = false;
+        stream.next();
+        return 'meta';
+      }
+
+      /* start of value of a pair */
+      if (state.pairStart) {
+        /* block literals */
+        if (stream.match(/^\s*(\||\>)\s*/)) { state.literal = true; return 'meta'; };
+        /* references */
+        if (stream.match(/^\s*(\&|\*)[a-z0-9\._-]+\b/i)) { return 'variable-2'; }
+        /* numbers */
+        if (state.inlinePairs == 0 && stream.match(/^\s*-?[0-9\.\,]+\s?$/)) { return 'number'; }
+        if (state.inlinePairs > 0 && stream.match(/^\s*-?[0-9\.\,]+\s?(?=(,|}))/)) { return 'number'; }
+        /* keywords */
+        if (stream.match(keywordRegex)) { return 'keyword'; }
+      }
+
+      /* pairs (associative arrays) -> key */
+      if (!state.pair && stream.match(/^\s*\S+(?=\s*:($|\s))/i)) {
+        state.pair = true;
+        state.keyCol = stream.indentation();
+        return "atom";
+      }
+      if (state.pair && stream.match(/^:\s*/)) { state.pairStart = true; return 'meta'; }
+
+      /* nothing found, continue */
+      state.pairStart = false;
+      state.escaped = (ch == '\\');
+      stream.next();
+      return null;
+    },
+    startState: function() {
+      return {
+        pair: false,
+        pairStart: false,
+        keyCol: 0,
+        inlinePairs: 0,
+        inlineList: 0,
+        literal: false,
+        escaped: false
+      };
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/x-yaml", "yaml");

data/vendor/assets/javascripts/inline-attach.js

@@ -0,0 +1,336 @@
+/*jslint newcap: true */
+/*global XMLHttpRequest: false, inlineAttach: false, FormData: false */
+/*
+ * Inline Text Attachment
+ *
+ * Author: Roy van Kaathoven
+ * Contact: ik@royvankaathoven.nl
+ */
+(function(document, window) {
+    "use strict";
+
+    /**
+     * Simple function to merge the given objects
+     *
+     * @param {Object[]} object Multiple object parameters
+     * @returns {Object}
+     */
+    function merge() {
+        var result = {};
+        for (var i = arguments.length - 1; i >= 0; i--) {
+            var obj = arguments[i];
+            for (var k in obj) {
+                result[k] = obj[k];
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @param {Object} options
+     */
+    window.inlineAttach = function(options, instance) {
+
+        var settings = merge(options, inlineAttach.defaults),
+            editor = instance,
+            filenameTag = '{filename}',
+            lastValue,
+            me = this;
+
+        /**
+         * Upload a given file blob
+         *
+         * @param {Blob} file
+         */
+        this.uploadFile = function(file) {
+            var formData = new FormData(),
+                xhr = new XMLHttpRequest(),
+                extension = 'png';
+
+            // Attach the file. If coming from clipboard, add a default filename (only works in Chrome for now)
+            // http://stackoverflow.com/questions/6664967/how-to-give-a-blob-uploaded-as-formdata-a-file-name
+            if (file.name) {
+                var fileNameMatches = file.name.match(/\.(.+)$/);
+                if (fileNameMatches) {
+                    extension = fileNameMatches[1];
+                }
+            }
+            formData.append(settings.uploadFieldName, file, "image-" + Date.now() + "." + extension);
+
+            // Add any available extra parameters
+            if (typeof settings.extraParams === "object") {
+                for (var key in settings.extraParams) {
+                    if (settings.extraParams.hasOwnProperty(key)) {
+                        formData.append(key, settings.extraParams[key]);
+                    }
+                }
+            }
+
+            xhr.open('POST', settings.uploadUrl);
+            xhr.onload = function() {
+                // If HTTP status is OK or Created
+                if (xhr.status === 200 || xhr.status === 201) {
+                    var data = JSON.parse(xhr.responseText);
+                    me.onUploadedFile(data);
+                } else {
+                    me.onErrorUploading();
+                }
+            };
+            xhr.send(formData);
+        };
+
+        /**
+         * Check if the given file is allowed
+         *
+         * @param {File} file
+         */
+        this.isAllowedFile = function(file) {
+            return settings.allowedTypes.indexOf(file.type) >= 0;
+        };
+
+        /**
+         * When a file has finished uploading
+         *
+         * @param {Object} data
+         */
+        this.onUploadedFile = function(data) {
+            var result = settings.onUploadedFile(data),
+                filename = data[settings.downloadFieldName];
+            if (result !== false && filename) {
+                var text = editor.getValue().replace(lastValue, settings.urlText.replace(filenameTag, filename));
+                editor.setValue(text);
+            }
+        };
+
+        /**
+         * Custom upload handler
+         *
+         * @param {Blob} file
+         * @return {Boolean} when false is returned it will prevent default upload behavior
+         */
+        this.customUploadHandler = function(file) {
+            return settings.customUploadHandler(file);
+        };
+
+        /**
+         * When a file didn't upload properly.
+         * Override by passing your own onErrorUploading function with settings.
+         *
+         * @param {Object} data
+         */
+        this.onErrorUploading = function() {
+            var text = editor.getValue().replace(lastValue, "");
+            editor.setValue(text);
+            if (settings.customErrorHandler()) {
+                window.alert(settings.errorText);
+            }
+        };
+
+        /**
+         * Append a line of text at the bottom, ensuring there aren't unnecessary newlines
+         *
+         * @param {String} appended Current content
+         * @param {String} previous Value which should be appended after the current content
+         */
+        function appendInItsOwnLine(previous, appended) {
+            return (previous + "\n\n[[D]]" + appended)
+                .replace(/(\n{2,})\[\[D\]\]/, "\n\n")
+                .replace(/^(\n*)/, "");
+        }
+
+        /**
+         * When a file has been received by a drop or paste event
+         * @param {Blob} file
+         */
+        this.onReceivedFile = function(file) {
+            var result = settings.onReceivedFile(file);
+            if (result !== false) {
+                lastValue = settings.progressText;
+                editor.setValue(appendInItsOwnLine(editor.getValue(), lastValue));
+            }
+        };
+
+        /**
+         * Catches the paste event
+         *
+         * @param {Event} e
+         * @returns {Boolean} If a file is handled
+         */
+        this.onPaste = function(e) {
+            var result = false,
+                clipboardData = e.clipboardData,
+                items;
+
+            if (typeof clipboardData === "object") {
+
+                items = clipboardData.items || clipboardData.files || [];
+
+                for (var i = 0; i < items.length; i++) {
+                    var item = items[i];
+                    if (me.isAllowedFile(item)) {
+                        result = true;
+                        this.onReceivedFile(item.getAsFile());
+                        if (this.customUploadHandler(item.getAsFile())) {
+                            this.uploadFile(item.getAsFile());
+                        }
+                    }
+                }
+            }
+
+
+            return result;
+        };
+
+        /**
+         * Catches onDrop event
+         *
+         * @param {Event} e
+         * @returns {Boolean} If a file is handled
+         */
+        this.onDrop = function(e) {
+            var result = false;
+            for (var i = 0; i < e.dataTransfer.files.length; i++) {
+                var file = e.dataTransfer.files[i];
+                if (me.isAllowedFile(file)) {
+                    result = true;
+                    this.onReceivedFile(file);
+                    if (this.customUploadHandler(file)) {
+                        this.uploadFile(file);
+                    }
+                }
+            }
+
+            return result;
+        };
+    };
+
+    /**
+     * Editor
+     */
+    window.inlineAttach.Editor = function(instance) {
+
+        var input = instance;
+
+        return {
+            getValue: function() {
+                return input.value;
+            },
+            setValue: function(val) {
+                input.value = val;
+            }
+        };
+    };
+
+    /**
+     * Default configuration
+     */
+    window.inlineAttach.defaults = {
+        /**
+         * URL to upload the attachment
+         */
+        uploadUrl: 'upload_attachment.php',
+
+        /**
+         * Request field name where the attachment will be placed in the form data
+         */
+        uploadFieldName: 'file',
+
+        /**
+         * Where is the filename placed in the response
+         */
+        downloadFieldName: 'filename',
+
+        /**
+         * Allowed types
+         */
+        allowedTypes: [
+            'image/jpeg',
+            'image/png',
+            'image/jpg',
+            'image/gif'
+        ],
+
+        /**
+         * Will be inserted on a drop or paste event
+         */
+        progressText: '![Uploading file...]()',
+
+        /**
+         * When a file has successfully been uploaded the last inserted text
+         * will be replaced by the urlText, the {filename} tag will be replaced
+         * by the filename that has been returned by the server
+         */
+        urlText: "![file]({filename})",
+
+        /**
+         * Text for default error when uploading
+         */
+        errorText: "Error uploading file",
+
+        /**
+         * Extra parameters which will be send when uploading a file
+         */
+        extraParams: {},
+
+        /**
+         * When a file is received by drag-drop or paste
+         */
+        onReceivedFile: function() {},
+
+        /**
+         * Custom upload handler
+         *
+         * @return {Boolean} when false is returned it will prevent default upload behavior
+         */
+        customUploadHandler: function() {
+            return true;
+        },
+
+        /**
+         * Custom error handler. Runs after removing the placeholder text and before the alert().
+         * Return false from this function to prevent the alert dialog.
+         *
+         * @return {Boolean} when false is returned it will prevent default error behavior
+         */
+        customErrorHandler: function() {
+            return true;
+        },
+
+        /**
+         * When a file has succesfully been uploaded
+         */
+        onUploadedFile: function() {}
+    };
+
+    /**
+     * Attach to a standard input field
+     *
+     * @param {Input} input
+     * @param {Object} options
+     */
+    window.inlineAttach.attachToInput = function(input, options) {
+
+        options = options || {};
+
+        var editor = new inlineAttach.Editor(input),
+            inlineattach = new inlineAttach(options, editor);
+
+        input.addEventListener('paste', function(e) {
+            inlineattach.onPaste(e);
+        }, false);
+        input.addEventListener('drop', function(e) {
+            e.stopPropagation();
+            e.preventDefault();
+            inlineattach.onDrop(e);
+        }, false);
+        input.addEventListener('dragenter', function(e) {
+            e.stopPropagation();
+            e.preventDefault();
+        }, false);
+        input.addEventListener('dragover', function(e) {
+            e.stopPropagation();
+            e.preventDefault();
+        }, false);
+    };
+
+})(document, window);