foodcritic 2.2.0 → 3.0.0

data/lib/foodcritic/command_line.rb

@@ -9,40 +9,59 @@ module FoodCritic
     def initialize(args)
       @args = args
       @original_args = args.dup
-      @options = {:fail_tags => [], :tags => [], :include_rules => []}
+      @options = {
+        :fail_tags => [],
+        :tags => [],
+        :include_rules => [],
+        :cookbook_paths => [],
+        :role_paths => [],
+        :environment_paths => []
+      }
       @parser = OptionParser.new do |opts|
         opts.banner = 'foodcritic [cookbook_paths]'
         opts.on("-t", "--tags TAGS",
           "Only check against rules with the specified tags.") do |t|
-          options[:tags] << t
+          @options[:tags] << t
         end
         opts.on("-f", "--epic-fail TAGS",
           "Fail the build if any of the specified tags are matched ('any' -> fail on any match).") do |t|
-          options[:fail_tags] << t
+          @options[:fail_tags] << t
         end
         opts.on("-c", "--chef-version VERSION",
           "Only check against rules valid for this version of Chef.") do |c|
-          options[:chef_version] = c
+          @options[:chef_version] = c
+        end
+        opts.on("-B", "--cookbook-path PATH",
+          "Cookbook path(s) to check.") do |b|
+          @options[:cookbook_paths] << b
         end
         opts.on("-C", "--[no-]context",
           "Show lines matched against rather than the default summary.") do |c|
-          options[:context] = c
+          @options[:context] = c
+        end
+        opts.on("-E", "--environment-path PATH",
+          "Environment path(s) to check.") do |e|
+          @options[:environment_paths] << e
         end
         opts.on("-I", "--include PATH",
           "Additional rule file path(s) to load.") do |i|
-          options[:include_rules] << i
+          @options[:include_rules] << i
         end
         opts.on("-G", "--search-gems",
           "Search rubygems for rule files with the path foodcritic/rules/**/*.rb") do |g|
-          options[:search_gems] = true
+          @options[:search_gems] = true
+        end
+        opts.on("-R", "--role-path PATH",
+          "Role path(s) to check.") do |r|
+          @options[:role_paths] << r
         end
         opts.on("-S", "--search-grammar PATH",
           "Specify grammar to use when validating search syntax.") do |s|
-          options[:search_grammar] = s
+          @options[:search_grammar] = s
         end
         opts.on("-V", "--version",
           "Display the foodcritic version.") do |v|
-          options[:version] = true
+          @options[:version] = true
         end
       end
       # -v is not implemented but OptionParser gives the Foodcritic's version
@@ -86,18 +105,13 @@ module FoodCritic
       "foodcritic #{FoodCritic::VERSION}"
     end
 
-    # If the cookbook paths provided are valid
+    # If the paths provided are valid
     #
     # @return [Boolean] True if the paths exist.
     def valid_paths?
-      @args.any? && @args.all? {|path| File.exists?(path) }
-    end
-
-    # The cookbook paths
-    #
-    # @return [Array<String>] Path(s) to the cookbook(s) being checked.
-    def cookbook_paths
-      @args
+      paths = options[:cookbook_paths] + options[:role_paths] +
+        options[:environment_paths]
+      paths.any? && paths.all?{|path| File.exists?(path) }
     end
 
     # Is the search grammar specified valid?
@@ -112,6 +126,27 @@ module FoodCritic
       search.parser?
     end
 
+    # The cookbook paths to check
+    #
+    # @return [Array<String>] Path(s) to the cookbook(s) being checked.
+    def cookbook_paths
+      @args + Array(@options[:cookbook_paths])
+    end
+
+    # The role paths to check
+    #
+    # @return [Array<String>] Path(s) to the role directories being checked.
+    def role_paths
+      Array(@options[:role_paths])
+    end
+
+    # The environment paths to check
+    #
+    # @return [Array<String>] Path(s) to the environment directories being checked.
+    def environment_paths
+      Array(@options[:environment_paths])
+    end
+
     # If matches should be shown with context rather than the default summary
     # display.
     #
@@ -124,6 +159,17 @@ module FoodCritic
     #
     # @return [Hash] The parsed command-line options.
     def options
+      original_options.merge({
+        :cookbook_paths => cookbook_paths,
+        :role_paths => role_paths,
+        :environment_paths => environment_paths,
+      })
+    end
+
+    # The original command-line options
+    #
+    # @return [Hash] The original command-line options.
+    def original_options
       @options
     end
 

data/lib/foodcritic/domain.rb

@@ -1,16 +1,24 @@
+require 'gherkin/tag_expression'
+
 module FoodCritic
 
   # A warning of a possible issue
   class Warning
-    attr_reader :rule, :match
+    attr_reader :rule, :match, :is_failed
 
     # Create a new warning.
     #
     #     Warning.new(rule, :filename => 'foo/recipes.default.rb',
     #       :line => 5, :column=> 40)
     #
-    def initialize(rule, match={})
+    def initialize(rule, match={}, options={})
       @rule, @match = rule, match
+      @is_failed = options[:fail_tags].empty? ? false : rule.matches_tags?(options[:fail_tags])
+    end
+
+    # If this warning has failed or not.
+    def failed?
+      @is_failed
     end
   end
 
@@ -19,15 +27,19 @@ module FoodCritic
 
     attr_reader :cookbook_paths, :warnings
 
-    def initialize(cookbook_paths, warnings, is_failed)
+    def initialize(cookbook_paths, warnings)
       @cookbook_paths = Array(cookbook_paths)
       @warnings = warnings
-      @is_failed = is_failed
     end
 
-    # If this review has failed or not.
+    # If any of the warnings in this review have failed or not.
     def failed?
-      @is_failed
+      warnings.any? { |w| w.failed? }
+    end
+
+    # Returns an array of warnings that are marked as failed.
+    def failures
+      warnings.select { |w| w.failed? }
     end
 
     # Returns a string representation of this review. This representation is
@@ -48,7 +60,7 @@ module FoodCritic
   # A rule to be matched against.
   class Rule
     attr_accessor :code, :name, :applies_to, :cookbook, :attributes, :recipe,
-      :provider, :resource, :metadata, :library, :template
+      :provider, :resource, :metadata, :library, :template, :role, :environment
 
     attr_writer :tags
 
@@ -64,6 +76,13 @@ module FoodCritic
       ['any'] + @tags
     end
 
+    # Checks the rule's tags to see if they match a Gherkin (Cucumber) expression
+    def matches_tags?(tag_expr)
+      Gherkin::TagExpression.new(tag_expr).evaluate(tags.map do |t|
+        Gherkin::Formatter::Model::Tag.new(t, 1)
+      end)
+    end
+
     # Returns a string representation of this rule.
     def to_s
       "#{@code}: #{@name}"

data/lib/foodcritic/dsl.rb

@@ -69,6 +69,9 @@ module FoodCritic
     rule_block :library
     rule_block :template
 
+    rule_block :environment
+    rule_block :role
+
     # Load the ruleset(s).
     def self.load(paths, chef_version=Linter::DEFAULT_CHEF_VERSION)
       dsl = RuleDsl.new(chef_version)

data/lib/foodcritic/linter.rb

@@ -1,7 +1,6 @@
 require 'optparse'
 require 'ripper'
 require 'rubygems'
-require 'gherkin/tag_expression'
 require 'set'
 
 module FoodCritic
@@ -25,8 +24,7 @@ module FoodCritic
       if ! cmd_line.valid_grammar?
         [cmd_line.help, 4]
       elsif cmd_line.valid_paths?
-        review = FoodCritic::Linter.new.check(cmd_line.cookbook_paths,
-          cmd_line.options)
+        review = FoodCritic::Linter.new.check(cmd_line.options)
         [review, review.failed? ? 3 : 0]
       else
         [cmd_line.help, 2]
@@ -38,55 +36,86 @@ module FoodCritic
     #
     # The `options` are a hash where the valid keys are:
     #
+    # * `:cookbook_paths` - Cookbook paths to lint
+    # * `:role_paths` - Role paths to lint
     # * `:include_rules` - Paths to additional rules to apply
     # * `:search_gems - If true then search for custom rules in installed gems.
     # * `:tags` - The tags to filter rules based on
     # * `:fail_tags` - The tags to fail the build on
     # * `:exclude_paths` - Paths to exclude from linting
     #
-    def check(cookbook_paths, options = {})
+    def check(options = {})
 
-      cookbook_paths = sanity_check_cookbook_paths(cookbook_paths)
       options = setup_defaults(options)
       @options = options
       @chef_version = options[:chef_version] || DEFAULT_CHEF_VERSION
 
       warnings = []; last_dir = nil; matched_rule_tags = Set.new
-
       load_rules
+      paths = specified_paths!(options)
 
       # Loop through each file to be processed and apply the rules
-      files_to_process(cookbook_paths, options[:exclude_paths]).each do |file|
-        ast = read_ast(file)
-        relevant_tags = options[:tags].any? ? options[:tags] : cookbook_tags(file)
-        active_rules(relevant_tags).each do |rule|
-          rule_matches = matches(rule.recipe, ast, file)
+      files_to_process(paths).each do |p|
 
-          if dsl_method_for_file(file)
-            rule_matches += matches(rule.send(dsl_method_for_file(file)),
-              ast, file)
-          end
+        relevant_tags = if options[:tags].any?
+          options[:tags]
+        else
+          cookbook_tags(p[:filename])
+        end
 
-          per_cookbook_rules(last_dir, file) do
-            if File.basename(file) == 'metadata.rb'
-              rule_matches += matches(rule.metadata, ast, file)
-            end
-            rule_matches += matches(rule.cookbook, cookbook_dir(file))
+        active_rules(relevant_tags).each do |rule|
+
+          state = {
+            :path_type => p[:path_type],
+            :file => p[:filename],
+            :ast => read_ast(p[:filename]),
+            :rule => rule,
+            :last_dir => last_dir
+          }
+
+          matches = if p[:path_type] == :cookbook
+            cookbook_matches(state)
+          else
+            other_matches(state)
           end
 
-          rule_matches = remove_ignored(rule_matches, rule, file)
+          matches = remove_ignored(matches, state[:rule], state[:file])
 
           # Convert the matches into warnings
-          rule_matches.each do |match|
-            warnings << Warning.new(rule, {:filename => file}.merge(match))
-            matched_rule_tags << rule.tags
+          matches.each do |match|
+            warnings << Warning.new(state[:rule],
+              {:filename => state[:file]}.merge(match), options)
+            matched_rule_tags << state[:rule].tags
           end
         end
-        last_dir = cookbook_dir(file)
+        last_dir = cookbook_dir(p[:filename])
+      end
+
+      Review.new(paths, warnings)
+    end
+
+    def cookbook_matches(state)
+      cbk_matches = matches(state[:rule].recipe, state[:ast], state[:file])
+
+      if dsl_method_for_file(state[:file])
+        cbk_matches += matches(state[:rule].send(
+          dsl_method_for_file(state[:file])), state[:ast], state[:file])
+      end
+
+      per_cookbook_rules(state[:last_dir], state[:file]) do
+        if File.basename(state[:file]) == 'metadata.rb'
+          cbk_matches += matches(
+            state[:rule].metadata, state[:ast], state[:file])
+        end
+        cbk_matches += matches(
+          state[:rule].cookbook, cookbook_dir(state[:file]))
       end
 
-      Review.new(cookbook_paths, warnings,
-        should_fail_build?(options[:fail_tags], matched_rule_tags))
+      cbk_matches
+    end
+
+    def other_matches(state)
+      matches(state[:rule].send(state[:path_type]), state[:ast], state[:file])
     end
 
     # Load the rules from the (fairly unnecessary) DSL.
@@ -120,7 +149,7 @@ module FoodCritic
     def ignore_line_match?(line, rule)
       ignores = line.to_s[/\s+#\s*(.*)/, 1]
       if ignores and ignores.include?('~')
-        ! matching_tags?(ignores.split(/[ ,]/), rule.tags)
+        ! rule.matches_tags?(ignores.split(/[ ,]/))
       else
         false
       end
@@ -147,7 +176,7 @@ module FoodCritic
 
     def active_rules(tags)
       @rules.select do |rule|
-        matching_tags?(tags, rule.tags) and
+        rule.matches_tags?(tags) and
         applies_to_version?(rule, chef_version)
       end
     end
@@ -178,19 +207,29 @@ module FoodCritic
 
     # Return the files within a cookbook tree that we are interested in trying
     # to match rules against.
-    def files_to_process(dirs, exclude_paths = [])
-      files = []
-      dirs.each do |dir|
-        exclusions = Dir.glob(exclude_paths.map{|p| File.join(dir, p)})
-        if File.directory? dir
-          cookbook_glob = '{metadata.rb,{attributes,definitions,libraries,providers,recipes,resources}/*.rb,templates/*/*.erb}'
-          files += (Dir.glob(File.join(dir, cookbook_glob)) +
-            Dir.glob(File.join(dir, "*/#{cookbook_glob}")) - exclusions)
-        else
-          files << dir unless exclusions.include?(dir)
+    def files_to_process(paths)
+      paths.reject{|type, _| type == :exclude}.map do |path_type, dirs|
+        dirs.map do |dir|
+          exclusions = []
+          unless paths[:exclude].empty?
+            exclusions = Dir.glob(paths[:exclude].map{|p| File.join(dir, p)})
+          end
+
+          if File.directory?(dir)
+            glob = if path_type == :cookbook
+              '{metadata.rb,{attributes,definitions,libraries,providers,recipes,resources}/*.rb,templates/*/*.erb}'
+            else
+              '*.rb'
+            end
+            (Dir.glob(File.join(dir, glob)) +
+             Dir.glob(File.join(dir, "*/#{glob}")) - exclusions)
+          else
+            dir unless exclusions.include?(dir)
+          end
+        end.compact.flatten.map do |filename|
+          {:filename => filename, :path_type => path_type}
         end
-      end
-      files
+      end.flatten
     end
 
     # Invoke the DSL method with the provided parameters.
@@ -211,34 +250,27 @@ module FoodCritic
       end.flatten
     end
 
-    # We use the Gherkin (Cucumber) syntax to specify tags.
-    def matching_tags?(tag_expr, tags)
-      Gherkin::TagExpression.new(tag_expr).evaluate(tags.map do |t|
-        Gherkin::Formatter::Model::Tag.new(t, 1)
-      end)
-    end
-
     def per_cookbook_rules(last_dir, file)
       yield if last_dir != cookbook_dir(file)
     end
 
-    def sanity_check_cookbook_paths(cookbook_paths)
-      raise ArgumentError, "Cookbook paths are required" if cookbook_paths.nil?
-      cookbook_paths = Array(cookbook_paths)
-      if cookbook_paths.empty?
-        raise ArgumentError, "Cookbook paths cannot be empty"
+    def specified_paths!(options)
+      paths = Hash[options.map do |key, value|
+        [key, Array(value)] if key.to_s.end_with?('paths')
+      end.compact]
+
+      unless paths.find{|k, v| k != :exclude_paths and ! v.empty?}
+        raise ArgumentError, "A cookbook path or role path must be specified"
       end
-      cookbook_paths
-    end
 
-    def setup_defaults(options)
-      {:tags => [], :fail_tags => [],
-                 :include_rules => [], :exclude_paths => []}.merge(options)
+      Hash[paths.map do |key, value|
+        [key.to_s.sub(/_paths$/, '').to_sym, value]
+      end]
     end
 
-    def should_fail_build?(fail_tags, matched_tags)
-      return false if fail_tags.empty?
-      matched_tags.any?{|tags| matching_tags?(fail_tags, tags)}
+    def setup_defaults(options)
+      {:tags => [], :fail_tags => [], :include_rules => [], :exclude_paths => [],
+       :cookbook_paths => [], :role_paths => []}.merge(options)
     end
 
   end