haml_lint 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9343eacc913a5864ba1b9537bffc6bdcd657deaf
-  data.tar.gz: 1aa917703eea3279812a58dfea38a4f342078bd7
+  metadata.gz: b7cae686b1a15d37a81d966b3c80c41fe51fbe2e
+  data.tar.gz: e1997a13d2721bedc442891b8a215e8e825180bf
 SHA512:
-  metadata.gz: 0915d21c8eb959014d5253dde8a71fc4b24b11146f02a1562abc47c38ec94da67ae829991131e27a029c8f3809cc4c2de1e2e05379c2093530063678ff2583d4
-  data.tar.gz: a890450c449514de7114891ce762354652ffb1b6d5a9811844906022706f6017a73fc296e7e0fe35622c0565e2e5dde95dc782d0ff544d64044eaa097f5a7e1b
+  metadata.gz: 62926eeddd753e8af645a8db5cc621cbf3807362453b6913a5f47060b8e13baaa9a8e4dcaa54f32111bc927c53ad08ccfa3ad71c141150c800aacd50a01afac7
+  data.tar.gz: 8c77947ce1117683f9386724b01a9447f3d5964e958026f872c89d0eff1c7cd70455506ce109041d72a2caaaa83c63e52cdbdb46085707adf81dbe6d6f646b51

data/config/default.yml

@@ -8,6 +8,9 @@
 skip_frontmatter: false
 
 linters:
+  AlignmentTabs:
+    enabled: true
+
   AltText:
     enabled: false
 
@@ -37,9 +40,20 @@ linters:
   HtmlAttributes:
     enabled: true
 
+  IdNames:
+    enabled: true
+    style: lisp_case
+
   ImplicitDiv:
     enabled: true
 
+  InstanceVariables:
+    enabled: true
+    file_types: partials
+    matchers:
+      all: .*
+      partials: \A_.*\.haml\z
+
   LeadingCommentSpace:
     enabled: true
 
@@ -56,6 +70,10 @@ linters:
   ObjectReferenceAttributes:
     enabled: true
 
+  RepeatedId:
+    enabled: true
+    severity: error
+
   RuboCop:
     enabled: true
     # These cops are incredibly noisy when it comes to HAML templates, so we

data/lib/haml_lint/adapter/haml_4.rb

@@ -0,0 +1,40 @@
+module HamlLint
+  class Adapter
+    # Adapts the Haml::Parser from Haml 4 for use in HamlLint
+    # :reek:UncommunicativeModuleName
+    class Haml4 < Adapter
+      extend Forwardable
+
+      # Parses the specified Haml code into an abstract syntax tree
+      #
+      # @example
+      #   HamlLint::Adapter::Haml4.new('%div')
+      #
+      # @api public
+      # @param source [String] Haml code to parse
+      # @param options [Haml::Options]
+      def initialize(source, options = Haml::Options.new)
+        @parser = Haml::Parser.new(source, options)
+      end
+
+      # @!method
+      #   Parses the source code into an abstract syntax tree
+      #
+      #   @example
+      #     HamlLint::Adapter::Haml4.new('%div')
+      #
+      #   @api public
+      #   @return [Haml::Parser::ParseNode]
+      # @raise [Haml::Error]
+      def_delegator :parser, :parse
+
+      private
+
+      # The Haml parser to adapt for HamlLint
+      #
+      # @api private
+      # @return [Haml::Parser] the Haml 4 parser
+      attr_reader :parser
+    end
+  end
+end

data/lib/haml_lint/adapter/haml_5.rb

@@ -0,0 +1,46 @@
+module HamlLint
+  class Adapter
+    # Adapts the Haml::Parser from Haml 5 for use in HamlLint
+    # :reek:UncommunicativeModuleName
+    class Haml5 < Adapter
+      # Parses the specified Haml code into an abstract syntax tree
+      #
+      # @example
+      #   HamlLint::Adapter::Haml5.new('%div')
+      #
+      # @api public
+      # @param source [String] Haml code to parse
+      # @param options [Haml::Options]
+      def initialize(source, options = Haml::Options.new)
+        @source = source
+        @parser = Haml::Parser.new(options)
+      end
+
+      # Parses the source code into an abstract syntax tree
+      #
+      # @example
+      #   HamlLint::Adapter::Haml5.new('%div').parse
+      #
+      # @api public
+      # @return [Haml::Parser::ParseNode]
+      # @raise [Haml::Error]
+      def parse
+        parser.call(source)
+      end
+
+      private
+
+      # The Haml parser to adapt for HamlLint
+      #
+      # @api private
+      # @return [Haml::Parser] the Haml 4 parser
+      attr_reader :parser
+
+      # The Haml code to parse
+      #
+      # @api private
+      # @return [String] Haml code to parse
+      attr_reader :source
+    end
+  end
+end

data/lib/haml_lint/adapter.rb

@@ -0,0 +1,36 @@
+require 'haml_lint/adapter/haml_4'
+require 'haml_lint/adapter/haml_5'
+require 'haml_lint/exceptions'
+
+module HamlLint
+  # Determines the adapter to use for the current Haml version
+  class Adapter
+    # Detects the adapter to use for the current Haml version
+    #
+    # @example
+    #   HamlLint::Adapter.detect_class.new('%div')
+    #
+    # @api public
+    # @return [Class] the adapter class
+    # @raise [HamlLint::Exceptions::UnknownHamlVersion]
+    def self.detect_class
+      version = haml_version
+      case version
+      when '~> 4.0' then HamlLint::Adapter::Haml4
+      when '~> 5.0' then HamlLint::Adapter::Haml5
+      else fail HamlLint::Exceptions::UnknownHamlVersion, "Cannot handle Haml version: #{version}"
+      end
+    end
+
+    # Determines the approximate version of Haml that is installed
+    #
+    # @api private
+    # @return [String] the approximate Haml version
+    def self.haml_version
+      Gem::Version
+        .new(Haml::VERSION)
+        .approximate_recommendation
+    end
+    private_class_method :haml_version
+  end
+end

data/lib/haml_lint/cli.rb

@@ -33,7 +33,7 @@ module HamlLint
     #
     # @return [Integer] exit status code
     def act_on_options(options)
-      log.color_enabled = options.fetch(:color, log.tty?)
+      configure_logger(options)
 
       if options[:help]
         print_help(options)
@@ -52,6 +52,14 @@ module HamlLint
       end
     end
 
+    # Given the provided options, configure the logger.
+    #
+    # @return [void]
+    def configure_logger(options)
+      log.color_enabled = options.fetch(:color, log.tty?)
+      log.summary_enabled = options.fetch(:summary, true)
+    end
+
     # Outputs a message and returns an appropriate error code for the specified
     # exception.
     def handle_exception(ex)
@@ -79,16 +87,11 @@ module HamlLint
     #
     # @return [Integer] exit status code
     def scan_for_lints(options)
-      report = Runner.new.run(options)
-      print_report(report, options)
-      report.failed? ? Sysexits::EX_DATAERR : Sysexits::EX_OK
-    end
-
-    # Outputs a report of the linter run using the specified reporter.
-    def print_report(report, options)
       reporter = options.fetch(:reporter,
                                HamlLint::Reporter::DefaultReporter).new(log)
-      reporter.display_report(report)
+      report = Runner.new.run(options.merge(reporter: reporter))
+      report.display
+      report.failed? ? Sysexits::EX_DATAERR : Sysexits::EX_OK
     end
 
     # Outputs a list of all currently available linters.

data/lib/haml_lint/comment_configuration.rb

@@ -0,0 +1,39 @@
+module HamlLint
+  # Determines what linters are enabled or disabled via comments.
+  class CommentConfiguration
+    # Instantiates a new {HamlLint::CommentConfiguration}.
+    #
+    # @param node [HamlLint::Tree::Node] the node to configure
+    def initialize(node)
+      @directives = node.directives.reverse
+    end
+
+    # Checks whether a linter is disabled for the node.
+    #
+    # @api public
+    # @param linter_name [String] the name of the linter
+    # @return [true, false]
+    def disabled?(linter_name)
+      most_recent_disabled = directives_for(linter_name).map(&:disable?).first
+
+      most_recent_disabled || false
+    end
+
+    private
+
+    # The list of directives in order of precedence.
+    #
+    # @api private
+    # @return [Array<HamlLint::Directive>]
+    attr_reader :directives
+
+    # Finds all directives applicable to the given linter name.
+    #
+    # @api private
+    # @param linter_name [String] the name of the linter
+    # @return [Array<HamlLint::Directive>] the filtered directives
+    def directives_for(linter_name)
+      directives.select { |directive| (directive.linters & ['all', linter_name]).any? }
+    end
+  end
+end

data/lib/haml_lint/directive.rb

@@ -0,0 +1,128 @@
+module HamlLint
+  # Handles linter configuration transformation via Haml comments.
+  class Directive
+    LINTER_REGEXP = /(?:[A-Z]\w+)/
+
+    DIRECTIVE_REGEXP = /
+      # "haml-lint:" with optional spacing
+      \s*haml-lint\s*:\s*
+
+      # The mode - either disable or enable
+      (?<mode>(?:dis|en)able)\b\s*
+
+      # "all" or a comma-separated list (with optional spaces) of linters
+      (?<linters>all | (?:#{LINTER_REGEXP}\s*,\s*)* #{LINTER_REGEXP})
+    /x
+
+    # Constructs a directive from source code as a given line.
+    #
+    # @param source [String] the source code to analyze
+    # @param line [Integer] the line number the source starts at
+    # @return [HamlLint::Directive]
+    def self.from_line(source, line)
+      match = DIRECTIVE_REGEXP.match(source)
+
+      if match
+        new(source, line, match[:mode], match[:linters].split(/\s*,\s*/))
+      else
+        Null.new(source, line)
+      end
+    end
+
+    # Instantiates a new {HamlLint::Directive}
+    #
+    # @api semipublic
+    # @param source [String] the source code to analyze
+    # @param line [Integer] the line number the source starts at
+    # @param mode [String] the type of directive, one of "disable" or "enable"
+    # @param linters [Array<String>] the name of the linters to act upon
+    def initialize(source, line, mode, linters)
+      @source = source
+      @line = line
+      @mode = mode
+      @linters = linters
+    end
+
+    # The names of the linters to act upon.
+    #
+    # @return [String]
+    attr_reader :linters
+
+    # The mode of the directive. One of "disable" or "enable".
+    #
+    # @return [String]
+    attr_reader :mode
+
+    # Checks whether a directive is equivalent to another.
+    #
+    # @api public
+    # @param other [HamlLint::Directive] the other directive
+    # @return [true, false]
+    def ==(other)
+      super unless other.is_a?(HamlLint::Directive)
+
+      mode == other.mode && linters == other.linters
+    end
+
+    # Checks whether this is a disable directive.
+    #
+    # @return [true, false]
+    def disable?
+      mode == 'disable'
+    end
+
+    # Checks whether this is an enable directive.
+    #
+    # @return [true, false]
+    def enable?
+      mode == 'enable'
+    end
+
+    # Formats the directive for display in a console.
+    #
+    # @return [String]
+    def inspect
+      "#<HamlLint::Directive(mode=#{mode}, linters=#{linters})>"
+    end
+
+    # A null representation of a directive.
+    class Null < Directive
+      # Instantiates a new null directive.
+      #
+      # @param source [String] the source code to analyze
+      # @param line [Integer] the line number the source starts at
+      def initialize(source, line)
+        @source = source
+        @line = line
+      end
+
+      # Stubs out the disable check as false.
+      #
+      # @return [false]
+      def disable?
+        false
+      end
+
+      # Stubs out the ensable check as false.
+      #
+      # @return [false]
+      def enable?
+        false
+      end
+
+      # Formats the null directive for display in a console.
+      #
+      # @return [String]
+      def inspect
+        '#<HamlLint::Directive::Null>'
+      end
+
+      # Stubs out the linters.
+      #
+      # @return [Array]
+      def linters
+        []
+      end
+    end
+  end
+end

data/lib/haml_lint/document.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'haml_lint/adapter'
+
 module HamlLint
   # Represents a parsed Haml document and its associated metadata.
   class Document
@@ -43,7 +45,7 @@ module HamlLint
       @source = strip_frontmatter(source)
       @source_lines = @source.split("\n")
 
-      @tree = process_tree(Haml::Parser.new(@source, Haml::Options.new).parse)
+      @tree = process_tree(HamlLint::Adapter.detect_class.new(@source).parse)
     rescue Haml::Error => ex
       error = HamlLint::Exceptions::ParseError.new(ex.message, ex.line)
       raise error

data/lib/haml_lint/exceptions.rb

@@ -15,4 +15,10 @@ module HamlLint::Exceptions
   # Raised when attempting to execute `Runner` with options that would result in
   # no linters being enabled.
   class NoLintersError < StandardError; end
+
+  # Raised when an unsupported Haml version is detected
+  class UnknownHamlVersion < StandardError; end
+
+  # Raised when a severity is not recognized
+  class UnknownSeverity < StandardError; end
 end

data/lib/haml_lint/haml_visitor.rb

@@ -14,14 +14,16 @@ module HamlLint
         visit_children(node) if descend == :children
       end
 
-      safe_send("visit_#{node_name(node)}", node, &block)
+      disabled = node.disabled?(self)
+
+      safe_send("visit_#{node_name(node)}", node, &block) unless disabled
 
       # Visit all children by default unless the block was invoked (indicating
       # the user intends to not recurse further, or wanted full control over
       # when the children were visited).
       visit_children(node) unless block_called
 
-      safe_send("after_visit_#{node_name(node)}", node, &block)
+      safe_send("after_visit_#{node_name(node)}", node, &block) unless disabled
     end
 
     def visit_children(parent)

data/lib/haml_lint/lint.rb

@@ -28,14 +28,14 @@ module HamlLint
       @filename = filename
       @line     = line || 0
       @message  = message
-      @severity = severity
+      @severity = Severity.new(severity)
     end
 
     # Return whether this lint has a severity of error.
     #
     # @return [Boolean]
     def error?
-      @severity == :error
+      @severity.error?
     end
   end
 end

data/lib/haml_lint/linter/alignment_tabs.rb

@@ -0,0 +1,12 @@
+module HamlLint
+  # Checks for tabs that are placed for alignment of tag content
+  class Linter::AlignmentTabs < Linter
+    REGEX = /[^\s*]\t+/
+
+    def visit_tag(node)
+      if REGEX.match(node.source_code)
+        record_lint(node, 'Avoid using tabs for alignment')
+      end
+    end
+  end
+end

data/lib/haml_lint/linter/consecutive_comments.rb

@@ -5,14 +5,31 @@ module HamlLint
 
     COMMENT_DETECTOR = ->(child) { child.type == :haml_comment }
 
-    def visit_root(node)
+    def visit_haml_comment(node)
+      return if previously_reported?(node)
+
       HamlLint::Utils.for_consecutive_items(
-        node.children,
+        possible_group(node),
         COMMENT_DETECTOR,
       ) do |group|
+        group.each { |group_node| reported_nodes << group_node }
         record_lint(group.first,
                     "#{group.count} consecutive comments can be merged into one")
       end
     end
+
+    private
+
+    def possible_group(node)
+      node.subsequents.unshift(node)
+    end
+
+    def previously_reported?(node)
+      reported_nodes.include?(node)
+    end
+
+    def reported_nodes
+      @reported_nodes ||= []
+    end
   end
 end

data/lib/haml_lint/linter/consecutive_silent_scripts.rb

@@ -8,9 +8,11 @@ module HamlLint
       child.type == :silent_script && child.children.empty?
     end
 
-    def visit_root(node)
+    def visit_silent_script(node)
+      return if previously_reported?(node)
+
       HamlLint::Utils.for_consecutive_items(
-        node.children,
+        possible_group(node),
         SILENT_SCRIPT_DETECTOR,
         config['max_consecutive'] + 1,
       ) do |group|
@@ -19,5 +21,19 @@ module HamlLint
                     'into a single `:ruby` filter')
       end
     end
+
+    private
+
+    def possible_group(node)
+      node.subsequents.unshift(node)
+    end
+
+    def previously_reported?(node)
+      reported_nodes.include?(node)
+    end
+
+    def reported_nodes
+      @reported_nodes ||= []
+    end
   end
 end

data/lib/haml_lint/linter/final_newline.rb

@@ -3,19 +3,20 @@ module HamlLint
   class Linter::FinalNewline < Linter
     include LinterRegistry
 
-    def visit_root(_node)
+    def visit_root(root)
       return if document.source.empty?
 
-      dummy_node = Struct.new(:line).new(document.source_lines.count)
+      node = root.node_for_line(document.source_lines.count)
+      return if node.disabled?(self)
+
       ends_with_newline = document.source.end_with?("\n")
 
       if config['present']
         unless ends_with_newline
-          record_lint(dummy_node, 'Files should end with a trailing newline')
+          record_lint(node, 'Files should end with a trailing newline')
         end
       elsif ends_with_newline
-        record_lint(dummy_node,
-                    'Files should not end with a trailing newline')
+        record_lint(node, 'Files should not end with a trailing newline')
       end
     end
   end

data/lib/haml_lint/linter/id_names.rb

@@ -0,0 +1,28 @@
+module HamlLint
+  # Checks for `id` attributes in specific cases on tags.
+  class Linter::IdNames < Linter
+    include LinterRegistry
+
+    STYLIZED_NAMES = {
+      'camel_case' => 'camelCase',
+      'lisp_case' => 'lisp-case',
+      'pascal_case' => 'PascalCase',
+      'snake_case' => 'snake_case',
+    }.freeze
+
+    STYLES = {
+      'camel_case' => /\A[a-z][\da-zA-Z]+\z/,
+      'lisp_case' => /\A[\da-z-]+\z/,
+      'pascal_case' => /\A[A-Z][\da-zA-Z]+\z/,
+      'snake_case' => /\A[\da-z_]+\z/,
+    }.freeze
+
+    def visit_tag(node)
+      return unless (id = node.tag_id)
+
+      style = config['style'] || 'lisp_case'
+      matcher = STYLES[style]
+      record_lint(node, "`id` attribute must be in #{STYLIZED_NAMES[style]}") unless id =~ matcher
+    end
+  end
+end

data/lib/haml_lint/linter/indentation.rb

@@ -9,14 +9,16 @@ module HamlLint
       tab: /^\t*(?![ ])/,
     }.freeze
 
-    def visit_root(_node)
+    def visit_root(root)
       regex = INDENT_REGEX[config['character'].to_sym]
       dummy_node = Struct.new(:line)
 
       document.source_lines.each_with_index do |line, index|
         next if line =~ regex
 
-        record_lint dummy_node.new(index + 1), 'Line contains tabs in indentation'
+        unless root.node_for_line(index).disabled?(self)
+          record_lint dummy_node.new(index + 1), 'Line contains tabs in indentation'
+        end
       end
     end
   end

data/lib/haml_lint/linter/instance_variables.rb

@@ -0,0 +1,77 @@
+module HamlLint
+  # Checks for the presence of instance variables
+  class Linter::InstanceVariables < Linter
+    include LinterRegistry
+
+    # Enables the linter if the tree is for the right file type.
+    #
+    # @param [HamlLint::Tree::RootNode] the root of a syntax tree
+    # @return [true, false] whether the linter is enabled for the tree
+    def visit_root(node)
+      @enabled = matcher.match(File.basename(node.file)) ? true : false
+    end
+
+    # Checks for instance variables in script nodes when the linter is enabled.
+    #
+    # @param [HamlLint::Tree:ScriptNode]
+    # @return [void]
+    def visit_script(node)
+      return unless enabled?
+
+      if node.parsed_script.contains_instance_variables?
+        record_lint(node, "Avoid using instance variables in #{file_types} views")
+      end
+    end
+
+    # @!method visit_silent_script(node)
+    #   Checks for instance variables in script nodes when the linter is enabled.
+    #
+    #   @param [HamlLint::Tree:SilentScriptNode]
+    #   @return [void]
+    alias visit_silent_script visit_script
+
+    # Checks for instance variables in tag nodes when the linter is enabled.
+    #
+    # @param [HamlLint::Tree:TagNode]
+    # @return [void]
+    def visit_tag(node)
+      return unless enabled?
+
+      visit_script(node) ||
+        if node.parsed_attributes.contains_instance_variables?
+          record_lint(node, "Avoid using instance variables in #{file_types} views")
+        end
+    end
+
+    private
+
+    # Tracks whether the linter is enabled for the file.
+    #
+    # @api private
+    # @return [true, false]
+    attr_reader :enabled
+
+    # @!method enabled?
+    #   Checks whether the linter is enabled for the file.
+    #
+    #   @api private
+    #   @return [true, false]
+    alias enabled? enabled
+
+    # The type of files the linter is configured to check.
+    #
+    # @api private
+    # @return [String]
+    def file_types
+      @file_types ||= config['file_types'] || 'partial'
+    end
+
+    # The matcher to use for testing whether to check a file by file name.
+    #
+    # @api private
+    # @return [Regexp]
+    def matcher
+      @matcher ||= Regexp.new(config['matchers'][file_types] || '\A_.*\.haml\z')
+    end
+  end
+end