haml_lint 0.13.0

data/lib/haml_lint/linter/empty_script.rb

@@ -0,0 +1,12 @@
+module HamlLint
+  # Checks for empty scripts.
+  class Linter::EmptyScript < Linter
+    include LinterRegistry
+
+    def visit_silent_script(node)
+      return unless node.script =~ /\A\s*\Z/
+
+      add_lint(node, 'Empty script should be removed')
+    end
+  end
+end

data/lib/haml_lint/linter/html_attributes.rb

@@ -0,0 +1,14 @@
+module HamlLint
+  # Checks for the setting of attributes via HTML shorthand syntax on elements
+  # (e.g. `%tag(lang=en)`).
+  class Linter::HtmlAttributes < Linter
+    include LinterRegistry
+
+    def visit_tag(node)
+      return unless node.html_attributes?
+
+      add_lint(node, "Prefer the hash attributes syntax (%tag{ lang: 'en' }) over " \
+                     'HTML attributes syntax (%tag(lang=en))')
+    end
+  end
+end

data/lib/haml_lint/linter/implicit_div.rb

@@ -0,0 +1,20 @@
+module HamlLint
+  # Checks for unnecessary uses of the `%div` prefix where a class name or ID
+  # already implies a div.
+  class Linter::ImplicitDiv < Linter
+    include LinterRegistry
+
+    def visit_tag(node)
+      return unless node.tag_name == 'div'
+
+      return unless node.static_classes.any? || node.static_ids.any?
+
+      tag = node.source_code[/\s*([^\s={\(\[]+)/, 1]
+      return unless tag.start_with?('%div')
+
+      add_lint(node,
+               "`#{tag}` can be written as `#{node.static_attributes_source}` " \
+               'since `%div` is implicit')
+    end
+  end
+end

data/lib/haml_lint/linter/leading_comment_space.rb

@@ -0,0 +1,14 @@
+module HamlLint
+  # Checks for comments that don't have a leading space.
+  class Linter::LeadingCommentSpace < Linter
+    include LinterRegistry
+
+    def visit_haml_comment(node)
+      # Skip if the node spans multiple lines starting on the second line,
+      # or starts with a space
+      return if node.text.match(/\A(\s*|\s+\S.*)$/)
+
+      add_lint(node, 'Comment should have a space after the `#`')
+    end
+  end
+end

data/lib/haml_lint/linter/line_length.rb

@@ -0,0 +1,19 @@
+module HamlLint
+  # Checks for lines longer than a maximum number of columns.
+  class Linter::LineLength < Linter
+    include LinterRegistry
+
+    MSG = 'Line is too long. [%d/%d]'
+
+    def visit_root(_node)
+      max_length = config['max']
+      dummy_node = Struct.new(:line)
+
+      parser.lines.each_with_index do |line, index|
+        next if line.length <= max_length
+
+        add_lint(dummy_node.new(index + 1), format(MSG, line.length, max_length))
+      end
+    end
+  end
+end

data/lib/haml_lint/linter/multiline_pipe.rb

@@ -0,0 +1,43 @@
+module HamlLint
+  # Checks for uses of the multiline pipe character.
+  class Linter::MultilinePipe < Linter
+    include LinterRegistry
+
+    MESSAGE = "Don't use the `|` character to split up lines. " \
+              'Wrap on commas or extract code into helper.'
+
+    def visit_tag(node)
+      check(node)
+    end
+
+    def visit_script(node)
+      check(node)
+    end
+
+    def visit_silent_script(node)
+      check(node)
+    end
+
+    def visit_plain(node)
+      line = line_text_for_node(node)
+
+      # Plain text nodes are allowed to consist of a single pipe
+      return if line.strip == '|'
+
+      add_lint(node, MESSAGE) if line.match(MULTILINE_PIPE_REGEX)
+    end
+
+    private
+
+    MULTILINE_PIPE_REGEX = /\s+\|\s*$/
+
+    def line_text_for_node(node)
+      parser.lines[node.line - 1]
+    end
+
+    def check(node)
+      line = line_text_for_node(node)
+      add_lint(node, MESSAGE) if line.match(MULTILINE_PIPE_REGEX)
+    end
+  end
+end

data/lib/haml_lint/linter/multiline_script.rb

@@ -0,0 +1,43 @@
+module HamlLint
+  # Checks scripts spread over multiple lines.
+  class Linter::MultilineScript < Linter
+    include LinterRegistry
+
+    # List of operators that can split a script into two lines that we want to
+    # alert on.
+    SPLIT_OPERATORS = %w[
+      || or && and
+      ||= &&=
+      ^ << >> | &
+      <<= >>= |= &=
+      + - * / ** %
+      += -= *= /= **= %=
+      < <= <=> >= >
+      = == === != =~ !~
+      .. ...
+      ? :
+      not
+      if unless while until
+      begin
+    ].to_set
+
+    def visit_script(node)
+      check(node)
+    end
+
+    def visit_silent_script(node)
+      check(node)
+    end
+
+    private
+
+    def check(node)
+      operator = node.script[/\s+(\S+)\z/, 1]
+      if SPLIT_OPERATORS.include?(operator)
+        add_lint(node,
+                 "Script with trailing operator `#{operator}` should be " \
+                 'merged with the script on the following line')
+      end
+    end
+  end
+end

data/lib/haml_lint/linter/object_reference_attributes.rb

@@ -0,0 +1,14 @@
+module HamlLint
+  # Checks for uses of the object reference syntax for assigning the class and
+  # ID attributes for an element (e.g. `%div[@user]`).
+  class Linter::ObjectReferenceAttributes < Linter
+    include LinterRegistry
+
+    def visit_tag(node)
+      return unless node.object_reference?
+
+      add_lint(node, 'Avoid using object reference syntax to assign class/id ' \
+                     'attributes for tags')
+    end
+  end
+end

data/lib/haml_lint/linter/rubocop.rb

@@ -0,0 +1,76 @@
+require 'haml_lint/script_extractor'
+require 'rubocop'
+require 'tempfile'
+
+module HamlLint
+  # Runs RuboCop on Ruby code contained within HAML templates.
+  class Linter::RuboCop < Linter
+    include LinterRegistry
+
+    def initialize(config)
+      super
+      @rubocop = ::RuboCop::CLI.new
+      @ignored_cops = Array(config['ignored_cops']).flatten
+    end
+
+    def run(parser)
+      @parser = parser
+      @extractor = ScriptExtractor.new(parser)
+      extracted_code = @extractor.extract.strip
+
+      # Ensure a final newline in the code we feed to RuboCop
+      find_lints(extracted_code + "\n") unless extracted_code.empty?
+    end
+
+    private
+
+    def find_lints(code)
+      original_filename = @parser.filename || 'ruby_script'
+      filename = "#{File.basename(original_filename)}.haml_lint.tmp"
+      directory = File.dirname(original_filename)
+
+      Tempfile.open(filename, directory) do |f|
+        begin
+          f.write(code)
+          f.close
+          extract_lints_from_offences(lint_file(f.path))
+        ensure
+          f.unlink
+        end
+      end
+    end
+
+    # Defined so we can stub the results in tests
+    def lint_file(file)
+      @rubocop.run(%w[--format HamlLint::OffenceCollector] << file)
+      OffenceCollector.offences
+    end
+
+    def extract_lints_from_offences(offences)
+      offences.select { |offence| !@ignored_cops.include?(offence.cop_name) }
+              .each do |offence|
+        @lints << Lint.new(self,
+                           @parser.filename,
+                           @extractor.source_map[offence.line],
+                           "#{offence.cop_name}: #{offence.message}")
+      end
+    end
+  end
+
+  # Collects offences detected by RuboCop.
+  class OffenceCollector < ::RuboCop::Formatter::BaseFormatter
+    attr_accessor :offences
+
+    class << self
+      attr_accessor :offences
+    end
+
+    def started(_target_files)
+      self.class.offences = []
+    end
+
+    def file_finished(_file, offences)
+      self.class.offences += offences
+    end
+  end
+end

data/lib/haml_lint/linter/ruby_comments.rb

@@ -0,0 +1,18 @@
+module HamlLint
+  # Checks for Ruby comments that can be written as HAML comments.
+  class Linter::RubyComments < Linter
+    include LinterRegistry
+
+    def visit_silent_script(node)
+      if code_comment?(node)
+        add_lint(node, 'Use `-#` for comments instead of `- #`')
+      end
+    end
+
+    private
+
+    def code_comment?(node)
+      node.script =~ /\A\s+#/
+    end
+  end
+end

data/lib/haml_lint/linter/space_before_script.rb

@@ -0,0 +1,52 @@
+module HamlLint
+  # Checks for Ruby script in HAML templates with no space after the `=`/`-`.
+  class Linter::SpaceBeforeScript < Linter
+    include LinterRegistry
+
+    MESSAGE_FORMAT = 'The %s symbol should have one space separating it from code'
+
+    def visit_tag(node) # rubocop:disable Metrics/CyclomaticComplexity
+      # If this tag has inline script
+      return unless node.contains_script?
+
+      text = node.script.strip
+      return if text.empty?
+
+      tag_with_text = tag_with_inline_text(node)
+
+      unless index = tag_with_text.rindex(text)
+        # For tags with inline text that contain interpolation, the parser
+        # converts them to inline script by surrounding them in string quotes,
+        # e.g. `%p Hello #{name}` becomes `%p= "Hello #{name}"`, causing the
+        # above search to fail. Check for this case by removing added quotes.
+        if text_without_quotes = strip_surrounding_quotes(text)
+          return unless index = tag_with_text.rindex(text_without_quotes)
+        end
+      end
+
+      # Check if the character before the start of the script is a space
+      # (need to do it this way as the parser strips whitespace from node)
+      return unless tag_with_text[index - 1] != ' '
+
+      add_lint(node, MESSAGE_FORMAT % '=')
+    end
+
+    def visit_script(node)
+      # Plain text nodes with interpolation are converted to script nodes, so we
+      # need to ignore them here.
+      return unless parser.lines[node.line - 1].lstrip.start_with?('=')
+      add_lint(node, MESSAGE_FORMAT % '=') if missing_space?(node)
+    end
+
+    def visit_silent_script(node)
+      add_lint(node, MESSAGE_FORMAT % '-') if missing_space?(node)
+    end
+
+    private
+
+    def missing_space?(node)
+      text = node.script
+      text[0] != ' ' if text
+    end
+  end
+end

data/lib/haml_lint/linter/space_inside_hash_attributes.rb

@@ -0,0 +1,32 @@
+module HamlLint
+  # Checks for spaces inside the braces of hash attributes
+  # (e.g. `%tag{ lang: en }` vs `%tag{lang: en}`).
+  class Linter::SpaceInsideHashAttributes < Linter
+    include LinterRegistry
+
+    STYLE = {
+      'no_space' => {
+        start_regex: /\A\{[^ ]/,
+        end_regex: /[^ ]\}\z/,
+        start_message: 'Hash attribute should start with no space after the opening brace',
+        end_message: 'Hash attribute should end with no space before the closing brace'
+      },
+      'space' => {
+        start_regex: /\A\{ [^ ]/,
+        end_regex:  /[^ ] \}\z/,
+        start_message: 'Hash attribute should start with one space after the opening brace',
+        end_message: 'Hash attribute should end with one space before the closing brace'
+      }
+    }
+
+    def visit_tag(node)
+      return unless node.hash_attributes?
+
+      style = STYLE[config['style'] == 'no_space' ? 'no_space' : 'space']
+      source = node.hash_attributes_source
+
+      add_lint(node, style[:start_message]) unless source =~ style[:start_regex]
+      add_lint(node, style[:end_message]) unless source =~ style[:end_regex]
+    end
+  end
+end

data/lib/haml_lint/linter/tag_name.rb

@@ -0,0 +1,13 @@
+module HamlLint
+  # Checks for tag names with uppercase letters.
+  class Linter::TagName < Linter
+    include LinterRegistry
+
+    def visit_tag(node)
+      tag = node.tag_name
+      return unless tag.match(/[A-Z]/)
+
+      add_lint(node, "`#{tag}` should be written in lowercase as `#{tag.downcase}`")
+    end
+  end
+end

data/lib/haml_lint/linter/trailing_whitespace.rb

@@ -0,0 +1,16 @@
+module HamlLint
+  # Checks for trailing whitespace.
+  class Linter::TrailingWhitespace < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      dummy_node = Struct.new(:line)
+
+      parser.lines.each_with_index do |line, index|
+        next unless line =~ /\s+$/
+
+        add_lint dummy_node.new(index + 1), 'Line contains trailing whitespace'
+      end
+    end
+  end
+end

data/lib/haml_lint/linter/unnecessary_interpolation.rb

@@ -0,0 +1,29 @@
+module HamlLint
+  # Checks for unnecessary uses of string interpolation.
+  #
+  # For example, the following two code snippets are equivalent, but the latter
+  # is more concise (and thus preferred):
+  #
+  #   %tag #{expression}
+  #   %tag= expression
+  class Linter::UnnecessaryInterpolation < Linter
+    include LinterRegistry
+
+    def visit_tag(node)
+      return if node.script.empty?
+
+      count = 0
+      chars = 2 # Include surrounding quote chars
+      HamlLint::Utils.extract_interpolated_values(node.script) do |interpolated_code|
+        count += 1
+        return if count > 1 # rubocop:disable Lint/NonLocalExitFromIterator
+        chars += interpolated_code.length + 3
+      end
+
+      if chars == node.script.length
+        add_lint(node, '`%... \#{expression}` can be written without ' \
+                       'interpolation as `%...= expression`')
+      end
+    end
+  end
+end

data/lib/haml_lint/linter/unnecessary_string_output.rb

@@ -0,0 +1,39 @@
+module HamlLint
+  # Checks for unnecessary outputting of strings in Ruby script tags.
+  #
+  # For example, the following two code snippets are equivalent, but the latter
+  # is more concise (and thus preferred):
+  #
+  #   %tag= "Some #{expression}"
+  #   %tag Some #{expression}
+  class Linter::UnnecessaryStringOutput < Linter
+    include LinterRegistry
+
+    MESSAGE = '`= "..."` should be rewritten as `...`'
+
+    def visit_tag(node)
+      if tag_has_inline_script?(node) && inline_content_is_string?(node)
+        add_lint(node, MESSAGE)
+      end
+    end
+
+    def visit_script(node)
+      # Some script nodes created by the HAML parser aren't actually script
+      # nodes declared via the `=` marker. Check for it.
+      return if node.source_code !~ /\s*=/
+
+      if outputs_string_literal?(node)
+        add_lint(node, MESSAGE)
+      end
+    end
+
+    private
+
+    def outputs_string_literal?(script_node)
+      tree = parse_ruby(script_node.script)
+      [:str, :dstr].include?(tree.type)
+    rescue ::Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
+      # Gracefully ignore syntax errors, as that's managed by a different linter
+    end
+  end
+end

data/lib/haml_lint/linter.rb

@@ -0,0 +1,156 @@
+module HamlLint
+  # Base implementation for all lint checks.
+  class Linter
+    include HamlVisitor
+
+    attr_reader :parser, :lints
+
+    # @param config [Hash] configuration for this linter
+    def initialize(config)
+      @config = config
+      @lints = []
+      @ruby_parser = nil
+    end
+
+    def run(parser)
+      @parser = parser
+      visit(parser.tree)
+    end
+
+    # Returns the simple name for this linter.
+    def name
+      self.class.name.split('::').last
+    end
+
+    private
+
+    attr_reader :config
+
+    def add_lint(node, message)
+      @lints << Lint.new(self, parser.filename, node.line, message)
+    end
+
+    # Parse Ruby code into an abstract syntax tree.
+    #
+    # @return [AST::Node]
+    def parse_ruby(source)
+      @ruby_parser ||= HamlLint::RubyParser.new
+      @ruby_parser.parse(source)
+    end
+
+    # Remove the surrounding double quotes from a string, ignoring any
+    # leading/trailing whitespace.
+    #
+    # @param string [String]
+    # @return [String] stripped with leading/trailing double quotes removed.
+    def strip_surrounding_quotes(string)
+      string[/\A\s*"(.*)"\s*\z/, 1]
+    end
+
+    # Returns whether a string contains any interpolation.
+    #
+    # @param string [String]
+    # @return [true,false]
+    def contains_interpolation?(string)
+      return false unless string
+      Haml::Util.contains_interpolation?(string)
+    end
+
+    # Returns whether this tag node has inline script, e.g. is of the form
+    # %tag= ...
+    #
+    # @param tag_node [HamlLint::Tree::TagNode]
+    # @return [true,false]
+    def tag_has_inline_script?(tag_node)
+      tag_with_inline_content = tag_with_inline_text(tag_node)
+      return false unless inline_content = inline_node_content(tag_node)
+      return false unless index = tag_with_inline_content.rindex(inline_content)
+
+      index -= 1
+      index -= 1 while [' ', '"', "'"].include?(tag_with_inline_content[index])
+
+      tag_with_inline_content[index] == '='
+    end
+
+    # Returns whether the inline content for a node is a string.
+    #
+    # For example, the following node has a literal string:
+    #
+    #   %tag= "A literal #{string}"
+    #
+    # whereas this one does not:
+    #
+    #   %tag A literal #{string}
+    #
+    # @param node [HamlLint::Tree::Node]
+    # @return [true,false]
+    def inline_content_is_string?(node)
+      tag_with_inline_content = tag_with_inline_text(node)
+      inline_content = inline_node_content(node)
+
+      index = tag_with_inline_content.rindex(inline_content) - 1
+
+      %w[' "].include?(tag_with_inline_content[index])
+    end
+
+    # Get the inline content for this node.
+    #
+    # Inline content is the content that appears inline right after the
+    # tag/script. For example, in the code below...
+    #
+    #   %tag Some inline content
+    #
+    # ..."Some inline content" would be the inline content.
+    #
+    # @param node [HamlLint::Tree::Node]
+    # @return [String]
+    def inline_node_content(node)
+      inline_content = node.script
+
+      if contains_interpolation?(inline_content)
+        strip_surrounding_quotes(inline_content)
+      else
+        inline_content
+      end
+    end
+
+    # Gets the next node following this node, ascending up the ancestor chain
+    # recursively if this node has no siblings.
+    #
+    # @param node [HamlLint::Tree::Node]
+    # @return [HamlLint::Tree::Node,nil]
+    def next_node(node)
+      return unless node
+      siblings = node.parent ? node.parent.children : [node]
+
+      next_sibling = siblings[siblings.index(node) + 1] if siblings.count > 1
+      return next_sibling if next_sibling
+
+      next_node(node.parent)
+    end
+
+    # Returns the line of the "following node" (child of this node or sibling or
+    # the last line in the file).
+    #
+    # @param node [HamlLint::Tree::Node]
+    def following_node_line(node)
+      [
+        [node.children.first, next_node(node)].compact.map(&:line),
+        parser.lines.count + 1,
+      ].flatten.min
+    end
+
+    # Extracts all text for a tag node and normalizes it, including additional
+    # lines following commas or multiline bar indicators ('|')
+    #
+    # @param tag_node [HamlLine::Tree::TagNode]
+    # @return [String] source code of original parse node
+    def tag_with_inline_text(tag_node)
+      # Normalize each of the lines to ignore the multiline bar (|) and
+      # excess whitespace
+      parser.lines[(tag_node.line - 1)...(following_node_line(tag_node) - 1)].map do |line|
+        line.strip.gsub(/\|\z/, '').rstrip
+      end.join(' ')
+    end
+  end
+end

data/lib/haml_lint/linter_registry.rb

@@ -0,0 +1,26 @@
+module HamlLint
+  class NoSuchLinter < StandardError; end
+
+  # Stores all defined linters.
+  module LinterRegistry
+    @linters = []
+
+    class << self
+      attr_reader :linters
+
+      def included(base)
+        @linters << base
+      end
+
+      def extract_linters_from(linter_names)
+        linter_names.map do |linter_name|
+          begin
+            HamlLint::Linter.const_get(linter_name)
+          rescue NameError
+            raise NoSuchLinter, "Linter #{linter_name} does not exist"
+          end
+        end
+      end
+    end
+  end
+end