bade 0.1.4 → 0.2.0

data/lib/bade/generator.rb

@@ -1,16 +1,363 @@
-require_relative 'node'
+# frozen_string_literal: true
+
+require_relative 'runtime'
+
+require_relative 'ast/document'
 
 module Bade
   class Generator
-    require_relative 'generator/html_generator'
-    require_relative 'generator/ruby_generator'
+    BUFF_NAME = :__buff
+    MIXINS_NAME = :__mixins
+    NEW_LINE_NAME = :__new_line
+    CURRENT_INDENT_NAME = :__indent
+    BASE_INDENT_NAME = :__base_indent
+
+    DEFAULT_BLOCK_NAME = 'default_block'
+
+    # @param [Document] document
+    #
+    # @return [String]
+    #
+    def self.document_to_lambda_string(document)
+      generator = self.new
+      generator.generate_lambda_string(document)
+    end
+
+    # @param [Bade::AST::Document] document
+    #
+    # @return [String] string to parse with Ruby
+    #
+    def generate_lambda_string(document)
+      @document = document
+      @buff = []
+      @indent = 0
+      @code_indent = 0
+
+      buff_code '# frozen_string_literal: true' # so it can be faster on Ruby 2.3+
+      buff_code ''
+      buff_code "lambda do |#{NEW_LINE_NAME}: \"\\n\", #{BASE_INDENT_NAME}: '  '|"
+
+      code_indent {
+        buff_code "self.#{NEW_LINE_NAME} = #{NEW_LINE_NAME}"
+        buff_code "self.#{BASE_INDENT_NAME} = #{BASE_INDENT_NAME}"
+
+        visit_document(document)
+
+        buff_code "output = #{BUFF_NAME}.join"
+        buff_code 'self.__reset'
+        buff_code 'output'
+      }
+
+      buff_code 'end'
+
+
+      @document = nil
+
+      @buff.join("\n")
+    end
+
+    # @param [String] text
+    #
+    def buff_print_text(text, indent: false, new_line: false)
+      buff_print_value(%Q{%Q{#{text}}}) if text.length > 0
+    end
+
+    def buff_print_value(value)
+      # buff_code %Q{#{BUFF_NAME} << #{CURRENT_INDENT_NAME}} if indent
+      buff_code(%Q{#{BUFF_NAME} << #{value}})
+    end
+
+    def buff_code(text)
+      @buff << '  ' * @code_indent + text
+    end
+
+
+    # @param document [Bade::Document]
+    #
+    def visit_document(document)
+      document.sub_documents.each do |sub_document|
+        visit_document(sub_document)
+      end
+
+      buff_code("# ----- start file #{document.file_path}") unless document.file_path.nil?
+      visit_node(document.root)
+      buff_code("# ----- end file #{document.file_path}") unless document.file_path.nil?
+    end
+
+    # @param current_node [Node]
+    #
+    def visit_node_children(current_node)
+      visit_nodes(current_node.children)
+    end
+
+    # @param nodes [Array<Node>]
+    #
+    def visit_nodes(nodes)
+      nodes.each { |node|
+        visit_node(node)
+      }
+    end
+
+    # @param current_node [Node]
+    #
+    def visit_node(current_node)
+      case current_node.type
+        when :root
+          visit_node_children(current_node)
+
+        when :text
+          buff_print_text current_node.value
+
+        when :tag
+          visit_tag(current_node)
+
+        when :code
+          buff_code(current_node.value)
+
+        when :html_comment
+          buff_print_text '<!-- '
+          visit_node_children(current_node)
+          buff_print_text ' -->'
+
+        when :comment
+          comment_text = '#' + current_node.children.map(&:value).join("\n#")
+          buff_code(comment_text)
+
+        when :doctype
+          buff_print_text current_node.xml_output
+
+        when :mixin_decl
+          params = formatted_mixin_params(current_node)
+          buff_code "#{MIXINS_NAME}['#{current_node.name}'] = __create_mixin('#{current_node.name}', &lambda { |#{params}|"
+
+          code_indent {
+            blocks_name_declaration(current_node)
+            visit_nodes(current_node.children - current_node.params)
+          }
+
+          buff_code '})'
+
+        when :mixin_call
+          params = formatted_mixin_params(current_node)
+          buff_code "#{MIXINS_NAME}['#{current_node.name}'].call!(#{params})"
+
+        when :output
+          data = current_node.value
+          output_code = if current_node.escaped
+                          "\#{__html_escaped(#{data})}"
+                        else
+                          "\#{#{data}}"
+                        end
+          buff_print_text output_code
+
+        when :newline
+          # buff_print_value(NEW_LINE_NAME)
+
+        when :import
+          base_path = File.expand_path(current_node.value, File.dirname(@document.file_path))
+          load_path = if base_path.end_with?('.rb') && File.exist?(base_path)
+                        base_path
+                      elsif File.exist?("#{base_path}.rb")
+                        "#{base_path}.rb"
+                      else
+                        nil # other cases are handled in Renderer
+                      end
+
+          buff_code "load('#{load_path}')" unless load_path.nil?
+
+        else
+          raise "Unknown type #{current_node.type}"
+      end
+    end
+
+    # @param [TagNode] current_node
+    #
+    # @return [nil]
+    #
+    def visit_tag(current_node)
+      attributes = formatted_attributes(current_node)
+      children_wo_attributes = (current_node.children - current_node.attributes)
+
+      text = "<#{current_node.name}"
 
-    # @param [Node] root
+      if attributes.length > 0
+        text += "#{attributes}"
+      end
+
+      other_than_new_lines = children_wo_attributes.any? { |node|
+        node.type != :newline
+      }
+
+      if other_than_new_lines
+        text += '>'
+      else
+        text += '/>'
+      end
+
+      conditional_nodes = current_node.children.select { |n| n.type == :output && n.conditional }
+
+      unless conditional_nodes.empty?
+        buff_code "if (#{conditional_nodes.map(&:value).join(') && (')})"
+
+        @code_indent += 1
+      end
+
+      buff_print_text(text, new_line: true, indent: true)
+
+      if other_than_new_lines
+        last_node = children_wo_attributes.last
+        is_last_newline = !last_node.nil? && last_node.type == :newline
+        nodes = if is_last_newline
+                  children_wo_attributes[0...-1]
+                else
+                  children_wo_attributes
+                end
+
+        code_indent do
+          visit_nodes(nodes)
+        end
+
+        buff_print_text("</#{current_node.name}>", new_line: true, indent: true)
+
+        # print new line after the tag
+        visit_node(last_node) if is_last_newline
+      end
+
+      unless conditional_nodes.empty?
+        @code_indent -= 1
+
+        buff_code 'end'
+      end
+    end
+
+    # @param [TagNode] tag_node
     #
-    # @return [Lambda]
+    # @return [String] formatted attributes
     #
-    def self.node_to_lambda(root, new_line: "\n", indent: "\t", filename: '')
+    def formatted_attributes(tag_node)
+      all_attributes = Hash.new { |hash, key| hash[key] = [] }
+      xml_attributes = []
+
+      tag_node.attributes.each do |attr|
+        unless all_attributes.include?(attr.name)
+          xml_attributes << attr.name
+        end
 
+        all_attributes[attr.name] << attr.value
+      end
+
+      xml_attributes.map do |attr_name|
+        joined = all_attributes[attr_name].join('), (')
+        %Q{\#{__tag_render_attribute('#{attr_name}', (#{joined}))}}
+      end.join
+    end
+
+    # Method for indenting generated code, indent is raised only in passed block
+    #
+    # @return [nil]
+    #
+    def code_indent(plus = 1)
+      @code_indent += plus
+      yield
+      @code_indent -= plus
+    end
+
+    # @param [MixinCommonNode] mixin_node
+    #
+    # @return [String] formatted params
+    #
+    def formatted_mixin_params(mixin_node)
+      params = mixin_node.params
+      result = []
+
+      if mixin_node.type == :mixin_call
+        blocks = mixin_node.blocks
+
+        other_children = (mixin_node.children - mixin_node.blocks - mixin_node.params)
+        if other_children.reject { |n| n.type == :newline }.count > 0
+          def_block_node = AST::NodeRegistrator.create(:mixin_block, mixin_node.lineno)
+          def_block_node.name = DEFAULT_BLOCK_NAME
+          def_block_node.children = other_children
+
+          blocks << def_block_node
+        end
+
+        if blocks.length > 0
+          buff_code '__blocks = {}'
+
+          blocks.each do |block|
+            block_definition(block)
+          end
+
+          result << '__blocks.dup'
+        else
+          result << '{}'
+        end
+      elsif mixin_node.type == :mixin_decl
+        result << '__blocks'
+      end
+
+
+      # normal params
+      result += params.select { |n| n.type == :mixin_param }.map(&:value)
+      result += params.select { |n| n.type == :mixin_key_param }.map { |param| "#{param.name}: #{param.value}" }
+
+      result.join(', ')
+    end
+
+    # Generates code for definition of block
+    #
+    # @param [MixinCallBlockNode] block_node
+    #
+    # @return [nil]
+    #
+    def block_definition(block_node)
+      buff_code "__blocks['#{block_node.name}'] = __create_block('#{block_node.name}') do"
+
+      code_indent do
+        buff_code '__buffs_push()'
+
+        visit_node_children(block_node)
+
+        buff_code '__buffs_pop()'
+      end
+
+      buff_code 'end'
+    end
+
+    # Generates code for block variables declaration in mixin definition
+    #
+    # @param [String] block_name
+    #
+    # @return [nil]
+    #
+    def block_name_declaration(block_name)
+      buff_code "#{block_name} = __blocks.delete('#{block_name}') { __create_block('#{block_name}') }"
+    end
+
+    # @param [MixinDeclarationNode] mixin_node
+    #
+    # @return [nil]
+    #
+    def blocks_name_declaration(mixin_node)
+      block_name_declaration(DEFAULT_BLOCK_NAME)
+
+      mixin_node.params.select { |n| n.type == :mixin_block_param }.each do |param|
+        block_name_declaration(param.value)
+      end
+    end
+
+
+
+    # @param [String] str
+    #
+    # @return [Void]
+    #
+    def escape_double_quotes!(str)
+      str.gsub!(/"/, '\"')
     end
   end
+
+  # backward compatibility
+  RubyGenerator = Generator
 end

data/lib/bade/parser.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'ast/node'
+require_relative 'ast/document'
+require_relative 'ast/node_registrator'
 
-require_relative 'node'
-require_relative 'document'
 require_relative 'ruby_extensions/string'
+require_relative 'ruby_extensions/array'
 
 module Bade
   class Parser
@@ -29,35 +33,36 @@ module Bade
 
     class ParserInternalError < StandardError; end
 
+    # @type @stacks [Array<Bade::Node>]
+
     # @return [Array<String>]
     #
     attr_reader :dependency_paths
 
-    # Initialize
+    # @return [String]
     #
-    # Available options:
-    #   :tabsize [Int]    default 4
-    #   :file [String]    default nil
+    attr_reader :file_path
+
+    # @param [Fixnum] tabsize
+    # @param [String] file_path
     #
-    def initialize(options = {})
+    def initialize(tabsize: 4, file_path: nil)
       @line = ''
 
-      tabsize = options.delete(:tabsize) { 4 }
       @tabsize = tabsize
+      @file_path = file_path
 
       @tab_re = /\G((?: {#{tabsize}})*) {0,#{tabsize-1}}\t/
       @tab = '\1' + ' ' * tabsize
 
-      @options = options
-
       reset
     end
 
     # @param [String, Array<String>] str
-    # @return [Bade::Document] root node
+    # @return [Bade::AST::Document] root node
     #
     def parse(str)
-      @document = Document.new(file_path: @options[:file_path])
+      @document = AST::Document.new(file_path: file_path)
       @root = @document.root
 
       @dependency_paths = []
@@ -65,7 +70,7 @@ module Bade
       if str.kind_of? Array
         reset(str, [[@root]])
       else
-        reset(str.split(/\r?\n/), [[@root]])
+        reset(str.split(/\r?\n/, -1), [[@root]]) # -1 is for not suppressing empty lines
       end
 
       parse_line while next_line
@@ -81,7 +86,7 @@ module Bade
     NAME_RE_STRING = "(#{WORD_RE}(?:#{WORD_RE}|:|-|_)*)"
 
     ATTR_NAME_RE_STRING = "\\A\\s*#{NAME_RE_STRING}"
-    CODE_ATTR_RE = /#{ATTR_NAME_RE_STRING}\s*(&?):\s*/
+    CODE_ATTR_RE = /#{ATTR_NAME_RE_STRING}\s*&?:\s*/
 
     TAG_RE = /\A#{NAME_RE_STRING}/
     CLASS_TAG_RE = /\A\.#{NAME_RE_STRING}/
@@ -119,6 +124,11 @@ module Bade
     def next_line
       if @lines.empty?
         @orig_line = @line = nil
+
+        last_newlines = remove_last_newlines
+        @root.children += last_newlines
+
+        nil
       else
         @orig_line = @lines.shift
         @lineno += 1
@@ -140,16 +150,16 @@ module Bade
     #
     # @param [Symbol] type
     #
-    def append_node(type, indent: @indents.length, add: false, data: nil)
+    def append_node(type, indent: @indents.length, add: false, value: nil)
       while indent >= @stacks.length
         @stacks << @stacks.last.dup
       end
 
       parent = @stacks[indent].last
-      node = Node.create(type, parent)
-      node.lineno = @lineno
+      node = AST::NodeRegistrator.create(type, @lineno)
+      parent.children << node
 
-      node.data = data
+      node.value = value unless value.nil?
 
       if add
         @stacks[indent] << node
@@ -158,19 +168,24 @@ module Bade
       node
     end
 
-    def parse_line
-      line = @line
+    # @return [Array<AST::Node>]
+    #
+    def remove_last_newlines
+      last_node = @stacks.last.last
+      last_newlines_count = last_node.children.rcount_matching { |n| n.type == :newline }
+      last_node.children.pop(last_newlines_count)
+    end
 
-      if line =~ /\A\s*\Z/
-        append_node :newline
+    def parse_line
+      if @line.strip.length == 0
+        append_node(:newline) unless @lines.empty?
         return
       end
 
-      indent = get_indent(line)
+      indent = get_indent(@line)
 
       # left strip
-      line.remove_indent!(indent, @tabsize)
-      @line = line
+      @line.remove_indent!(indent, @tabsize)
 
       # If there's more stacks than indents, it means that the previous
       # line is expecting this line to be indented.
@@ -181,19 +196,36 @@ module Bade
       else
         # This line was *not* indented more than the line before,
         # so we'll just forget about the stack that the previous line pushed.
-        @stacks.pop if expecting_indentation
+        if expecting_indentation
+          last_newlines = remove_last_newlines
+
+          @stacks.pop
+
+          new_node = @stacks.last.last
+          new_node.children += last_newlines
+        end
 
         # This line was deindented.
         # Now we're have to go through the all the indents and figure out
         # how many levels we've deindented.
         while indent < @indents.last
+          last_newlines = remove_last_newlines
+
           @indents.pop
           @stacks.pop
+
+          new_node = @stacks.last.last
+          new_node.children += last_newlines
         end
 
         # Remove old stacks we don't need
         while not @stacks[indent].nil? and indent < @stacks[indent].length - 1
+          last_newlines = remove_last_newlines
+
           @stacks[indent].pop
+
+          new_node = @stacks.last.last
+          new_node.children += last_newlines
         end
 
         # This line's indentation happens lie "between" two other line's
@@ -208,83 +240,98 @@ module Bade
       parse_line_indicators
     end
 
-    def parse_line_indicators
-      add_new_line = true
+    module LineIndicatorRegexps
+      IMPORT = /\Aimport /
+      MIXIN_DECL = /\Amixin #{NAME_RE_STRING}/
+      MIXIN_CALL = /\A\+#{NAME_RE_STRING}/
+      BLOCK_DECLARATION = /\Ablock #{NAME_RE_STRING}/
+      HTML_COMMENT = /\A\/\/! /
+      NORMAL_COMMENT = /\A\/\//
+      TEXT_BLOCK_START = /\A\|( ?)/
+      INLINE_HTML = /\A</
+      CODE_BLOCK = /\A-/
+      OUTPUT_BLOCK = /\A(\??)(&?)=/
+      DOCTYPE = /\Adoctype\s/i
+      TAG_CLASS_START_BLOCK = /\A\./
+      TAG_ID_START_BLOCK = /\A#/
+    end
+
+    module ParseRubyCodeRegexps
+      END_NEW_LINE = /\A\s*\n/
+      END_PARAMS_ARG = /\A\s*[,)]/
+    end
 
+    def parse_line_indicators(add_newline: true)
       case @line
-        when /\Aimport /
+        when LineIndicatorRegexps::IMPORT
           @line = $'
           parse_import
 
-        when /\Amixin #{NAME_RE_STRING}/
+        when LineIndicatorRegexps::MIXIN_DECL
           # Mixin declaration
           @line = $'
           parse_mixin_declaration($1)
 
-        when /\A\+#{NAME_RE_STRING}/
+        when LineIndicatorRegexps::MIXIN_CALL
           # Mixin call
           @line = $'
           parse_mixin_call($1)
 
-        when /\Ablock #{NAME_RE_STRING}/
+        when LineIndicatorRegexps::BLOCK_DECLARATION
           @line = $'
           if @stacks.last.last.type == :mixin_call
-            append_node :mixin_block, data: $1, add: true
+            node = append_node(:mixin_block, add: true)
+            node.name = $1
           else
             # keyword block used outside of mixin call
             parse_tag($&)
           end
 
-        when /\A\/\/! /
+        when LineIndicatorRegexps::HTML_COMMENT
           # HTML comment
-          append_node :html_comment, add: true
+          append_node(:html_comment, add: true)
           parse_text_block $', @indents.last + @tabsize
 
-        when /\A\/\//
+        when LineIndicatorRegexps::NORMAL_COMMENT
           # Comment
-          append_node :comment, add: true
+          append_node(:comment, add: true)
           parse_text_block $', @indents.last + @tabsize
 
-        when /\A\|( ?)/
+        when LineIndicatorRegexps::TEXT_BLOCK_START
           # Found a text block.
           parse_text_block $', @indents.last + @tabsize
 
-        when /\A</
+        when LineIndicatorRegexps::INLINE_HTML
           # Inline html
-          append_node :text, data: @line
+          append_node(:text, value: @line)
 
-        when /\A-\s*(.*)\Z/
+        when LineIndicatorRegexps::CODE_BLOCK
           # Found a code block.
-          code_node = append_node :ruby_code
-          code_node.data = $1
-          add_new_line = false
+          append_node(:code, value: $'.strip)
 
-        when /\A(&?)=/
+        when LineIndicatorRegexps::OUTPUT_BLOCK
           # Found an output block.
           # We expect the line to be broken or the next line to be indented.
           @line = $'
-          output_node = append_node :output
-          output_node.escaped = $1.length == 1
-          output_node.data = parse_ruby_code("\n")
-
-        when /\A(\w+):\s*\Z/
-          # Embedded template detected. It is treated as block.
-          @stacks.last << [:slim, :embedded, $1, parse_text_block]
+          output_node = append_node(:output)
+          output_node.conditional = $1.length == 1
+          output_node.escaped = $2.length == 1
+          output_node.value = parse_ruby_code(ParseRubyCodeRegexps::END_NEW_LINE)
 
-        when /\Adoctype\s/i
+        when LineIndicatorRegexps::DOCTYPE
           # Found doctype declaration
-          append_node :doctype, data: $'.strip
+          append_node(:doctype, value: $'.strip)
 
         when TAG_RE
           # Found a HTML tag.
           @line = $' if $1
           parse_tag($&)
 
-        when /\A\./
+        when LineIndicatorRegexps::TAG_CLASS_START_BLOCK
           # Found class name -> implicit div
           parse_tag 'div'
 
-        when /\A#/
+        when LineIndicatorRegexps::TAG_ID_START_BLOCK
           # Found id name -> implicit div
           parse_tag 'div'
 
@@ -292,38 +339,54 @@ module Bade
           syntax_error 'Unknown line indicator'
       end
 
-      append_node :newline if add_new_line
+      append_node(:newline) if add_newline && !@lines.empty?
     end
 
     def parse_import
       path = eval(@line)
-      import_node = append_node :import
-      import_node.data = path
+      append_node(:import, value: path)
 
       @dependency_paths << path unless @dependency_paths.include?(path)
     end
 
+    module MixinRegexps
+      TEXT_START = /\A /
+      BLOCK_EXPANSION = /\A:\s+/
+      OUTPUT_CODE = /\A(&?)=/
+
+      PARAMS_END = /\A\s*\)/
+
+      PARAMS_END_SPACES = /^\s*$/
+      PARAMS_ARGS_DELIMITER = /\A\s*,/
+
+      PARAMS_PARAM_NAME = /\A\s*#{NAME_RE_STRING}/
+      PARAMS_BLOCK_NAME = /\A\s*&#{NAME_RE_STRING}/
+      PARAMS_KEY_PARAM_NAME = CODE_ATTR_RE
+    end
+
     def parse_mixin_call(mixin_name)
-      mixin_node = append_node :mixin_call, add: true
-      mixin_node.data = mixin_name
+      mixin_name = fixed_trailing_colon(mixin_name)
+
+      mixin_node = append_node(:mixin_call, add: true)
+      mixin_node.name = mixin_name
 
       parse_mixin_call_params
 
       case @line
-        when /\A /
+        when MixinRegexps::TEXT_START
           @line = $'
           parse_text
 
-        when /\A:\s+/
+        when MixinRegexps::BLOCK_EXPANSION
           # Block expansion
           @line = $'
-          parse_line_indicators
+          parse_line_indicators(add_newline: false)
 
-        when /\A(&?)=/
+        when MixinRegexps::OUTPUT_CODE
           # Handle output code
-          parse_line_indicators
+          parse_line_indicators(add_newline: false)
 
-        when /^$/
+        when ''
           # nothing
 
         else
@@ -334,47 +397,45 @@ module Bade
     def parse_mixin_call_params
       # between tag name and attribute must not be space
       # and skip when is nothing other
-      if @line =~ /\A\(/
-        @line = $'
+      if @line.start_with?('(')
+        @line.remove_first!
       else
         return
       end
 
-      end_re = /\A\s*\)/
-
       while true
         case @line
-          when CODE_ATTR_RE
+          when MixinRegexps::PARAMS_KEY_PARAM_NAME
             @line = $'
-            attr_node = append_node :mixin_key_param
-            attr_node.name = $1
-            attr_node.value = parse_ruby_code(',)')
+            attr_node = append_node(:mixin_key_param)
+            attr_node.name = fixed_trailing_colon($1)
+            attr_node.value = parse_ruby_code(ParseRubyCodeRegexps::END_PARAMS_ARG)
 
-          when /\A\s*,/
+          when MixinRegexps::PARAMS_ARGS_DELIMITER
             # args delimiter
             @line = $'
             next
 
-          when /^\s*$/
+          when MixinRegexps::PARAMS_END_SPACES
             # spaces and/or end of line
             next_line
             next
 
-          when end_re
+          when MixinRegexps::PARAMS_END
             # Find ending delimiter
             @line = $'
             break
 
           else
-            attr_node = append_node :mixin_param
-            attr_node.data = parse_ruby_code(',)')
+            attr_node = append_node(:mixin_param)
+            attr_node.value = parse_ruby_code(ParseRubyCodeRegexps::END_PARAMS_ARG)
         end
       end
     end
 
     def parse_mixin_declaration(mixin_name)
-      mixin_node = append_node :mixin_declaration, add: true
-      mixin_node.data = mixin_name
+      mixin_node = append_node(:mixin_decl, add: true)
+      mixin_node.name = mixin_name
 
       parse_mixin_declaration_params
     end
@@ -382,37 +443,35 @@ module Bade
     def parse_mixin_declaration_params
       # between tag name and attribute must not be space
       # and skip when is nothing other
-      if @line =~ /\A\(/
-        @line = $'
+      if @line.start_with?('(')
+        @line.remove_first!
       else
         return
       end
 
-      end_re = /\A\s*\)/
-
       while true
         case @line
-          when CODE_ATTR_RE
+          when MixinRegexps::PARAMS_KEY_PARAM_NAME
             # Value ruby code
             @line = $'
-            attr_node = append_node :mixin_key_param
-            attr_node.name = $1
-            attr_node.value = parse_ruby_code(',)')
+            attr_node = append_node(:mixin_key_param)
+            attr_node.name = fixed_trailing_colon($1)
+            attr_node.value = parse_ruby_code(ParseRubyCodeRegexps::END_PARAMS_ARG)
 
-          when /\A\s*#{NAME_RE_STRING}/
+          when MixinRegexps::PARAMS_PARAM_NAME
             @line = $'
-            append_node :mixin_param, data: $1
+            append_node(:mixin_param, value: $1)
 
-          when /\A\s*&#{NAME_RE_STRING}/
+          when MixinRegexps::PARAMS_BLOCK_NAME
             @line = $'
-            append_node :mixin_block_param, data: $1
+            append_node(:mixin_block_param, value: $1)
 
-          when /\A\s*,/
+          when MixinRegexps::PARAMS_ARGS_DELIMITER
             # args delimiter
             @line = $'
             next
 
-          when end_re
+          when MixinRegexps::PARAMS_END
             # Find ending delimiter
             @line = $'
             break
@@ -425,17 +484,26 @@ module Bade
 
     def parse_text
       text = @line
-      text = text.gsub(/&\{/, '#{ html_escaped ')
-      append_node :text, data: text
+      text = text.gsub(/&\{/, '#{ __html_escaped ')
+      append_node(:text, value: text)
     end
 
 
+    module TagRegexps
+      BLOCK_EXPANSION = /\A:\s+/
+      OUTPUT_CODE = LineIndicatorRegexps::OUTPUT_BLOCK
+      TEXT_START = /\A /
+
+      PARAMS_ARGS_DELIMITER = /\A\s*,/
+      PARAMS_END = /\A\s*\)/
+    end
+
     # @param value [String]
     #
     def fixed_trailing_colon(value)
-      if value =~ /(:)\Z/
-        value = value.sub /:\Z/, ''
-        @line.prepend ':'
+      if String === value && value.end_with?(':')
+        value = value.remove_last
+        @line.prepend(':')
       end
 
       value
@@ -447,30 +515,30 @@ module Bade
     def parse_tag(tag)
       tag = fixed_trailing_colon(tag)
 
-      if tag.is_a? Node
+      if tag.is_a?(AST::Node)
         tag_node = tag
       else
-        tag_node = append_node :tag, add: true
+        tag_node = append_node(:tag, add: true)
         tag_node.name = tag
       end
 
       parse_tag_attributes
 
       case @line
-        when /\A:\s+/
+        when TagRegexps::BLOCK_EXPANSION
           # Block expansion
           @line = $'
-          parse_line_indicators
+          parse_line_indicators(add_newline: false)
 
-        when /\A(&?)=/
+        when TagRegexps::OUTPUT_CODE
           # Handle output code
-          parse_line_indicators
+          parse_line_indicators(add_newline: false)
 
         when CLASS_TAG_RE
           # Class name
           @line = $'
 
-          attr_node = append_node :tag_attribute
+          attr_node = append_node(:tag_attr)
           attr_node.name = 'class'
           attr_node.value = fixed_trailing_colon($1).single_quote
 
@@ -480,18 +548,18 @@ module Bade
           # Id name
           @line = $'
 
-          attr_node = append_node :tag_attribute
+          attr_node = append_node(:tag_attr)
           attr_node.name = 'id'
           attr_node.value = fixed_trailing_colon($1).single_quote
 
           parse_tag tag_node
 
-        when /\A /
+        when TagRegexps::TEXT_START
           # Text content
           @line = $'
           parse_text
 
-        when /^$/
+        when ''
           # nothing
 
         else
@@ -504,29 +572,27 @@ module Bade
 
       # between tag name and attribute must not be space
       # and skip when is nothing other
-      if @line =~ /\A\(/
-        @line = $'
+      if @line.start_with?('(')
+        @line.remove_first!
       else
         return
       end
 
-      end_re = /\A\s*\)/
-
       while true
         case @line
           when CODE_ATTR_RE
             # Value ruby code
             @line = $'
-            attr_node = append_node :tag_attribute
+            attr_node = append_node(:tag_attr)
             attr_node.name = $1
-            attr_node.value = parse_ruby_code(',)')
+            attr_node.value = parse_ruby_code(ParseRubyCodeRegexps::END_PARAMS_ARG)
 
-          when /\A\s*,/
+          when TagRegexps::PARAMS_ARGS_DELIMITER
             # args delimiter
             @line = $'
             next
 
-          when end_re
+          when TagRegexps::PARAMS_END
             # Find ending delimiter
             @line = $'
             break
@@ -537,8 +603,8 @@ module Bade
             syntax_error('Expected attribute') unless @line.empty?
 
             # Attributes span multiple lines
-            @stacks.last << [:newline]
-            syntax_error("Expected closing delimiter #{delimiter}") if @lines.empty?
+            append_node(:newline)
+            syntax_error('Expected closing tag attributes delimiter `)`') if @lines.empty?
             next_line
         end
       end
@@ -553,9 +619,9 @@ module Bade
       end
 
       until @lines.empty?
-        if @lines.first =~ /\A\s*\Z/
+        if @lines.first.blank?
           next_line
-          append_node :newline
+          append_node(:newline)
         else
           indent = get_indent(@lines.first)
           break if indent <= @indents.last
@@ -575,13 +641,17 @@ module Bade
 
     # Parse ruby code, ended with outer delimiters
     #
-    # @param [String] outer_delimiters
+    # @param [String, Regexp] outer_delimiters
     #
     # @return [Void] parsed ruby code
     #
     def parse_ruby_code(outer_delimiters)
-      code = ''
-      end_re = /\A\s*[#{Regexp.escape outer_delimiters.to_s}]/
+      code = String.new
+      end_re = if Regexp === outer_delimiters
+                 outer_delimiters
+               else
+                 /\A\s*[#{Regexp.escape outer_delimiters.to_s}]/
+               end
       delimiters = []
 
       until @line.empty? or (delimiters.count == 0 and @line =~ end_re)
@@ -634,8 +704,8 @@ module Bade
     RUBY_END_DELIMITERS = (%w(\) ] }) + RUBY_NOT_NESTABLE_DELIMITERS).freeze
     RUBY_ALL_DELIMITERS = (RUBY_START_DELIMITERS + RUBY_END_DELIMITERS).uniq.freeze
 
-    RUBY_START_DELIMITERS_RE = /\A[#{Regexp.escape RUBY_START_DELIMITERS.join('')}]/
-    RUBY_END_DELIMITERS_RE = /\A[#{Regexp.escape RUBY_END_DELIMITERS.join('')}]/
+    RUBY_START_DELIMITERS_RE = /\A[#{Regexp.escape RUBY_START_DELIMITERS.join}]/
+    RUBY_END_DELIMITERS_RE = /\A[#{Regexp.escape RUBY_END_DELIMITERS.join}]/
 
 
     # ----------- Errors ---------------
@@ -645,7 +715,7 @@ module Bade
     # @param [String] message
     #
     def syntax_error(message)
-      raise SyntaxError.new(message, @options[:file], @orig_line, @lineno,
+      raise SyntaxError.new(message, file_path, @orig_line, @lineno,
                   @orig_line && @line ? @orig_line.size - @line.size : 0)
     end
   end