foodcritic 3.0.3 → 4.0.0

data/lib/foodcritic/ast.rb

@@ -1,22 +1,21 @@
 module FoodCritic
   module AST
-
     private
 
     def ast_hash_node?(node)
-      node.first.respond_to?(:first) and node.first.first == :assoc_new
+      node.first.respond_to?(:first) && node.first.first == :assoc_new
     end
 
     def ast_node_has_children?(node)
-      node.respond_to?(:first) and ! node.respond_to?(:match)
+      node.respond_to?(:first) && !node.respond_to?(:match)
     end
 
     # If the provided node is the line / column information.
     def position_node?(node)
-      node.respond_to?(:length) and node.length == 2 and
-        node.respond_to?(:all?) and node.all?{|child| child.respond_to?(:to_i)}
+      node.respond_to?(:length) &&
+        node.length == 2 &&
+        node.respond_to?(:all?) &&
+        node.all? { |child| child.respond_to?(:to_i) }
     end
-
   end
-
 end

data/lib/foodcritic/chef.rb

@@ -1,8 +1,6 @@
 module FoodCritic
-
   # Encapsulates functions that previously were calls to the Chef gem.
   module Chef
-
     def chef_dsl_methods
       load_metadata
       @dsl_metadata[:dsl_methods].map(&:to_sym)
@@ -25,7 +23,7 @@ module FoodCritic
 
     # Is this a valid Lucene query?
     def valid_query?(query)
-      raise ArgumentError, "Query cannot be nil or empty" if query.to_s.empty?
+      fail ArgumentError, 'Query cannot be nil or empty' if query.to_s.empty?
 
       # Attempt to create a search query parser
       search = FoodCritic::Chef::Search.new
@@ -48,23 +46,27 @@ module FoodCritic
     # The DSL metadata doesn't necessarily reflect the version of Chef in the
     # local user gemset.
     def load_metadata
-      version = self.respond_to?(:chef_version) ? chef_version : Linter::DEFAULT_CHEF_VERSION
+      version = if self.respond_to?(:chef_version)
+                  chef_version
+                else
+                  Linter::DEFAULT_CHEF_VERSION
+                end
       metadata_path = [version, version.sub(/\.[a-z].*/, ''),
-	               Linter::DEFAULT_CHEF_VERSION].map do |version|
-	metadata_path(version)
-      end.find{|m| File.exists?(m)}
+        Linter::DEFAULT_CHEF_VERSION].map do |version|
+          metadata_path(version)
+        end.find { |m| File.exist?(m) }
       @dsl_metadata ||= Yajl::Parser.parse(IO.read(metadata_path),
-        :symbolize_keys => true)
+                                           symbolize_keys: true)
     end
 
     def metadata_path(chef_version)
       File.join(File.dirname(__FILE__), '..', '..',
-        "chef_dsl_metadata/chef_#{chef_version}.json")
+                "chef_dsl_metadata/chef_#{chef_version}.json")
     end
 
     def resource_check?(key, resource_type, field)
       if resource_type.to_s.empty? || field.to_s.empty?
-        raise ArgumentError, "Arguments cannot be nil or empty."
+        fail ArgumentError, 'Arguments cannot be nil or empty.'
       end
 
       load_metadata
@@ -80,10 +82,10 @@ module FoodCritic
     end
 
     class Search
-
       # The search grammars that ship with any Chef gems installed locally.
       # These are returned in descending version order (a newer Chef version
       #   could break our ability to load the grammar).
+      # Grammars are not available from Chef 11+.
       def chef_search_grammars
         Gem.path.map do |gem_path|
           Dir["#{gem_path}/gems/chef-*/**/lucene.treetop"]
@@ -92,16 +94,17 @@ module FoodCritic
 
       # Create the search parser from the first loadable grammar.
       def create_parser(grammar_paths)
-        @search_parser ||= grammar_paths.inject(nil) do |parser,lucene_grammar|
-            begin
-              break parser unless parser.nil?
-              # Don't instantiate custom nodes
-              Treetop.load_from_string(
-                IO.read(lucene_grammar).gsub(/<[^>]+>/, ''))
-              LuceneParser.new
-            rescue
-              # Silently swallow and try the next grammar
-            end
+        @search_parser ||=
+          grammar_paths.inject(nil) do |parser, lucene_grammar|
+          begin
+            break parser unless parser.nil?
+            # Don't instantiate custom nodes
+            Treetop.load_from_string(
+              IO.read(lucene_grammar).gsub(/<[^>]+>/, ''))
+            LuceneParser.new
+          rescue
+            # Silently swallow and try the next grammar
+          end
         end
       end
 
@@ -114,8 +117,6 @@ module FoodCritic
       def parser
         @search_parser
       end
-
     end
   end
-
 end

data/lib/foodcritic/command_line.rb

@@ -1,8 +1,6 @@
 module FoodCritic
-
   # Command line parsing.
   class CommandLine
-
     # Create a new instance of CommandLine
     #
     # @param [Array] args The command line arguments
@@ -10,59 +8,69 @@ module FoodCritic
       @args = args
       @original_args = args.dup
       @options = {
-        :fail_tags => [],
-        :tags => [],
-        :include_rules => [],
-        :cookbook_paths => [],
-        :role_paths => [],
-        :environment_paths => []
+        fail_tags: [],
+        tags: [],
+        include_rules: [],
+        cookbook_paths: [],
+        role_paths: [],
+        environment_paths: [],
+        exclude_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|
+        opts.on('-t', '--tags TAGS',
+                'Check against (or exclude ~) rules with the '\
+                'specified tags.') do |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|
+        opts.on('-f', '--epic-fail TAGS',
+                "Fail the build based on tags. Use 'any' to fail "\
+                'on all warnings.') do |t|
           @options[:fail_tags] << t
         end
-        opts.on("-c", "--chef-version VERSION",
-          "Only check against rules valid for this version of Chef.") do |c|
+        opts.on('-c', '--chef-version VERSION',
+                'Only check against rules valid for this version '\
+                'of Chef.') do |c|
           @options[:chef_version] = c
         end
-        opts.on("-B", "--cookbook-path PATH",
-          "Cookbook path(s) to check.") do |b|
+        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|
+        opts.on('-C', '--[no-]context',
+                'Show lines matched against rather than the '\
+                'default summary.') do |c|
           @options[:context] = c
         end
-        opts.on("-E", "--environment-path PATH",
-          "Environment path(s) to check.") do |e|
+        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|
+        opts.on('-I', '--include PATH',
+                'Additional rule file path(s) to load.') do |i|
           @options[:include_rules] << i
         end
-        opts.on("-G", "--search-gems",
-          "Search rubygems for rule files with the path foodcritic/rules/**/*.rb") do |g|
+        opts.on('-G', '--search-gems',
+                'Search rubygems for rule files with the path '\
+                'foodcritic/rules/**/*.rb') do |g|
           @options[:search_gems] = true
         end
-        opts.on("-R", "--role-path PATH",
-          "Role path(s) to check.") do |r|
+        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|
+        opts.on('-S', '--search-grammar PATH',
+                'Specify grammar to use when validating search syntax.') do |s|
           @options[:search_grammar] = s
         end
-        opts.on("-V", "--version",
-          "Display the foodcritic version.") do |v|
+        opts.on('-V', '--version',
+                'Display the foodcritic version.') do |v|
           @options[:version] = true
         end
+        opts.on('-X', '--exclude PATH',
+                'Exclude path(s) from being linted.') do |e|
+          options[:exclude_paths] << e
+        end
       end
       # -v is not implemented but OptionParser gives the Foodcritic's version
       # if that flag is passed
@@ -81,7 +89,7 @@ module FoodCritic
     #
     # @return [Boolean] True if help should be shown.
     def show_help?
-      @args.length == 1 and @args.first == '--help'
+      @args.length == 1 && @args.first == '--help'
     end
 
     # The help text.
@@ -111,7 +119,7 @@ module FoodCritic
     def valid_paths?
       paths = options[:cookbook_paths] + options[:role_paths] +
         options[:environment_paths]
-      paths.any? && paths.all?{|path| File.exists?(path) }
+      paths.any? && paths.all? { |path| File.exist?(path) }
     end
 
     # Is the search grammar specified valid?
@@ -120,7 +128,7 @@ module FoodCritic
     #   loaded.
     def valid_grammar?
       return true unless options.key?(:search_grammar)
-      return false unless File.exists?(options[:search_grammar])
+      return false unless File.exist?(options[:search_grammar])
       search = FoodCritic::Chef::Search.new
       search.create_parser([options[:search_grammar]])
       search.parser?
@@ -142,7 +150,7 @@ module FoodCritic
 
     # The environment paths to check
     #
-    # @return [Array<String>] Path(s) to the environment directories being checked.
+    # @return [Array<String>] Path(s) to the environment directories checked.
     def environment_paths
       Array(@options[:environment_paths])
     end
@@ -159,11 +167,13 @@ 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,
-      })
+      original_options.merge(
+        {
+          cookbook_paths: cookbook_paths,
+          role_paths: role_paths,
+          environment_paths: environment_paths,
+        }
+      )
     end
 
     # The original command-line options
@@ -172,7 +182,5 @@ module FoodCritic
     def original_options
       @options
     end
-
   end
-
 end

data/lib/foodcritic/domain.rb

@@ -1,7 +1,6 @@
 require 'gherkin/tag_expression'
 
 module FoodCritic
-
   # A warning of a possible issue
   class Warning
     attr_reader :rule, :match, :is_failed
@@ -11,9 +10,13 @@ module FoodCritic
     #     Warning.new(rule, :filename => 'foo/recipes.default.rb',
     #       :line => 5, :column=> 40)
     #
-    def initialize(rule, match={}, options={})
+    def initialize(rule, match = {}, options = {})
       @rule, @match = rule, match
-      @is_failed = options[:fail_tags].empty? ? false : rule.matches_tags?(options[:fail_tags])
+      @is_failed = if options[:fail_tags].empty?
+                     false
+                   else
+                     rule.matches_tags?(options[:fail_tags])
+                   end
     end
 
     # If this warning has failed or not.
@@ -24,7 +27,6 @@ module FoodCritic
 
   # The collected warnings (if any) raised against a cookbook tree.
   class Review
-
     attr_reader :cookbook_paths, :warnings
 
     def initialize(cookbook_paths, warnings)
@@ -51,23 +53,24 @@ module FoodCritic
       @warnings.map do |w|
         ["#{w.rule.code}: #{w.rule.name}: #{w.match[:filename]}",
          w.match[:line].to_i]
-      end.sort do |x,y|
+      end.sort do |x, y|
         x.first == y.first ? x[1] <=> y[1] : x.first <=> y.first
-      end.map{|w|"#{w.first}:#{w[1]}"}.uniq.join("\n")
+      end.map { |w|"#{w.first}:#{w[1]}" }.uniq.join("\n")
     end
   end
 
   # A rule to be matched against.
   class Rule
     attr_accessor :code, :name, :applies_to, :cookbook, :attributes, :recipe,
-      :provider, :resource, :metadata, :library, :template, :role, :environment
+                  :provider, :resource, :metadata, :library, :template, :role,
+                  :environment
 
     attr_writer :tags
 
     def initialize(code, name)
       @code, @name = code, name
       @tags = [code]
-      @applies_to = Proc.new {|version| true}
+      @applies_to = Proc.new { |version| true }
     end
 
     # The tags associated with this rule. Rule is always tagged with the tag
@@ -76,7 +79,7 @@ module FoodCritic
       ['any'] + @tags
     end
 
-    # Checks the rule's tags to see if they match a Gherkin (Cucumber) expression
+    # Checks the rule 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)
@@ -88,5 +91,4 @@ module FoodCritic
       "#{@code}: #{@name}"
     end
   end
-
 end

data/lib/foodcritic/dsl.rb

@@ -1,7 +1,6 @@
 require 'pathname'
 
 module FoodCritic
-
   # The DSL methods exposed for defining rules. A minimal example rule:
   #
   #     rule "FC123", "My rule name" do
@@ -27,7 +26,7 @@ module FoodCritic
 
     include Api
 
-    def initialize(chef_version=Linter::DEFAULT_CHEF_VERSION)
+    def initialize(chef_version = Linter::DEFAULT_CHEF_VERSION)
       @chef_version = chef_version
     end
 
@@ -38,8 +37,8 @@ module FoodCritic
       yield self
     end
 
-    # Add tags to the rule which can be used by the end user to filter the rules
-    # to be applied.
+    # Add tags to the rule which can be used by the end user to filter the
+    # rules to be applied.
     def tags(tags)
       rules.last.tags += tags
     end
@@ -73,7 +72,7 @@ module FoodCritic
     rule_block :role
 
     # Load the ruleset(s).
-    def self.load(paths, chef_version=Linter::DEFAULT_CHEF_VERSION)
+    def self.load(paths, chef_version = Linter::DEFAULT_CHEF_VERSION)
       dsl = RuleDsl.new(chef_version)
       paths.map do |path|
         File.directory?(path) ? Dir["#{path}/**/*.rb"].sort : path
@@ -82,7 +81,5 @@ module FoodCritic
       end
       dsl.rules
     end
-
   end
-
 end

data/lib/foodcritic/error_checker.rb

@@ -1,8 +1,6 @@
 module FoodCritic
-
   # Expose if any errors are found in parsing
   class ErrorChecker < Ripper::SexpBuilder
-
     # Create a new instance of ErrorChecker
     #
     # @see Ripper::SexpBuilder#initialize
@@ -25,6 +23,5 @@ module FoodCritic
     end
 
     self.register_error_handlers
-
   end
 end

data/lib/foodcritic/linter.rb

@@ -6,12 +6,11 @@ require 'set'
 module FoodCritic
   # The main entry point for linting your Chef cookbooks.
   class Linter
-
     include FoodCritic::Api
 
     # The default version that will be used to determine relevant rules. This
     # can be over-ridden at the command line with the `--chef-version` option.
-    DEFAULT_CHEF_VERSION = "11.4.0"
+    DEFAULT_CHEF_VERSION = '11.10.4'
     attr_reader :chef_version
 
     # Perform a lint check. This method is intended for use by the command-line
@@ -21,7 +20,7 @@ module FoodCritic
       # The first item is the string output, the second is exit code.
       return [cmd_line.help, 0] if cmd_line.show_help?
       return [cmd_line.version, 0] if cmd_line.show_version?
-      if ! cmd_line.valid_grammar?
+      if !cmd_line.valid_grammar?
         [cmd_line.help, 4]
       elsif cmd_line.valid_paths?
         review = FoodCritic::Linter.new.check(cmd_line.options)
@@ -45,7 +44,6 @@ module FoodCritic
     # * `:exclude_paths` - Paths to exclude from linting
     #
     def check(options = {})
-
       options = setup_defaults(options)
       @options = options
       @chef_version = options[:chef_version] || DEFAULT_CHEF_VERSION
@@ -58,33 +56,34 @@ module FoodCritic
       files_to_process(paths).each do |p|
 
         relevant_tags = if options[:tags].any?
-          options[:tags]
-        else
-          cookbook_tags(p[:filename])
-        end
+                          options[:tags]
+                        else
+                          cookbook_tags(p[:filename])
+                        end
 
         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
+            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
+                      cookbook_matches(state)
+                    else
+                      other_matches(state)
+                    end
 
           matches = remove_ignored(matches, state[:rule], state[:file])
 
           # Convert the matches into warnings
           matches.each do |match|
             warnings << Warning.new(state[:rule],
-              {:filename => state[:file]}.merge(match), options)
+                                    { filename: state[:file] }.merge(match),
+                                    options)
             matched_rule_tags << state[:rule].tags
           end
         end
@@ -133,8 +132,8 @@ module FoodCritic
     private
 
     def rule_files_in_gems
-      Gem::Specification.latest_specs(true).map do |spec| 
-        spec.matches_for_glob('foodcritic/rules/**/*.rb') 
+      Gem::Specification.latest_specs(true).map do |spec|
+        spec.matches_for_glob('foodcritic/rules/**/*.rb')
       end.flatten
     end
 
@@ -142,14 +141,14 @@ module FoodCritic
       matches.reject do |m|
         matched_file = m[:filename] || file
         (line = m[:line]) && File.exist?(matched_file) &&
-           ignore_line_match?(File.readlines(matched_file)[line-1], rule)
+           ignore_line_match?(File.readlines(matched_file)[line - 1], rule)
       end
     end
 
     def ignore_line_match?(line, rule)
       ignores = line.to_s[/\s+#\s*(.*)/, 1]
-      if ignores and ignores.include?('~')
-        ! rule.matches_tags?(ignores.split(/[ ,]/))
+      if ignores && ignores.include?('~')
+        !rule.matches_tags?(ignores.split(/[ ,]/))
       else
         false
       end
@@ -176,18 +175,17 @@ module FoodCritic
 
     def active_rules(tags)
       @rules.select do |rule|
-        rule.matches_tags?(tags) and
-        applies_to_version?(rule, chef_version)
+        rule.matches_tags?(tags) && applies_to_version?(rule, chef_version)
       end
     end
 
     def cookbook_dir(file)
       Pathname.new(File.join(File.dirname(file),
-        case File.basename(file)
-          when 'metadata.rb' then ''
-          when /\.erb$/ then '../..'
-          else '..'
-        end)).cleanpath
+                             case File.basename(file)
+                             when 'metadata.rb' then ''
+                             when /\.erb$/ then '../..'
+                             else '..'
+                             end)).cleanpath
     end
 
     def dsl_method_for_file(file)
@@ -208,26 +206,31 @@ module FoodCritic
     # Return the files within a cookbook tree that we are interested in trying
     # to match rules against.
     def files_to_process(paths)
-      paths.reject{|type, _| type == :exclude}.map do |path_type, dirs|
+      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)})
+            exclusions = Dir.glob(paths[:exclude].map do |p|
+              File.join(dir, p, '**/**')
+            end)
           end
 
           if File.directory?(dir)
             glob = if path_type == :cookbook
-              '{metadata.rb,{attributes,definitions,libraries,providers,recipes,resources}/*.rb,templates/*/*.erb}'
-            else
-              '*.rb'
-            end
+                     '{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}
+          { filename: filename, path_type: path_type }
         end
       end.flatten
     end
@@ -243,7 +246,7 @@ module FoodCritic
         if m.respond_to?(:node_name)
           match(m)
         elsif m.respond_to?(:xpath)
-          m.to_a.map{|m| match(m)}
+          m.to_a.map { |m| match(m) }
         else
           m
         end
@@ -259,8 +262,8 @@ module FoodCritic
         [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"
+      unless paths.find { |k, v| k != :exclude_paths && !v.empty? }
+        fail ArgumentError, 'A cookbook path or role path must be specified'
       end
 
       Hash[paths.map do |key, value|
@@ -269,9 +272,8 @@ module FoodCritic
     end
 
     def setup_defaults(options)
-      {:tags => [], :fail_tags => [], :include_rules => [], :exclude_paths => [],
-       :cookbook_paths => [], :role_paths => []}.merge(options)
+      { tags: [], fail_tags: [], include_rules: [], exclude_paths: [],
+       cookbook_paths: [], role_paths: [] }.merge(options)
     end
-
   end
 end