foodcritic 1.4.0 → 1.5.0

data/lib/foodcritic/notifications.rb

@@ -0,0 +1,145 @@
+module FoodCritic
+
+  # This module contains the logic for the parsing of
+  # [Chef Notifications](http://wiki.opscode.com/display/chef/Resources#Resources-Notifications).
+  module Notifications
+
+    # Extracts notification details from the provided AST, returning an
+    # array of notification hashes.
+    #
+    #     template "/etc/www/configures-apache.conf" do
+    #       notifies :restart, "service[apache]"
+    #     end
+    #
+    #     => [{:resource_name=>"apache",
+    #       :resource_type=>:service,
+    #       :type=>:notifies,
+    #       :style=>:new,
+    #       :action=>:restart,
+    #       :timing=>:delayed}]
+    #
+    def notifications(ast)
+      # Sanity check the AST provided.
+      return [] unless ast.respond_to?(:xpath)
+
+      # We are mapping each `notifies` or `subscribes` line in the provided
+      # AST to a Hash with the extracted details.
+      notification_nodes(ast).map do |notify|
+
+        # Chef supports two styles of notification.
+        notified_resource = if new_style_notification?(notify)
+          # `notifies :restart, "service[foo]"`
+          new_style_notification(notify)
+        else
+          # `notifies :restart, resources(:service => "foo")`
+          old_style_notification(notify)
+        end
+
+        # Ignore if the notification was not parsed
+        next unless notified_resource
+
+        # Now merge the extract notification details with the attributes
+        # that are common to both styles of notification.
+        notified_resource.merge({
+          # The `:type` of notification: `:subscribes` or `:notifies`.
+          :type => notification_type(notify),
+
+          # The `:style` of notification: `:new` or `:old`.
+          :style => new_style_notification?(notify) ? :new : :old,
+
+          # The target resource action.
+          :action => notification_action(notify),
+
+          # The notification timing. Either `:immediate` or `:delayed`.
+          :timing => notification_timing(notify)
+        })
+      end.compact
+    end
+
+    private
+
+    # Extract the `:resource_name` and `:resource_type` from a new-style
+    # notification.
+    def new_style_notification(notify)
+
+      # Given `notifies :restart, "service[foo]"` the target is the
+      # `"service[foo]"` string portion.
+      target_path = 'args_add_block/args_add/descendant::tstring_content/@value'
+      target = notify.xpath("arg_paren/#{target_path} | #{target_path}").to_s
+
+      # Test the target string against the standard syntax for a new-style
+      # notification: `resource_type[resource_name]`.
+      match = target.match(/^([^\[]+)\[(.*)\]$/)
+      return nil unless match
+
+      # Convert the captured resource type and name to symbols.
+      resource_type, resource_name =
+        match.captures.tap{|m| m[0] = m[0].to_sym}
+
+      # Normally the `resource_name` will be a simple string. However in the
+      # case where it has an embedded sub-expression then we will return the
+      # AST to the caller to handle.
+      if notify.xpath('descendant::string_embexpr').empty?
+        return nil if resource_name.empty?
+      else
+        resource_name =
+          notify.xpath('args_add_block/args_add/string_literal')
+      end
+      {:resource_name => resource_name, :resource_type => resource_type}
+    end
+
+    # Extract the `:resource_name` and `:resource_type` from an old-style
+    # notification.
+    def old_style_notification(notify)
+      resources = resource_hash_references(notify)
+      resource_type = resources.xpath('symbol[1]/ident/@value').to_s.to_sym
+      resource_name = resources.xpath('string_add[1][count(../
+        descendant::string_add) = 1]/tstring_content/@value').to_s
+      resource_name = resources if resource_name.empty?
+      {:resource_name => resource_name, :resource_type => resource_type}
+    end
+
+    def notification_timing(notify)
+      # The notification timing should be the last symbol on the notifies element.
+      timing = notify.xpath('args_add_block/args_add/symbol_literal[last()]/
+        symbol/ident[1]/@value')
+      if timing.empty?
+        # "By default, notifications are :delayed"
+        :delayed
+      else
+        case timing.first.to_s.to_sym
+          # Both forms are valid, but we return `:immediate` for both to avoid
+          # the caller having to recognise both.
+          when :immediately, :immediate then :immediate
+
+          # Pass the timing through unmodified if we don't recognise it.
+          else timing.first.to_s.to_sym
+        end
+      end
+    end
+
+    def new_style_notification?(notify)
+      resource_hash_references(notify).empty?
+    end
+
+    def notification_action(notify)
+      notify.xpath('descendant::symbol[1]/ident/@value').to_s.to_sym
+    end
+
+    def notification_nodes(ast, &block)
+      type_path = '[ident/@value="notifies" or ident/@value="subscribes"]'
+      ast.xpath("descendant::command#{type_path} |
+        descendant::method_add_arg[fcall#{type_path}]")
+    end
+
+    def notification_type(notify)
+      notify.xpath('ident/@value[1] | fcall/ident/@value[1]').to_s.to_sym
+    end
+
+    def resource_hash_references(ast)
+      ast.xpath('descendant::method_add_arg[fcall/ident/
+        @value="resources"]/descendant::assoc_new')
+    end
+
+  end
+end

data/lib/foodcritic/rake_task.rb

@@ -0,0 +1,34 @@
+require 'rake'
+require 'rake/tasklib'
+
+module FoodCritic
+  module Rake
+    class LintTask < ::Rake::TaskLib
+      attr_accessor :name, :files
+      attr_writer :options
+
+      def initialize(name = :foodcritic)
+        @name = name
+        @files = Dir.pwd
+        @options = {}
+        yield self if block_given?
+        define
+      end
+
+      def options
+        {:fail_tags => ['correctness'], # differs to default cmd-line behaviour
+         :exclude_paths => ['test/**/*']}.merge(@options)
+      end
+
+      def define
+        desc "Lint Chef cookbooks"
+        task(name) do
+          result = FoodCritic::Linter.new.check(files, options)
+          puts result
+          fail if result.failed?
+        end
+      end
+
+    end
+  end
+end

data/lib/foodcritic/repl.rb

@@ -0,0 +1,28 @@
+module FoodCritic
+  module REPL
+
+    # Convenience method to repeat the last check. Intended to be used from the
+    # REPL.
+    def recheck
+      check(@last_cookbook_paths, @last_options)
+    end
+
+    def reset_rules
+      load_rules!(@last_options)
+    end
+
+    # Convenience method to retrieve the last review. Intended to be used from
+    # the REPL.
+    def review
+      @review
+    end
+
+    def with_repl(cookbook_paths, options)
+      @last_cookbook_paths, @last_options = cookbook_paths, options
+      @review = yield if block_given?
+      binding.pry if options[:repl]
+      @review
+    end
+
+  end
+end

data/lib/foodcritic/rules.rb

@@ -1,3 +1,14 @@
+# This file contains all of the rules that ship with foodcritic.
+#
+# * Foodcritic rules perform static code analysis - rather than the cookbook code
+#   being loaded by the interpreter it is parsed into a tree (AST) that is then
+#   passed to each rule.
+# * Rules can use a number of API functions that ship with foodcritic to make
+#   sense of the parse tree.
+# * Rules can also use XPath to query the AST. A rule can consist of a XPath
+#   query only, as any nodes returned from a `recipe` block will be converted
+#   into warnings.
+
 rule "FC001",
      "Use strings in preference to symbols to access node attributes" do
   tags %w{style attributes}
@@ -101,17 +112,12 @@ end
 
 rule "FC008", "Generated cookbook metadata needs updating" do
   tags %w{style metadata}
-  cookbook do |filename|
-    metadata_path = Pathname.new(File.join(filename, 'metadata.rb')).cleanpath
-    next unless File.exists? metadata_path
-    md = read_ast(metadata_path)
+  metadata do |ast,filename|
     {'maintainer' => 'YOUR_COMPANY_NAME',
      'maintainer_email' => 'YOUR_EMAIL'}.map do |field,value|
-      md.xpath(%Q{//command[ident/@value='#{field}']/
-                  descendant::tstring_content[@value='#{value}']}).map do |m|
-        match(m).merge(:filename => metadata_path)
-      end
-    end.flatten
+      ast.xpath(%Q{//command[ident/@value='#{field}']/
+                  descendant::tstring_content[@value='#{value}']})
+    end
   end
 end
 
@@ -253,26 +259,6 @@ rule "FC019", "Access node attributes in a consistent manner" do
   end
 end
 
-rule "FC020", "Conditional execution string attribute looks like Ruby" do
-  tags %w{correctness}
-  applies_to {|version| version >= gem_version("0.7.4")}
-  recipe do |ast, filename|
-    conditions = ast.xpath(%q{//command[(ident/@value='only_if' or ident/
-      @value='not_if') and descendant::tstring_content]}).map{|m| match(m)}
-    unless conditions.empty?
-      lines = File.readlines(filename) # go back for the raw untokenized string
-      conditions.map do |condition|
-        line = lines[(condition[:line].to_i) -1]
-        {:match => condition,
-         :raw_string => line.strip.sub(/^(not|only)_if[\s+]["']/, '').chop}
-      end.find_all do |cond|
-        ruby_code?(cond[:raw_string]) and
-          ! os_command?(cond[:raw_string])
-      end.map{|cond| cond[:match]}
-    end
-  end
-end
-
 rule "FC021", "Resource condition in provider may not behave as expected" do
   tags %w{correctness lwrp}
   applies_to {|version| version >= gem_version("0.10.6")}
@@ -401,10 +387,8 @@ end
 
 rule "FC029", "No leading cookbook name in recipe metadata" do
   tags %w{correctness metadata}
-  cookbook do |filename|
-    metadata_path = Pathname.new(File.join(filename, 'metadata.rb')).cleanpath
-    next unless File.exists? metadata_path
-    read_ast(metadata_path).xpath('//command[ident/@value="recipe"]').map do |declared_recipe|
+  metadata do |ast,filename|
+    ast.xpath('//command[ident/@value="recipe"]').map do |declared_recipe|
       next unless declared_recipe.xpath('count(//vcall|//var_ref)').to_i == 0
       recipe_name = declared_recipe.xpath('args_add_block/
         descendant::tstring_content[1]/@value').to_s
@@ -412,28 +396,19 @@ rule "FC029", "No leading cookbook name in recipe metadata" do
         recipe_name.split('::').first == cookbook_name(filename.to_s)
           declared_recipe
       end
-    end.compact.map {|m| match(m).merge(:filename => metadata_path.to_s) }
+    end.compact
   end
 end
 
 rule "FC030", "Cookbook contains debugger breakpoints" do
   tags %w{annoyances}
-  cookbook do |cookbook_dir|
-    Dir[cookbook_dir + '**/*.rb'].map do |ruby_file|
-      read_ast(ruby_file).xpath('//call[(vcall|var_ref)/ident/@value="binding"]
-        [ident/@value="pry"]').map do |bp|
-        match(bp).merge({:filename => ruby_file})
-      end
-    end +
-    Dir[cookbook_dir + 'templates/**/*.erb'].map do |template_file|
-      IO.read(template_file).lines.with_index(1).map do |line, line_number|
-        # Not properly parsing the template
-        if line =~ /binding\.pry/
-          {:filename => template_file, :line => line_number}
-        end
-      end.compact
-    end
+  recipe do |ast|
+    ast.xpath('//call[(vcall|var_ref)/ident/@value="binding"]
+      [ident/@value="pry"]')
   end
+  library{recipe}
+  metadata{recipe}
+  template{recipe}
 end
 
 rule "FC031", "Cookbook without metadata file" do
@@ -455,3 +430,63 @@ rule "FC032", "Invalid notification timing" do
     end
   end
 end
+
+rule "FC033", "Missing template" do
+  tags %w{correctness}
+  recipe do |ast,filename|
+    find_resources(ast, :type => :template).reject do |resource|
+      resource_attributes(resource)['local']
+    end.map do |resource|
+      file = template_file(resource_attributes(resource,
+        :return_expressions => true))
+      {:resource => resource, :file => file}
+    end.reject do |resource|
+      resource[:file].respond_to?(:xpath)
+    end.select do |resource|
+      template_paths(filename).none? do |path|
+        relative_path = []
+        Pathname.new(path).ascend do |template_path|
+          relative_path << template_path.basename
+          break if template_path.dirname.dirname.basename.to_s == 'templates'
+        end
+        File.join(relative_path.reverse) == resource[:file]
+      end
+    end.map{|resource| resource[:resource]}
+  end
+end
+
+rule "FC034", "Unused template variables" do
+  tags %w{correctness}
+  recipe do |ast,filename|
+    Array(resource_attributes_by_type(ast)['template']).select do
+      |t| t['variables'] and t['variables'].respond_to?(:xpath)
+    end.map do |resource|
+      template_paths = Dir[Pathname.new(filename).dirname.dirname +
+        'templates' + '**/*.erb']
+      template_path = template_paths.find{|p| File.basename(p) == resource['source']}
+      next unless template_path
+      passed_vars = resource['variables'].xpath('symbol/ident/@value').map{|tv| tv.to_s}
+      template_vars = read_ast(template_path).xpath('//var_ref/ivar/' +
+        '@value').map{|v| v.to_s.sub(/^@/, '')}
+      file_match(template_path) unless (passed_vars - template_vars).empty?
+    end.compact
+  end
+end
+
+rule "FC035", "Template uses node attribute directly" do
+  tags %w{style}
+  template do |ast,filename|
+    [file_match(filename)] unless attribute_access(ast).empty?
+  end
+end
+
+rule "FC037", "Invalid notification action" do
+  tags %w{correctness}
+  recipe do |ast|
+    find_resources(ast).select do |resource|
+      notifications(resource).any? do |n|
+        ! resource_action?(n[:resource_type], n[:action])
+      end
+    end
+  end
+end

data/lib/foodcritic/template.rb

@@ -0,0 +1,44 @@
+module FoodCritic
+  module Template
+
+    # Extract expressions <%= expr %> from Erb templates.
+    class ExpressionExtractor
+
+      include Erubis::Basic::Converter
+
+      def initialize
+        init_converter({})
+      end
+
+      def extract(template_code)
+        @expressions = []
+        convert(template_code)
+        @expressions
+      end
+
+      def add_expr(src, code, indicator)
+        if indicator == '='
+          @expressions << {:type => :expression, :code => code.strip}
+        end
+      end
+
+      def add_text(src, text)
+
+      end
+
+      def add_preamble(codebuf)
+
+      end
+
+      def add_postamble(codebuf)
+
+      end
+
+      def add_stmt(src, code)
+        @expressions << {:type => :statement, :code => code.strip}
+      end
+
+    end
+
+  end
+end

data/lib/foodcritic/version.rb

@@ -1,4 +1,4 @@
 module FoodCritic
   # The current version of foodcritic
-  VERSION = '1.4.0'
+  VERSION = '1.5.0'
 end

data/lib/foodcritic/xml.rb

@@ -0,0 +1,40 @@
+module FoodCritic
+  module XML
+
+    private
+
+    def xml_array_node(doc, xml_node, child)
+      n = xml_create_node(doc, child)
+      xml_node.add_child(build_xml(child, doc, n))
+    end
+
+    def xml_create_node(doc, c)
+      Nokogiri::XML::Node.new(c.first.to_s.gsub(/[^a-z_]/, ''), doc)
+    end
+
+    def xml_document(doc, xml_node)
+      if doc.nil?
+        doc = Nokogiri::XML('<opt></opt>')
+        xml_node = doc.root
+      end
+      [doc, xml_node]
+    end
+
+    def xml_hash_node(doc, xml_node, child)
+      child.each do |c|
+        n = xml_create_node(doc, c)
+        c.drop(1).each do |a|
+          xml_node.add_child(build_xml(a, doc, n))
+        end
+      end
+    end
+
+    def xml_position_node(doc, xml_node, child)
+      pos = Nokogiri::XML::Node.new("pos", doc)
+      pos['line'] = child.first.to_s
+      pos['column'] = child[1].to_s
+      xml_node.add_child(pos)
+    end
+  end
+
+end