haml_lint 0.44.0 → 0.46.0

data/lib/haml_lint/linter_registry.rb

@@ -27,11 +27,9 @@ module HamlLint
       # @return [Array<Class>]
       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
+          HamlLint::Linter.const_get(linter_name)
+        rescue NameError
+          raise NoSuchLinter, "Linter #{linter_name} does not exist"
         end
       end
     end

data/lib/haml_lint/logger.rb

@@ -30,7 +30,7 @@ module HamlLint
     #
     # @param output [String] the output to send
     # @param newline [true,false] whether to append a newline
-    def log(output, newline = true)
+    def log(output, newline = true) # rubocop:disable Style/OptionalBooleanParameter
       @out.print(output)
       @out.print("\n") if newline
     end
@@ -97,7 +97,7 @@ module HamlLint
 
     private
 
-    def color(code, output, newline = true)
+    def color(code, output, newline = true) # rubocop:disable Style/OptionalBooleanParameter
       log(color_enabled ? "\033[#{code}m#{output}\033[0m" : output, newline)
     end
   end

data/lib/haml_lint/options.rb

@@ -32,7 +32,7 @@ module HamlLint
 
     private
 
-    def add_linter_options(parser)
+    def add_linter_options(parser) # rubocop:disable Metrics/MethodLength
       parser.on('--auto-gen-config', 'Generate a configuration file acting as a TODO list') do
         @options[:auto_gen_config] = true
       end
@@ -55,6 +55,20 @@ module HamlLint
       parser.on('-p', '--parallel', 'Run linters in parallel using available CPUs') do
         @options[:parallel] = true
       end
+
+      parser.on('-a', '--auto-correct', 'Auto-correct offenses (only when it’s safe)') do
+        @options[:autocorrect] = :safe
+      end
+
+      parser.on('-A', '--auto-correct-all', 'Auto-correct offenses (safe and unsafe)') do
+        @options[:autocorrect] = :all
+      end
+
+      parser.on('--auto-correct-only', "Only do auto-correct, don't lint. " \
+          'Also activates safe auto-correct if no auto-correct is selected') do
+        @options[:autocorrect_only] = true
+        @options[:autocorrect] ||= :safe
+      end
     end
 
     def add_report_options(parser)
@@ -99,7 +113,7 @@ module HamlLint
       end
     end
 
-    def add_info_options(parser)
+    def add_info_options(parser) # rubocop:disable Metrics/MethodLength
       parser.on('--show-linters', 'Display available linters') do
         @options[:show_linters] = true
       end
@@ -108,6 +122,16 @@ module HamlLint
         @options[:show_reporters] = true
       end
 
+      parser.on('-d', '--debug', 'Add some debug information to messages') do
+        @options[:debug] = true
+      end
+
+      parser.on('--internal-debug', 'Add lots of (internal) debug information.' \
+                " Also affects some lint's line numbers to skip sourcemap") do
+        @options[:debug] = true
+        @options[:internal_debug] = true
+      end
+
       parser.on_tail('-h', '--help', 'Display help documentation') do
         @options[:help] = parser.help
       end

data/lib/haml_lint/rake_task.rb

@@ -104,7 +104,7 @@ module HamlLint
     # @param task_args [Rake::TaskArguments]
     def run_cli(task_args)
       cli_args = parse_args
-      logger = quiet ? HamlLint::Logger.silent : HamlLint::Logger.new(STDOUT)
+      logger = quiet ? HamlLint::Logger.silent : HamlLint::Logger.new($stdout)
       result = HamlLint::CLI.new(logger).run(Array(cli_args) + files_to_lint(task_args))
 
       fail "#{HamlLint::APP_NAME} failed with exit code #{result}" unless result == 0
@@ -115,7 +115,7 @@ module HamlLint
     #
     # @param task_args [Rake::TaskArguments]
     def files_to_lint(task_args)
-      # Note: we're abusing Rake's argument handling a bit here. We call the
+      # NOTE: we're abusing Rake's argument handling a bit here. We call the
       # first argument `files` but it's actually only the first file--we pull
       # the rest out of the `extras` from the task arguments. This is so we
       # can specify an arbitrary list of files separated by commas on the

data/lib/haml_lint/reporter/hash_reporter.rb

@@ -14,7 +14,7 @@ module HamlLint
       lints = report.lints
       grouped = lints.group_by(&:filename)
 
-      report_hash = {
+      {
         metadata: metadata,
         files: grouped.map { |l| map_file(l) },
         summary: {
@@ -23,8 +23,6 @@ module HamlLint
           inspected_file_count: report.files.length,
         },
       }
-
-      report_hash
     end
 
     private

data/lib/haml_lint/reporter/offense_count_reporter.rb

@@ -10,7 +10,7 @@ module HamlLint
       return if total_count.zero?
 
       lints.group_by { |l| lint_type_group(l) }
-           .map { |linter, lints_for_this_linter| [linter, lints_for_this_linter.size] }.to_h
+           .transform_values(&:size)
            .sort_by { |_linter, lint_count| -lint_count }
            .each do |linter, lint_count|
         log.log "#{lint_count.to_s.ljust(total_count.to_s.length + 2)} #{linter}"

data/lib/haml_lint/reporter/utils.rb

@@ -56,6 +56,10 @@ module HamlLint
       # @param lint [HamlLint::Lint] the lint to print
       # @return [void]
       def print_message(lint)
+        if lint.corrected
+          log.success('[Corrected] ', false)
+        end
+
         if lint.linter
           log.success("#{lint.linter.name}: ", false)
         end
@@ -70,10 +74,15 @@ module HamlLint
       def print_summary(report)
         return unless log.summary_enabled
 
+        log.log('')
         print_summary_files(report)
-        print_summary_lints(report)
 
-        log.log ' detected'
+        print_summary_lints(report, is_append: true)
+
+        log.log ' detected', false
+
+        print_summary_corrected_lints(report, is_append: true)
+        log.log ''
       end
 
       # Prints a summary of the number of files linted in a report.
@@ -81,14 +90,17 @@ module HamlLint
       # @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
+        log.log "#{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
+      # @param is_append [Boolean] if this is appending to a line. Will preffix with ", ".
       # @return [void]
-      def print_summary_lints(report)
+      def print_summary_lints(report, is_append:)
+        log.log ', ', false if is_append
+
         lint_count = report.lints.size
         lint_message = pluralize('lint', count: lint_count)
 
@@ -98,6 +110,23 @@ module HamlLint
           log.error lint_message, false
         end
       end
+
+      # Prints a summary of the number of lints corrected in a report.
+      #
+      # @param report [HamlLint::Report] the report to print
+      # @param is_append [Boolean] if this is appending to a line. Will preffix with ", ".
+      # @return [void]
+      def print_summary_corrected_lints(report, is_append:)
+        lint_count = report.lints.count(&:corrected)
+        return if lint_count == 0
+
+        log.log ', ', false if is_append
+
+        lint_message = pluralize('lint', count: lint_count)
+
+        log.info lint_message, false
+        log.log ' corrected', false
+      end
     end
   end
 end

data/lib/haml_lint/ruby_extraction/ad_hoc_chunk.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # This chunk just adds its code to the ruby, but does not attempt to transfer their correction
+  # in any way.
+  #
+  # Used for piece of code that just need to be in the generated ruby for reasons specific to
+  # the use cases, such as needing a `begin` to do add indentation.
+  class AdHocChunk < BaseChunk
+    def initialize(*args, **kwargs)
+      super(*args, **kwargs.merge(end_marker_indent: nil))
+    end
+
+    def wrap_in_markers
+      false
+    end
+
+    def transfer_correction(coordinator, all_corrected_ruby_lines, haml_lines); end
+  end
+end

data/lib/haml_lint/ruby_extraction/base_chunk.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # This is the base class for all of the Chunks of HamlLint::RubyExtraction.
+  # A Chunk represents a part of the HAML file that HamlLint::Linter::RuboCop
+  # is processing and will insert some Ruby code in a file passed to RuboCop.
+  #
+  # There are chunks for most HAML concepts, even if they don't represent Ruby
+  # code. For example, there is a chunk that represents a `%div` tag, which
+  # uses a `begin` in the generated Ruby to add indentation for the children
+  # of the %div in the Ruby file just like there is in the HAML file.
+  class BaseChunk
+    COMMA_CHANGES_LINES = true
+
+    # @return [HamlLint::Tree::Node] Haml node that this comes from
+    attr_reader :node
+
+    # @return [Integer] First line index of the auto-correctable code in the Haml source
+    #   Usually same as node.line - 1, but some cases, such as interpolation in a filter will
+    #   will be different.
+    attr_reader :haml_line_index
+
+    # @return [Integer] Line number of the line marker in the ruby source placed before
+    #   this auto-correctable code
+    attr_reader :start_marker_line_number
+
+    # @return [Integer] The indentation (number of spaces) to use to index the marker
+    #   that follows this chunk. Unlike the marker before, this one can vary.
+    attr_reader :end_marker_indent
+
+    # @return [Array<String>] The ruby lines that this chunk will insert
+    attr_reader :ruby_lines
+
+    def initialize(node,
+                   ruby_lines,
+                   end_marker_indent:, haml_line_index: node.line - 1)
+      ruby_lines = [ruby_lines] if ruby_lines.is_a?(String)
+      @node = node
+      @ruby_lines = ruby_lines
+      @haml_line_index = haml_line_index
+      @end_marker_indent = end_marker_indent
+    end
+
+    # To be overridden in subclasses.
+    # Return a new chunk which is the result of fusing self with the given following chunk.
+    # If no fusion is possible, returns nil
+    def fuse(_following_chunk)
+      nil
+    end
+
+    # Overwrites haml_lines to match the Ruby code that was corrected by RuboCop which is in
+    # all_corrected_ruby_lines. This can change non-ruby parts to, especially for
+    # indentation.
+    #
+    # This will be called on ruby chunks in the reverse order they were created. Two benefits
+    # of this approach:
+    # * No need to track when lines in haml_lines are moved to apply changes later in the file
+    # * When fixing indentation of lines that follow a corrected line, those following lines will
+    #   already have been corrected and so require nothing.
+    # Can be overridden by subclasses to make it do nothing
+    def transfer_correction(coordinator, _all_corrected_ruby_lines, haml_lines)
+      to_ruby_lines = coordinator.extract_from_corrected_lines(@start_marker_line_number, @ruby_lines.size)
+      transfer_correction_logic(coordinator, to_ruby_lines, haml_lines)
+    end
+
+    # To be overriden by subclasses.
+    #
+    # Logic to transfer the corrections that turned from_ruby_lines into to_ruby_lines.
+    #
+    # This method only received the ruby code that belongs to this chunk. (It was
+    # extracted using #extract_from by #transfer_correction)
+    def transfer_correction_logic(_coordinator, _to_ruby_lines, _haml_lines)
+      raise "Implement #transfer_correction_logic in #{self.class.name}"
+    end
+
+    def start_marker_indent
+      ruby_lines.first[/ */].size
+    end
+
+    def haml_end_line_index
+      @haml_line_index + nb_haml_lines - 1
+    end
+
+    def nb_haml_lines
+      @ruby_lines.size - skip_line_indexes_in_source_map.size
+    end
+
+    def full_assemble(coordinator)
+      if wrap_in_markers
+        @start_marker_line_number = coordinator.add_marker(start_marker_indent,
+                                                           haml_line_index: haml_line_index)
+        assemble_in(coordinator)
+        coordinator.add_marker(@end_marker_indent, haml_line_index: haml_end_line_index)
+      else
+        assemble_in(coordinator)
+      end
+    end
+
+    def assemble_in(coordinator)
+      coordinator.add_lines(@ruby_lines,
+                            haml_line_index: haml_line_index,
+                            skip_indexes_in_source_map: skip_line_indexes_in_source_map)
+    end
+
+    def skip_line_indexes_in_source_map
+      []
+    end
+
+    def wrap_in_markers
+      true
+    end
+  end
+end