haml_lint 0.13.0 → 0.14.0

data/lib/haml_lint/linter/multiline_pipe.rb

@@ -24,7 +24,7 @@ module HamlLint
       # 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)
+      record_lint(node, MESSAGE) if line.match(MULTILINE_PIPE_REGEX)
     end
 
     private
@@ -32,12 +32,12 @@ module HamlLint
     MULTILINE_PIPE_REGEX = /\s+\|\s*$/
 
     def line_text_for_node(node)
-      parser.lines[node.line - 1]
+      document.source_lines[node.line - 1]
     end
 
     def check(node)
       line = line_text_for_node(node)
-      add_lint(node, MESSAGE) if line.match(MULTILINE_PIPE_REGEX)
+      record_lint(node, MESSAGE) if line.match(MULTILINE_PIPE_REGEX)
     end
   end
 end

data/lib/haml_lint/linter/multiline_script.rb

@@ -34,9 +34,9 @@ module HamlLint
     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')
+        record_lint(node,
+                    "Script with trailing operator `#{operator}` should be " \
+                    'merged with the script on the following line')
       end
     end
   end

data/lib/haml_lint/linter/object_reference_attributes.rb

@@ -7,7 +7,7 @@ module HamlLint
     def visit_tag(node)
       return unless node.object_reference?
 
-      add_lint(node, 'Avoid using object reference syntax to assign class/id ' \
+      record_lint(node, 'Avoid using object reference syntax to assign class/id ' \
                      'attributes for tags')
     end
   end

data/lib/haml_lint/linter/rubocop.rb

@@ -1,4 +1,4 @@
-require 'haml_lint/script_extractor'
+require 'haml_lint/ruby_extractor'
 require 'rubocop'
 require 'tempfile'
 
@@ -7,33 +7,35 @@ module HamlLint
   class Linter::RuboCop < Linter
     include LinterRegistry
 
-    def initialize(config)
-      super
-      @rubocop = ::RuboCop::CLI.new
-      @ignored_cops = Array(config['ignored_cops']).flatten
-    end
+    def visit_root(_node)
+      extractor = HamlLint::RubyExtractor.new
+      extracted_source = extractor.extract(document)
 
-    def run(parser)
-      @parser = parser
-      @extractor = ScriptExtractor.new(parser)
-      extracted_code = @extractor.extract.strip
+      return if extracted_source.source.empty?
 
-      # Ensure a final newline in the code we feed to RuboCop
-      find_lints(extracted_code + "\n") unless extracted_code.empty?
+      find_lints(extracted_source.source, extracted_source.source_map)
     end
 
     private
 
-    def find_lints(code)
-      original_filename = @parser.filename || 'ruby_script'
+    # Executes RuboCop against the given Ruby code and records the offenses as
+    # lints.
+    #
+    # @param ruby [String] Ruby code
+    # @param source_map [Hash] map of Ruby code line numbers to original line
+    #   numbers in the template
+    def find_lints(ruby, source_map)
+      rubocop = ::RuboCop::CLI.new
+
+      original_filename = document.file || '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.write(ruby)
           f.close
-          extract_lints_from_offences(lint_file(f.path))
+          extract_lints_from_offenses(lint_file(rubocop, f.path), source_map)
         ensure
           f.unlink
         end
@@ -41,36 +43,60 @@ module HamlLint
     end
 
     # Defined so we can stub the results in tests
-    def lint_file(file)
-      @rubocop.run(%w[--format HamlLint::OffenceCollector] << file)
-      OffenceCollector.offences
+    #
+    # @param rubocop [RuboCop::CLI]
+    # @param file [String]
+    # @return [Array<RuboCop::Cop::Offense>]
+    def lint_file(rubocop, file)
+      rubocop.run(rubocop_flags << file)
+      OffenseCollector.offenses
     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}")
+    # Aggregates RuboCop offenses and converts them to {HamlLint::Lint}s
+    # suitable for reporting.
+    #
+    # @param offenses [Array<RuboCop::Cop::Offense>]
+    # @param source_map [Hash]
+    def extract_lints_from_offenses(offenses, source_map)
+      dummy_node = Struct.new(:line)
+
+      offenses.select { |offense| !config['ignored_cops'].include?(offense.cop_name) }
+              .each do |offense|
+        record_lint(dummy_node.new(source_map[offense.line]), offense.message)
       end
     end
-  end
 
-  # Collects offences detected by RuboCop.
-  class OffenceCollector < ::RuboCop::Formatter::BaseFormatter
-    attr_accessor :offences
+    # Returns flags that will be passed to RuboCop CLI.
+    #
+    # @return [Array<String>]
+    def rubocop_flags
+      flags = %w[--format HamlLint::OffenseCollector]
+      flags += ['--config', ENV['HAML_LINT_RUBOCOP_CONF']] if ENV['HAML_LINT_RUBOCOP_CONF']
+      flags
+    end
+  end
 
+  # Collects offenses detected by RuboCop.
+  class OffenseCollector < ::RuboCop::Formatter::BaseFormatter
     class << self
-      attr_accessor :offences
+      # List of offenses reported by RuboCop.
+      attr_accessor :offenses
     end
 
+    # Executed when RuboCop begins linting.
+    #
+    # @param _target_files [Array<String>]
     def started(_target_files)
-      self.class.offences = []
+      self.class.offenses = []
     end
 
-    def file_finished(_file, offences)
-      self.class.offences += offences
+    # Executed when a file has been scanned by RuboCop, adding the reported
+    # offenses to our collection.
+    #
+    # @param _file [String]
+    # @param offenses [Array<RuboCop::Cop::Offense>]
+    def file_finished(_file, offenses)
+      self.class.offenses += offenses
     end
   end
 end

data/lib/haml_lint/linter/ruby_comments.rb

@@ -5,7 +5,7 @@ module HamlLint
 
     def visit_silent_script(node)
       if code_comment?(node)
-        add_lint(node, 'Use `-#` for comments instead of `- #`')
+        record_lint(node, 'Use `-#` for comments instead of `- #`')
       end
     end
 

data/lib/haml_lint/linter/space_before_script.rb

@@ -28,18 +28,18 @@ module HamlLint
       # (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 % '=')
+      record_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)
+      return unless document.source_lines[node.line - 1].lstrip.start_with?('=')
+      record_lint(node, MESSAGE_FORMAT % '=') if missing_space?(node)
     end
 
     def visit_silent_script(node)
-      add_lint(node, MESSAGE_FORMAT % '-') if missing_space?(node)
+      record_lint(node, MESSAGE_FORMAT % '-') if missing_space?(node)
     end
 
     private

data/lib/haml_lint/linter/space_inside_hash_attributes.rb

@@ -25,8 +25,8 @@ module HamlLint
       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]
+      record_lint(node, style[:start_message]) unless source =~ style[:start_regex]
+      record_lint(node, style[:end_message]) unless source =~ style[:end_regex]
     end
   end
 end

data/lib/haml_lint/linter/tag_name.rb

@@ -7,7 +7,7 @@ module HamlLint
       tag = node.tag_name
       return unless tag.match(/[A-Z]/)
 
-      add_lint(node, "`#{tag}` should be written in lowercase as `#{tag.downcase}`")
+      record_lint(node, "`#{tag}` should be written in lowercase as `#{tag.downcase}`")
     end
   end
 end

data/lib/haml_lint/linter/trailing_whitespace.rb

@@ -6,10 +6,10 @@ module HamlLint
     def visit_root(_node)
       dummy_node = Struct.new(:line)
 
-      parser.lines.each_with_index do |line, index|
+      document.source_lines.each_with_index do |line, index|
         next unless line =~ /\s+$/
 
-        add_lint dummy_node.new(index + 1), 'Line contains trailing whitespace'
+        record_lint dummy_node.new(index + 1), 'Line contains trailing whitespace'
       end
     end
   end

data/lib/haml_lint/linter/unnecessary_interpolation.rb

@@ -14,15 +14,15 @@ module HamlLint
 
       count = 0
       chars = 2 # Include surrounding quote chars
-      HamlLint::Utils.extract_interpolated_values(node.script) do |interpolated_code|
+      HamlLint::Utils.extract_interpolated_values(node.script) do |interpolated_code, _line|
         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`')
+        record_lint(node, '`%... \#{expression}` can be written without ' \
+                          'interpolation as `%...= expression`')
       end
     end
   end

data/lib/haml_lint/linter/unnecessary_string_output.rb

@@ -13,7 +13,7 @@ module HamlLint
 
     def visit_tag(node)
       if tag_has_inline_script?(node) && inline_content_is_string?(node)
-        add_lint(node, MESSAGE)
+        record_lint(node, MESSAGE)
       end
     end
 
@@ -23,7 +23,7 @@ module HamlLint
       return if node.source_code !~ /\s*=/
 
       if outputs_string_literal?(node)
-        add_lint(node, MESSAGE)
+        record_lint(node, MESSAGE)
       end
     end
 
@@ -31,9 +31,16 @@ module HamlLint
 
     def outputs_string_literal?(script_node)
       tree = parse_ruby(script_node.script)
-      [:str, :dstr].include?(tree.type)
+      [:str, :dstr].include?(tree.type) &&
+        starts_with_reserved_character?(tree.children.first)
     rescue ::Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
       # Gracefully ignore syntax errors, as that's managed by a different linter
     end
+
+    # Returns whether a string starts with a character that would otherwise be
+    # given special treatment, thus making enclosing it in a string necessary.
+    def starts_with_reserved_character?(string)
+      string !~ %r{\A\s*[/#-=%~]}
+    end
   end
 end

data/lib/haml_lint/linter.rb

@@ -1,33 +1,52 @@
 module HamlLint
   # Base implementation for all lint checks.
+  #
+  # @abstract
   class Linter
     include HamlVisitor
 
-    attr_reader :parser, :lints
+    # List of lints reported by this linter.
+    #
+    # @todo Remove once spec/support/shared_linter_context returns an array of
+    #   lints for the subject instead of the linter itself.
+    attr_reader :lints
 
+    # Initializes a linter with the specified configuration.
+    #
     # @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)
+    # Runs the linter against the given Haml document.
+    #
+    # @param document [HamlLint::Document]
+    def run(document)
+      @document = document
+      @lints = []
+      visit(document.tree)
+      @lints
     end
 
     # Returns the simple name for this linter.
+    #
+    # @return [String]
     def name
       self.class.name.split('::').last
     end
 
     private
 
-    attr_reader :config
+    attr_reader :config, :document
 
-    def add_lint(node, message)
-      @lints << Lint.new(self, parser.filename, node.line, message)
+    # Record a lint for reporting back to the user.
+    #
+    # @param node [#line] node to extract the line number from
+    # @param message [String] error/warning to display to the user
+    def record_lint(node, message)
+      @lints << HamlLint::Lint.new(self, @document.file, node.line, message,
+                                   config.fetch('severity', :warning).to_sym)
     end
 
     # Parse Ruby code into an abstract syntax tree.
@@ -136,7 +155,7 @@ module HamlLint
     def following_node_line(node)
       [
         [node.children.first, next_node(node)].compact.map(&:line),
-        parser.lines.count + 1,
+        @document.source_lines.count + 1,
       ].flatten.min
     end
 
@@ -148,7 +167,8 @@ module HamlLint
     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|
+      @document.source_lines[(tag_node.line - 1)...(following_node_line(tag_node) - 1)]
+        .map do |line|
         line.strip.gsub(/\|\z/, '').rstrip
       end.join(' ')
     end

data/lib/haml_lint/linter_registry.rb

@@ -6,12 +6,23 @@ module HamlLint
     @linters = []
 
     class << self
+      # List of all registered linters.
       attr_reader :linters
 
-      def included(base)
-        @linters << base
+      # Executed when a linter includes the {LinterRegistry} module.
+      #
+      # This results in the linter being registered with the registry.
+      #
+      # @param subclass [Class]
+      def included(subclass)
+        @linters << subclass
       end
 
+      # Return a list of {HamlLint::Linter} {Class}es corresponding to the
+      # specified list of names.
+      #
+      # @param linter_names [Array<String>]
+      # @return [Array<Class>]
       def extract_linters_from(linter_names)
         linter_names.map do |linter_name|
           begin

data/lib/haml_lint/linter_selector.rb

@@ -0,0 +1,77 @@
+module HamlLint
+  # Chooses the appropriate linters to run given the specified configuration.
+  class LinterSelector
+    # Creates a selector using the given configuration and additional options.
+    #
+    # @param config [HamlLint::Configuration]
+    # @param options [Hash]
+    def initialize(config, options)
+      @config = config
+      @options = options
+    end
+
+    # Returns the set of linters to run against the given file.
+    #
+    # @param file [String]
+    # @raise [HamlLint::Exceptions::NoLintersError] when no linters are enabled
+    # @return [Array<HamlLint::Linter>]
+    def linters_for_file(file)
+      @linters ||= extract_enabled_linters(@config, @options)
+      @linters.select { |linter| run_linter_on_file?(@config, linter, file) }
+    end
+
+    private
+
+    # Returns a list of linters that are enabled given the specified
+    # configuration and additional options.
+    #
+    # @param config [HamlLint::Configuration]
+    # @param options [Hash]
+    # @return [Array<HamlLint::Linter>]
+    def extract_enabled_linters(config, options)
+      included_linters = LinterRegistry
+        .extract_linters_from(options.fetch(:included_linters, []))
+
+      included_linters = LinterRegistry.linters if included_linters.empty?
+
+      excluded_linters = LinterRegistry
+        .extract_linters_from(options.fetch(:excluded_linters, []))
+
+      # After filtering out explicitly included/excluded linters, only include
+      # linters which are enabled in the configuration
+      linters = (included_linters - excluded_linters).map do |linter_class|
+        linter_config = config.for_linter(linter_class)
+        linter_class.new(linter_config) if linter_config['enabled']
+      end.compact
+
+      # Highlight condition where all linters were filtered out, as this was
+      # likely a mistake on the user's part
+      if linters.empty?
+        raise HamlLint::Exceptions::NoLintersError, 'No linters specified'
+      end
+
+      linters
+    end
+
+    # Whether to run the given linter against the specified file.
+    #
+    # @param config [HamlLint::Configuration]
+    # @param linter [HamlLint::Linter]
+    # @param file [String]
+    # @return [Boolean]
+    def run_linter_on_file?(config, linter, file)
+      linter_config = config.for_linter(linter)
+
+      if linter_config['include'].any? &&
+         !HamlLint::Utils.any_glob_matches?(linter_config['include'], file)
+        return false
+      end
+
+      if HamlLint::Utils.any_glob_matches?(linter_config['exclude'], file)
+        return false
+      end
+
+      true
+    end
+  end
+end

data/lib/haml_lint/node_transformer.rb

@@ -7,11 +7,11 @@ module HamlLint
   # would expect. This class is intended to isolate and handle these cases so
   # that linters don't have to deal with them.
   class NodeTransformer
-    # Creates a node transformer for the given parser context.
+    # Creates a node transformer for the given Haml document.
     #
-    # @param parser [HamlLint::Parser]
-    def initialize(parser)
-      @parser = parser
+    # @param document [HamlLint::Document]
+    def initialize(document)
+      @document = document
     end
 
     # Transforms the given {Haml::Parser::ParseNode} into its corresponding
@@ -19,7 +19,7 @@ module HamlLint
     def transform(haml_node)
       node_class = "#{HamlLint::Utils.camel_case(haml_node.type.to_s)}Node"
 
-      HamlLint::Tree.const_get(node_class).new(@parser, haml_node)
+      HamlLint::Tree.const_get(node_class).new(@document, haml_node)
     rescue NameError
       # TODO: Wrap in parser error?
       raise

data/lib/haml_lint/options.rb

@@ -31,11 +31,6 @@ module HamlLint
     private
 
     def add_linter_options(parser)
-      parser.on('-e', '--exclude file,...', Array,
-                'List of file names to exclude') do |files|
-        @options[:excluded_files] = files
-      end
-
       parser.on('-i', '--include-linter linter,...', Array,
                 'Specify which linters you want to run') do |linters|
         @options[:included_linters] = linters
@@ -48,10 +43,22 @@ module HamlLint
 
       parser.on('-r', '--reporter reporter', String,
                 'Specify which reporter you want to use to generate the output') do |reporter|
-        @options[:reporter] = HamlLint::Reporter.const_get("#{reporter.capitalize}Reporter")
+        @options[:reporter] = load_reporter_class(reporter.capitalize)
       end
     end
 
+    # Returns the class of the specified Reporter.
+    #
+    # @param reporter_name [String]
+    # @raise [HamlLint::Exceptions::InvalidCLIOption] if reporter doesn't exist
+    # @return [Class]
+    def load_reporter_class(reporter_name)
+      HamlLint::Reporter.const_get("#{reporter_name}Reporter")
+    rescue NameError
+      raise HamlLint::Exceptions::InvalidCLIOption,
+            "#{reporter_name}Reporter does not exist"
+    end
+
     def add_file_options(parser)
       parser.on('-c', '--config config-file', String,
                 'Specify which configuration file you want to use') do |conf_file|

data/lib/haml_lint/rake_task.rb

@@ -1,5 +1,6 @@
 require 'rake'
 require 'rake/tasklib'
+require 'haml_lint/constants'
 
 module HamlLint
   # Rake task interface for haml-lint command line interface.
@@ -51,6 +52,8 @@ module HamlLint
     attr_accessor :quiet
 
     # Create the task so it exists in the current namespace.
+    #
+    # @param name [Symbol] task name
     def initialize(name = :haml_lint)
       @name = name
       @files = ['.'] # Search for everything under current directory by default
@@ -63,27 +66,34 @@ module HamlLint
 
     private
 
+    # Defines the Rake task.
     def define
       desc default_description unless ::Rake.application.last_description
 
       task(name, [:files]) do |_task, task_args|
         # Lazy-load so task doesn't affect Rakefile load time
-        require 'haml_lint'
         require 'haml_lint/cli'
 
         run_cli(task_args)
       end
     end
 
+    # Executes the CLI given the specified task arguments.
+    #
+    # @param task_args [Rake::TaskArguments]
     def run_cli(task_args)
       cli_args = ['--config', config] if config
 
       logger = quiet ? HamlLint::Logger.silent : HamlLint::Logger.new(STDOUT)
       result = HamlLint::CLI.new(logger).run(Array(cli_args) + files_to_lint(task_args))
 
-      fail "haml-lint failed with exit code #{result}" unless result == 0
+      fail "#{HamlLint::APP_NAME} failed with exit code #{result}" unless result == 0
     end
 
+    # Returns the list of files that should be linted given the specified task
+    # arguments.
+    #
+    # @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
       # first argument `files` but it's actually only the first file--we pull
@@ -96,8 +106,13 @@ module HamlLint
     end
 
     # Friendly description that shows the full command that will be executed.
+    #
+    # This allows us to change the information displayed by `rake --tasks` based
+    # on the options passed to the constructor which defined the task.
+    #
+    # @return [String]
     def default_description
-      description = 'Run `haml-lint'
+      description = "Run `#{HamlLint::APP_NAME}"
       description += " --config #{config}" if config
       description += " #{files.join(' ')}" if files.any?
       description += ' [files...]`'

data/lib/haml_lint/report.rb

@@ -1,9 +1,16 @@
 module HamlLint
   # Contains information about all lints detected during a scan.
   class Report
+    # List of lints that were found.
     attr_accessor :lints
+
+    # List of files that were linted.
     attr_reader :files
 
+    # Creates a report.
+    #
+    # @param lints [Array<HamlLint::Lint>] lints that were found
+    # @param files [Array<String>] files that were linted
     def initialize(lints, files)
       @lints = lints.sort_by { |l| [l.filename, l.line] }
       @files = files

data/lib/haml_lint/reporter/default_reporter.rb

@@ -2,8 +2,8 @@ module HamlLint
   # Outputs lints in a simple format with the filename, line number, and lint
   # message.
   class Reporter::DefaultReporter < Reporter
-    def report_lints
-      sorted_lints = lints.sort_by { |l| [l.filename, l.line] }
+    def display_report(report)
+      sorted_lints = report.lints.sort_by { |l| [l.filename, l.line] }
 
       sorted_lints.each do |lint|
         print_location(lint)