foodcritic 2.2.0 → 3.0.0

data/features/support/command_helpers.rb

@@ -44,11 +44,16 @@ module FoodCritic
       'FC039' => 'Node method cannot be accessed with key',
       'FC040' => 'Execute resource used to run git commands',
       'FC041' => 'Execute resource used to run curl or wget commands',
-      'FC042' => 'Prefer include_recipe to require_recipe', 
+      'FC042' => 'Prefer include_recipe to require_recipe',
       'FC043' => 'Prefer new notification syntax',
       'FC044' => 'Avoid bare attribute keys',
       'FC045' => 'Consider setting cookbook name in metadata',
       'FC046' => 'Attribute assignment uses assign unless nil',
+      'FC047' => 'Attribute assignment does not specify precedence',
+      'FC048' => 'Prefer Mixlib::ShellOut',
+      'FC049' => 'Role name does not match containing file name',
+      'FC050' => 'Name includes invalid characters',
+      'FC051' => 'Template partials loop indefinitely',
       'FCTEST001' => 'Test Rule'
     }
 
@@ -97,10 +102,14 @@ module FoodCritic
                           :resource => 'resources/site.rb', :libraries => 'libraries/lib.rb'}[options[:file_type]]
       end
       options = {:line => 1, :expect_warning => true, :file => 'recipes/default.rb'}.merge!(options)
+      unless options[:file].include?('roles') ||
+        options[:file].include?('environments')
+          options[:file] = "cookbooks/example/#{options[:file]}"
+      end
       if options[:warning_only]
         warning = "#{code}: #{WARNINGS[code]}"
       else
-        warning = "#{code}: #{WARNINGS[code]}: cookbooks/example/#{options[:file]}:#{options[:line]}#{"\n" if ! options[:line].nil?}"
+        warning = "#{code}: #{WARNINGS[code]}: #{options[:file]}:#{options[:line]}#{"\n" if ! options[:line].nil?}"
       end
       options[:expect_warning] ? expect_output(warning) : expect_no_output(warning)
     end
@@ -122,19 +131,29 @@ module FoodCritic
       expect_output(Regexp.new(expected_switch))
     end
 
+    def man_page_options
+      man_path = Pathname.new(__FILE__) + '../../../man/foodcritic.1.ronn'
+      option_lines = File.read(man_path).split('## ').find do |s|
+        s.start_with?('OPTIONS')
+      end.split("\n").select{|o| o.start_with?(' *')}
+      option_lines.map do |o|
+        o.sub('`[`no-`]`', '').split('`').select{|f| f.include?('-')}
+      end.map do |option|
+        {:short => option.first.sub(/^-/, ''),
+         :long => option.last.sub(/^--/, '')}
+      end.sort_by{|o| o[:short]}
+    end
+
     # Assert that the usage message is displayed.
     #
     # @param [Boolean] is_exit_zero The exit code to check for.
     def usage_displayed(is_exit_zero)
       expect_output 'foodcritic [cookbook_paths]'
-      expect_usage_option('c', 'chef-version VERSION', 'Only check against rules valid for this version of Chef.')
-      expect_usage_option('f', 'epic-fail TAGS',
-        "Fail the build if any of the specified tags are matched ('any' -> fail on any match).")
-      expect_usage_option('t', 'tags TAGS', 'Only check against rules with the specified tags.')
-      expect_usage_option('C', '[no-]context', 'Show lines matched against rather than the default summary.')
-      expect_usage_option('I', 'include PATH', 'Additional rule file path(s) to load.')
-      expect_usage_option('S', 'search-grammar PATH', 'Specify grammar to use when validating search syntax.')
-      expect_usage_option('V', 'version', 'Display the foodcritic version.')
+
+      usage_options.each do |option|
+        expect_usage_option(option[:short], option[:long], option[:description])
+      end
+
       if is_exit_zero
         assert_no_error_occurred
       else
@@ -142,6 +161,48 @@ module FoodCritic
       end
     end
 
+    def usage_options
+      [
+        {:short => 'c', :long => 'chef-version VERSION',
+         :description => 'Only check against rules valid for this version of Chef.'},
+
+        {:short => 'f', :long => 'epic-fail TAGS',
+         :description => "Fail the build if any of the specified tags are matched ('any' -> fail on any match)."},
+
+        {:short => 't', :long => 'tags TAGS',
+         :description => 'Only check against rules with the specified tags.'},
+
+        {:short => 'B', :long => 'cookbook-path PATH',
+         :description => 'Cookbook path(s) to check.'},
+
+        {:short => 'C', :long => '[no-]context',
+         :description => 'Show lines matched against rather than the default summary.'},
+
+        {:short => 'E', :long => 'environment-path PATH',
+         :description => 'Environment path(s) to check.'},
+
+        {:short => 'I', :long => 'include PATH',
+         :description => 'Additional rule file path(s) to load.'},
+
+        {:short => 'R', :long => 'role-path PATH',
+         :description => 'Role path(s) to check.'},
+
+        {:short => 'S', :long => 'search-grammar PATH',
+         :description => 'Specify grammar to use when validating search syntax.'},
+
+        {:short => 'V', :long => 'version',
+         :description => 'Display the foodcritic version.'}
+
+      ]
+    end
+
+    def usage_options_for_diff
+      usage_options.map do |o|
+        {:short => o[:short],
+         :long => o[:long].split(' ').first.sub(/^\[no-\]/, '')}
+      end.sort_by{|o| o[:short]}
+    end
+
   end
 
   # Helpers used when features are executed in-process.

data/features/support/cookbook_helpers.rb

@@ -13,7 +13,7 @@ module FoodCritic
     # Create a Gemfile for a cookbook
     def buildable_gemfile
       write_file 'cookbooks/example/Gemfile', %q{
-        source :rubygems
+        source 'https://rubygems.org/'
         gem 'rake'
         gem 'foodcritic', :path => '../../../..'
       }
@@ -82,8 +82,10 @@ module FoodCritic
     # @param [Hash] lwrp The options to use for the created LWRP
     # @option lwrp [Symbol] :default_action One of :no_default_action, :ruby_default_action, :dsl_default_action
     # @option lwrp [Symbol] :notifies One of :does_not_notify, :does_notify, :does_notify_without_parens, :deprecated_syntax, :class_variable
+    # @option lwrp [Symbol] :use_inline_resources Defaults to false
     def cookbook_with_lwrp(lwrp)
-      lwrp = {:default_action => false, :notifies => :does_not_notify}.merge!(lwrp)
+      lwrp = {:default_action => false, :notifies => :does_not_notify,
+              :use_inline_resources => false}.merge!(lwrp)
       ruby_default_action = %q{
         def initialize(*args)
           super
@@ -101,6 +103,7 @@ module FoodCritic
                        :deprecated_syntax => 'new_resource.updated = true',
                        :class_variable => '@updated = true'}
       write_provider("site", %Q{
+        #{'use_inline_resources' if lwrp[:use_inline_resources]}
         action :create do
           log "Here is where I would create a site"
           #{notifications[lwrp[:notifies]]}
@@ -108,6 +111,14 @@ module FoodCritic
       })
     end
 
+    def cookbook_with_lwrp_actions(actions)
+      write_resource("site", %Q{
+        actions #{actions.map{|a| a[:name].inspect}.join(', ')}
+        attribute :name, :kind_of => String, :name_attribute => true
+      })
+      write_provider("site", actions.map{|a| provider_action(a)}.join("\n"))
+    end
+
     # Create an cookbook with the maintainer specified in the metadata
     #
     # @param [String] name The maintainer name
@@ -136,6 +147,20 @@ module FoodCritic
       }
     end
 
+    # Create an environment file
+    #
+    # @param [Hash] options The options to use for the environment
+    # @option options [String] :dir The relative directory to write to
+    # @option options [String] :environment_name The name of the environment declared in the file
+    # @option options [String] :file_name The containing file relative to the environments directory
+    def environment(options={})
+      options = {:dir => 'environments'}.merge(options)
+      write_file "#{options[:dir]}/#{options[:file_name]}", %Q{
+        #{Array(options[:environment_name]).map{|r| "name #{r}"}.join("\n")}
+        cookbook "apache2"
+      }.strip
+    end
+
     # Create a placeholder minitest spec that would be linted due to its path
     # unless an exclusion is specified.
     def minitest_spec_attributes
@@ -145,6 +170,30 @@ module FoodCritic
       }
     end
 
+    def provider_action(action)
+      case action[:notify_type]
+      when :none then %Q{
+        action #{action[:name].inspect} do
+          log "Would take action here"
+        end
+      }
+      when :updated_by_last_action then %Q{
+        action #{action[:name].inspect} do
+          log "Would take action here"
+          # Explicitly update
+          new_resource.updated_by_last_action(true)
+        end
+      }
+      when :converge_by then %Q{
+        action #{action[:name].inspect} do
+          converge_by "#{action[:name]} site" do
+            log "Would take action here"
+          end
+        end
+      }
+      end
+    end
+
     # Create a Rakefile that uses the linter rake task
     #
     # @param [Symbol] task Type of task
@@ -273,11 +322,16 @@ module FoodCritic
     # @param [Hash] dep The options to use for dependency
     # @option dep [Boolean] :is_declared True if this dependency has been declared in the cookbook metadata
     # @option dep [Boolean] :is_scoped True if the include_recipe references a specific recipe or the cookbook
+    # @option dep [Boolean] :parentheses True if the include_recipe is called with parentheses
     def recipe_with_dependency(dep)
-      dep = {:is_scoped => true, :is_declared => true}.merge!(dep)
-      write_recipe %Q{
-        include_recipe 'foo#{dep[:is_scoped] ? '::default' : ''}'
-      }
+      dep = {:is_scoped => true, :is_declared => true,
+             :parentheses => false}.merge!(dep)
+      recipe = "foo#{dep[:is_scoped] ? '::default' : ''}"
+      write_recipe(if dep[:parentheses]
+        "include_recipe('#{recipe}')"
+      else
+        "include_recipe '#{recipe}'"
+      end)
       write_metadata %Q{
         version "1.9.0"
         depends "#{dep[:is_declared] ? 'foo' : 'dogs'}"
@@ -377,6 +431,34 @@ module FoodCritic
       }
     end
 
+    # Create a role file
+    #
+    # @param [Hash] options The options to use for the role
+    # @option options [String] :role_name The name of the role declared in the role file
+    # @option options [String] :file_name The containing file relative to the roles directory
+    # @option options [Symbol] :format Either :ruby or :json. Default is :ruby
+    def role(options={})
+      options = {:format => :ruby, :dir => 'roles'}.merge(options)
+      content = if options[:format] == :json
+        %Q{
+          {
+            "chef_type": "role",
+            "json_class": "Chef::Role",
+            #{Array(options[:role_name]).map{|r| "name: #{r},"}.join("\n")}
+            "run_list": [
+              "recipe[apache2]",
+            ]
+          }
+        }
+      else
+        %Q{
+          #{Array(options[:role_name]).map{|r| "name #{r}"}.join("\n")}
+          run_list "recipe[apache2]"
+        }
+      end
+      write_file "#{options[:dir]}/#{options[:file_name]}", content.strip
+    end
+
     # Create a rule with the specified Chef version constraints
     #
     # @param [String] from_version The from version

data/lib/foodcritic/api.rb

@@ -11,6 +11,8 @@ module FoodCritic
     include FoodCritic::Chef
     include FoodCritic::Notifications
 
+    class RecursedTooFarError < StandardError; end
+
     # Find attribute access by type.
     def attribute_access(ast, options = {})
       options = {:type => :any, :ignore_calls => false}.merge!(options)
@@ -22,10 +24,10 @@ module FoodCritic
 
       case options[:type]
         when :any then
-          vivified_attribute_access(ast, options[:cookbook_dir]) +
-          standard_attribute_access(ast, options)
+          vivified_attribute_access(ast, options) +
+            standard_attribute_access(ast, options)
         when :vivified then
-          vivified_attribute_access(ast, options[:cookbook_dir])
+          vivified_attribute_access(ast, options)
         else
           standard_attribute_access(ast, options)
       end
@@ -108,7 +110,22 @@ module FoodCritic
       #       depends cbk
       #     end
       deps = deps.to_a + word_list_values(ast, "//command[ident/@value='depends']")
-      deps.map{|dep| dep['value']}
+      deps.uniq.map{|dep| dep['value'].strip }
+    end
+
+    # The key / value pair in an environment or role ruby file
+    def field(ast, field_name)
+      if field_name.nil? || field_name.to_s.empty?
+        raise ArgumentError, "Field name cannot be nil or empty"
+      end
+      ast.xpath("//command[ident/@value='#{field_name}']")
+    end
+
+    # The value for a specific key in an environment or role ruby file
+    def field_value(ast, field_name)
+      field(ast, field_name).xpath('args_add_block/descendant::tstring_content
+        [count(ancestor::args_add) = 1][count(ancestor::string_add) = 1]
+        /@value').map{|a| a.to_s}.last
     end
 
     # Create a match for a specified file. Use this if the presence of the file
@@ -164,8 +181,13 @@ module FoodCritic
         filter << '[count(descendant::string_embexpr) = 0]'
       end
 
-      included = ast.xpath(%Q{//command[ident/@value = 'include_recipe']#{filter.join}
-        [descendant::args_add/string_literal]/descendant::tstring_content})
+      string_desc = '[descendant::args_add/string_literal]/descendant::tstring_content'
+      included = ast.xpath([
+        "//command[ident/@value = 'include_recipe']",
+        "//fcall[ident/@value = 'include_recipe']/following-sibling::arg_paren",
+      ].map do |recipe_include|
+        recipe_include + filter.join + string_desc
+      end.join(' | '))
 
       # Hash keyed by recipe name with matched nodes.
       included.inject(Hash.new([])){|h, i| h[i['value']] += [i]; h}
@@ -191,8 +213,7 @@ module FoodCritic
     # Read the AST for the given Ruby source file
     def read_ast(file)
       source = if file.to_s.split(File::SEPARATOR).include?('templates')
-        Template::ExpressionExtractor.new.extract(
-          File.read(file)).map{|e| e[:code]}.join(';')
+        template_expressions_only(file)
       else
         File.read(file)
       end
@@ -312,10 +333,23 @@ module FoodCritic
       end
     end
 
+    def templates_included(all_templates, template_path, depth=1)
+      raise RecursedTooFarError.new(template_path) if depth > 10
+      partials = read_ast(template_path).xpath('//*[self::command or
+        child::fcall][descendant::ident/@value="render"]//args_add/
+        string_literal//tstring_content/@value').map{|p| p.to_s}
+      Array(template_path) + partials.map do |included_partial|
+        partial_path = Array(all_templates).find do |path|
+          File.basename(path) == included_partial.to_s
+        end
+        Array(partial_path) + templates_included(all_templates, partial_path, depth + 1)
+      end.flatten.uniq
+    end
+
     # Templates in the current cookbook
     def template_paths(recipe_path)
-      Dir[Pathname.new(recipe_path).dirname.dirname + 'templates' +
-        '**/*'].select{|path| File.file?(path)}
+      Dir.glob(Pathname.new(recipe_path).dirname.dirname + 'templates' +
+        '**/*', File::FNM_DOTMATCH).select{|path| File.file?(path)}
     end
 
     private
@@ -390,6 +424,12 @@ module FoodCritic
       end
     end
 
+    def ignore_attributes_xpath(ignores)
+      Array(ignores).map do |ignore|
+        "[count(descendant::*[@value='#{ignore}']) = 0]"
+      end.join
+    end
+
     def node_method?(meth, cookbook_dir)
       chef_dsl_methods.include?(meth) || patched_node_method?(meth, cookbook_dir)
     end
@@ -433,7 +473,22 @@ module FoodCritic
     class AttFilter
       def is_att_type(value)
         return [] unless value.respond_to?(:select)
-        value.select{|n| %w{node default override set normal}.include?(n.to_s)}
+        value.select do |n|
+          %w{
+            automatic_attrs
+            default
+            default_unless
+            force_default
+            force_override
+            node
+            normal
+            normal_unless
+            override
+            override_unless
+            set
+            set_unless
+          }.include?(n.to_s)
+        end
       end
     end
 
@@ -444,31 +499,45 @@ module FoodCritic
         end.inject(:+)
       else
         type = if options[:type] == :string
-	         'tstring_content'
-	       else
-                 '*[self::symbol or self::dyna_symbol]'
-	       end
+          'tstring_content'
+        else
+          '*[self::symbol or self::dyna_symbol]'
+        end
         expr = '//*[self::aref_field or self::aref][count(method_add_arg) = 0]'
         expr += '[count(is_att_type(descendant::var_ref/ident/@value)) =
           count(descendant::var_ref/ident/@value)]'
         expr += '[is_att_type(descendant::ident'
         expr += '[not(ancestor::aref/call)]' if options[:ignore_calls]
-        expr += "/@value)]/descendant::#{type}"
-	if options[:type] == :string
+        expr += '/@value)]'
+        expr += ignore_attributes_xpath(options[:ignore])
+        expr += "/descendant::#{type}"
+        if options[:type] == :string
           expr += '[count(ancestor::dyna_symbol) = 0]'
         end
         ast.xpath(expr, AttFilter.new).sort
       end
     end
 
-    def vivified_attribute_access(ast, cookbook_dir)
-      calls = ast.xpath(%q{//*[self::call or self::field]
+    def template_expressions_only(file)
+      exprs = Template::ExpressionExtractor.new.extract(File.read(file))
+      lines = Array.new(exprs.map{|e| e[:line]}.max || 0, '')
+      exprs.each do |e|
+        lines[e[:line] -1] += ';' unless lines[e[:line] -1].empty?
+        lines[e[:line] -1] += e[:code]
+      end
+      lines.join("\n")
+    end
+
+    def vivified_attribute_access(ast, options={})
+      calls = ast.xpath(%Q{//*[self::call or self::field]
         [is_att_type(vcall/ident/@value) or is_att_type(var_ref/ident/@value)]
+        #{ignore_attributes_xpath(options[:ignore])}
         [@value='.'][count(following-sibling::arg_paren) = 0]}, AttFilter.new)
       calls.select do |call|
         call.xpath("aref/args_add_block").size == 0 and
           (call.xpath("descendant::ident").size > 1 and
-            ! node_method?(call.xpath("ident/@value").to_s.to_sym, cookbook_dir))
+            ! node_method?(call.xpath("ident/@value").to_s.to_sym,
+                options[:cookbook_dir]))
       end.sort
     end