haml_lint 0.21.0 → 0.22.0

data/lib/haml_lint/linter/line_length.rb

@@ -7,14 +7,16 @@ module HamlLint
 
     MSG = 'Line is too long. [%d/%d]'.freeze
 
-    def visit_root(_node)
+    def visit_root(root)
       max_length = config['max']
-      dummy_node = Struct.new(:line)
 
       document.source_lines.each_with_index do |line, index|
         next if line.length <= max_length
 
-        record_lint(dummy_node.new(index + 1), format(MSG, line.length, max_length))
+        node = root.node_for_line(index + 1)
+        unless node.disabled?(self)
+          record_lint(node, format(MSG, line.length, max_length))
+        end
       end
     end
   end

data/lib/haml_lint/linter/repeated_id.rb

@@ -0,0 +1,34 @@
+module HamlLint
+  # Detects repeated instances of an element ID in a file
+  class Linter::RepeatedId < Linter
+    include LinterRegistry
+
+    MESSAGE_FORMAT = %{Do not repeat id "#%s" on the page}.freeze
+
+    def visit_tag(node)
+      id = node.tag_id
+      return unless id && !id.empty?
+
+      nodes = (id_map[id] << node)
+      case nodes.size
+      when 1 then return
+      when 2 then add_lints_for_first_duplications(nodes)
+      else add_lint(node, id)
+      end
+    end
+
+    private
+
+    def add_lint(node, id)
+      record_lint(node, MESSAGE_FORMAT % id)
+    end
+
+    def add_lints_for_first_duplications(nodes)
+      nodes.each { |node| add_lint(node, node.tag_id) }
+    end
+
+    def id_map
+      @id_map ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+  end
+end

data/lib/haml_lint/linter/syntax.rb

@@ -0,0 +1,6 @@
+module HamlLint
+  # A catch-all linter for syntax violations raised by the Haml parser.
+  class Linter::Syntax < Linter
+    include LinterRegistry
+  end
+end

data/lib/haml_lint/linter/trailing_whitespace.rb

@@ -3,13 +3,14 @@ module HamlLint
   class Linter::TrailingWhitespace < Linter
     include LinterRegistry
 
-    def visit_root(_node)
-      dummy_node = Struct.new(:line)
-
+    def visit_root(root)
       document.source_lines.each_with_index do |line, index|
         next unless line =~ /\s+$/
 
-        record_lint dummy_node.new(index + 1), 'Line contains trailing whitespace'
+        node = root.node_for_line(index + 1)
+        unless node.disabled?(self)
+          record_lint node, 'Line contains trailing whitespace'
+        end
       end
     end
   end

data/lib/haml_lint/linter.rb

@@ -33,7 +33,7 @@ module HamlLint
     #
     # @return [String]
     def name
-      self.class.name.split('::').last
+      self.class.name.to_s.split('::').last
     end
 
     private

data/lib/haml_lint/logger.rb

@@ -5,6 +5,10 @@ module HamlLint
     # @return [true,false]
     attr_accessor :color_enabled
 
+    # Whether to output a summary in the log for certain reporters.
+    # @return [true,false]
+    attr_accessor :summary_enabled
+
     # Creates a logger which outputs nothing.
     # @return [HamlLint::Logger]
     def self.silent
@@ -14,8 +18,10 @@ module HamlLint
     # Creates a new {HamlLint::Logger} instance.
     #
     # @param out [IO] the output destination.
-    def initialize(out)
+    # @param summary [true,false] whether to print summaries
+    def initialize(out, summary: true)
       @out = out
+      @summary_enabled = summary
     end
 
     # Print the specified output.

data/lib/haml_lint/options.rb

@@ -15,6 +15,7 @@ module HamlLint
 
         add_linter_options parser
         add_file_options parser
+        add_logger_options parser
         add_info_options parser
       end.parse!(args)
 
@@ -45,6 +46,15 @@ module HamlLint
                 'Specify which reporter you want to use to generate the output') do |reporter|
         @options[:reporter] = load_reporter_class(reporter.capitalize)
       end
+
+      parser.on('--fail-fast', 'Fail after the first file with lint above the fail level') do
+        @options[:fail_fast] = true
+      end
+
+      parser.on('--fail-level fail_level', String,
+                'Specify which level you want the suite to fail') do |fail_level|
+        @options[:fail_level] = HamlLint::Severity.new(fail_level.to_sym)
+      end
     end
 
     # Returns the class of the specified Reporter.
@@ -80,10 +90,6 @@ module HamlLint
         @options[:show_reporters] = true
       end
 
-      parser.on('--[no-]color', 'Force output to be colorized') do |color|
-        @options[:color] = color
-      end
-
       parser.on_tail('-h', '--help', 'Display help documentation') do
         @options[:help] = parser.help
       end
@@ -96,5 +102,15 @@ module HamlLint
         @options[:verbose_version] = true
       end
     end
+
+    def add_logger_options(parser)
+      parser.on('--[no-]color', 'Force output to be colorized') do |color|
+        @options[:color] = color
+      end
+
+      parser.on('--[no-]summary', 'Print a summary of your linting report') do |summary|
+        @options[:summary] = summary
+      end
+    end
   end
 end

data/lib/haml_lint/parsed_ruby.rb

@@ -0,0 +1,22 @@
+require 'delegate'
+
+module HamlLint
+  # A thin wrapper around the syntax tree from the Parser gem.
+  class ParsedRuby < SimpleDelegator
+    # !@method syntax_tree
+    #   Returns the bare syntax tree from the wrapper.
+    #
+    #   @api semipublic
+    #   @return [Array] syntax tree in the form returned by Parser gem
+    alias syntax_tree __getobj__
+
+    # Checks whether the syntax tree contains any instance variables.
+    #
+    # @return [true, false]
+    def contains_instance_variables?
+      return false unless syntax_tree
+
+      syntax_tree.ivar_type? || syntax_tree.each_descendant.any?(&:ivar_type?)
+    end
+  end
+end

data/lib/haml_lint/rake_task.rb

@@ -51,6 +51,16 @@ module HamlLint
     # @return [true,false]
     attr_accessor :quiet
 
+    # The severity level above which we should fail the Rake task.
+    #
+    # @example
+    #   HamlLint::RakeTask.new do |task|
+    #     task.fail_level = 'error'
+    #   end
+    #
+    # @return [String]
+    attr_accessor :fail_level
+
     # Create the task so it exists in the current namespace.
     #
     # @param name [Symbol] task name
@@ -82,8 +92,7 @@ module HamlLint
     #
     # @param task_args [Rake::TaskArguments]
     def run_cli(task_args)
-      cli_args = ['--config', config] if config
-
+      cli_args = parse_args
       logger = quiet ? HamlLint::Logger.silent : HamlLint::Logger.new(STDOUT)
       result = HamlLint::CLI.new(logger).run(Array(cli_args) + files_to_lint(task_args))
 
@@ -118,5 +127,10 @@ module HamlLint
       description += ' [files...]`'
       description
     end
+
+    def parse_args
+      cli_args = config ? ['--config', config] : []
+      cli_args.concat(['--fail-level', fail_level]) if fail_level
+    end
   end
 end

data/lib/haml_lint/report.rb

@@ -4,6 +4,9 @@ module HamlLint
     # List of lints that were found.
     attr_accessor :lints
 
+    # The level of lint to fail after detecting
+    attr_reader :fail_level
+
     # List of files that were linted.
     attr_reader :files
 
@@ -11,13 +14,54 @@ module HamlLint
     #
     # @param lints [Array<HamlLint::Lint>] lints that were found
     # @param files [Array<String>] files that were linted
-    def initialize(lints, files)
+    # @param fail_level [Symbol] the severity level to fail on
+    # @param reporter [HamlLint::Reporter] the reporter for the report
+    def initialize(lints = [], files = [], fail_level = :warning, reporter:)
       @lints = lints.sort_by { |l| [l.filename, l.line] }
       @files = files
+      @fail_level = Severity.new(fail_level)
+      @reporter = reporter
+    end
+
+    # Adds a lint to the report and notifies the reporter.
+    #
+    # @param lint [HamlLint::Lint] lint to add
+    # @return [void]
+    def add_lint(lint)
+      lints << lint
+      @reporter.added_lint(lint)
+    end
+
+    # Displays the report via the configured reporter.
+    #
+    # @return [void]
+    def display
+      @reporter.display_report(self)
     end
 
+    # Checks whether any lints were over the fail level
+    #
+    # @return [Boolean]
     def failed?
-      @lints.any?
+      @lints.any? { |lint| lint.severity >= fail_level }
+    end
+
+    # Adds a file to the list of linted files and notifies the reporter.
+    #
+    # @param file [String] the name of the file that was finished
+    # @param lints [Array<HamlLint::Lint>] the lints for the finished file
+    # @return [void]
+    def finish_file(file, lints)
+      files << file
+      @reporter.finished_file(file, lints)
+    end
+
+    # Notifies the reporter that the report has started.
+    #
+    # @param files [Array<String>] the files to lint
+    # @return [void]
+    def start(files)
+      @reporter.start(files)
     end
   end
 end

data/lib/haml_lint/reporter/default_reporter.rb

@@ -1,39 +1,17 @@
+require 'haml_lint/reporter/utils'
+
 module HamlLint
   # Outputs lints in a simple format with the filename, line number, and lint
   # message.
   class Reporter::DefaultReporter < Reporter
-    def display_report(report)
-      sorted_lints = report.lints.sort_by { |l| [l.filename, l.line] }
-
-      sorted_lints.each do |lint|
-        print_location(lint)
-        print_type(lint)
-        print_message(lint)
-      end
-    end
-
-    private
+    include Reporter::Utils
 
-    def print_location(lint)
-      log.info lint.filename, false
-      log.log ':', false
-      log.bold lint.line, false
+    def added_lint(lint)
+      print_lint(lint)
     end
 
-    def print_type(lint)
-      if lint.error?
-        log.error ' [E] ', false
-      else
-        log.warning ' [W] ', false
-      end
-    end
-
-    def print_message(lint)
-      if lint.linter
-        log.success("#{lint.linter.name}: ", false)
-      end
-
-      log.log lint.message
+    def display_report(report)
+      print_summary(report)
     end
   end
 end

data/lib/haml_lint/reporter/hash_reporter.rb

@@ -0,0 +1,51 @@
+module HamlLint
+  # Outputs report as a Ruby Hash for easy use by other tools.
+  class Reporter::HashReporter < Reporter
+    def display_report(report)
+      lints = report.lints
+      grouped = lints.group_by(&:filename)
+
+      report_hash = {
+        metadata: metadata,
+        files: grouped.map { |l| map_file(l) },
+        summary: {
+          offense_count: lints.length,
+          target_file_count: grouped.length,
+          inspected_file_count: report.files.length,
+        },
+      }
+
+      report_hash
+    end
+
+    private
+
+    def metadata
+      {
+        haml_lint_version: HamlLint::VERSION,
+        ruby_engine:      RUBY_ENGINE,
+        ruby_patchlevel:  RUBY_PATCHLEVEL.to_s,
+        ruby_platform:    RUBY_PLATFORM,
+      }
+    end
+
+    def map_file(file)
+      {
+        path: file.first,
+        offenses: file.last.map { |o| map_offense(o) },
+      }
+    end
+
+    def map_offense(offense)
+      {
+        severity: offense.severity,
+        message: offense.message,
+        location: {
+          line: offense.line,
+        },
+      }.tap do |h|
+        h[:linter_name] = offense.linter.name if offense.linter
+      end
+    end
+  end
+end

data/lib/haml_lint/reporter/hooks.rb

@@ -0,0 +1,25 @@
+module HamlLint
+  class Reporter
+    # A collection of hook methods for incremental processing.
+    module Hooks
+      # A hook that is called for each lint as it is detected.
+      #
+      # @param _lint [HamlLint::Lint] the lint added to the report
+      # @return [void]
+      def added_lint(_lint); end
+
+      # A hook that is called for each file as it is finished processing.
+      #
+      # @param _file [String] the name of the file that just finished
+      # @param _lints [Array<HamlLint::Lint>] the lints added to the report
+      # @return [void]
+      def finished_file(_file, _lints); end
+
+      # A hook that is called when the processing starts.
+      #
+      # @param _files [Array<String>] the names of the files to be processed
+      # @return [void]
+      def start(_files); end
+    end
+  end
+end

data/lib/haml_lint/reporter/json_reporter.rb

@@ -1,51 +1,8 @@
 module HamlLint
   # Outputs report as a JSON document.
-  class Reporter::JsonReporter < Reporter
+  class Reporter::JsonReporter < Reporter::HashReporter
     def display_report(report)
-      lints = report.lints
-      grouped = lints.group_by(&:filename)
-
-      report_hash = {
-        metadata: metadata,
-        files: grouped.map { |l| map_file(l) },
-        summary: {
-          offense_count: lints.length,
-          target_file_count: grouped.length,
-          inspected_file_count: report.files.length,
-        },
-      }
-
-      log.log report_hash.to_json
-    end
-
-    private
-
-    def metadata
-      {
-        haml_lint_version: HamlLint::VERSION,
-        ruby_engine:      RUBY_ENGINE,
-        ruby_patchlevel:  RUBY_PATCHLEVEL.to_s,
-        ruby_platform:    RUBY_PLATFORM,
-      }
-    end
-
-    def map_file(file)
-      {
-        path: file.first,
-        offenses: file.last.map { |o| map_offense(o) },
-      }
-    end
-
-    def map_offense(offense)
-      {
-        severity: offense.severity,
-        message: offense.message,
-        location: {
-          line: offense.line,
-        },
-      }.tap do |h|
-        h[:linter_name] = offense.linter.name if offense.linter
-      end
+      log.log super.to_json
     end
   end
 end

data/lib/haml_lint/reporter/progress_reporter.rb

@@ -0,0 +1,47 @@
+require 'rainbow'
+require 'haml_lint/reporter/utils'
+
+module HamlLint
+  # Outputs files as they are output as a simple symbol, then outputs
+  # a summary of each lint.
+  class Reporter::ProgressReporter < Reporter
+    include Reporter::Utils
+
+    DOT = '.'.freeze
+
+    def display_report(report)
+      lints = report.lints
+
+      log.log("\n\nOffenses:\n", true) if lints.any?
+      lints.each { |lint| print_lint(lint) }
+
+      print_summary(report)
+    end
+
+    def finished_file(_file, lints)
+      report_file_as_mark(lints)
+    end
+
+    def start(files)
+      log.log("Inspecting #{pluralize('file', count: files.size)}", true)
+    end
+
+    private
+
+    def dot
+      @dot ||= Rainbow(DOT).green
+    end
+
+    def report_file_as_mark(lints)
+      mark =
+        if lints.empty?
+          dot
+        else
+          worst_lint = lints.max_by(&:severity)
+          worst_lint.severity.mark_with_color
+        end
+
+      log.log(mark, false)
+    end
+  end
+end

data/lib/haml_lint/reporter/utils.rb

@@ -0,0 +1,101 @@
+module HamlLint
+  class Reporter
+    # Formatting helpers for printing the default report format.
+    module Utils
+      # Pluralizes a word based on a count.
+      #
+      # @param word [String] the word to pluralize
+      # @param count [Integer] the count of items
+      # @return [String]
+      def pluralize(word, count: 1)
+        if count.zero? || count > 1
+          "#{count} #{word}s"
+        else
+          "#{count} #{word}"
+        end
+      end
+
+      # Prints the lint with its location and severity.
+      #
+      # @param lint [HamlLint::Lint] the lint to print
+      # @return [void]
+      def print_lint(lint)
+        print_location(lint)
+        print_type(lint)
+        print_message(lint)
+      end
+
+      # Prints the location of a lint.
+      #
+      # @param lint [HamlLint::Lint] the lint to print
+      # @return [void]
+      def print_location(lint)
+        log.info lint.filename, false
+        log.log ':', false
+        log.bold lint.line, false
+      end
+
+      # Prints the severity of a lint.
+      #
+      # @param lint [HamlLint::Lint] the lint to print
+      # @return [void]
+      def print_type(lint)
+        message = " [#{lint.severity.mark}] "
+
+        if lint.error?
+          log.error message, false
+        else
+          log.warning message, false
+        end
+      end
+
+      # Prints the description of a lint.
+      #
+      # @param lint [HamlLint::Lint] the lint to print
+      # @return [void]
+      def print_message(lint)
+        if lint.linter
+          log.success("#{lint.linter.name}: ", false)
+        end
+
+        log.log lint.message
+      end
+
+      # Prints a summary of a report when summaries are enabled.
+      #
+      # @param report [HamlLint::Report] the report to print
+      # @return [void]
+      def print_summary(report)
+        return unless log.summary_enabled
+
+        print_summary_files(report)
+        print_summary_lints(report)
+
+        log.log ' detected'
+      end
+
+      # Prints a summary of the number of files linted in a report.
+      #
+      # @param report [HamlLint::Report] the report to print
+      # @return [void]
+      def print_summary_files(report)
+        log.log "\n#{pluralize('file', count: report.files.count)} inspected, ", false
+      end
+
+      # Prints a summary of the number of lints found in a report.
+      #
+      # @param report [HamlLint::Report] the report to print
+      # @return [void]
+      def print_summary_lints(report)
+        lint_count = report.lints.size
+        lint_message = pluralize('lint', count: lint_count)
+
+        if lint_count == 0
+          log.log lint_message, false
+        else
+          log.error lint_message, false
+        end
+      end
+    end
+  end
+end

data/lib/haml_lint/reporter.rb

@@ -1,9 +1,13 @@
+require 'haml_lint/reporter/hooks'
+
 module HamlLint
   # Abstract lint reporter. Subclass and override {#display_report} to
   # implement a custom lint reporter.
   #
   # @abstract
   class Reporter
+    include Reporter::Hooks
+
     # Creates the reporter that will display the given report.
     #
     # @param logger [HamlLint::Logger]