haml_lint 0.13.0 → 0.14.0

data/lib/haml_lint/reporter/json_reporter.rb

@@ -1,29 +1,34 @@
 module HamlLint
   # Outputs report as a JSON document.
   class Reporter::JsonReporter < Reporter
-    def report_lints
+    def display_report(report)
+      lints = report.lints
       grouped = lints.group_by(&:filename)
 
-      report = {
-        metadata: {
-          hamllint_version: VERSION,
-          ruby_engine:      RUBY_ENGINE,
-          ruby_patchlevel:  RUBY_PATCHLEVEL.to_s,
-          ruby_platform:    RUBY_PLATFORM,
-        },
+      report_hash = {
+        metadata: metadata,
         files: grouped.map { |l| map_file(l) },
         summary: {
           offense_count: lints.length,
           target_file_count: grouped.length,
-          inspected_file_count: files.length,
+          inspected_file_count: report.files.length,
         },
       }
 
-      log.log report.to_json
+      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,

data/lib/haml_lint/reporter.rb

@@ -1,36 +1,42 @@
 module HamlLint
-  # Abstract lint reporter. Subclass and override {#report_lints} to
+  # Abstract lint reporter. Subclass and override {#display_report} to
   # implement a custom lint reporter.
   #
   # @abstract
   class Reporter
-    attr_reader :lints
-    attr_reader :files
-
+    # Creates the reporter that will display the given report.
+    #
     # @param logger [HamlLint::Logger]
-    # @param report [HamlLint::Report]
-    def initialize(logger, report)
+    def initialize(logger)
       @log = logger
-      @lints = report.lints
-      @files = report.files
     end
 
     # Implemented by subclasses to display lints from a {HamlLint::Report}.
-    def report_lints
-      raise NotImplementedError
+    #
+    # @param report [HamlLint::Report]
+    def display_report(report)
+      raise NotImplementedError,
+            "Implement `display_report` to display #{report}"
     end
 
-    # Keep tracking all the descendants of this class for the list of available reporters
+    # Keep tracking all the descendants of this class for the list of available
+    # reporters.
+    #
+    # @return [Array<Class>]
     def self.descendants
       @descendants ||= []
     end
 
+    # Executed when this class is subclassed.
+    #
+    # @param descendant [Class]
     def self.inherited(descendant)
       descendants << descendant
     end
 
     private
 
+    # @return [HamlLint::Logger] logger to send output to
     attr_reader :log
   end
 end

data/lib/haml_lint/{script_extractor.rb → ruby_extractor.rb}

@@ -19,24 +19,33 @@ module HamlLint
   #       link_to 'Sign In', sign_in_path
   #     end
   #
-  class ScriptExtractor
+  # The translation won't be perfect, and won't make any real sense, but the
+  # relationship between variable declarations/uses and the flow control graph
+  # will remain intact.
+  class RubyExtractor
     include HamlVisitor
 
-    attr_reader :source, :source_map
-
-    def initialize(parser)
-      @parser = parser
-    end
-
-    def extract
-      visit(@parser.tree)
-      @source = @code.join("\n")
+    # Stores the extracted source and a map of lines of generated source to the
+    # original source that created them.
+    #
+    # @attr_reader source [String] generated source code
+    # @attr_reader source_map [Hash] map of line numbers from generated source
+    #   to original source line number
+    RubySource = Struct.new(:source, :source_map)
+
+    # Extracts Ruby code from Sexp representing a Slim document.
+    #
+    # @param document [HamlLint::Document]
+    # @return [HamlLint::RubyExtractor::RubySource]
+    def extract(document)
+      visit(document.tree)
+      RubySource.new(@source_lines.join("\n"), @source_map)
     end
 
     def visit_root(_node)
-      @code = []
-      @total_lines = 0
+      @source_lines = []
       @source_map = {}
+      @line_count = 0
       @indent_level = 0
 
       yield # Collect lines of code from children
@@ -104,8 +113,8 @@ module HamlLint
         end
       else
         add_line('puts', node)
-        HamlLint::Utils.extract_interpolated_values(node.text) do |interpolated_code|
-          add_line(interpolated_code, node)
+        HamlLint::Utils.extract_interpolated_values(node.text) do |interpolated_code, line|
+          add_line(interpolated_code, node.line + line)
         end
       end
     end
@@ -140,7 +149,7 @@ module HamlLint
 
       indent = (' ' * 2 * indent_level)
 
-      @code << indent + code
+      @source_lines << indent + code
 
       original_line =
         node_or_line.respond_to?(:line) ? node_or_line.line : node_or_line
@@ -149,8 +158,8 @@ module HamlLint
       # resulting code will span multiple lines, so we need to create a
       # mapping for each line.
       (code.count("\n") + 1).times do
-        @total_lines += 1
-        @source_map[@total_lines] = original_line
+        @line_count += 1
+        @source_map[@line_count] = original_line
       end
     end
 

data/lib/haml_lint/runner.rb

@@ -1,76 +1,76 @@
 module HamlLint
   # Responsible for running the applicable linters against the desired files.
   class Runner
-    # Make the list of applicable files available
-    attr_reader :files
-
     # Runs the appropriate linters against the desired files given the specified
     # options.
     #
-    # @param options [Hash]
-    # @raise [HamlLint::Exceptions::NoLintersError] when no linters are enabled
+    # @param [Hash] options
+    # @option options :config_file [String] path of configuration file to load
+    # @option options :config [HamlLint::Configuration] configuration to use
+    # @option options :excluded_files [Array<String>]
+    # @option options :included_linters [Array<String>]
+    # @option options :excluded_linters [Array<String>]
     # @return [HamlLint::Report] a summary of all lints found
     def run(options = {})
       config = load_applicable_config(options)
-      files = extract_applicable_files(options, config)
-      linters = extract_enabled_linters(config, options)
+      files = extract_applicable_files(config, options)
 
-      raise HamlLint::Exceptions::NoLintersError, 'No linters specified' if linters.empty?
+      linter_selector = HamlLint::LinterSelector.new(config, options)
 
-      @lints = []
-      files.each do |file|
-        find_lints(file, linters, config)
-      end
-
-      linters.each do |linter|
-        @lints += linter.lints
-      end
+      lints = files.map do |file|
+        collect_lints(file, linter_selector, config)
+      end.flatten
 
-      HamlLint::Report.new(@lints, files)
+      HamlLint::Report.new(lints, files)
     end
 
     private
 
+    # Returns the {HamlLint::Configuration} that should be used given the
+    # specified options.
+    #
+    # @param options [Hash]
+    # @return [HamlLint::Configuration]
     def load_applicable_config(options)
       if options[:config_file]
         HamlLint::ConfigurationLoader.load_file(options[:config_file])
+      elsif options[:config]
+        options[:config]
       else
         HamlLint::ConfigurationLoader.load_applicable_config
       end
     end
 
-    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
-      (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
-    end
-
-    def find_lints(file, linters, config)
-      parser = Parser.new(file, config.hash)
-
-      linters.each do |linter|
-        linter.run(parser)
+    # Runs all provided linters using the specified config against the given
+    # file.
+    #
+    # @param file [String] path to file to lint
+    # @param linter_selector [HamlLint::LinterSelector]
+    # @param config [HamlLint::Configuration]
+    def collect_lints(file, linter_selector, config)
+      begin
+        document = HamlLint::Document.new(File.read(file), file: file, config: config)
+      rescue Haml::Error => ex
+        return [HamlLint::Lint.new(nil, file, ex.line, ex.to_s, :error)]
       end
-    rescue Haml::Error => ex
-      @lints << Lint.new(nil, file, ex.line, ex.to_s, :error)
+
+      linter_selector.linters_for_file(file).map do |linter|
+        linter.run(document)
+      end.flatten
     end
 
-    def extract_applicable_files(options, config)
+    # Returns the list of files that should be linted given the specified
+    # configuration and options.
+    #
+    # @param config [HamlLint::Configuration]
+    # @param options [Hash]
+    # @return [Array<String>]
+    def extract_applicable_files(config, options)
       included_patterns = options[:files]
-      excluded_files = options.fetch(:excluded_files, [])
+      excluded_patterns = config['exclude']
+      excluded_patterns += options.fetch(:excluded_files, [])
 
-      HamlLint::FileFinder.new(config).find(included_patterns, excluded_files)
+      HamlLint::FileFinder.new(config).find(included_patterns, excluded_patterns)
     end
   end
 end

data/lib/haml_lint/tree/node.rb

@@ -14,12 +14,11 @@ module HamlLint::Tree
 
     # Creates a node wrapping the given {Haml::Parser::ParseNode} struct.
     #
-    # @param parser [HamlLint::Parser] parser that created this node
+    # @param document [HamlLint::Document] Haml document that created this node
     # @param parse_node [Haml::Parser::ParseNode] parse node created by HAML's parser
-    def initialize(parser, parse_node)
-      # TODO: Change signature to take source code object, not parser
+    def initialize(document, parse_node)
       @line = parse_node.line
-      @parser = parser
+      @document = document
       @value = parse_node.value
       @type = parse_node.type
     end
@@ -50,12 +49,12 @@ module HamlLint::Tree
         if next_node
           next_node.line - 1
         else
-          @parser.lines.count + 1
+          @document.source_lines.count + 1
         end
 
-      @parser.lines[@line - 1...next_node_line]
-             .join("\n")
-             .gsub(/^\s*\z/m, '') # Remove blank lines at the end
+      @document.source_lines[@line - 1...next_node_line]
+               .join("\n")
+               .gsub(/^\s*\z/m, '') # Remove blank lines at the end
     end
 
     def inspect

data/lib/haml_lint/utils.rb

@@ -3,56 +3,123 @@ module HamlLint
   module Utils
     module_function
 
-    # Yields interpolated values within a block of filter text.
-    def extract_interpolated_values(filter_text)
-      Haml::Util.handle_interpolation(filter_text.dump) do |scan|
+    # Returns whether a glob pattern (or any of a list of patterns) matches the
+    # specified file.
+    #
+    # This is defined here so our file globbing options are consistent
+    # everywhere we perform globbing.
+    #
+    # @param glob [String, Array]
+    # @param file [String]
+    # @return [Boolean]
+    def any_glob_matches?(globs_or_glob, file)
+      Array(globs_or_glob).any? do |glob|
+        ::File.fnmatch?(glob, file,
+                        ::File::FNM_PATHNAME | # Wildcards don't match path separators
+                        ::File::FNM_DOTMATCH)  # `*` wildcard matches dotfiles
+      end
+    end
+
+    # Yields interpolated values within a block of text.
+    #
+    # @param text [String]
+    # @yield Passes interpolated code and line number that code appears on in
+    #   the text.
+    # @yieldparam interpolated_code [String] code that was interpolated
+    # @yieldparam line [Integer] line number code appears on in text
+    def extract_interpolated_values(text) # rubocop:disable Metrics/AbcSize
+      dumped_text = text.dump
+      newline_positions = extract_substring_positions(dumped_text, '\\\n')
+
+      Haml::Util.handle_interpolation(dumped_text) do |scan|
+        line = (newline_positions.find_index { |marker| scan.pos <= marker } ||
+                newline_positions.size) + 1
+
         escape_count = (scan[2].size - 1) / 2
-        return unless escape_count.even? # rubocop:disable Lint/NonLocalExitFromIterator
+        break unless escape_count.even?
 
         dumped_interpolated_str = Haml::Util.balance(scan, '{', '}', 1)[0][0...-1]
 
         # Hacky way to turn a dumped string back into a regular string
-        yield eval('"' + dumped_interpolated_str + '"') # rubocop:disable Eval
+        yield [eval('"' + dumped_interpolated_str + '"'), line] # rubocop:disable Eval
       end
     end
 
+    # Returns indexes of all occurrences of a substring within a string.
+    #
+    # Note, this will not return overlaping substrings, so searching for "aa"
+    # in "aaa" will only find one substring, not two.
+    #
+    # @param text [String] the text to search
+    # @param substr [String] the substring to search for
+    # @return [Array<Integer>] list of indexes where the substring occurs
+    def extract_substring_positions(text, substr)
+      positions = []
+      scanner = StringScanner.new(text)
+      positions << scanner.pos while scanner.scan(/(.*?)#{substr}/)
+      positions
+    end
+
     # Converts a string containing underscores/hyphens/spaces into CamelCase.
     def camel_case(str)
       str.split(/_|-| /).map { |part| part.sub(/^\w/) { |c| c.upcase } }.join
     end
 
-    # Find all consecutive nodes satisfying the given {Proc} of a minimum size
-    # and yield each group.
+    # Find all consecutive items satisfying the given block of a minimum size,
+    # yielding each group of consecutive items to the provided block.
     #
     # @param items [Array]
-    # @param min_size [Fixnum] minimum number of consecutive items before
-    #   yielding
     # @param satisfies [Proc] function that takes an item and returns true/false
-    def find_consecutive(items, min_size, satisfies)
-      current = -1
+    # @param min_consecutive [Fixnum] minimum number of consecutive items before
+    #   yielding the group
+    # @yield Passes list of consecutive items all matching the criteria defined
+    #   by the `satisfies` {Proc} to the provided block
+    # @yieldparam group [Array] List of consecutive items
+    # @yieldreturn [Boolean] block should return whether item matches criteria
+    #   for inclusion
+    def for_consecutive_items(items, satisfies, min_consecutive = 2)
+      current_index = -1
 
-      while (current += 1) < items.count
-        next unless satisfies[items[current]]
+      while (current_index += 1) < items.count
+        next unless satisfies[items[current_index]]
 
-        count = count_consecutive(items, current, satisfies)
-        next unless count >= min_size
+        count = count_consecutive(items, current_index, &satisfies)
+        next unless count >= min_consecutive
 
         # Yield the chunk of consecutive items
-        yield items[current...(current + count)]
+        yield items[current_index...(current_index + count)]
 
-        current += count # Skip this patch of consecutive items to find more
+        current_index += count # Skip this patch of consecutive items to find more
       end
     end
 
     # Count the number of consecutive items satisfying the given {Proc}.
     #
     # @param items [Array]
-    # @param offset [Fixnum] index to start searching
-    # @param satisfies [Proc] function to evaluate item with
-    def count_consecutive(items, offset, satisfies)
+    # @param offset [Fixnum] index to start searching from
+    # @yield [item] Passes item to the provided block.
+    # @yieldparam item [Object] Item to evaluate as matching criteria for
+    #   inclusion
+    # @yieldreturn [Boolean] whether to include the item
+    # @return [Integer]
+    def count_consecutive(items, offset = 0, &block)
       count = 1
-      count += 1 while (offset + count < items.count) && satisfies[items[offset + count]]
+      count += 1 while (offset + count < items.count) && block.call(items[offset + count])
       count
     end
+
+    # Calls a block of code with a modified set of environment variables,
+    # restoring them once the code has executed.
+    def with_environment(env)
+      old_env = {}
+      env.each do |var, value|
+        old_env[var] = ENV[var.to_s]
+        ENV[var.to_s] = value
+      end
+
+      yield
+    ensure
+      old_env.each { |var, value| ENV[var.to_s] = value }
+    end
   end
 end

data/lib/haml_lint/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 module HamlLint
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 end

data/lib/haml_lint.rb

@@ -2,7 +2,7 @@ require 'haml_lint/constants'
 require 'haml_lint/exceptions'
 require 'haml_lint/configuration'
 require 'haml_lint/configuration_loader'
-require 'haml_lint/parser'
+require 'haml_lint/document'
 require 'haml_lint/haml_visitor'
 require 'haml_lint/lint'
 require 'haml_lint/linter_registry'
@@ -11,6 +11,7 @@ require 'haml_lint/linter'
 require 'haml_lint/logger'
 require 'haml_lint/reporter'
 require 'haml_lint/report'
+require 'haml_lint/linter_selector'
 require 'haml_lint/file_finder'
 require 'haml_lint/runner'
 require 'haml_lint/utils'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: haml_lint
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Brigade Engineering
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-03 00:00:00.000000000 Z
+date: 2015-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml
@@ -97,6 +97,7 @@ files:
 - lib/haml_lint/configuration.rb
 - lib/haml_lint/configuration_loader.rb
 - lib/haml_lint/constants.rb
+- lib/haml_lint/document.rb
 - lib/haml_lint/exceptions.rb
 - lib/haml_lint/file_finder.rb
 - lib/haml_lint/haml_visitor.rb
@@ -124,18 +125,18 @@ files:
 - lib/haml_lint/linter/unnecessary_interpolation.rb
 - lib/haml_lint/linter/unnecessary_string_output.rb
 - lib/haml_lint/linter_registry.rb
+- lib/haml_lint/linter_selector.rb
 - lib/haml_lint/logger.rb
 - lib/haml_lint/node_transformer.rb
 - lib/haml_lint/options.rb
-- lib/haml_lint/parser.rb
 - lib/haml_lint/rake_task.rb
 - lib/haml_lint/report.rb
 - lib/haml_lint/reporter.rb
 - lib/haml_lint/reporter/default_reporter.rb
 - lib/haml_lint/reporter/json_reporter.rb
+- lib/haml_lint/ruby_extractor.rb
 - lib/haml_lint/ruby_parser.rb
 - lib/haml_lint/runner.rb
-- lib/haml_lint/script_extractor.rb
 - lib/haml_lint/tree/comment_node.rb
 - lib/haml_lint/tree/doctype_node.rb
 - lib/haml_lint/tree/filter_node.rb

data/lib/haml_lint/parser.rb

@@ -1,87 +0,0 @@
-require 'haml'
-
-module HamlLint
-  # Parses a HAML document for inspection by linters.
-  class Parser
-    attr_reader :contents, :filename, :lines, :tree
-
-    # Creates a parser containing the parse tree of a HAML document.
-    #
-    # @param haml_or_filename [String]
-    # @param options [Hash]
-    # @option options [true,false] 'skip_frontmatter' Whether to skip
-    #   frontmatter included by frameworks such as Middleman or Jekyll
-    def initialize(haml_or_filename, options = {})
-      if File.exist?(haml_or_filename)
-        build_from_file(haml_or_filename)
-      else
-        build_from_string(haml_or_filename)
-      end
-
-      process_options(options)
-
-      build_parse_tree
-    end
-
-    private
-
-    # @param path [String]
-    def build_from_file(path)
-      @filename = path
-      @contents = File.read(path)
-    end
-
-    # @param haml [String]
-    def build_from_string(haml)
-      @contents = haml
-    end
-
-    def build_parse_tree
-      original_tree = Haml::Parser.new(@contents, Haml::Options.new).parse
-
-      # Remove the trailing empty HAML comment that the parser creates to signal
-      # the end of the HAML document
-      if Gem::Requirement.new('~> 4.0.0').satisfied_by?(Gem.loaded_specs['haml'].version)
-        original_tree.children.pop
-      end
-
-      @node_transformer = HamlLint::NodeTransformer.new(self)
-      @tree = convert_tree(original_tree)
-    end
-
-    def process_options(options)
-      if options['skip_frontmatter'] &&
-        @contents =~ /
-          # From the start of the string
-          \A
-          # First-capture match --- followed by optional whitespace up
-          # to a newline then 0 or more chars followed by an optional newline.
-          # This matches the --- and the contents of the frontmatter
-          (---\s*\n.*?\n?)
-          # From the start of the line
-          ^
-          # Second capture match --- or ... followed by optional whitespace
-          # and newline. This matches the closing --- for the frontmatter.
-          (---|\.\.\.)\s*$\n?/mx
-        @contents = $POSTMATCH
-      end
-
-      @lines = @contents.split("\n")
-    end
-
-    # Converts a HAML parse tree to a tree of {HamlLint::Tree::Node} objects.
-    #
-    # This provides a cleaner interface with which the linters can interact with
-    # the parse tree.
-    def convert_tree(haml_node, parent = nil)
-      new_node = @node_transformer.transform(haml_node)
-      new_node.parent = parent
-
-      new_node.children = haml_node.children.map do |child|
-        convert_tree(child, new_node)
-      end
-
-      new_node
-    end
-  end
-end