plate-lang 0.1.0

data/lib/plate/grammar.y

@@ -0,0 +1,145 @@
+class Plate::Parser
+
+token FRONT_MATTER
+token HEADER 
+token NEWLINE TERMINATOR
+token STRING
+token IDENTIFIER
+token INDENT DEDENT
+token P
+token DIV
+token CLASS
+token STYLE SCRIPT ATTRIBUTE
+token HIGHLIGHT
+
+rule
+  Program:
+    /* nothing */                          { result = Nodes.new([]) }
+  | Expressions                            { result = val[0] }
+  ;
+  
+  Expressions:
+    Expression                             { result = Nodes.new(val) }
+  | Expressions Terminator Expression      { result = val[0] << val[2] }
+  | Expressions Terminator                 { result = val[0] }
+  | Terminator                             { result = Nodes.new([]) }
+  ;
+
+  Expression:
+    Literal
+  | FrontMatter
+  | Header
+  | Link 
+  | Image
+  | GetLocal
+  | Paragraph
+  | Div
+  | Class
+  | Style
+  | Script
+  | Attribute
+  | Code
+  ;
+
+  Terminator:
+    NEWLINE
+  | TERMINATOR
+  ;
+
+  FrontMatter:
+    FRONT_MATTER                           { result = FrontMatterNode.new(val[0]) }
+  ;
+  
+  Literal:
+    STRING                                 { result = StringNode.new(val[0]) }
+  ;
+  
+  Header:
+    HEADER Terminator Expression Block     { result = HeaderNode.new(val[0].size, val[2], val[3]) }
+  | HEADER Expression Block                { result = HeaderNode.new(val[0].size, val[1], val[2]) }
+  | HEADER Terminator Expression           { result = HeaderNode.new(val[0].size, val[2], Nodes.new([])) }
+  | HEADER Expression                      { result = HeaderNode.new(val[0].size, val[1], Nodes.new([])) }
+  ;
+
+  Link:
+    "[" LinkContent "]" "(" Expression ")" 
+      Terminator Attributes                { result = LinkNode.new(val[1], val[4], val[7]) }
+  | "[" LinkContent "]" "(" Expression ")" 
+      Terminator                           { result = LinkNode.new(val[1], val[4], []) }
+  | "[" LinkContent "]" "(" Expression ")" { result = LinkNode.new(val[1], val[4], []) }
+  ;
+
+  LinkContent:
+    Terminator Expression                  { result = val[1] }
+  | Expression                             { result = val[0] }
+  ;
+
+  Image:
+    "![" "]" "(" Expression ")" 
+      Terminator Attributes                { result = ImageNode.new(val[3], val[6]) }
+  | "![" "]" "(" Expression ")" 
+      Terminator                           { result = ImageNode.new(val[3], []) }
+  | "![" "]" "(" Expression ")"            { result = ImageNode.new(val[3], []) }
+  ;
+
+  Code:
+    "```" HIGHLIGHT "```"                  { result = HighlightNode.new(val[1]) }
+  ;
+
+  Paragraph:
+    P Block                                { result = ParagraphNode.new(val[1]) }
+  ;
+
+  Div:
+    DIV Block                              { result = DivNode.new(val[1]) }
+  ;
+
+  Class:
+    CLASS Block                            { result = ClassNode.new(val[0], val[1]) }
+  ;
+
+  GetLocal:
+    IDENTIFIER                             { result = GetLocalNode.new(val[0]) }
+  ;
+
+  Block:
+    INDENT Terminator Expressions DEDENT   { result = val[2] }
+  | INDENT Expressions DEDENT              { result = val[1] }
+  ;
+
+  Attributes:
+    "{" "}"                                { result = [] }
+  | "{" AttrList "}"                       { result = val[1] }
+  ;
+
+  AttrList:
+    Expression                             { result = val }
+  | AttrList "," Expression                { result = val[0] << val[2] }
+  ;
+
+  Style:
+    STYLE ":" Expression                   { result = StyleNode.new(val[0], val[2]) }
+  ;
+
+  Script:
+    SCRIPT ":" Expression                  { result = ScriptNode.new(val[0], val[2]) }
+  ;
+
+  Attribute:
+    ATTRIBUTE                              { result = AttributeNode.new(val[0]) }
+  ;
+end
+
+---- header
+require 'plate/lexer'
+require 'plate/nodes'
+
+---- inner
+  def parse(code)
+    @tokens = Lexer.new.tokenize(code)
+    do_parse
+  end
+  
+  def next_token
+    @tokens.shift
+  end

data/lib/plate/lexer.rb

@@ -0,0 +1,138 @@
+module Plate
+  KEYWORDS = %w(p div)
+
+  class Lexer
+    attr_accessor :current_indent, :indent_stack, :tokens
+
+    def dedent
+      indent_stack.pop
+      self.current_indent = indent_stack.last || 0
+      tokens << [:DEDENT, current_indent]
+    end
+
+    def tokenize(code)
+      code.chomp!
+      code.gsub!(/^\s*\/\/.*\n/, '')
+      self.tokens = []
+
+      self.current_indent = 0
+      self.indent_stack = []
+
+      i = 0
+      while i < code.size
+        chunk = code[i..-1]
+
+        if i == 0 && front_matter = chunk[/\A---\n(.*?)---/m, 1]
+          tokens << [:FRONT_MATTER, front_matter]
+          tokens << [:NEWLINE, "\n"]
+          i += front_matter.size + 8
+
+        elsif identifier = chunk[/\A([a-z][\w:\/\. \-]*)/, 1]
+          if KEYWORDS.include?(identifier)
+            tokens << [identifier.upcase.to_sym, identifier]
+          elsif identifier =~ /\A\w+\z/
+            tokens << [:IDENTIFIER, identifier]
+          else
+            tokens << [:STRING, identifier]
+          end
+          i += identifier.size
+
+        elsif klass = chunk[/\A\.([\w\-\.]+)/, 1]
+          tokens << [:CLASS, klass]
+          i += klass.size + 1
+
+        elsif style = chunk[/\A@([\w\-]+)/, 1]
+          tokens << [:STYLE, style]
+          i += style.size + 1
+
+        elsif script = chunk[/\A\$([\w\-]+)/, 1]
+          tokens << [:SCRIPT, script]
+          i += script.size + 1
+
+        elsif value = chunk[/\A:([^\n]*)/, 1]
+          tokens << [":", ":"]
+          tokens << [(value.strip =~ /\A[a-z]\w*\z/ ? :IDENTIFIER : :STRING), value.strip]
+          i += value.size + 1
+
+        elsif attrs = chunk[/\A(\s*\{.*)\}/, 1]
+          tokens << ["{", "{"]
+          attrs.gsub(/\A.*{/, '').split(/,\s*/).each_with_index do |attr, i|
+            unless i.zero?
+              tokens << [",", ","]
+            end
+            tokens << [:ATTRIBUTE, attr]
+          end
+          tokens << ["}", "}"]
+          tokens << [:TERMINATOR, " "]
+          i += attrs.size + 1
+
+        elsif header = chunk[/\A(#+\s*)/, 1]
+          tokens << [:HEADER, header.strip]
+          i += header.size
+
+        elsif highlight = chunk[/\A(```.+?```)/m, 1]
+          tokens << ["```", "```"]
+          tokens << [:HIGHLIGHT, highlight.gsub(/\A```\n/, '').gsub(/\n.*```\z/, '')]
+          tokens << ["```", "```"]
+          i += highlight.size
+
+        elsif string = chunk[/\A((?:[^\n\[\]\(\)!\\]|\\.)(?:[^\n\[\]\(\)\\]|\\.)*)/, 1]
+          tokens << [:STRING, string]
+          i += string.size
+
+        elsif indent = chunk[/\A\n( *)/m, 1]
+          if indent.size.odd? || 
+            (indent.size > current_indent && indent.size != current_indent + 2)
+            raise "Bad indent, #{current_indent} -> #{indent.size}: #{chunk[/\A\n(.*)\n/, 1]}"
+          end
+
+          if indent.size > current_indent
+            self.current_indent = indent.size
+            indent_stack.push(current_indent)
+            tokens << [:INDENT, indent.size]
+          elsif indent.size == current_indent
+            tokens << [:NEWLINE, "\n"]
+          elsif indent.size < current_indent
+            begin
+              dedent
+            end while indent.size < current_indent
+            tokens << [:NEWLINE, "\n"]
+          end
+          i += indent.size + 1
+
+        #elsif chunk.match(/\A\n/)
+        #  tokens << [:NEWLINE, "\n"]
+        #  i += 1
+
+        elsif open = chunk[/\A(!?\[)/, 1]
+          tokens << [:TERMINATOR, " "]
+          tokens << [open, open]
+          i += open.size 
+
+        elsif close = chunk[/\A(\))/, 1]
+          tokens << [close, close]
+          tokens << [:TERMINATOR, " "]
+          i += 1
+
+        #elsif chunk.match(/\A\s/)
+        #  tokens << [:TERMINATOR, " "]
+        #  tokens << [:STRING, " "]
+        #  i += 1
+
+        else
+          value = chunk[0, 1]
+          tokens << [value, value]
+          i += 1
+        end
+      end
+
+      if current_indent > 0
+        begin
+          dedent
+        end while current_indent > 0
+        tokens << [:NEWLINE, "\n"]
+      end
+      tokens
+    end
+  end
+end

data/lib/plate/nodes.rb

@@ -0,0 +1,107 @@
+module Plate
+  class Nodes < Struct.new(:nodes)
+    def <<(node)
+      nodes << node
+      self
+    end
+  end
+
+  class LiteralNode < Struct.new(:value); end
+
+  class StringNode < LiteralNode; end
+
+  class HighlightNode < Struct.new(:code); end
+
+  class GetLocalNode < Struct.new(:name); end
+
+  class AttributeNode < Struct.new(:value); end
+
+  class StyleNode < Struct.new(:attribute, :value); end
+
+  class ScriptNode < Struct.new(:event, :body); end
+
+  class FrontMatterNode < Struct.new(:yaml); end
+
+  module Inspector
+    def inspect_with(values)
+      i = public_method(:inspect).super_method.call
+      i.gsub(/>\z/, ", #{values.join(', ')}>")
+    end
+  end
+
+  RichNode = Struct.new(:styles, :scripts, :body) do
+    include Inspector
+
+    def initialize(body)
+      self.styles = []
+      self.scripts = {}
+      self.body = body
+    end
+  end
+
+  class HeaderNode < RichNode
+    attr_accessor :level, :text
+    def initialize(level, text, body)
+      super(body)
+      self.level = level
+      self.text = text
+    end
+
+    def inspect
+      inspect_with([level, text])
+    end
+  end
+
+  class ClassNode < RichNode
+    attr_accessor :klass
+    def initialize(klass, body)
+      super(body)
+      self.klass = klass
+    end
+
+    def inspect
+      inspect_with([klass])
+    end
+  end
+
+  class ParagraphNode < RichNode
+    def initialize(body)
+      super(body)
+    end
+  end
+
+  class DivNode < RichNode
+    def initialize(body)
+      super(body)
+    end
+  end
+
+  AttributableNode = Struct.new(:attributes) do
+    include Inspector
+  end
+
+  class LinkNode < AttributableNode
+    attr_accessor :text, :href 
+    def initialize(text, href, attributes)
+      self.text = text
+      self.href = href
+      self.attributes = attributes
+    end
+
+    def inspect
+      inspect_with([text, href])
+    end
+  end
+
+  class ImageNode < AttributableNode
+    attr_accessor :src
+    def initialize(src, attributes)
+      self.src = src
+      self.attributes = attributes
+    end
+
+    def inspect
+      inspect_with([src])
+    end
+  end
+end