bade 0.2.0 → 0.2.1

data/lib/bade/parser/parser_constants.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+
+module Bade
+  require_relative '../parser'
+
+  class Parser
+    WORD_RE = ''.respond_to?(:encoding) ? '\p{Word}' : '\w'
+    NAME_RE_STRING = "(#{WORD_RE}(?:#{WORD_RE}|:|-|_)*)".freeze
+
+    ATTR_NAME_RE_STRING = "\\A\\s*#{NAME_RE_STRING}".freeze
+    CODE_ATTR_RE = /#{ATTR_NAME_RE_STRING}\s*&?:\s*/
+
+    TAG_RE = /\A#{NAME_RE_STRING}/
+    CLASS_TAG_RE = /\A\.#{NAME_RE_STRING}/
+    ID_TAG_RE = /\A##{NAME_RE_STRING}/
+  end
+end

data/lib/bade/parser/parser_lines.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+
+module Bade
+  require_relative '../parser'
+
+  class Parser
+    module LineIndicatorRegexps
+      IMPORT = /\Aimport /
+      MIXIN_DECL = /\Amixin #{NAME_RE_STRING}/
+      MIXIN_CALL = /\A\+#{NAME_RE_STRING}/
+      BLOCK_DECLARATION = /\Ablock #{NAME_RE_STRING}/
+      HTML_COMMENT = %r{\A//! }
+      NORMAL_COMMENT = %r{\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
+
+    def reset(lines = nil, stacks = nil)
+      # Since you can indent however you like in Slim, we need to keep a list
+      # of how deeply indented you are. For instance, in a template like this:
+      #
+      #   doctype       # 0 spaces
+      #   html          # 0 spaces
+      #    head         # 1 space
+      #       title     # 4 spaces
+      #
+      # indents will then contain [0, 1, 4] (when it's processing the last line.)
+      #
+      # We uses this information to figure out how many steps we must "jump"
+      # out when we see an de-indented line.
+      @indents = [0]
+
+      # Whenever we want to output something, we'll *always* output it to the
+      # last stack in this array. So when there's a line that expects
+      # indentation, we simply push a new stack onto this array. When it
+      # processes the next line, the content will then be outputted into that
+      # stack.
+      @stacks = stacks
+
+      @lineno = 0
+      @lines = lines
+
+      # @return [String]
+      @line = @orig_line = nil
+    end
+
+    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
+        @line = @orig_line.dup
+      end
+    end
+
+    def parse_line
+      if @line.strip.empty?
+        append_node(:newline) unless @lines.empty?
+        return
+      end
+
+      indent = get_indent(@line)
+
+      # left strip
+      @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.
+      expecting_indentation = @stacks.length > @indents.length
+
+      if indent > @indents.last
+        @indents << indent
+      else
+        # This line was *not* indented more than the line before,
+        # so we'll just forget about the stack that the previous line pushed.
+        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 !@stacks[indent].nil? && 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
+        # indentation:
+        #
+        #   hello
+        #       world
+        #     this      # <- This should not be possible!
+        syntax_error('Malformed indentation') if indent != @indents.last
+      end
+
+      parse_line_indicators
+    end
+
+    def parse_line_indicators(add_newline: true)
+      case @line
+      when LineIndicatorRegexps::IMPORT
+        @line = $'
+        parse_import
+
+      when LineIndicatorRegexps::MIXIN_DECL
+        # Mixin declaration
+        @line = $'
+        parse_mixin_declaration($1)
+
+      when LineIndicatorRegexps::MIXIN_CALL
+        # Mixin call
+        @line = $'
+        parse_mixin_call($1)
+
+      when LineIndicatorRegexps::BLOCK_DECLARATION
+        @line = $'
+        if @stacks.last.last.type == :mixin_call
+          node = append_node(:mixin_block, add: true)
+          node.name = $1
+        else
+          # keyword block used outside of mixin call
+          parse_tag($&)
+        end
+
+      when LineIndicatorRegexps::HTML_COMMENT
+        # HTML comment
+        append_node(:html_comment, add: true)
+        parse_text_block $', @indents.last + @tabsize
+
+      when LineIndicatorRegexps::NORMAL_COMMENT
+        # Comment
+        append_node(:comment, add: true)
+        parse_text_block $', @indents.last + @tabsize
+
+      when LineIndicatorRegexps::TEXT_BLOCK_START
+        # Found a text block.
+        parse_text_block $', @indents.last + @tabsize
+
+      when LineIndicatorRegexps::INLINE_HTML
+        # Inline html
+        parse_text
+
+      when LineIndicatorRegexps::CODE_BLOCK
+        # Found a code block.
+        append_node(:code, value: $'.strip)
+
+      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.conditional = $1.length == 1
+        output_node.escaped = $2.length == 1
+        output_node.value = parse_ruby_code(ParseRubyCodeRegexps::END_NEW_LINE)
+
+      when LineIndicatorRegexps::DOCTYPE
+        # Found doctype declaration
+        append_node(:doctype, value: $'.strip)
+
+      when TAG_RE
+        # Found a HTML tag.
+        @line = $' if $1
+        parse_tag($&)
+
+      when LineIndicatorRegexps::TAG_CLASS_START_BLOCK
+        # Found class name -> implicit div
+        parse_tag 'div'
+
+      when LineIndicatorRegexps::TAG_ID_START_BLOCK
+        # Found id name -> implicit div
+        parse_tag 'div'
+
+      else
+        syntax_error 'Unknown line indicator'
+      end
+
+      append_node(:newline) if add_newline && !@lines.empty?
+    end
+  end
+end

data/lib/bade/parser/parser_mixin.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+
+module Bade
+  require_relative '../parser'
+
+  class Parser
+    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_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 MixinRegexps::TEXT_START
+        @line = $'
+        parse_text
+
+      when MixinRegexps::BLOCK_EXPANSION
+        # Block expansion
+        @line = $'
+        parse_line_indicators(add_newline: false)
+
+      when MixinRegexps::OUTPUT_CODE
+        # Handle output code
+        parse_line_indicators(add_newline: false)
+
+      when ''
+        # nothing
+
+      else
+        syntax_error "Unknown symbol after mixin calling, line = `#{@line}'"
+      end
+    end
+
+    def parse_mixin_call_params
+      # between tag name and attribute must not be space
+      # and skip when is nothing other
+      return unless @line.start_with?('(')
+
+      # remove starting bracket
+      @line.remove_first!
+
+      loop do
+        case @line
+        when MixinRegexps::PARAMS_KEY_PARAM_NAME
+          @line = $'
+          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 MixinRegexps::PARAMS_ARGS_DELIMITER
+          # args delimiter
+          @line = $'
+          next
+
+        when MixinRegexps::PARAMS_END_SPACES
+          # spaces and/or end of line
+          next_line
+          next
+
+        when MixinRegexps::PARAMS_END
+          # Find ending delimiter
+          @line = $'
+          break
+
+        else
+          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_decl, add: true)
+      mixin_node.name = mixin_name
+
+      parse_mixin_declaration_params
+    end
+
+    def parse_mixin_declaration_params
+      # between tag name and attribute must not be space
+      # and skip when is nothing other
+      return unless @line.start_with?('(')
+
+      # remove starting bracket
+      @line.remove_first!
+
+      loop do
+        case @line
+        when MixinRegexps::PARAMS_KEY_PARAM_NAME
+          # Value ruby code
+          @line = $'
+          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 MixinRegexps::PARAMS_PARAM_NAME
+          @line = $'
+          append_node(:mixin_param, value: $1)
+
+        when MixinRegexps::PARAMS_BLOCK_NAME
+          @line = $'
+          append_node(:mixin_block_param, value: $1)
+
+        when MixinRegexps::PARAMS_ARGS_DELIMITER
+          # args delimiter
+          @line = $'
+          next
+
+        when MixinRegexps::PARAMS_END
+          # Find ending delimiter
+          @line = $'
+          break
+
+        else
+          syntax_error('wrong mixin attribute syntax')
+        end
+      end
+    end
+  end
+end

data/lib/bade/parser/parser_ruby_code.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+
+module Bade
+  require_relative '../parser'
+
+  class Parser
+    module ParseRubyCodeRegexps
+      END_NEW_LINE = /\A\s*\n/
+      END_PARAMS_ARG = /\A\s*[,)]/
+    end
+
+    # Parse ruby code, ended with outer delimiters
+    #
+    # @param [String, Regexp] outer_delimiters
+    #
+    # @return [Void] parsed ruby code
+    #
+    def parse_ruby_code(outer_delimiters)
+      code = String.new
+      end_re = if outer_delimiters.is_a?(Regexp)
+                 outer_delimiters
+               else
+                 /\A\s*[#{Regexp.escape outer_delimiters.to_s}]/
+               end
+      delimiters = []
+
+      until @line.empty? || (delimiters.count == 0 && @line =~ end_re)
+        char = @line[0]
+
+        # backslash escaped delimiter
+        if char == '\\' && RUBY_ALL_DELIMITERS.include?(@line[1])
+          code << @line.slice!(0, 2)
+          next
+        end
+
+        case char
+        when RUBY_START_DELIMITERS_RE
+          if RUBY_NOT_NESTABLE_DELIMITERS.include?(char) && delimiters.last == char
+            # end char of not nestable delimiter
+            delimiters.pop
+          else
+            # diving
+            delimiters << char
+          end
+
+        when RUBY_END_DELIMITERS_RE
+          # rising
+          delimiters.pop if char == RUBY_DELIMITERS_REVERSE[delimiters.last]
+        end
+
+        code << @line.slice!(0)
+      end
+
+      syntax_error('Unexpected end of ruby code') unless delimiters.empty?
+
+      code.strip
+    end
+
+    RUBY_DELIMITERS_REVERSE = {
+      '(' => ')',
+      '[' => ']',
+      '{' => '}',
+    }.freeze
+
+    RUBY_QUOTES = %w(' ").freeze
+
+    RUBY_NOT_NESTABLE_DELIMITERS = RUBY_QUOTES
+
+    RUBY_START_DELIMITERS = (%w(\( [ {) + RUBY_NOT_NESTABLE_DELIMITERS).freeze
+    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}]/
+  end
+end