Method handle_multiline has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def handle_multiline(line)
      return unless is_multiline?(line.text)
      line.text.slice!(-1)
      loop do
        new_line = @template.first

• Read up
  Read up

Method each_attr has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

    def each_attr(tokens)
      attr_tokens = []
      open_tokens = Hash.new { |h, k| h[k] = 0 }

      tokens.each do |token|

• Read up
  Read up

Method compile_contents has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.

Open

      def compile_contents(node, &block)
        case
        when !node.children.empty?
          yield(node)
        when node.value[:value].nil? && self_closing?(node)

• Read up
  Read up

Method process_line has 34 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def process_line(line)
      case line.text[0]
      when DIV_CLASS; push div(line)
      when DIV_ID
        return push plain(line) if %w[{ @ $].include?(line.text[1])

Method parse_new_attributes has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def parse_new_attributes(text)
      scanner = StringScanner.new(text)
      last_line = @line.index + 1
      attributes = {}

Method each_attr has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def each_attr(tokens)
      attr_tokens = []
      open_tokens = Hash.new { |h, k| h[k] = 0 }

      tokens.each do |token|

Method build_attributes has 33 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      def build_attributes(is_html, attr_wrapper, escape_attrs, hyphenate_data_attrs, attributes = {})
        # @TODO this is an absolutely ridiculous amount of arguments. At least
        # some of this needs to be moved into an instance method.
        join_char = hyphenate_data_attrs ? '-' : '_'

Method compile_boolean! has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def compile_boolean!(temple, key, values)
      exp = literal_for(values.last)

      if Temple::StaticAnalyzer.static?(exp)
        value = eval(exp)

• Read up
  Read up

Method next_line has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def next_line
      line = @template.shift || raise(StopIteration)

      # `flat?' here is a little outdated,
      # so we have to manually check if either the previous or current line

• Read up
  Read up

Method on_multi has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def on_multi(*exps)
      exps = exps.dup
      result = [:multi]
      buffer = []

• Read up
  Read up

Method parse_object_ref has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def parse_object_ref(ref)
      prefix = ref[1]
      ref = ref[0]
      # Let's make sure the value isn't nil. If it is, return the default Hash.
      return {} if ref.nil?

• Read up
  Read up

Method compute_tabs has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def compute_tabs(line)
      return 0 if line.text.empty? || !line.whitespace

      if @indentation.nil?
        @indentation = line.whitespace

• Read up
  Read up

Method balance has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def balance(scanner, start, finish, count = 0)
      str = ''.dup
      scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
      regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
      while scanner.scan(regexp)

• Read up
  Read up

Method count_lines has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def self.count_lines(exp)
      type, *args = exp
      case type
      when :multi
        args.map { |a| count_lines(a) }.reduce(:+) || 0

• Read up
  Read up

Method close_silent_script has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def close_silent_script(node)
      @script_level_stack.pop if ["if", "case", "unless"].include? node.value[:keyword]

      # Post-process case statements to normalize the nesting of "when" clauses
      return unless node.value[:keyword] == "case"

• Read up
  Read up

Method capture_haml has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def capture_haml(*args, &block)
      buffer = eval('if defined? _hamlout then _hamlout else nil end', block.binding) || haml_buffer
      with_haml_buffer(buffer) do
        position = haml_buffer.buffer.length

• Read up
  Read up

Method haml_internal_concat has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def haml_internal_concat(text = "", newline = true, indent = true)
      if haml_buffer.tabulation == 0
        haml_buffer.buffer << "#{text}#{"\n" if newline}"
      else
        haml_buffer.buffer << %[#{haml_indent if indent}#{text.to_s.gsub("\n", "\n#{haml_indent}")}#{"\n" if newline}]

• Read up
  Read up

Method build has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def build(escape_attrs, quote, format, boolean_attributes, object_ref, *hashes)

Method handle_ruby_multiline has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def handle_ruby_multiline(line)
      line.text.rstrip!
      return line unless is_ruby_multiline?(line.text)
      begin
        # Use already fetched @next_line in the first loop. Otherwise, fetch next

• Read up
  Read up

Method build_boolean! has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def build_boolean!(escape_attrs, quote, format, buf, key, value)