faml 0.2.0

data/lib/faml/parser.rb

@@ -0,0 +1,211 @@
+require 'faml/ast'
+require 'faml/element_parser'
+require 'faml/filter_parser'
+require 'faml/indent_tracker'
+require 'faml/line_parser'
+require 'faml/parser_utils'
+require 'faml/ruby_multiline'
+require 'faml/script_parser'
+require 'faml/syntax_error'
+
+module Faml
+  class Parser
+    def initialize(options = {})
+    end
+
+    def call(template_str)
+      @ast = Ast::Root.new
+      @stack = []
+      @line_parser = LineParser.new(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?
+        line = @line_parser.next_line
+        if !@ast.is_a?(Ast::HamlComment) && @filter_parser.enabled?
+          ast = @filter_parser.append(line)
+          if ast
+            @ast << ast
+          end
+        end
+        unless @filter_parser.enabled?
+          parse_line(line)
+        end
+      end
+
+      ast = @filter_parser.finish
+      if ast
+        @ast << ast
+      end
+      @indent_tracker.finish
+      @ast
+    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 << Ast::Empty.new
+        return
+      end
+
+      if @ast.is_a?(Ast::HamlComment)
+        @ast << Ast::Text.new(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 << Ast::Doctype.new(text[3 .. -1].strip)
+    end
+
+    def parse_comment(text)
+      text = text[1, text.size-1].strip
+      comment = Ast::HtmlComment.new
+      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 = ParserUtils.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 << Ast::Text.new(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 << Ast::HamlComment.new
+        return
+      end
+      script = text[/\A- *(.*)\z/, 1]
+      if script.empty?
+        syntax_error!("No Ruby code to evaluate")
+      end
+      script += RubyMultiline.read(@line_parser, script)
+      @ast << Ast::SilentScript.new([], script)
+    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)
+    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
+      @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!
+      end
+      nil
+    end
+
+    def indent_leave(indent_level, text)
+      parent_ast = @stack.pop
+      case @ast
+      when Ast::Script, 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 SyntaxError.new(message, @line_parser.lineno)
+    end
+  end
+end

data/lib/faml/parser_utils.rb

@@ -0,0 +1,17 @@
+module Faml
+  module ParserUtils
+    module_function
+
+    def balance(scanner, start, finish, depth = 1)
+      re = /(#{Regexp.escape(start)}|#{Regexp.escape(finish)})/
+      while depth > 0 && scanner.scan_until(re)
+        if scanner.matched == start
+          depth += 1
+        else
+          depth -= 1
+        end
+      end
+      depth
+    end
+  end
+end

data/lib/faml/rails_handler.rb

@@ -0,0 +1,10 @@
+module Faml
+  class RailsHandler
+    def call(template)
+      Engine.new(
+        use_html_safe: true,
+        generator: Temple::Generators::RailsOutputBuffer,
+      ).call(template.source)
+    end
+  end
+end

data/lib/faml/railtie.rb

@@ -0,0 +1,9 @@
+module Faml
+  class Railtie < ::Rails::Railtie
+    initializer :faml do |app|
+      require 'faml/rails_handler'
+      ActionView::Template.register_template_handler(:haml, Faml::RailsHandler.new)
+      ActionView::Template.register_template_handler(:faml, Faml::RailsHandler.new)
+    end
+  end
+end

data/lib/faml/ruby_multiline.rb

@@ -0,0 +1,23 @@
+module Faml
+  module RubyMultiline
+    def self.read(line_parser, current_text)
+      buf = []
+      while is_ruby_multiline?(current_text)
+        current_text = line_parser.next_line
+        buf << current_text
+      end
+      buf.join(' ')
+    end
+
+    # `text' is a Ruby multiline block if it:
+    # - ends with a comma
+    # - but not "?," which is a character literal
+    #   (however, "x?," is a method call and not a literal)
+    # - and not "?\," which is a character literal
+    def self.is_ruby_multiline?(text)
+      text && text.length > 1 && text[-1] == ?, &&
+        !((text[-3, 2] =~ /\W\?/) || text[-3, 2] == "?\\")
+    end
+    private_class_method :is_ruby_multiline?
+  end
+end

data/lib/faml/script_parser.rb

@@ -0,0 +1,84 @@
+require 'faml/ast'
+require 'faml/ruby_multiline'
+require 'faml/syntax_error'
+
+module Faml
+  class ScriptParser
+    def initialize(line_parser)
+      @line_parser = line_parser
+    end
+
+    def parse(text)
+      case text[0]
+      when '=', '~'
+        parse_script(text)
+      when '&'
+        parse_sanitized(text)
+      when '!'
+        parse_unescape(text)
+      else
+        parse_text(text)
+      end
+    end
+
+    private
+
+    def parse_script(text)
+      if text[1] == '='
+        Ast::Text.new(text[2 .. -1].strip)
+      else
+        script = text[1 .. -1].lstrip
+        if script.empty?
+          syntax_error!('No Ruby code to evaluate')
+        end
+        script += RubyMultiline.read(@line_parser, script)
+        Ast::Script.new([], script)
+      end
+    end
+
+    def parse_sanitized(text)
+      case
+      when text.start_with?('&==')
+        Ast::Text.new(text[3 .. -1].lstrip)
+      when text[1] == '=' || text[1] == '~'
+        script = text[2 .. -1].lstrip
+        if script.empty?
+          syntax_error!('No Ruby code to evaluate')
+        end
+        script += RubyMultiline.read(@line_parser, script)
+        Ast::Script.new([], script, true, text[1] == '~')
+      else
+        Ast::Text.new(text[1 .. -1].strip)
+      end
+    end
+
+    def parse_unescape(text)
+      case
+      when text.start_with?('!==')
+        Ast::Text.new(text[3 .. -1].lstrip, false)
+      when text[1] == '=' || text[1] == '~'
+        script = text[2 .. -1].lstrip
+        if script.empty?
+          syntax_error!('No Ruby code to evaluate')
+        end
+        script += RubyMultiline.read(@line_parser, script)
+        Ast::Script.new([], script, false, text[1] == '~')
+      else
+        Ast::Text.new(text[1 .. -1].lstrip, false)
+      end
+    end
+
+    def parse_text(text)
+      text = text.lstrip
+      if text.empty?
+        nil
+      else
+        Ast::Text.new(text)
+      end
+    end
+
+    def syntax_error!(message)
+      raise SyntaxError.new(message, @line_parser.lineno)
+    end
+  end
+end

data/lib/faml/static_hash_parser.rb

@@ -0,0 +1,113 @@
+require 'parser/current'
+
+module Faml
+  class StaticHashParser
+    FAILURE_TAG = :failure
+
+    SPECIAL_ATTRIBUTES = %w[id class data].freeze
+
+    attr_reader :static_attributes, :dynamic_attributes
+
+    def initialize
+      @static_attributes = {}
+      @dynamic_attributes = {}
+    end
+
+    def parse(text)
+      parser = ::Parser::CurrentRuby.new
+      parser.diagnostics.consumer = nil
+      buffer = ::Parser::Source::Buffer.new('(faml)')
+      buffer.source = text
+      walk(parser.parse(buffer))
+    rescue ::Parser::SyntaxError
+      false
+    end
+
+    def walk(node)
+      catch(FAILURE_TAG) do
+        walk_hash(node)
+        return true
+      end
+      false
+    end
+
+    private
+
+    def walk_hash(node)
+      if node.type != :hash
+        throw FAILURE_TAG
+      end
+      node.children.each do |pair|
+        walk_pair(pair)
+      end
+    end
+
+    def walk_pair(node)
+      if node.type != :pair
+        throw FAILURE_TAG
+      end
+      key = node.children[0]
+      val = node.children[1]
+
+      if key_static = try_static_key(key)
+        try_static_value(key_static, val)
+      else
+        throw FAILURE_TAG
+      end
+    end
+
+    def try_static_key(node)
+      case node.type
+      when :sym
+        node.location.expression.source.gsub(/\A:/, '').to_sym
+      when :int, :float, :str
+        eval(node.location.expression.source)
+      end
+    end
+
+    def try_static_value(key_static, node)
+      case node.type
+      when :sym
+        @static_attributes[key_static] = node.location.expression.source.gsub(/\A:/, '').to_sym
+      when :true, :false, :nil, :int, :float, :str
+        @static_attributes[key_static] = eval(node.location.expression.source)
+      when :dstr
+        @dynamic_attributes[key_static] = node.location.expression.source
+      when :send
+        if SPECIAL_ATTRIBUTES.include?(key_static.to_s)
+          throw FAILURE_TAG
+        else
+          @dynamic_attributes[key_static] = node.location.expression.source
+        end
+      when :hash
+        try_static_hash_value(key_static, node)
+        # TODO: Add array case
+      else
+        throw FAILURE_TAG
+      end
+    end
+
+    def try_static_hash_value(key_static, node)
+      parser = self.class.new
+      if parser.walk(node)
+        merge_attributes(key_static, parser)
+      else
+        # TODO: Is it really impossible to optimize?
+        throw FAILURE_TAG
+      end
+    end
+
+    def merge_attributes(key_static, parser)
+      unless parser.static_attributes.empty?
+        @static_attributes[key_static] = parser.static_attributes
+      end
+
+      unless parser.dynamic_attributes.empty?
+        expr = parser.dynamic_attributes.map do |k, v|
+          "#{k.inspect} => #{v}"
+        end.join(', ')
+        @dynamic_attributes[key_static] = "{#{expr}}"
+      end
+    end
+  end
+end