fast_haml 0.1.0

data/lib/fast_haml/line_parser.rb

@@ -0,0 +1,66 @@
+module FastHaml
+  class LineParser
+    attr_reader :lineno
+
+    def initialize(template_str)
+      @lines = template_str.each_line.map { |line| line.chomp.rstrip }
+      @lineno = 0
+    end
+
+    def next_line
+      line = move_next
+      if 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
+    end
+  end
+end

data/lib/fast_haml/parser.rb

@@ -0,0 +1,251 @@
+require 'fast_haml/ast'
+require 'fast_haml/element_parser'
+require 'fast_haml/filter_parser'
+require 'fast_haml/indent_tracker'
+require 'fast_haml/line_parser'
+require 'fast_haml/parser_utils'
+require 'fast_haml/ruby_multiline'
+require 'fast_haml/syntax_error'
+
+module FastHaml
+  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 = '%'
+    SCRIPT_PREFIX = '='
+    COMMENT_PREFIX = '/'
+    SILENT_SCRIPT_PREFIX = '-'
+    DIV_ID_PREFIX = '#'
+    DIV_CLASS_PREFIX = '.'
+    FILTER_PREFIX = ':'
+    ESCAPE_PREFIX = '\\'
+    PRESERVE_PREFIX = '~'
+    SANITIZE_PREFIX = '&'
+
+    def parse_line(line)
+      text, indent = @indent_tracker.process(line, @line_parser.lineno)
+
+      if text.empty?
+        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
+        case
+        when text.start_with?('!!!')
+          parse_doctype(text)
+        when text.start_with?('!==')
+          parse_plain(text[3 .. -1].lstrip, escape_html: false)
+        when text[1] == SCRIPT_PREFIX
+          parse_script(text)
+        when text[1] == PRESERVE_PREFIX
+          parse_script("!=#{text[2 .. -1].lstrip}", preserve: true)
+        when text[1] == ' '
+          parse_plain(text[1 .. -1].lstrip, escape_html: false)
+        else
+          parse_plain(text)
+        end
+      when COMMENT_PREFIX
+        parse_comment(text)
+      when SCRIPT_PREFIX
+        if text[1] == SCRIPT_PREFIX
+          parse_plain(text[2 .. -1].strip)
+        else
+          parse_script(text)
+        end
+      when SILENT_SCRIPT_PREFIX
+        parse_silent_script(text)
+      when PRESERVE_PREFIX
+        # preserve has no meaning in non-html_escape mode
+        parse_script(text)
+      when DIV_ID_PREFIX, DIV_CLASS_PREFIX
+        if text.start_with?('#{')
+          parse_plain(text)
+        else
+          parse_line("#{indent}%div#{text}")
+        end
+      when FILTER_PREFIX
+        parse_filter(text)
+      when SANITIZE_PREFIX
+        case
+        when text.start_with?('&==')
+          parse_plain(text[3 .. -1].lstrip)
+        when text[1] == SCRIPT_PREFIX
+          parse_script(text)
+        when text[1] == PRESERVE_PREFIX
+          parse_script("&=#{text[2 .. -1].lstrip}", preserve: true)
+        else
+          parse_plain(text[1 .. -1].strip)
+        end
+      else
+        parse_plain(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, escape_html: true)
+      @ast << Ast::Text.new(text, escape_html)
+    end
+
+    def parse_element(text)
+      @ast << ElementParser.new(text, @line_parser.lineno, @line_parser).parse
+    end
+
+    def parse_script(text, preserve: false)
+      m = text.match(/\A([!&~])?[=~] *(.*)\z/)
+      script = m[2]
+      if script.empty?
+        syntax_error!("No Ruby code to evaluate")
+      end
+      script += RubyMultiline.read(@line_parser, script)
+      node = Ast::Script.new([], script)
+      case m[1]
+      when '!'
+        node.escape_html = false
+      when '&'
+        node.escape_html = true
+      end
+      node.preserve = preserve
+      @ast << node
+    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)
+      @stack.push(@ast)
+      @ast = @ast.children.last
+      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/fast_haml/parser_utils.rb

@@ -0,0 +1,17 @@
+module FastHaml
+  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/fast_haml/rails_handler.rb

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

data/lib/fast_haml/railtie.rb

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

data/lib/fast_haml/ruby_multiline.rb

@@ -0,0 +1,23 @@
+module FastHaml
+  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/fast_haml/static_hash_parser.rb

@@ -0,0 +1,113 @@
+require 'parser/current'
+
+module FastHaml
+  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('(fast_haml)')
+      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

data/lib/fast_haml/syntax_error.rb

@@ -0,0 +1,10 @@
+module FastHaml
+  class SyntaxError < StandardError
+    attr_reader :lineno
+
+    def initialize(message, lineno)
+      super("#{message} at line #{lineno}")
+      @lineno = lineno
+    end
+  end
+end

data/lib/fast_haml/text_compiler.rb

@@ -0,0 +1,69 @@
+require 'strscan'
+require 'fast_haml/parser_utils'
+
+module FastHaml
+  class TextCompiler
+    class InvalidInterpolation < StandardError
+    end
+
+    def initialize(escape_html: true)
+      @escape_html = escape_html
+    end
+
+    def compile(text, escape_html: @escape_html)
+      if contains_interpolation?(text)
+        compile_interpolation(text, escape_html: escape_html)
+      else
+        [:static, text]
+      end
+    end
+
+    private
+
+    INTERPOLATION_BEGIN = /(\\*)(#[\{$@])/o
+
+    def contains_interpolation?(text)
+      INTERPOLATION_BEGIN === text
+    end
+
+    def compile_interpolation(text, escape_html: @escape_html)
+      s = StringScanner.new(text)
+      temple = [:multi]
+      pos = s.pos
+      while s.scan_until(INTERPOLATION_BEGIN)
+        escapes = s[1].size
+        pre = s.string.byteslice(pos ... (s.pos - s.matched.size))
+        temple << [:static, pre] << [:static, "\\" * (escapes/2)]
+        if escapes % 2 == 0
+          # perform interpolation
+          if s[2] == '#{'
+            temple << [:escape, escape_html, [:dynamic, find_close_brace(s)]]
+          else
+            var = s[2][-1]
+            s.scan(/\w+/)
+            var << s.matched
+            temple << [:escape, escape_html, [:dynamic, var]]
+          end
+        else
+          # escaped
+          temple << [:static, s[2]]
+        end
+        pos = s.pos
+      end
+      temple << [:static, s.rest]
+      temple
+    end
+
+    INTERPOLATION_BRACE = /[\{\}]/o
+
+    def find_close_brace(scanner)
+      pos = scanner.pos
+      depth = ParserUtils.balance(scanner, '{', '}')
+      if depth != 0
+        raise InvalidInterpolation.new(scanner.string)
+      else
+        scanner.string.byteslice(pos ... (scanner.pos-1))
+      end
+    end
+  end
+end

data/lib/fast_haml/tilt.rb

@@ -0,0 +1,16 @@
+require 'tilt'
+require 'fast_haml/engine'
+
+module FastHaml
+  class Tilt < Tilt::Template
+    def prepare
+      @code = Engine.new(options).call(data)
+    end
+
+    def precompiled_template(locals = {})
+      @code
+    end
+  end
+
+  ::Tilt.register(Tilt, 'haml')
+end

data/lib/fast_haml/version.rb

@@ -0,0 +1,3 @@
+module FastHaml
+  VERSION = "0.1.0"
+end

data/lib/fast_haml.rb

@@ -0,0 +1,10 @@
+require 'fast_haml/engine'
+require 'fast_haml/tilt'
+require 'fast_haml/version'
+
+begin
+  gem 'rails'
+  require 'rails'
+  require 'fast_haml/railtie'
+rescue LoadError
+end

data/spec/rails/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/spec/rails/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/rails/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/rails/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/rails/app/controllers/books_controller.rb

@@ -0,0 +1,8 @@
+class BooksController < ApplicationController
+  def hello
+  end
+
+  def with_variables
+    @book = Book.new(params.permit(:title))
+  end
+end

data/spec/rails/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/rails/app/models/book.rb

@@ -0,0 +1,9 @@
+class Book
+  include ActiveModel::Model
+
+  attr_accessor :title
+
+  def to_s
+    "<span>#{title}</span>".html_safe
+  end
+end

data/spec/rails/app/views/books/hello.html.haml

@@ -0,0 +1,2 @@
+.container
+  %span Hello, World