haml_parser 0.1.0

data/lib/haml_parser/error.rb

@@ -0,0 +1,10 @@
+module HamlParser
+  class Error < StandardError
+    attr_accessor :lineno
+
+    def initialize(message, lineno)
+      super(message)
+      @lineno = lineno
+    end
+  end
+end

data/lib/haml_parser/filter_parser.rb

@@ -0,0 +1,58 @@
+require 'haml_parser/ast'
+
+module HamlParser
+  class FilterParser
+    def initialize(indent_tracker)
+      @ast = nil
+      @indent_level = nil
+      @indent_tracker = indent_tracker
+    end
+
+    def enabled?
+      !!@ast
+    end
+
+    def start(name, filename, lineno)
+      @ast = Ast::Filter.new
+      @ast.name = name
+      @ast.filename = filename
+      @ast.lineno = lineno
+    end
+
+    def append(line)
+      indent, text = @indent_tracker.split(line)
+      if text.empty?
+        @ast.texts << ''
+        return
+      end
+      indent_level = indent.size
+
+      if @indent_level
+        if indent_level < @indent_level
+          # Finish filter
+          @indent_level = nil
+          ast = @ast
+          @ast = nil
+          return ast
+        end
+      else
+        if indent_level > @indent_tracker.current_level
+          # Start filter
+          @indent_level = indent_level
+        else
+          # Empty filter
+          @ast = nil
+          return nil
+        end
+      end
+
+      text = line[@indent_level .. -1]
+      @ast.texts << text
+      nil
+    end
+
+    def finish
+      @ast
+    end
+  end
+end

data/lib/haml_parser/indent_tracker.rb

@@ -0,0 +1,116 @@
+require 'haml_parser/error'
+
+module HamlParser
+  class IndentTracker
+    class IndentMismatch < Error
+      attr_reader :current_level, :indent_levels
+
+      def initialize(current_level, indent_levels, lineno)
+        super("Unexpected indent level: #{current_level}: indent_level=#{indent_levels}", lineno)
+        @current_level = current_level
+        @indent_levels = indent_levels
+      end
+    end
+
+    class InconsistentIndent < Error
+      attr_reader :previous_size, :current_size
+
+      def initialize(previous_size, current_size, lineno)
+        super("Inconsistent indentation: #{current_size} spaces used for indentation, but the rest of the document was indented using #{previous_size} spaces.", lineno)
+        @previous_size = previous_size
+        @current_size = current_size
+      end
+    end
+
+    class HardTabNotAllowed < Error
+      def initialize(lineno)
+        super('Indentation with hard tabs are not allowed :-p', lineno)
+      end
+    end
+
+    def initialize(on_enter: nil, on_leave: nil)
+      @indent_levels = [0]
+      @on_enter = on_enter || lambda { |level, text| }
+      @on_leave = on_leave || lambda { |level, text| }
+      @comment_level = nil
+    end
+
+    def process(line, lineno)
+      if line =~ /\A\t/
+        raise HardTabNotAllowed.new(lineno)
+      end
+      indent, text = split(line)
+      indent_level = indent.size
+
+      unless text.empty?
+        track(indent_level, text, lineno)
+      end
+      [text, indent]
+    end
+
+    def split(line)
+      m = line.match(/\A( *)(.*)\z/)
+      [m[1], m[2]]
+    end
+
+    def finish
+      indent_leave(0, '', -1)
+    end
+
+    def current_level
+      @indent_levels.last
+    end
+
+    def enter_comment!
+      @comment_level = @indent_levels[-2]
+    end
+
+    def check_indent_level!(lineno)
+      if @indent_levels.size >= 3
+        previous_size = @indent_levels[-2] - @indent_levels[-3]
+        current_size = @indent_levels[-1] - @indent_levels[-2]
+        if previous_size != current_size
+          raise InconsistentIndent.new(previous_size, current_size, lineno)
+        end
+      end
+    end
+
+    private
+
+    def track(indent_level, text, lineno)
+      if indent_level > @indent_levels.last
+        indent_enter(indent_level, text, lineno)
+      elsif indent_level < @indent_levels.last
+        indent_leave(indent_level, text, lineno)
+      end
+    end
+
+    def indent_enter(indent_level, text, lineno)
+      unless @comment_level
+        @indent_levels.push(indent_level)
+        @on_enter.call(indent_level, text)
+      end
+    end
+
+    def indent_leave(indent_level, text, lineno)
+      if @comment_level
+        if indent_level <= @comment_level
+          # finish comment mode
+          @comment_level = nil
+        else
+          # still in comment
+          return
+        end
+      end
+
+      while indent_level < @indent_levels.last
+        @indent_levels.pop
+        @on_leave.call(indent_level, text)
+      end
+
+      if indent_level != @indent_levels.last
+        raise IndentMismatch.new(indent_level, @indent_levels.dup, lineno)
+      end
+    end
+  end
+end

data/lib/haml_parser/line_parser.rb

@@ -0,0 +1,67 @@
+module HamlParser
+  class LineParser
+    attr_reader :filename, :lineno
+
+    def initialize(filename, template_str)
+      @filename = filename
+      @lines = template_str.each_line.map { |line| line.chomp.rstrip }
+      @lineno = 0
+    end
+
+    def next_line(in_filter: false)
+      line = move_next
+      if !in_filter && is_multiline?(line)
+        next_multiline(line)
+      else
+        line
+      end
+    end
+
+    def has_next?
+      @lineno < @lines.size
+    end
+
+    private
+
+    MULTILINE_SUFFIX = ' |'
+
+    # Regex to check for blocks with spaces around arguments. Not to be confused
+    # with multiline script.
+    # For example:
+    #     foo.each do | bar |
+    #       = bar
+    #
+    BLOCK_WITH_SPACES = /do\s*\|\s*[^\|]*\s+\|\z/o
+
+    def is_multiline?(line)
+      line = line.lstrip
+      line.end_with?(MULTILINE_SUFFIX) && line !~ BLOCK_WITH_SPACES
+    end
+
+    def move_next
+      @lines[@lineno].tap do
+        @lineno += 1
+      end
+    end
+
+    def move_back
+      @lineno -= 1
+    end
+
+    def next_multiline(line)
+      buf = [line[0, line.size-1]]
+      while @lineno < @lines.size
+        line = move_next
+
+        if is_multiline?(line)
+          line = line[0, line.size-1]
+          buf << line.lstrip
+        else
+          move_back
+          break
+        end
+      end
+      buf.join("\n")
+    end
+  end
+end

data/lib/haml_parser/parser.rb

@@ -0,0 +1,239 @@
+require 'haml_parser/ast'
+require 'haml_parser/element_parser'
+require 'haml_parser/error'
+require 'haml_parser/filter_parser'
+require 'haml_parser/indent_tracker'
+require 'haml_parser/line_parser'
+require 'haml_parser/ruby_multiline'
+require 'haml_parser/script_parser'
+require 'haml_parser/utils'
+
+module HamlParser
+  class Parser
+    def initialize(options = {})
+      @filename = options[:filename]
+    end
+
+    def call(template_str)
+      @ast = Ast::Root.new
+      @stack = []
+      @line_parser = LineParser.new(@filename, template_str)
+      @indent_tracker = IndentTracker.new(on_enter: method(:indent_enter), on_leave: method(:indent_leave))
+      @filter_parser = FilterParser.new(@indent_tracker)
+
+      while @line_parser.has_next?
+        in_filter = !@ast.is_a?(Ast::HamlComment) && @filter_parser.enabled?
+        line = @line_parser.next_line(in_filter: in_filter)
+        if in_filter
+          ast = @filter_parser.append(line)
+          if ast
+            @ast << ast
+          end
+        end
+        unless @filter_parser.enabled?
+          line_count = line.count("\n")
+          line.delete!("\n")
+          parse_line(line)
+          line_count.times do
+            @ast << create_node(Ast::Empty)
+          end
+        end
+      end
+
+      ast = @filter_parser.finish
+      if ast
+        @ast << ast
+      end
+      @indent_tracker.finish
+      @ast
+    rescue Error => e
+      if @filename && e.lineno
+        e.backtrace.unshift "#{@filename}:#{e.lineno}"
+      end
+      raise e
+    end
+
+    private
+
+    DOCTYPE_PREFIX = '!'
+    ELEMENT_PREFIX = '%'
+    COMMENT_PREFIX = '/'
+    SILENT_SCRIPT_PREFIX = '-'
+    DIV_ID_PREFIX = '#'
+    DIV_CLASS_PREFIX = '.'
+    FILTER_PREFIX = ':'
+    ESCAPE_PREFIX = '\\'
+
+    def parse_line(line)
+      text, indent = @indent_tracker.process(line, @line_parser.lineno)
+
+      if text.empty?
+        @ast << create_node(Ast::Empty)
+        return
+      end
+
+      if @ast.is_a?(Ast::HamlComment)
+        @ast << create_node(Ast::Text) { |t| t.text = text }
+        return
+      end
+
+      case text[0]
+      when ESCAPE_PREFIX
+        parse_plain(text[1 .. -1])
+      when ELEMENT_PREFIX
+        parse_element(text)
+      when DOCTYPE_PREFIX
+        if text.start_with?('!!!')
+          parse_doctype(text)
+        else
+          parse_script(text)
+        end
+      when COMMENT_PREFIX
+        parse_comment(text)
+      when SILENT_SCRIPT_PREFIX
+        parse_silent_script(text)
+      when DIV_ID_PREFIX, DIV_CLASS_PREFIX
+        if text.start_with?('#{')
+          parse_script(text)
+        else
+          parse_line("#{indent}%div#{text}")
+        end
+      when FILTER_PREFIX
+        parse_filter(text)
+      else
+        parse_script(text)
+      end
+    end
+
+    def parse_doctype(text)
+      @ast << create_node(Ast::Doctype) { |d| d.doctype = text[3 .. -1].strip }
+    end
+
+    def parse_comment(text)
+      text = text[1, text.size-1].strip
+      comment = create_node(Ast::HtmlComment)
+      comment.comment = text
+      if text[0] == '['
+        comment.conditional, rest = parse_conditional_comment(text)
+        text.replace(rest)
+      end
+      @ast << comment
+    end
+
+    CONDITIONAL_COMMENT_REGEX = /[\[\]]/o
+
+    def parse_conditional_comment(text)
+      s = StringScanner.new(text[1 .. -1])
+      depth = Utils.balance(s, '[', ']')
+      if depth == 0
+        [s.pre_match, s.rest.lstrip]
+      else
+        syntax_error!('Unmatched brackets in conditional comment')
+      end
+    end
+
+    def parse_plain(text)
+      @ast << create_node(Ast::Text) { |t| t.text = text }
+    end
+
+    def parse_element(text)
+      @ast << ElementParser.new(@line_parser).parse(text)
+    end
+
+    def parse_script(text)
+      @ast << ScriptParser.new(@line_parser).parse(text)
+    end
+
+    def parse_silent_script(text)
+      if text.start_with?('-#')
+        @ast << create_node(Ast::HamlComment)
+        return
+      end
+      node = create_node(Ast::SilentScript)
+      script = text[/\A- *(.*)\z/, 1]
+      node.script = [script, *RubyMultiline.read(@line_parser, script)].join("\n")
+      @ast << node
+    end
+
+    def parse_filter(text)
+      filter_name = text[/\A#{FILTER_PREFIX}(\w+)\z/, 1]
+      unless filter_name
+        syntax_error!("Invalid filter name: #{text}")
+      end
+      @filter_parser.start(filter_name, @line_parser.filename, @line_parser.lineno)
+    end
+
+    def indent_enter(_, text)
+      empty_lines = []
+      while @ast.children.last.is_a?(Ast::Empty)
+        empty_lines << @ast.children.pop
+      end
+      @stack.push(@ast)
+      @ast = @ast.children.last
+      case @ast
+      when Ast::Text
+        syntax_error!('nesting within plain text is illegal')
+      when Ast::Doctype
+        syntax_error!('nesting within a header command is illegal')
+      end
+      @ast.children = empty_lines
+      if @ast.is_a?(Ast::Element) && @ast.self_closing
+        syntax_error!('Illegal nesting: nesting within a self-closing tag is illegal')
+      end
+      if @ast.is_a?(Ast::HtmlComment) && !@ast.comment.empty?
+        syntax_error!('Illegal nesting: nesting within a html comment that already has content is illegal.')
+      end
+      if @ast.is_a?(Ast::HamlComment)
+        @indent_tracker.enter_comment!
+      else
+        @indent_tracker.check_indent_level!(@line_parser.lineno)
+      end
+      nil
+    end
+
+    def indent_leave(indent_level, text)
+      parent_ast = @stack.pop
+      case @ast
+      when Ast::SilentScript
+        if indent_level == @indent_tracker.current_level
+          @ast.mid_block_keyword = mid_block_keyword?(text)
+        end
+      end
+      @ast = parent_ast
+      nil
+    end
+
+    MID_BLOCK_KEYWORDS = %w[else elsif rescue ensure end when]
+    START_BLOCK_KEYWORDS = %w[if begin case unless]
+    # Try to parse assignments to block starters as best as possible
+    START_BLOCK_KEYWORD_REGEX = /(?:\w+(?:,\s*\w+)*\s*=\s*)?(#{Regexp.union(START_BLOCK_KEYWORDS)})/
+    BLOCK_KEYWORD_REGEX = /^-?\s*(?:(#{Regexp.union(MID_BLOCK_KEYWORDS)})|#{START_BLOCK_KEYWORD_REGEX.source})\b/
+
+    def block_keyword(text)
+      m = text.match(BLOCK_KEYWORD_REGEX)
+      if m
+        m[1] || m[2]
+      else
+        nil
+      end
+    end
+
+    def mid_block_keyword?(text)
+      MID_BLOCK_KEYWORDS.include?(block_keyword(text))
+    end
+
+    def syntax_error!(message)
+      raise Error.new(message, @line_parser.lineno)
+    end
+
+    def create_node(klass, &block)
+      klass.new.tap do |node|
+        node.filename = @line_parser.filename
+        node.lineno = @line_parser.lineno
+        if block
+          block.call(node)
+        end
+      end
+    end
+  end
+end