written 0.0.5 → 0.1.1

data/lib/written/app/assets/javascripts/written/parsers/inline/link.coffee

@@ -1,16 +1,46 @@
 class Link
   constructor: (match) ->
     @match = match
-    @node = "<a>".toHTML()
-
-  render: (textNode) =>
-    @node.href = @match[4]
-    name = "<strong>".toHTML()
-    anchor = textNode.splitText(textNode.textContent.indexOf(@match[0]))
-    anchor.splitText(@match[0].length)
-    name.textContent = @match[1]
-    @node.appendChild(name)
-    @node.appendChild(document.createTextNode(@match[3]))
-    textNode.parentElement.replaceChild(@node, anchor)
-
-Written.Parsers.Inline.register Link, /!{0}(\[([^\]]+)\])(\(([^\)]+)\))/gi
+
+  index: =>
+    @match.index 
+
+  length: =>
+    @match[0].length
+
+  markdown: =>
+    "<a is='written-a' href='javascript:void(0)'><strong>#{@match[1]}</strong>#{@match[3]}</a>".toHTML()
+
+  html: =>
+    "<a href='#{@match[4]}'>#{@match[2]}</a>".toHTML()
+
+Link.rule = /!{0}(\[([^\]]+)\])(\(([^\)]+)\))/gi
+
+Written.Parsers.Inline.register Link
+
+prototype = Object.create(HTMLAnchorElement.prototype)
+
+prototype.getRange = (offset, walker) ->
+  range = document.createRange()
+
+  if !@firstChild?
+    range.setStart(this, 0)
+  else
+    while walker.nextNode()
+      if walker.currentNode.length < offset
+        offset -= walker.currentNode.length
+        continue
+
+      range.setStart(walker.currentNode, offset)
+      break
+
+  range.collapse(true)
+  range
+
+prototype.toString = ->
+  @textContent
+
+document.registerElement('written-a', {
+  prototype: prototype
+  extends: 'a'
+})

data/lib/written/app/assets/javascripts/written/parsers/inline/list.coffee

@@ -0,0 +1,27 @@
+prototype = Object.create(HTMLLIElement.prototype)
+
+prototype.getRange = (offset, walker) ->
+  range = document.createRange()
+
+  if !@firstChild?
+    range.setStart(this, 0)
+  else
+    while walker.nextNode()
+      if walker.currentNode.length < offset
+        offset -= walker.currentNode.length
+        continue
+
+      range.setStart(walker.currentNode, offset)
+      break
+
+  range.collapse(true)
+  range
+
+prototype.toString = ->
+  @textContent
+
+document.registerElement('written-li', {
+  prototype: prototype
+  extends: 'li'
+})
+

data/lib/written/app/assets/javascripts/written/parsers/inline/strong.coffee

@@ -1,12 +1,46 @@
 class Strong
   constructor: (match) ->
     @match = match
-    @node = "<strong>".toHTML()
 
-  render: (textNode) =>
-    strong = textNode.splitText(textNode.textContent.indexOf(@match[0]))
-    strong.splitText(@match[0].length)
-    @node.appendChild(document.createTextNode(@match[0]))
-    textNode.parentElement.replaceChild(@node, strong)
+  index: =>
+    @match.index
 
-Written.Parsers.Inline.register Strong, /((\*{2})[^\*]+(\*{2}))/gi
+  length: =>
+    @match[0].length
+
+  markdown: =>
+    "<strong is='written-strong'>#{@match[0]}</strong>".toHTML()
+
+  html: =>
+    "<strong>#{@match[3]}</strong>".toHTML()
+
+Strong.rule = /((\*{1})([^\*]+)(\*{1}))/gi
+
+Written.Parsers.Inline.register Strong
+
+prototype = Object.create(HTMLElement.prototype)
+
+prototype.getRange = (offset, walker) ->
+  range = document.createRange()
+
+  if !@firstChild?
+    range.setStart(this, 0)
+  else
+    while walker.nextNode()
+      if walker.currentNode.length < offset
+        offset -= walker.currentNode.length
+        continue
+
+      range.setStart(walker.currentNode, offset)
+      break
+
+  range.collapse(true)
+  range
+
+prototype.toString = ->
+  @textContent
+
+document.registerElement('written-strong', {
+  prototype: prototype
+  extends: 'strong'
+})

data/lib/written/app/assets/javascripts/written/parsers/parsers.coffee

@@ -1,113 +1,27 @@
-Written.Parsers = {
-  freeze: ->
-    Written.Parsers.Block.freeze()
-    Written.Parsers.Inline.freeze()
-}
-
-Written.Parsers.Block = new class
-  constructor: ->
-    @parsers = []
-
-  freeze: ->
-    @parsers.push this.defaultParser
-
-    Object.freeze(this)
-    Object.freeze(@parsers)
-
-  get: (name) ->
-    parser = @parsers.find (parser) ->
-      parser.parser.name.localeCompare(name) == 0
-
-    if parser
-      parser.parser
-
-
-
-  register: (parser, rule, defaultParser = false) ->
-    if defaultParser
-      this.defaultParser = {
-        rule: rule,
-        parser: parser
-      }
-    else
-      @parsers.push {
-        rule: rule,
-        parser: parser
-      }
-
-  parse: (lines) =>
-    elements = []
-    currentNode = undefined
-    while (line = lines.pop()) != undefined
-      str = line.toString()
-      if !currentNode
-        parser = @find(str)
-        currentNode = parser.render(str)
-        elements.push(currentNode)
-        continue
-
-      if currentNode.dataset.status != 'opened'
-        parser = @find(str)
-        currentNode.nextDocumentNode = parser.render(str)
-        currentNode = currentNode.nextDocumentNode
-        currentNode.writtenNodeParser = parser
-        elements.push(currentNode)
-        continue
-      else if currentNode.writtenNodeParser.valid(str)
-        currentNode.writtenNodeParser.render(str)
-        continue
-      else
-        parser = @find(str)
-        currentNode.nextDocumentNode = parser.render(str)
-        currentNode = currentNode.nextDocumentNode
-        currentNode.writtenNodeParser = parser
-        elements.push(currentNode)
-
-    elements[0]
-
-  find: (str) ->
-    parser = undefined
-    for p in @parsers
-      if match = p.rule.exec(str)
-        parser = new p.parser(match)
-        break
-
-    return parser
-
-
-Written.Parsers.Inline = new class
+class @Written.Parsers
   constructor: ->
-    @parsers = []
-
-  freeze: ->
-    Object.freeze(this)
-    Object.freeze(@parsers)
+    @block = new Written.Parsers.Block()
+    @inline = new Written.Parsers.Inline()
 
-  get: (name) ->
-    parser = @parsers.find (parser) ->
-      parser.parser.name.localeCompare(name) == 0
+  use: (type, name) ->
+    if type != 'block' && type != 'inline'
+      raise 'error: Written.Parsers can either be "block" or "inline"'
+      return
 
-    if parser
-      parser.parser
+    @[type].use(name)
 
-
-  register: (parser, rule) ->
-    @parsers.push {
-      rule: rule,
-      parser: parser
+  available: ->
+    {
+      block: Written.Parsers.Block.parsers.available,
+      inline: Written.Parsers.Inline.parsers.available
     }
 
-  parse: (block) =>
-    walker = document.createTreeWalker(block, NodeFilter.SHOW_TEXT)
-    for p in @parsers
-      walker.currentNode = walker.root
-
-      while walker.nextNode()
-        if match = p.rule.exec(walker.currentNode.textContent)
-          new p.parser(match).render(walker.currentNode)
-
-
-  isLeafNode: (node) ->
-    if node.children.length == 0
-      return NodeFilter.FILTER_ACCEPT
-
+  freeze: ->
+    @block.freeze()
+    @inline.freeze()
+
+@Written.Parsers.default = ->
+  parsers = new Written.Parsers()
+  parsers.use('inline', 'all')
+  parsers.use('block', 'all')
+  parsers

data/lib/written/app/assets/javascripts/written/polyfills/CustomElements/CustomElements.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+(function() {
+
+// Establish polyfill scope. We do this here to store flags. Flags are not
+// supported in the build.
+window.CustomElements = window.CustomElements || {flags:{}};
+
+// Flags. Convert url arguments to flags
+var flags = {};
+if (!flags.noOpts) {
+  location.search.slice(1).split('&').forEach(function(option) {
+    var parts = option.split('=');
+    var match;
+    if (parts[0] && (match = parts[0].match(/wc-(.+)/))) {
+      flags[match[1]] = parts[1] || true;
+    }
+  });
+}
+
+
+// exports
+window.CustomElements.flags = flags;
+
+})();

data/lib/written/app/assets/javascripts/written/polyfills/CustomElements/base.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+window.CustomElements = window.CustomElements || {flags:{}};
+
+(function(scope) {
+
+// imports
+var flags = scope.flags;
+
+// world's simplest module initializer
+var modules = [];
+var addModule = function(module) {
+	modules.push(module);
+};
+
+var initializeModules = function() {
+	modules.forEach(function(module) {
+		module(scope);
+	});
+};
+
+// exports
+scope.addModule = addModule;
+scope.initializeModules = initializeModules;
+scope.hasNative = Boolean(document.registerElement);
+scope.isIE = /Trident/.test(navigator.userAgent);
+
+// NOTE: For consistent timing, use native custom elements only when not
+// polyfilling other key related web components features.
+scope.useNative = !flags.register && scope.hasNative &&
+		!window.ShadowDOMPolyfill && (!window.HTMLImports || window.HTMLImports.useNative);
+
+})(window.CustomElements);

data/lib/written/app/assets/javascripts/written/polyfills/CustomElements/boot.js

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+ * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+ * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+ * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+ * Code distributed by Google as part of the polymer project is also
+ * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+ */
+(function(scope){
+
+// imports
+var useNative = scope.useNative;
+var initializeModules = scope.initializeModules;
+
+var isIE = scope.isIE;
+
+// If native, setup stub api and bail.
+// NOTE: we fire `WebComponentsReady` under native for api compatibility
+if (useNative) {
+  // stub
+  var nop = function() {};
+
+  // exports
+  scope.watchShadow = nop;
+  scope.upgrade = nop;
+  scope.upgradeAll = nop;
+  scope.upgradeDocumentTree = nop;
+  scope.upgradeSubtree = nop;
+  scope.takeRecords = nop;
+
+  scope.instanceof = function(obj, base) {
+    return obj instanceof base;
+  };
+
+} else {
+  // Initialize polyfill modules. Note, polyfill modules are loaded but not
+  // executed; this is a convenient way to control which modules run when
+  // the polyfill is required and allows the polyfill to load even when it's
+  // not needed.
+  initializeModules();
+}
+
+// imports
+var upgradeDocumentTree = scope.upgradeDocumentTree;
+var upgradeDocument = scope.upgradeDocument;
+
+// ShadowDOM polyfill wraps elements but some elements like `document`
+// cannot be wrapped so we help the polyfill by wrapping some elements.
+if (!window.wrap) {
+  if (window.ShadowDOMPolyfill) {
+    window.wrap = window.ShadowDOMPolyfill.wrapIfNeeded;
+    window.unwrap = window.ShadowDOMPolyfill.unwrapIfNeeded;
+  } else {
+    window.wrap = window.unwrap = function(node) {
+      return node;
+    };
+  }
+}
+
+// eagarly upgrade imported documents
+if (window.HTMLImports) {
+  window.HTMLImports.__importsParsingHook = function(elt) {
+    if (elt.import) {
+      upgradeDocument(wrap(elt.import));
+    }
+  };
+}
+
+// bootstrap parsing
+function bootstrap() {
+  // one more upgrade to catch out of order registrations
+  upgradeDocumentTree(window.wrap(document));
+  // install upgrade hook if HTMLImports are available
+  // set internal 'ready' flag, now document.registerElement will trigger
+  // synchronous upgrades
+  window.CustomElements.ready = true;
+  // async to ensure *native* custom elements upgrade prior to this
+  // DOMContentLoaded can fire before elements upgrade (e.g. when there's
+  // an external script)
+  // Delay doubly to help workaround
+  // https://code.google.com/p/chromium/issues/detail?id=516550.
+  // CustomElements must use requestAnimationFrame in attachedCallback
+  // to query style/layout data. The WebComponentsReady event is intended
+  // to convey overall readiness, which ideally should be after elements
+  // are attached. Adding a slight extra delay to WebComponentsReady
+  // helps preserve this guarantee.
+  var requestAnimationFrame = window.requestAnimationFrame || function(f) {
+    setTimeout(f, 16);
+  };
+  requestAnimationFrame(function() {
+    setTimeout(function() {
+      // capture blunt profiling data
+      window.CustomElements.readyTime = Date.now();
+      if (window.HTMLImports) {
+        window.CustomElements.elapsed = window.CustomElements.readyTime - window.HTMLImports.readyTime;
+      }
+      // notify the system that we are bootstrapped
+      document.dispatchEvent(
+        new CustomEvent('WebComponentsReady', {bubbles: true})
+      );
+    });
+  });
+}
+
+// When loading at readyState complete time (or via flag), boot custom elements
+// immediately.
+// If relevant, HTMLImports must already be loaded.
+if (document.readyState === 'complete' || scope.flags.eager) {
+  bootstrap();
+// When loading at readyState interactive time, bootstrap only if HTMLImports
+// are not pending. Also avoid IE as the semantics of this state are unreliable.
+} else if (document.readyState === 'interactive' && !window.attachEvent &&
+    (!window.HTMLImports || window.HTMLImports.ready)) {
+  bootstrap();
+// When loading at other readyStates, wait for the appropriate DOM event to
+// bootstrap.
+} else {
+  var loadEvent = window.HTMLImports && !window.HTMLImports.ready ?
+      'HTMLImportsLoaded' : 'DOMContentLoaded';
+  window.addEventListener(loadEvent, bootstrap);
+}
+
+})(window.CustomElements);