haml_lint 0.13.0

data/lib/haml_lint/script_extractor.rb

@@ -0,0 +1,181 @@
+module HamlLint
+  # Utility class for extracting Ruby script from a HAML file that can then be
+  # linted with a Ruby linter (i.e. is "legal" Ruby). The goal is to turn this:
+  #
+  #     - if signed_in?(viewer)
+  #       %span Stuff
+  #       = link_to 'Sign Out', sign_out_path
+  #     - else
+  #       .some-class{ class: my_method }= my_method
+  #       = link_to 'Sign In', sign_in_path
+  #
+  # into this:
+  #
+  #     if signed_in?(viewer)
+  #       link_to 'Sign Out', sign_out_path
+  #     else
+  #       { class: my_method }
+  #       my_method
+  #       link_to 'Sign In', sign_in_path
+  #     end
+  #
+  class ScriptExtractor
+    include HamlVisitor
+
+    attr_reader :source, :source_map
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def extract
+      visit(@parser.tree)
+      @source = @code.join("\n")
+    end
+
+    def visit_root(_node)
+      @code = []
+      @total_lines = 0
+      @source_map = {}
+      @indent_level = 0
+
+      yield # Collect lines of code from children
+    end
+
+    def visit_plain(node)
+      # Don't output the text, as we don't want to have to deal with any RuboCop
+      # cops regarding StringQuotes or AsciiComments, and it's not important to
+      # overall document anyway.
+      add_line('puts', node)
+    end
+
+    def visit_tag(node)
+      additional_attributes = node.dynamic_attributes_sources
+
+      # Include dummy references to code executed in attributes list
+      # (this forces a "use" of a variable to prevent "assigned but unused
+      # variable" lints)
+      additional_attributes.each do |attributes_code|
+        # Normalize by removing excess whitespace to avoid format lints
+        attributes_code = attributes_code.gsub(/\s*\n\s*/, ' ').strip
+
+        # Attributes can either be a method call or a literal hash, so wrap it
+        # in a method call itself in order to avoid having to differentiate the
+        # two.
+        add_line("{}.merge(#{attributes_code.strip})", node)
+      end
+
+      check_tag_static_hash_source(node)
+
+      # We add a dummy puts statement to represent the tag name being output.
+      # This prevents some erroneous RuboCop warnings.
+      add_line("puts # #{node.tag_name}", node)
+
+      code = node.script.strip
+      add_line(code, node) unless code.empty?
+    end
+
+    def visit_script(node)
+      code = node.text
+      add_line(code.strip, node)
+
+      start_block = anonymous_block?(code) || start_block_keyword?(code)
+
+      if start_block
+        @indent_level += 1
+      end
+
+      yield # Continue extracting code from children
+
+      if start_block
+        @indent_level -= 1
+        add_line('end', node)
+      end
+    end
+
+    def visit_silent_script(node, &block)
+      visit_script(node, &block)
+    end
+
+    def visit_filter(node)
+      if node.filter_type == 'ruby'
+        node.text.split("\n").each_with_index do |line, index|
+          add_line(line, node.line + index + 1)
+        end
+      else
+        add_line('puts', node)
+        HamlLint::Utils.extract_interpolated_values(node.text) do |interpolated_code|
+          add_line(interpolated_code, node)
+        end
+      end
+    end
+
+    private
+
+    def check_tag_static_hash_source(node)
+      # Haml::Parser converts hashrocket-style hash attributes of strings and symbols
+      # to static attributes, and excludes them from the dynamic attribute sources:
+      # https://github.com/haml/haml/blob/08f97ec4dc8f59fe3d7f6ab8f8807f86f2a15b68/lib/haml/parser.rb#L400-L404
+      # https://github.com/haml/haml/blob/08f97ec4dc8f59fe3d7f6ab8f8807f86f2a15b68/lib/haml/parser.rb#L540-L554
+      # Here, we add the hash source back in so it can be inspected by rubocop.
+      if node.hash_attributes? && node.dynamic_attributes_sources.empty?
+        normalized_attr_source = node.dynamic_attributes_source[:hash].gsub(/\s*\n\s*/, ' ')
+
+        add_line(normalized_attr_source, node)
+      end
+    end
+
+    def add_line(code, node_or_line)
+      return if code.empty?
+
+      indent_level = @indent_level
+
+      if node_or_line.respond_to?(:line)
+        # Since mid-block keywords are children of the corresponding start block
+        # keyword, we need to reduce their indentation level by 1. However, we
+        # don't do this unless this is an actual tag node (a raw line number
+        # means this came from a `:ruby` filter).
+        indent_level -= 1 if mid_block_keyword?(code)
+      end
+
+      indent = (' ' * 2 * indent_level)
+
+      @code << indent + code
+
+      original_line =
+        node_or_line.respond_to?(:line) ? node_or_line.line : node_or_line
+
+      # For interpolated code in filters that spans multiple lines, the
+      # resulting code will span multiple lines, so we need to create a
+      # mapping for each line.
+      (code.count("\n") + 1).times do
+        @total_lines += 1
+        @source_map[@total_lines] = original_line
+      end
+    end
+
+    def anonymous_block?(text)
+      text =~ /\bdo\s*(\|\s*[^\|]*\s*\|)?\z/
+    end
+
+    START_BLOCK_KEYWORDS = %w[if unless case begin for until while]
+    def start_block_keyword?(text)
+      START_BLOCK_KEYWORDS.include?(block_keyword(text))
+    end
+
+    MID_BLOCK_KEYWORDS = %w[else elsif when rescue ensure]
+    def mid_block_keyword?(text)
+      MID_BLOCK_KEYWORDS.include?(block_keyword(text))
+    end
+
+    def block_keyword(text)
+      # Need to handle 'for'/'while' since regex stolen from HAML parser doesn't
+      if keyword = text[/\A\s*([^\s]+)\s+/, 1]
+        return keyword if %w[for until while].include?(keyword)
+      end
+
+      return unless keyword = text.scan(Haml::Parser::BLOCK_KEYWORD_REGEX)[0]
+      keyword[0] || keyword[1]
+    end
+  end
+end

data/lib/haml_lint/tree/comment_node.rb

@@ -0,0 +1,5 @@
+module HamlLint::Tree
+  # Represents a visible XHTML comment in a HAML document.
+  class CommentNode < Node
+  end
+end

data/lib/haml_lint/tree/doctype_node.rb

@@ -0,0 +1,5 @@
+module HamlLint::Tree
+  # Represents a doctype definition for a HAML document.
+  class DoctypeNode < Node
+  end
+end

data/lib/haml_lint/tree/filter_node.rb

@@ -0,0 +1,9 @@
+module HamlLint::Tree
+  # Represents a filter node which contains arbitrary code.
+  class FilterNode < Node
+    # The type of code contained in this filter.
+    def filter_type
+      @value[:name]
+    end
+  end
+end

data/lib/haml_lint/tree/haml_comment_node.rb

@@ -0,0 +1,18 @@
+module HamlLint::Tree
+  # Represents a HAML comment node.
+  class HamlCommentNode < Node
+    # Returns the full text content of this comment, including newlines if a
+    # single comment spans multiple lines.
+    #
+    # @return [String]
+    def text
+      content = source_code
+      indent = content[/^ */]
+
+      content.gsub(/^#{indent}/, '')
+             .gsub(/^-#/, '')
+             .gsub(/^  /, '')
+             .rstrip
+    end
+  end
+end

data/lib/haml_lint/tree/node.rb

@@ -0,0 +1,98 @@
+module HamlLint::Tree
+  # Decorator class that provides a convenient set of helpers for HAML's
+  # {Haml::Parser::ParseNode} struct.
+  #
+  # The goal is to abstract away the details of the underlying struct and
+  # provide a cleaner and more uniform interface for getting information about a
+  # node, as there are a number of weird/special cases in the struct returned by
+  # the HAML parser.
+  #
+  # @abstract
+  class Node
+    attr_accessor :children, :parent
+    attr_reader :line, :type
+
+    # Creates a node wrapping the given {Haml::Parser::ParseNode} struct.
+    #
+    # @param parser [HamlLint::Parser] parser that created this node
+    # @param parse_node [Haml::Parser::ParseNode] parse node created by HAML's parser
+    def initialize(parser, parse_node)
+      # TODO: Change signature to take source code object, not parser
+      @line = parse_node.line
+      @parser = parser
+      @value = parse_node.value
+      @type = parse_node.type
+    end
+
+    # Returns the first node found under the subtree which matches the given
+    # block.
+    #
+    # Returns nil if no node matching the given block was found.
+    #
+    # @return [HamlLint::Tree::Node,nil]
+    def find(&block)
+      return self if block.call(self)
+
+      children.each do |child|
+        if result = child.find(&block)
+          return result
+        end
+      end
+
+      nil # Otherwise no matching node was found
+    end
+
+    # Source code of all lines this node spans (excluding children).
+    #
+    # @return [String]
+    def source_code
+      next_node_line =
+        if next_node
+          next_node.line - 1
+        else
+          @parser.lines.count + 1
+        end
+
+      @parser.lines[@line - 1...next_node_line]
+             .join("\n")
+             .gsub(/^\s*\z/m, '') # Remove blank lines at the end
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+
+    # Returns the node that follows this node, whether it be a sibling or an
+    # ancestor's child, but not a child of this node.
+    #
+    # If you are also willing to return the child, call {#next_node}.
+    #
+    # Returns nil if there is no successor.
+    #
+    # @return [HamlLint::Tree::Node,nil]
+    def successor
+      siblings = parent ? parent.children : [self]
+
+      next_sibling = siblings[siblings.index(self) + 1] if siblings.count > 1
+      return next_sibling if next_sibling
+
+      parent.successor if parent
+    end
+
+    # Returns the next node that appears after this node in the document.
+    #
+    # Returns nil if there is no next node.
+    #
+    # @return [HamlLint::Tree::Node,nil]
+    def next_node
+      children.first || successor
+    end
+
+    # Returns the text content of this node.
+    #
+    # @return [String]
+    def text
+      @value[:text].to_s
+    end
+  end
+end

data/lib/haml_lint/tree/plain_node.rb

@@ -0,0 +1,5 @@
+module HamlLint::Tree
+  # Represents a node that contains plain text.
+  class PlainNode < Node
+  end
+end

data/lib/haml_lint/tree/root_node.rb

@@ -0,0 +1,5 @@
+module HamlLint::Tree
+  # Represents the root node of a HAML document that contains all other nodes.
+  class RootNode < Node
+  end
+end

data/lib/haml_lint/tree/script_node.rb

@@ -0,0 +1,11 @@
+module HamlLint::Tree
+  # Represents a node which produces output based on Ruby code.
+  class ScriptNode < Node
+    # Returns the source for the script following the `-` marker.
+    #
+    # @return [String]
+    def script
+      @value[:text]
+    end
+  end
+end

data/lib/haml_lint/tree/silent_script_node.rb

@@ -0,0 +1,12 @@
+module HamlLint::Tree
+  # Represents a HAML silent script node (`- some_expression`) which executes
+  # code without producing output.
+  class SilentScriptNode < Node
+    # Returns the source for the script following the `-` marker.
+    #
+    # @return [String]
+    def script
+      @value[:text]
+    end
+  end
+end

data/lib/haml_lint/tree/tag_node.rb

@@ -0,0 +1,221 @@
+module HamlLint::Tree
+  # Represents a tag node in a HAML document.
+  class TagNode < Node
+    # Computed set of attribute hashes code.
+    #
+    # This is a combination of all dynamically calculated attributes from the
+    # different attribute setting syntaxes (`{...}`/`(...)`), converted into
+    # Ruby code.
+    #
+    # @return [Array<String>]
+    def dynamic_attributes_sources
+      @value[:attributes_hashes]
+    end
+
+    # Returns whether this tag contains executable script (e.g. is followed by a
+    # `=`).
+    #
+    # @return [true,false]
+    def contains_script?
+      @value[:parse] && !@value[:value].strip.empty?
+    end
+
+    # Returns whether this tag has a specified attribute.
+    #
+    # @return [true,false]
+    def has_hash_attribute?(attribute)
+      hash_attributes? && existing_attributes.include?(attribute)
+    end
+
+    # List of classes statically defined for this tag.
+    #
+    # @example For `%tag.button.button-info{ class: status }`, this returns:
+    #   ['button', 'button-info']
+    #
+    # @return [Array<String>] list of statically defined classes with leading
+    #   dot removed
+    def static_classes
+      @static_classes ||=
+        begin
+          static_attributes_source.scan(/\.([-:\w]+)/)
+        end
+    end
+
+    # List of ids statically defined for this tag.
+    #
+    # @example For `%tag.button#start-button{ id: special_id }`, this returns:
+    #   ['start-button']
+    #
+    # @return [Array<String>] list of statically defined ids with leading `#`
+    #   removed
+    def static_ids
+      @static_ids ||=
+        begin
+          static_attributes_source.scan(/#([-:\w]+)/)
+        end
+    end
+
+    # Static element attributes defined after the tag name.
+    #
+    # @example For `%tag.button#start-button`, this returns:
+    #   '.button#start-button'
+    #
+    # @return [String]
+    def static_attributes_source
+      attributes_source[:static] || ''
+    end
+
+    # Returns the source code for the dynamic attributes defined in `{...}`,
+    # `(...)`, or `[...]` after a tag name.
+    #
+    # @example For `%tag.class{ id: 'hello' }(lang=en)`, this returns:
+    #   { :hash => " id: 'hello' ", :html => "lang=en" }
+    #
+    # @return [Hash]
+    def dynamic_attributes_source
+      @dynamic_attributes_source ||=
+        attributes_source.reject { |key| key == :static }
+    end
+
+    # Returns the source code for the static and dynamic attributes
+    # of a tag.
+    #
+    # @example For `%tag.class{ id: 'hello' }(lang=en)`, this returns:
+    #   { :static => '.class', :hash => " id: 'hello' ", :html => "lang=en" }
+    #
+    # @return [Hash]
+    def attributes_source
+      @attr_source ||=
+        begin
+          _explicit_tag, static_attrs, rest = source_code
+            .scan(/\A\s*(%[-:\w]+)?([-:\w\.\#]*)(.*)/m)[0]
+
+          attr_types = {
+            '{' => [:hash, %w[{ }]],
+            '(' => [:html, %w[( )]],
+            '[' => [:object_ref, %w[[ ]]],
+          }
+
+          attr_source = { static: static_attrs }
+          while rest
+            type, chars = attr_types[rest[0]]
+            break unless type # Not an attribute opening character, so we're done
+
+            # Can't define multiple of the same attribute type (e.g. two {...})
+            break if attr_source[type]
+
+            attr_source[type], rest = Haml::Util.balance(rest, *chars)
+          end
+
+          attr_source
+        end
+    end
+
+    # Whether this tag node has a set of hash attributes defined via the
+    # curly brace syntax (e.g. `%tag{ lang: 'en' }`).
+    #
+    # @return [true,false]
+    def hash_attributes?
+      !dynamic_attributes_source[:hash].nil?
+    end
+
+    # Attributes defined after the tag name in Ruby hash brackets (`{}`).
+    #
+    # @example For `%tag.class{ lang: 'en' }`, this returns:
+    #   " lang: 'en' "
+    #
+    # @return [String] source without the surrounding curly braces
+    def hash_attributes_source
+      dynamic_attributes_source[:hash]
+    end
+
+    # Whether this tag node has a set of HTML attributes defined via the
+    # parentheses syntax (e.g. `%tag(lang=en)`).
+    #
+    # @return [true,false]
+    def html_attributes?
+      !dynamic_attributes_source[:html].nil?
+    end
+
+    # Attributes defined after the tag name in parentheses (`()`).
+    #
+    # @example For `%tag.class(lang=en)`, this returns:
+    #   "lang=en"
+    #
+    # @return [String] source without the surrounding parentheses
+    def html_attributes_source
+      dynamic_attributes_source[:html] || ''
+    end
+
+    # Name of the HTML tag.
+    #
+    # @return [String]
+    def tag_name
+      @value[:name]
+    end
+
+    # Whether this tag node has a set of square brackets (e.g. `%tag[...]`)
+    # following it that indicates its class and ID will be to the value of the
+    # given object's {#to_key} or {#id} method (in that order).
+    #
+    # @return [true,false]
+    def object_reference?
+      @value[:object_ref].to_s != 'nil'
+    end
+
+    # Source code for the contents of the node's object reference.
+    #
+    # @see http://haml.info/docs/yardoc/file.REFERENCE.html#object_reference_
+    # @return [String,nil] string source of object reference or `nil` if it has
+    #   not been defined
+    def object_reference_source
+      (@value[:object_ref] if object_reference?) || ''
+    end
+
+    # Whether this node had a `<` after it signifying that outer whitespace
+    # should be removed.
+    #
+    # @return [true,false]
+    def remove_inner_whitespace?
+      @value[:nuke_inner_whitespace]
+    end
+
+    # Whether this node had a `>` after it signifying that outer whitespace
+    # should be removed.
+    #
+    # @return [true,false]
+    def remove_outer_whitespace?
+      @value[:nuke_inner_whitespace]
+    end
+
+    # Returns the script source that will be evaluated to produce this tag's
+    # inner content, if any.
+    #
+    # @return [String]
+    def script
+      (@value[:value] if @value[:parse]) || ''
+    end
+
+    # Returns the static inner content for this tag.
+    #
+    # If this tag contains dynamic content of any kind, this will still return
+    # an empty string, and you'll have to use {#script} to obtain the source.
+    #
+    # @return [String]
+    def text
+      (@value[:value] if @value[:parse]) || ''
+    end
+
+    private
+
+    def parsed_attributes
+      HamlLint::RubyParser.new.parse(hash_attributes_source)
+    end
+
+    def existing_attributes
+      parsed_attributes.children.collect do |parsed_attribute|
+        parsed_attribute.children.first.to_a.first
+      end
+    end
+  end
+end

data/lib/haml_lint/utils.rb

@@ -0,0 +1,58 @@
+module HamlLint
+  # A miscellaneous set of utility functions.
+  module Utils
+    module_function
+
+    # Yields interpolated values within a block of filter text.
+    def extract_interpolated_values(filter_text)
+      Haml::Util.handle_interpolation(filter_text.dump) do |scan|
+        escape_count = (scan[2].size - 1) / 2
+        return unless escape_count.even? # rubocop:disable Lint/NonLocalExitFromIterator
+
+        dumped_interpolated_str = Haml::Util.balance(scan, '{', '}', 1)[0][0...-1]
+
+        # Hacky way to turn a dumped string back into a regular string
+        yield eval('"' + dumped_interpolated_str + '"') # rubocop:disable Eval
+      end
+    end
+
+    # Converts a string containing underscores/hyphens/spaces into CamelCase.
+    def camel_case(str)
+      str.split(/_|-| /).map { |part| part.sub(/^\w/) { |c| c.upcase } }.join
+    end
+
+    # Find all consecutive nodes satisfying the given {Proc} of a minimum size
+    # and yield each group.
+    #
+    # @param items [Array]
+    # @param min_size [Fixnum] minimum number of consecutive items before
+    #   yielding
+    # @param satisfies [Proc] function that takes an item and returns true/false
+    def find_consecutive(items, min_size, satisfies)
+      current = -1
+
+      while (current += 1) < items.count
+        next unless satisfies[items[current]]
+
+        count = count_consecutive(items, current, satisfies)
+        next unless count >= min_size
+
+        # Yield the chunk of consecutive items
+        yield items[current...(current + count)]
+
+        current += count # Skip this patch of consecutive items to find more
+      end
+    end
+
+    # Count the number of consecutive items satisfying the given {Proc}.
+    #
+    # @param items [Array]
+    # @param offset [Fixnum] index to start searching
+    # @param satisfies [Proc] function to evaluate item with
+    def count_consecutive(items, offset, satisfies)
+      count = 1
+      count += 1 while (offset + count < items.count) && satisfies[items[offset + count]]
+      count
+    end
+  end
+end

data/lib/haml_lint/version.rb

@@ -0,0 +1,4 @@
+# Defines the gem version.
+module HamlLint
+  VERSION = '0.13.0'
+end

data/lib/haml_lint.rb

@@ -0,0 +1,36 @@
+require 'haml_lint/constants'
+require 'haml_lint/exceptions'
+require 'haml_lint/configuration'
+require 'haml_lint/configuration_loader'
+require 'haml_lint/parser'
+require 'haml_lint/haml_visitor'
+require 'haml_lint/lint'
+require 'haml_lint/linter_registry'
+require 'haml_lint/ruby_parser'
+require 'haml_lint/linter'
+require 'haml_lint/logger'
+require 'haml_lint/reporter'
+require 'haml_lint/report'
+require 'haml_lint/file_finder'
+require 'haml_lint/runner'
+require 'haml_lint/utils'
+require 'haml_lint/version'
+
+require 'haml'
+
+# Load all parse tree node classes
+require 'haml_lint/tree/node'
+require 'haml_lint/node_transformer'
+Dir[File.expand_path('haml_lint/tree/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end
+
+# Load all linters
+Dir[File.expand_path('haml_lint/linter/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end
+
+# Load all reporters
+Dir[File.expand_path('haml_lint/reporter/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end