written 0.0.2

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

@@ -0,0 +1,12 @@
+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)
+
+Written.Parsers.Inline.register Strong, /((\*{2})[^\*]+(\*{2}))/gi

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

@@ -0,0 +1,98 @@
+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)
+
+
+  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
+  constructor: ->
+    @parsers = []
+
+  freeze: ->
+    Object.freeze(this)
+    Object.freeze(@parsers)
+
+
+  register: (parser, rule) ->
+    @parsers.push {
+      rule: rule,
+      parser: parser
+    }
+
+  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
+

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

@@ -0,0 +1,4 @@
+#= require_tree ./vendors
+#= require_tree ./written/core
+#= require_tree ./written/extensions
+#= require_tree ./written/parsers

data/lib/written/app/assets/stylesheets/vendors/prism.css

@@ -0,0 +1,138 @@
+/* http://prismjs.com/download.html?themes=prism&languages=markup+css+clike+javascript+apacheconf+bash+c+csharp+cpp+ruby+git+go+haml+http+java+nginx+objectivec+php+python+scss */
+/**
+ * prism.js default theme for JavaScript, CSS and HTML
+ * Based on dabblet (http://dabblet.com)
+ * @author Lea Verou
+ */
+
+code[class*="language-"],
+pre[class*="language-"] {
+	color: black;
+	text-shadow: 0 1px white;
+	font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
+	direction: ltr;
+	text-align: left;
+	white-space: pre;
+	word-spacing: normal;
+	word-break: normal;
+	word-wrap: normal;
+	line-height: 1.5;
+
+	-moz-tab-size: 4;
+	-o-tab-size: 4;
+	tab-size: 4;
+
+	-webkit-hyphens: none;
+	-moz-hyphens: none;
+	-ms-hyphens: none;
+	hyphens: none;
+}
+
+pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
+code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
+	text-shadow: none;
+	background: #b3d4fc;
+}
+
+pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
+code[class*="language-"]::selection, code[class*="language-"] ::selection {
+	text-shadow: none;
+	background: #b3d4fc;
+}
+
+@media print {
+	code[class*="language-"],
+	pre[class*="language-"] {
+		text-shadow: none;
+	}
+}
+
+/* Code blocks */
+pre[class*="language-"] {
+	padding: 1em;
+	margin: .5em 0;
+	overflow: auto;
+}
+
+:not(pre) > code[class*="language-"],
+pre[class*="language-"] {
+	background: #f5f2f0;
+}
+
+/* Inline code */
+:not(pre) > code[class*="language-"] {
+	padding: .1em;
+	border-radius: .3em;
+}
+
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+	color: slategray;
+}
+
+.token.punctuation {
+	color: #999;
+}
+
+.namespace {
+	opacity: .7;
+}
+
+.token.property,
+.token.tag,
+.token.boolean,
+.token.number,
+.token.constant,
+.token.symbol,
+.token.deleted {
+	color: #905;
+}
+
+.token.selector,
+.token.attr-name,
+.token.string,
+.token.char,
+.token.builtin,
+.token.inserted {
+	color: #690;
+}
+
+.token.operator,
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+	color: #a67f59;
+	background: hsla(0, 0%, 100%, .5);
+}
+
+.token.atrule,
+.token.attr-value,
+.token.keyword {
+	color: #07a;
+}
+
+.token.function {
+	color: #DD4A68;
+}
+
+.token.regex,
+.token.important,
+.token.variable {
+	color: #e90;
+}
+
+.token.important,
+.token.bold {
+	font-weight: bold;
+}
+.token.italic {
+	font-style: italic;
+}
+
+.token.entity {
+	cursor: help;
+}
+

data/lib/written/app/assets/stylesheets/written.scss

@@ -0,0 +1,21 @@
+[data-editor="written"] {
+  white-space: pre-wrap;
+
+  p {
+    min-height: 1.2em;
+  }
+
+  h1 {
+    font-size: 3em;
+  }
+
+  ul, li {
+    list-style-type: none;
+  }
+
+  figure {
+    background: gray;
+    img {
+    }
+  }
+}

data/lib/written/document.rb

@@ -0,0 +1,42 @@
+require 'written/parsers'
+require 'written/node'
+
+module Written
+  class Document
+
+    attr_reader :nodes
+
+    def initialize(content)
+      @nodes = content.lines.map do |text|
+        Node.new(text.chomp)
+      end
+    end
+
+    def parsers
+      [
+        Written::Parsers::Code,
+        Written::Parsers::Heading,
+        Written::Parsers::Image,
+        Written::Parsers::List,
+        Written::Parsers::Word,
+        Written::Parsers::Link
+      ]
+    end
+
+    def parse!
+      parsers.each do |parser|
+        parser.parse!(self)
+      end
+    end
+
+    def to_html
+      @nodes.map do |node|
+        if node.instance_of?(Written::Node)
+          "<p>#{node.to_s}</p>"
+        else
+          node.to_s
+        end
+      end.join
+    end
+  end
+end

data/lib/written/node.rb

@@ -0,0 +1,21 @@
+module Written
+  module Nodes
+    autoload :Image,                   'written/nodes/image'
+    autoload :UnorderedList,           'written/nodes/unordered_list'
+    autoload :OrderedList,             'written/nodes/ordered_list'
+    autoload :Code,                    'written/nodes/code'
+    autoload :Heading,                 'written/nodes/heading'
+  end
+
+  class Node
+    attr_accessor :content
+
+    def initialize(content)
+      @content = content || String.new
+    end
+
+    def to_s
+      @content
+    end
+  end
+end

data/lib/written/nodes/code.rb

@@ -0,0 +1,65 @@
+require 'cgi'
+
+module Written
+  module Nodes
+    class Code < Node
+
+      attr_reader :offset
+
+      attr_accessor :title, :block
+
+      def initialize(data)
+
+        @offset = data.offset(0)[0]
+        @language = (data[3] || "").strip
+        @block = nil
+        @title = nil
+
+        @content = data[4]
+
+      end
+
+      def block?
+        @block == true
+      end
+
+      def content=(new_content)
+        if new_content.is_a?(Array)
+          @content = CGI::escapeHTML(new_content.join("\n"))
+        else
+          @content = new_content
+        end
+      end
+
+      def code_element
+        str = "<code"
+
+        unless @language.nil?
+          str << " class='language-#{@language}'>"
+        end
+
+        str << @content
+        str << "</code>"
+        str
+      end
+
+      def to_s
+
+        str = String.new
+
+        unless @title.nil?
+          str << "<header>#{@title}</header>"
+        end
+
+        str << code_element
+
+        if block?
+          return "<pre>#{str}</pre>"
+        else
+          return str
+        end
+      end
+    end
+  end
+end
+

data/lib/written/nodes/heading.rb

@@ -0,0 +1,15 @@
+module Written
+  module Nodes
+    class Heading < Node
+      def initialize(size, content)
+        @size = size
+        @content = content
+      end
+
+      def to_s
+        "<h#{@size}>#{@content}</h#{@size}>"
+      end
+    end
+  end
+end
+

data/lib/written/nodes/image.rb

@@ -0,0 +1,14 @@
+module Written
+  module Nodes
+    class Image < Node
+      def initialize(title, src)
+        @title = title
+        @src = src
+      end
+
+      def to_s
+        "<figure><img src='#{@src}' /><figcaption>#{@title}</figcaption></figure>"
+      end
+    end
+  end
+end

data/lib/written/nodes/ordered_list.rb

@@ -0,0 +1,18 @@
+module Written
+  module Nodes
+    class OrderedList < Node
+
+      def initialize(text)
+        @content = "<li>#{text}</li>"
+      end
+
+      def append(text)
+        @content << "<li>#{text}</li>"
+      end
+
+      def to_s
+        "<ol>#{@content}</ol>"
+      end
+    end
+  end
+end

data/lib/written/nodes/unordered_list.rb

@@ -0,0 +1,19 @@
+module Written
+  module Nodes
+    class UnorderedList < Node
+
+      def initialize(text)
+        @content = "<li>#{text}</li>"
+      end
+
+      def append(text)
+        @content << "<li>#{text}</li>"
+      end
+
+      def to_s
+        "<ul>#{@content}</ul>"
+      end
+    end
+  end
+end
+

data/lib/written/parsers/base.rb

@@ -0,0 +1,26 @@
+module Written::Parsers
+  class Base
+    class << self
+      private :new
+    end
+
+    def self.parse!(document)
+      i = 0
+      while !document.nodes[i].nil? do
+        node = new(document, document.nodes[i], i).parse!
+        i = document.nodes.index(node) + 1
+      end
+    end
+
+    def initialize(document, node, index)
+      @document = document
+      @node = node
+      @index = index
+    end
+
+    def parse!
+      return @node
+    end
+
+  end
+end

data/lib/written/parsers/code.rb

@@ -0,0 +1,60 @@
+module Written::Parsers
+  class Code < Base
+    OPENING_TAG = /((~{3,})([a-z]+)?)(.+)?/i
+    attr_accessor :open
+
+    def parse!
+
+      unless @node.instance_of?(Written::Node)
+        return @node
+      end
+
+      while m = OPENING_TAG.match(@node.content)
+        node = Written::Nodes::Code.new(m) 
+        @node.content.slice!(m.offset(1)[0], m[1].size)
+        close(node, m[2].size)
+      end
+
+      return @node
+    end
+
+    def close(node, tildeCount)
+      regex = Regexp.new("(~{#{tildeCount},})", Regexp::IGNORECASE)
+
+      if match = regex.match(node.content)
+        @node.content.slice!(node.offset, match.offset(1)[1])
+        node.content.slice!(match.offset(0)[0], node.content.length - match.offset(0)[0])
+        node.content.lstrip!
+        @node.content.insert(node.offset, node.to_s)
+
+      elsif node.offset == 0
+        extract_siblings(node, regex)
+        @node = node
+      end
+    end
+
+    def extract_siblings(node, regex)
+      i = @index + 1
+      nodes = []
+      node.title = (node.content || "").strip
+
+      while !(n = @document.nodes[i]).nil?
+        match = regex.match(n.content)
+        @document.nodes.delete_at(i)
+        if match.nil?
+          nodes.push n
+        else
+          break
+        end
+      end
+
+      node.content = nodes
+      node.block = true
+
+      @document.nodes[@index] = node
+
+      return node
+    end
+
+  end
+end

data/lib/written/parsers/heading.rb

@@ -0,0 +1,19 @@
+module Written::Parsers
+  class Heading < Base
+    RULE = /^(\#{1,6} )(.+)/i
+
+    def parse!
+
+      unless @node.instance_of?(Written::Node)
+        return @node
+      end
+
+      if match = RULE.match(@node.content)
+        size = match[1].length - 1
+        @node = Written::Nodes::Heading.new(size, match[2])
+        @document.nodes[@index] = @node
+      end
+      return @node
+    end
+  end
+end

data/lib/written/parsers/image.rb

@@ -0,0 +1,19 @@
+module Written::Parsers
+  class Image < Base
+    RULE = /^(!{1}\[([^\]]+)\])(\(([^\s]+)?\))$/i
+
+    def parse!
+
+      unless @node.instance_of?(Written::Node)
+        return @node
+      end
+
+      if match = RULE.match(@node.content)
+        @node = Written::Nodes::Image.new(match[2], match[4])
+        @document.nodes[@index] = @node
+      end
+      return @node
+    end
+  end
+end
+

data/lib/written/parsers/link.rb

@@ -0,0 +1,12 @@
+module Written::Parsers
+  class Link < Base
+    RULE = /!{0}(\[([^\]]+)\])(\(([^\)]+)\))/i
+
+    def parse!
+      while match = RULE.match(@node.content) do
+        @node.content.gsub! match[0], "<a href='#{match[4]}'>#{match[2]}</a>"
+      end
+      return @node
+    end
+  end
+end

data/lib/written/parsers/list.rb

@@ -0,0 +1,33 @@
+module Written::Parsers
+  class List < Base
+    UL = /^(-\s)(.+)?$/i
+    OL = /^(\d+\.\s)(.+)?$/i
+
+    def parse!
+
+      unless @node.instance_of?(Written::Node)
+        return @node
+      end
+
+      if match = UL.match(@node.content)
+        list! match, Written::Nodes::UnorderedList
+      elsif match = OL.match(@node.content)
+        list! match, Written::Nodes::OrderedList
+      end
+      return @node
+    end
+
+    def list!(match, tag)
+      previous_node = @document.nodes[@index - 1]
+      if previous_node.nil? || !previous_node.instance_of?(tag)
+        @node = tag.new(match[2])
+        @document.nodes[@index] = @node
+      else
+        @index -= 1
+        @document.nodes.delete(@node)
+        previous_node.append(match[2])
+        @node = previous_node
+      end
+    end
+  end
+end

data/lib/written/parsers/word.rb

@@ -0,0 +1,16 @@
+module Written::Parsers
+  class Word < Base
+    RULE = /((\*{1,2})([^\*]+)(\*{1,2}))/i
+
+    def parse!
+      while match = RULE.match(@node.content) do
+        if match[2].length == 1
+          @node.content.gsub! match[0], "<em>#{match[3]}</em>"
+        elsif match[2].length == 2
+          @node.content.gsub! match[0], "<strong>#{match[3]}</strong>"
+        end
+      end
+      return @node
+    end
+  end
+end

data/lib/written/parsers.rb

@@ -0,0 +1,11 @@
+module Written
+  module Parsers
+    autoload :Base,       'written/parsers/base'
+    autoload :Word,       'written/parsers/word'
+    autoload :List,       'written/parsers/list'
+    autoload :Image,      'written/parsers/image'
+    autoload :Code,       'written/parsers/code'
+    autoload :Heading,    'written/parsers/heading'
+    autoload :Link,       'written/parsers/link'
+  end
+end