slim_lint 0.2.0 → 0.3.0

data/lib/slim_lint/runner.rb

@@ -1,72 +1,76 @@
 module SlimLint
   # 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 [SlimLint::Exceptions::NoLintersError] when no linters are enabled
+    # @option config_file [String] path of configuration file to load
+    # @option config [SlimLint::Configuration] configuration to use
+    # @option excluded_files [Array<String>]
+    # @option included_linters [Array<String>]
+    # @option excluded_linters [Array<String>]
     # @return [SlimLint::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 SlimLint::Exceptions::NoLintersError, 'No linters specified' if linters.empty?
+      linter_selector = SlimLint::LinterSelector.new(config, options)
 
-      @lints = []
-      files.each do |file|
-        find_lints(file, linters, config)
-      end
+      lints = files.map do |file|
+        collect_lints(file, linter_selector, config)
+      end.flatten
 
-      SlimLint::Report.new(@lints, files)
+      SlimLint::Report.new(lints, files)
     end
 
     private
 
+    # Returns the {SlimLint::Configuration} that should be used given the
+    # specified options.
+    #
+    # @param options [Hash]
+    # @return [SlimLint::Configuration]
     def load_applicable_config(options)
       if options[:config_file]
         SlimLint::ConfigurationLoader.load_file(options[:config_file])
+      elsif options[:config]
+        options[:config]
       else
         SlimLint::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)
-      document = SlimLint::Document.new(File.read(file), file: file, config: config)
-
-      linters.each do |linter|
-        @lints += linter.run(document)
+    # Runs all provided linters using the specified config against the given
+    # file.
+    #
+    # @param file [String] path to file to lint
+    # @param linter_selector [SlimLint::LinterSelector]
+    # @param config [SlimLint::Configuration]
+    def collect_lints(file, linter_selector, config)
+      begin
+        document = SlimLint::Document.new(File.read(file), file: file, config: config)
+      rescue Slim::Parser::SyntaxError => ex
+        return [SlimLint::Lint.new(nil, file, ex.line, ex.error, :error)]
       end
-    rescue Slim::Parser::SyntaxError => ex
-      @lints << Lint.new(nil, file, ex.line, ex.error, :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 [SlimLint::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, [])
 
-      SlimLint::FileFinder.new(config).find(included_patterns, excluded_files)
+      SlimLint::FileFinder.new(config).find(included_patterns, excluded_patterns)
     end
   end
 end

data/lib/slim_lint/sexp.rb

@@ -8,19 +8,22 @@ module SlimLint
     # corresponds to this Sexp.
     attr_accessor :line
 
-    # Creates an {Sexp} from the given {Array}-based Sexp, performing a deep
-    # copy.
-    def initialize(sexp)
-      sexp.each do |child|
-        item =
-          case child
-          when Array
-            Sexp.new(child)
-          else
-            child
-          end
-
-        push(item)
+    # Creates an {Sexp} from the given {Array}-based Sexp.
+    #
+    # This provides a convenient way to convert between literal arrays of
+    # {Symbol}s and {Sexp}s containing {Atom}s and nested {Sexp}s. These objects
+    # all expose a similar API that conveniently allows the two objects to be
+    # treated similarly due to duck typing.
+    #
+    # @param array_sexp [Array]
+    def initialize(array_sexp)
+      array_sexp.each do |atom_or_sexp|
+        case atom_or_sexp
+        when Array
+          push Sexp.new(atom_or_sexp)
+        else
+          push SlimLint::Atom.new(atom_or_sexp)
+        end
       end
     end
 
@@ -42,46 +45,56 @@ module SlimLint
     # Note that nested Sexps will also be matched, so be careful about the cost
     # of matching against a complicated pattern.
     #
-    # @param sexp_pattern [Sexp]
+    # @param sexp_pattern [Object,Array]
     # @return [Boolean]
     def match?(sexp_pattern)
+      # Delegate matching logic if we're comparing against a matcher
+      if sexp_pattern.is_a?(SlimLint::Matcher::Base)
+        return sexp_pattern.match?(self)
+      end
+
       # If there aren't enough items to compare then this obviously won't match
-      return unless length >= sexp_pattern.length
+      return false unless sexp_pattern.is_a?(Array) && length >= sexp_pattern.length
 
       sexp_pattern.each_with_index do |sub_pattern, index|
-        case sub_pattern
-        when Array
-          return false unless self[index].match?(sub_pattern)
-        else
-          return false unless self[index] == sub_pattern
-        end
+        return false unless self[index].match?(sub_pattern)
       end
 
       true
     end
 
+    # Returns pretty-printed representation of this S-expression.
+    #
+    # @return [String]
+    def inspect
+      display
+    end
+
+    protected
+
+    # Pretty-prints this Sexp in a form that is more readable.
+    #
+    # @param depth [Integer] indentation level to display Sexp at
+    # @return [String]
     def display(depth = 1) # rubocop:disable Metrics/AbcSize
       indentation = ' ' * 2 * depth
-      output = indentation
       output = '['
-      output << "\n"
 
       each_with_index do |nested_sexp, index|
+        output << "\n"
         output += indentation
 
-        case nested_sexp
-        when Sexp
+        if nested_sexp.is_a?(SlimLint::Sexp)
           output += nested_sexp.display(depth + 1)
         else
           output += nested_sexp.inspect
         end
 
-        if index < length - 1
-          output += ",\n"
-        end
+        # Add trailing comma unless this is the last item
+        output += ',' if index < length - 1
       end
-      output << "\n"
-      output << ' ' * 2 * (depth - 1)
+
+      output << "\n" << ' ' * 2 * (depth - 1) unless empty?
       output << ']'
 
       output

data/lib/slim_lint/sexp_visitor.rb

@@ -2,42 +2,23 @@ module SlimLint
   # Provides an interface which when included allows a class to visit nodes in
   # the Sexp of a Slim document.
   module SexpVisitor
-    SexpPattern = Struct.new(:sexp, :callback_method_name)
-
     # Traverse the Sexp looking for matches with registered patterns, firing
     # callbacks for all matches.
     #
-    # @param sexp [Sexp]
+    # @param sexp [SlimLint::Sexp]
     def trigger_pattern_callbacks(sexp)
-      on_start sexp
+      return if on_start(sexp) == :stop
       traverse sexp
     end
 
     # Traverse the given Sexp, firing callbacks if they are defined.
     #
-    # @param sexp [Sexp]
+    # @param sexp [SlimLint::Sexp]
     def traverse(sexp)
-      block_called = false
-
-      # Define a block within the closure of this method so that pattern matcher
-      # blocks can call `yield` within their block definitions to force
-      # traversal of their children.
-      block = ->(action = :descend) do
-        block_called = true
-        case action
-        when Sexp
-          # User explicitly yielded a Sexp, indicating they want to control the
-          # flow of traversal. Traverse the Sexp they returned.
-          traverse(action)
-        when :descend
-          traverse_children(sexp)
-        end
-      end
-
       patterns.each do |pattern|
         next unless sexp.match?(pattern.sexp)
 
-        result = method(pattern.callback_method_name).call(sexp, &block)
+        result = method(pattern.callback_method_name).call(sexp)
 
         # Returning :stop indicates we should stop searching this Sexp
         # (i.e. stop descending this branch of depth-first search).
@@ -45,42 +26,74 @@ module SlimLint
         return if result == :stop # rubocop:disable Lint/NonLocalExitFromIterator
       end
 
-      # If no pattern matchers called `yield` explicitly, continue traversing
-      # children by default (matchers can return `:stop` to not continue).
-      traverse_children(sexp) unless block_called
+      # Continue traversing children by default (match blocks can return `:stop`
+      # to not continue).
+      traverse_children(sexp)
     end
 
+    # Traverse the children of this {Sexp}.
+    #
+    # @param sexp [SlimLint::Sexp]
     def traverse_children(sexp)
       sexp.each do |nested_sexp|
         traverse nested_sexp if nested_sexp.is_a?(Sexp)
       end
     end
 
+    # Returns the map of capture names to captured values.
+    #
+    # @return [Hash, CaptureMap]
+    def captures
+      self.class.captures || {}
+    end
+
     # Returns the list of registered Sexp patterns.
+    #
+    # @return [Array<SlimLint::SexpVisitor::SexpPattern>]
     def patterns
       self.class.patterns || []
     end
 
     # Executed before searching for any pattern matches.
     #
-    # @param sexp [SlimLint::Sexp]
+    # @param sexp [SlimLint::Sexp] see {SexpVisitor::DSL.on_start}
+    # @return [Symbol] see {SexpVisitor::DSL.on_start}
     def on_start(*)
       # Overidden by DSL.on_start
     end
 
+    # Mapping of Sexp pattern to callback method name.
+    #
+    # @attr_reader sexp [Array] S-expression pattern that when matched triggers the
+    #     callback
+    # @attr_reader callback_method_name [Symbol] name of the method to call when pattern is matched
+    SexpPattern = Struct.new(:sexp, :callback_method_name)
+    private_constant :SexpPattern
+
     # Exposes a convenient Domain-specific Language (DSL) that makes declaring
     # Sexp match patterns very easy.
     #
     # Include them with `extend SlimLint::SexpVisitor::DSL`
     module DSL
       # Registered patterns that this visitor will look for when traversing the
-      # Sexp.
+      # {SlimLint::Sexp}.
       attr_reader :patterns
 
+      # @return [Hash] map of capture names to captured values
+      attr_reader :captures
+
       # DSL helper that defines a sexp pattern and block that will be executed if
       # the given pattern is found.
       #
       # @param sexp_pattern [Sexp]
+      # @yield block to execute when the specified pattern is matched
+      # @yieldparam sexp [SlimLint::Sexp] Sexp that matched the pattern
+      # @yieldreturn [SlimLint::Sexp,Symbol,void]
+      #   If a Sexp is returned, indicates that traversal should jump directly
+      #   to that Sexp.
+      #   If `:stop` is returned, halts further traversal down this branch
+      #   (i.e. stops recursing, but traversal at higher levels will continue).
+      #   Otherwise traversal will continue as normal.
       def on(sexp_pattern, &block)
         # TODO: Index Sexps on creation so we can quickly jump to potential
         # matches instead of checking array.
@@ -97,9 +110,34 @@ module SlimLint
       end
 
       # Define a block of code to run before checking for any pattern matches.
+      #
+      # @yield block to execute
+      # @yieldparam sexp [SlimLint::Sexp] the root Sexp
+      # @yieldreturn [Symbol] if `:stop`, indicates that no further processing
+      #   should occur
       def on_start(&block)
         define_method(:on_start, block)
       end
+
+      # Represents a pattern that matches anything.
+      #
+      # @return [SlimLint::Matcher::Anything]
+      def anything
+        SlimLint::Matcher::Anything.new
+      end
+
+      # Represents a pattern that matches the specified matcher, storing the
+      # matched value in the captures list under the given name.
+      #
+      # @param capture_name [Symbol]
+      # @param matcher [SlimLint::Matcher::Base]
+      # @return [SlimLint::Matcher::Capture]
+      def capture(capture_name, matcher)
+        @captures ||= SlimLint::CaptureMap.new
+
+        @captures[capture_name] =
+          SlimLint::Matcher::Capture.from_matcher(matcher)
+      end
     end
   end
 end

data/lib/slim_lint/utils.rb

@@ -3,6 +3,23 @@ module SlimLint
   module Utils
     module_function
 
+    # 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
+
     # Find all consecutive items satisfying the given block of a minimum size,
     # yielding each group of consecutive items to the provided block.
     #

data/lib/slim_lint/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 module SlimLint
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/slim_lint.rb

@@ -6,13 +6,14 @@ require 'slim_lint/exceptions'
 require 'slim_lint/configuration'
 require 'slim_lint/configuration_loader'
 require 'slim_lint/utils'
+require 'slim_lint/atom'
 require 'slim_lint/sexp'
 require 'slim_lint/file_finder'
 require 'slim_lint/linter_registry'
 require 'slim_lint/logger'
 require 'slim_lint/version'
 
-# Need to load slim before we can
+# Need to load slim before we can define filters
 require 'slim'
 
 # Load all filters (required by SlimLint::Engine)
@@ -22,14 +23,22 @@ end
 
 require 'slim_lint/engine'
 require 'slim_lint/document'
+require 'slim_lint/capture_map'
 require 'slim_lint/sexp_visitor'
 require 'slim_lint/lint'
 require 'slim_lint/ruby_parser'
 require 'slim_lint/linter'
 require 'slim_lint/reporter'
 require 'slim_lint/report'
+require 'slim_lint/linter_selector'
 require 'slim_lint/runner'
 
+# Load all matchers
+require 'slim_lint/matcher/base'
+Dir[File.expand_path('slim_lint/matcher/*.rb', File.dirname(__FILE__))].each do |file|
+  require file
+end
+
 # Load all linters
 Dir[File.expand_path('slim_lint/linter/*.rb', File.dirname(__FILE__))].each do |file|
   require file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slim_lint
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Shane da Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-20 00:00:00.000000000 Z
+date: 2015-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slim
@@ -91,6 +91,8 @@ files:
 - bin/slim-lint
 - config/default.yml
 - lib/slim_lint.rb
+- lib/slim_lint/atom.rb
+- lib/slim_lint/capture_map.rb
 - lib/slim_lint/cli.rb
 - lib/slim_lint/configuration.rb
 - lib/slim_lint/configuration_loader.rb
@@ -112,7 +114,12 @@ files:
 - lib/slim_lint/linter/tag_case.rb
 - lib/slim_lint/linter/trailing_whitespace.rb
 - lib/slim_lint/linter_registry.rb
+- lib/slim_lint/linter_selector.rb
 - lib/slim_lint/logger.rb
+- lib/slim_lint/matcher/anything.rb
+- lib/slim_lint/matcher/base.rb
+- lib/slim_lint/matcher/capture.rb
+- lib/slim_lint/matcher/nothing.rb
 - lib/slim_lint/options.rb
 - lib/slim_lint/rake_task.rb
 - lib/slim_lint/report.rb
@@ -147,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Slim template linting tool