fast_haml 0.1.0

data/lib/fast_haml/element_parser.rb

@@ -0,0 +1,288 @@
+require 'strscan'
+require 'fast_haml/ast'
+require 'fast_haml/parser_utils'
+require 'fast_haml/ruby_multiline'
+require 'fast_haml/syntax_error'
+
+module FastHaml
+  class ElementParser
+    def initialize(text, lineno, line_parser)
+      @text = text
+      @lineno = lineno
+      @line_parser = line_parser
+    end
+
+    ELEMENT_REGEXP = /\A%([-:\w]+)([-:\w.#]*)(.+)?\z/o
+
+    def parse
+      m = @text.match(ELEMENT_REGEXP)
+      unless m
+        syntax_error!('Invalid element declaration')
+      end
+
+      element = Ast::Element.new
+      element.tag_name = m[1]
+      element.static_class, element.static_id = parse_class_and_id(m[2])
+      rest = m[3] || ''
+
+      element.attributes, rest = parse_attributes(rest.lstrip)
+      element.nuke_inner_whitespace, element.nuke_outer_whitespace, rest = parse_nuke_whitespace(rest)
+      element.self_closing, rest = parse_self_closing(rest)
+      element.oneline_child = parse_oneline_child(rest)
+
+      element
+    end
+
+    private
+
+    def parse_class_and_id(class_and_id)
+      classes = []
+      id = ''
+      class_and_id.scan(/([#.])([-:_a-zA-Z0-9]+)/) do |type, prop|
+        case type
+        when '.'
+          classes << prop
+        when '#'
+          id = prop
+        end
+      end
+
+      [classes.join(' '), id]
+    end
+
+    OLD_ATTRIBUTE_BEGIN = '{'
+    NEW_ATTRIBUTE_BEGIN = '('
+
+    def parse_attributes(rest)
+      old_attributes = ''
+      new_attributes = ''
+
+      loop do
+        case rest[0]
+        when OLD_ATTRIBUTE_BEGIN
+          unless old_attributes.empty?
+            break
+          end
+          old_attributes, rest = parse_old_attributes(rest)
+        when NEW_ATTRIBUTE_BEGIN
+          unless new_attributes.empty?
+            break
+          end
+          new_attributes, rest = parse_new_attributes(rest)
+        else
+          break
+        end
+      end
+
+      attributes = old_attributes
+      unless new_attributes.empty?
+        t = to_old_syntax(new_attributes)
+        if attributes.empty?
+          attributes = t
+        else
+          attributes << ", " << t
+        end
+      end
+      [attributes, rest]
+    end
+
+    def parse_old_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      loop do
+        depth = ParserUtils.balance(s, '{', '}')
+        if depth == 0
+          attr = s.pre_match + s.matched
+          return [attr[1, attr.size-2], s.rest.lstrip]
+        else
+          if text[-1] == ',' && @line_parser.has_next?
+            text << @line_parser.next_line
+          else
+            syntax_error!('Unmatched brace')
+          end
+        end
+      end
+    end
+
+    def parse_new_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      new_attributes = []
+      loop do
+        pre_pos = s.pos
+        depth = ParserUtils.balance(s, '(', ')', depth)
+        if depth == 0
+          t = s.string.byteslice(pre_pos ... s.pos-1)
+          new_attributes.concat(parse_new_attribute_list(t))
+          return [new_attributes, s.rest.lstrip]
+        else
+          if @line_parser.has_next?
+            text << ' ' << @line_parser.next_line
+          else
+            syntax_error!('Unmatched paren')
+          end
+        end
+      end
+    end
+
+    def parse_new_attribute_list(text)
+      s = StringScanner.new(text)
+      list = []
+      until s.eos?
+        name = scan_key(s)
+        s.skip(/\s*/)
+
+        if scan_operator(s)
+          s.skip(/\s*/)
+          value = scan_value(s)
+        else
+          value = 'true'
+        end
+        s.skip(/\s*/)
+
+        list << [name, value]
+      end
+      list
+    end
+
+    def scan_key(scanner)
+      scanner.scan(/[-:\w]+/).tap do |name|
+        unless name
+          syntax_error!('Invalid attribute list (missing attributename)')
+        end
+      end
+    end
+
+    def scan_operator(scanner)
+      scanner.skip(/=/)
+    end
+
+    def scan_value(scanner)
+      if quote = scanner.scan(/["']/)
+        scan_quoted_value(scanner, quote)
+      else
+        scan_variable_value(scanner)
+      end
+    end
+
+    def scan_quoted_value(scanner, quote)
+      re = /((?:\\.|\#(?!\{)|[^#{quote}\\#])*)(#{quote}|#\{)/
+      pos = scanner.pos
+      loop do
+        unless scanner.scan(re)
+          syntax_error!('Invalid attribute list (mismatched quotation)')
+        end
+        if scanner[2] == quote
+          break
+        end
+        depth = ParserUtils.balance(scanner, '{', '}')
+        if depth != 0
+          syntax_error!('Invalid attribute list (mismatched interpolation)')
+        end
+      end
+      str = scanner.string.byteslice(pos-1 .. scanner.pos-1)
+
+      # Even if the quote is single, string interpolation is performed in Haml.
+      str[0] = '"'
+      str[-1] = '"'
+      str
+    end
+
+    def scan_variable_value(scanner)
+      scanner.scan(/(@@?|\$)?\w+/).tap do |var|
+        unless var
+          syntax_error!('Invalid attribute list (invalid variable name)')
+        end
+      end
+    end
+
+    def to_old_syntax(new_attributes)
+      new_attributes.map { |k, v| "#{k.inspect} => #{v}" }.join(', ')
+    end
+
+    def parse_nuke_whitespace(rest)
+      m = rest.match(/\A(><|<>|[><])(.*)\z/)
+      if m
+        nuke_whitespace = m[1]
+        [
+          nuke_whitespace.include?('<'),
+          nuke_whitespace.include?('>'),
+          m[2],
+        ]
+      else
+        [false, false, rest]
+      end
+    end
+
+    def parse_self_closing(rest)
+      if rest[0] == '/'
+        if rest.size > 1
+          syntax_error!("Self-closing tags can't have content")
+        end
+        [true, '']
+      else
+        [false, rest]
+      end
+    end
+
+    def parse_oneline_child(rest)
+      case rest[0]
+      when '=', '~'
+        if rest[1] == '='
+          Ast::Text.new(rest[2 .. -1].strip)
+        else
+          script = rest[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
+      when '&'
+        case
+        when rest.start_with?('&==')
+          Ast::Text.new(rest[3 .. -1].lstrip)
+        when rest[1] == '=' || rest[1] == '~'
+          script = rest[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, rest[1] == '~')
+        else
+          Ast::Text.new(rest[1 .. -1].strip)
+        end
+      when '!'
+        case
+        when rest.start_with?('!==')
+          Ast::Text.new(rest[3 .. -1].lstrip, false)
+        when rest[1] == '=' || rest[1] == '~'
+          script = rest[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, rest[1] == '~')
+          Ast::Script.new([], script, false, true)
+        else
+          Ast::Text.new(rest[1 .. -1].lstrip, false)
+        end
+      else
+        rest = rest.lstrip
+        if rest.empty?
+          nil
+        else
+          Ast::Text.new(rest)
+        end
+      end
+    end
+
+    def syntax_error!(message)
+      raise SyntaxError.new(message, @lineno)
+    end
+  end
+end

data/lib/fast_haml/engine.rb

@@ -0,0 +1,32 @@
+require 'temple'
+require 'fast_haml/compiler'
+require 'fast_haml/html'
+require 'fast_haml/parser'
+
+module FastHaml
+  class Engine < Temple::Engine
+    define_options(
+      generator: Temple::Generators::ArrayBuffer,
+    )
+
+    DEFAULT_OPTIONS = {
+        format: :html,
+        attr_quote: "'",
+    }.freeze
+
+    def initialize(opts = {})
+      super(DEFAULT_OPTIONS.merge(opts))
+    end
+
+    use Parser
+    use Compiler
+    use Html
+    filter :Escapable
+    filter :ControlFlow
+    filter :MultiFlattener
+    filter :StaticMerger
+    use :Generator do
+      options[:generator].new(options.to_hash.reject {|k,v| !options[:generator].options.valid_key?(k) })
+    end
+  end
+end

data/lib/fast_haml/filter_compilers/base.rb

@@ -0,0 +1,29 @@
+require 'fast_haml/text_compiler'
+
+module FastHaml
+  module FilterCompilers
+    class Base
+      protected
+
+      def compile_texts(temple, texts, tab_width: 0)
+        tabs = ' ' * tab_width
+        texts.each do |text|
+          temple << [:static, tabs] << text_compiler.compile(text) << [:static, "\n"]
+        end
+        nil
+      end
+
+      def text_compiler
+        @text_compiler ||= TextCompiler.new(escape_html: false)
+      end
+
+      def strip_last_empty_lines(texts)
+        texts = texts.dup
+        while texts.last && texts.last.empty?
+          texts.pop
+        end
+        texts
+      end
+    end
+  end
+end

data/lib/fast_haml/filter_compilers/cdata.rb

@@ -0,0 +1,15 @@
+require 'fast_haml/filter_compilers/base'
+
+module FastHaml
+  module FilterCompilers
+    class Cdata < Base
+      def compile(texts)
+        temple = [:multi, [:static, "<![CDATA[\n"]]
+        compile_texts(temple, strip_last_empty_lines(texts), tab_width: 4)
+        temple << [:static, "]]>"]
+      end
+    end
+
+    register(:cdata, Cdata)
+  end
+end

data/lib/fast_haml/filter_compilers/css.rb

@@ -0,0 +1,15 @@
+require 'fast_haml/filter_compilers/base'
+
+module FastHaml
+  module FilterCompilers
+    class Css < Base
+      def compile(texts)
+        temple = [:multi, [:static, "\n"]]
+        compile_texts(temple, strip_last_empty_lines(texts), tab_width: 2)
+        [:haml, :tag, 'style', false, [:html, :attrs], temple]
+      end
+    end
+
+    register(:css, Css)
+  end
+end

data/lib/fast_haml/filter_compilers/escaped.rb

@@ -0,0 +1,22 @@
+require 'fast_haml/filter_compilers/base'
+
+module FastHaml
+  module FilterCompilers
+    class Escaped < Base
+      include Temple::Utils
+
+      def compile(texts)
+        temple = [:multi]
+        compile_texts(temple, strip_last_empty_lines(texts))
+        escape_code = Temple::Filters::Escapable.new.instance_variable_get(:@escape_code)
+        sym = unique_name
+        [:multi,
+          [:capture, sym, temple],
+          [:dynamic, escape_code % sym],
+        ]
+      end
+    end
+
+    register(:escaped, Escaped)
+  end
+end

data/lib/fast_haml/filter_compilers/javascript.rb

@@ -0,0 +1,15 @@
+require 'fast_haml/filter_compilers/base'
+
+module FastHaml
+  module FilterCompilers
+    class Javascript < Base
+      def compile(texts)
+        temple = [:multi, [:static, "\n"]]
+        compile_texts(temple, strip_last_empty_lines(texts), tab_width: 2)
+        [:haml, :tag, 'script', false, [:html, :attrs], [:html, :js, temple]]
+      end
+    end
+
+    register(:javascript, Javascript)
+  end
+end

data/lib/fast_haml/filter_compilers/plain.rb

@@ -0,0 +1,17 @@
+require 'fast_haml/filter_compilers/base'
+
+module FastHaml
+  module FilterCompilers
+    class Plain < Base
+      def compile(texts)
+        temple = [:multi]
+        texts = strip_last_empty_lines(texts)
+        compile_texts(temple, texts[0 .. -2])
+        temple << text_compiler.compile(texts[-1])
+        temple
+      end
+    end
+
+    register(:plain, Plain)
+  end
+end

data/lib/fast_haml/filter_compilers/preserve.rb

@@ -0,0 +1,30 @@
+require 'fast_haml/filter_compilers/base'
+
+module FastHaml
+  module FilterCompilers
+    class Preserve < Base
+      include Temple::Utils
+
+      def compile(texts)
+        temple = [:multi]
+        texts.each do |text|
+          temple << text_compiler.compile(text)
+          unless texts.last.equal?(text)
+            temple << [:static, "\n"]
+          end
+        end
+        sym = unique_name
+        [:multi,
+          [:capture, sym, temple],
+          [:dynamic, "::FastHaml::FilterCompilers::Preserve.preserve(#{sym})"],
+        ]
+      end
+
+      def self.preserve(str)
+        str.gsub("\n", '&#x000A;')
+      end
+    end
+
+    register(:preserve, Preserve)
+  end
+end

data/lib/fast_haml/filter_compilers/ruby.rb

@@ -0,0 +1,13 @@
+require 'fast_haml/filter_compilers/base'
+
+module FastHaml
+  module FilterCompilers
+    class Ruby < Base
+      def compile(texts)
+        [:multi, [:code, strip_last_empty_lines(texts).join("\n")], [:newline]]
+      end
+    end
+
+    register(:ruby, Ruby)
+  end
+end

data/lib/fast_haml/filter_compilers.rb

@@ -0,0 +1,37 @@
+module FastHaml
+  module FilterCompilers
+    class NotFound < StandardError
+      attr_reader
+
+      def initialize(name)
+        super("Unable to find compiler for #{name}")
+        @name = name
+      end
+    end
+
+    def self.compilers
+      @compilers ||= {}
+    end
+
+    def self.register(name, compiler)
+      compilers[name.to_s] = compiler
+    end
+
+    def self.find(name)
+      name = name.to_s
+      if compilers.has_key?(name.to_s)
+        compilers[name].new
+      else
+        raise NotFound.new(name)
+      end
+    end
+  end
+end
+
+require 'fast_haml/filter_compilers/cdata'
+require 'fast_haml/filter_compilers/css'
+require 'fast_haml/filter_compilers/escaped'
+require 'fast_haml/filter_compilers/javascript'
+require 'fast_haml/filter_compilers/plain'
+require 'fast_haml/filter_compilers/preserve'
+require 'fast_haml/filter_compilers/ruby'

data/lib/fast_haml/filter_parser.rb

@@ -0,0 +1,54 @@
+module FastHaml
+  class FilterParser
+    def initialize(indent_tracker)
+      @ast = nil
+      @indent_level = nil
+      @indent_tracker = indent_tracker
+    end
+
+    def enabled?
+      !!@ast
+    end
+
+    def start(name)
+      @ast = Ast::Filter.new
+      @ast.name = name
+    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/fast_haml/html.rb

@@ -0,0 +1,44 @@
+require 'fast_haml/attribute_builder'
+
+module FastHaml
+  class Html < Temple::HTML::Fast
+    def on_haml_tag(name, self_closing, attrs, content = nil)
+      name = name.to_s
+      closed = self_closing && (!content || empty_exp?(content))
+      result = [:multi, [:static, "<#{name}"], compile(attrs)]
+      result << [:static, (closed && @format != :html ? ' /' : '') + '>']
+      result << compile(content) if content
+      result << [:static, "</#{name}>"] if !closed
+      result
+    end
+
+    def on_haml_attrs(code)
+      [:dynamic, "::FastHaml::AttributeBuilder.build(#{options[:attr_quote].inspect}, #{code})"]
+    end
+
+    def on_haml_attr(name, value)
+      if empty_exp?(value)
+        if @format == :html
+          [:static, " #{name}"]
+        else
+          [:static, " #{name}=#{options[:attr_quote]}#{name}#{options[:attr_quote]}"]
+        end
+      else
+        [:multi,
+          [:static, " #{name}=#{options[:attr_quote]}"],
+          compile(value),
+          [:static, options[:attr_quote]]]
+      end
+    end
+
+    def on_haml_doctype(type)
+      compile([:html, :doctype, type])
+    rescue Temple::FilterError
+      [:multi]
+    end
+
+    def on_haml_preserve(sym)
+      [:dynamic, "::FastHaml::Compiler.find_and_preserve(#{sym}.to_s)"]
+    end
+  end
+end

data/lib/fast_haml/indent_tracker.rb

@@ -0,0 +1,84 @@
+module FastHaml
+  class IndentTracker
+    class IndentMismatch < StandardError
+      attr_reader :lineno
+
+      def initialize(message, lineno)
+        super("#{message} at line #{lineno}")
+        @lineno = 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)
+      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
+
+    private
+
+    def track(indent_level, text, lineno)
+      if indent_level > @indent_levels.last
+        indent_enter(indent_level, text)
+      elsif indent_level < @indent_levels.last
+        indent_leave(indent_level, text, lineno)
+      end
+    end
+
+    def indent_enter(indent_level, text)
+      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("Unexpected indent level: #{indent_level}: indent_level=#{@indent_levels}", lineno)
+      end
+    end
+  end
+end