foodcritic 0.11.1 → 1.0.0

data/lib/foodcritic.rb

@@ -9,7 +9,7 @@ require_relative 'foodcritic/chef'
 require_relative 'foodcritic/command_line'
 require_relative 'foodcritic/domain'
 require_relative 'foodcritic/error_checker'
-require_relative 'foodcritic/helpers'
+require_relative 'foodcritic/api'
 require_relative 'foodcritic/dsl'
 require_relative 'foodcritic/linter'
 require_relative 'foodcritic/output'

data/lib/foodcritic/{helpers.rb → api.rb}

@@ -3,36 +3,55 @@ require 'nokogiri'
 module FoodCritic
 
   # Helper methods that form part of the Rules DSL.
-  module Helpers
+  module Api
 
     include FoodCritic::Chef
-    include FoodCritic::Chef::Search
 
-    # Create a match from the specified node.
+    # Find attribute accesses by type.
     #
-    # @param [Nokogiri::XML::Node] node The node to create a match for
-    # @return [Hash] Hash with the matched node name and position with the recipe
-    def match(node)
-      pos = node.xpath('descendant::pos').first
-      {:matched => node.respond_to?(:name) ? node.name : '', :line => pos['line'], :column => pos['column']}
-    end
+    # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check
+    # @param [Symbol] type The approach used to access the attributes
+    #   (:string, :symbol or :vivified).
+    # @param [Boolean] ignore_calls Exclude attribute accesses that mix
+    #   strings/symbols with dot notation. Defaults to false.
+    # @return [Array] The matching nodes if any
+    def attribute_access(ast, options = {})
+      options = {:type => :any, :ignore_calls => false}.merge!(options)
+      return [] unless ast.respond_to?(:xpath)
+      unless [:string, :symbol, :vivified].include?(options[:type])
+        raise ArgumentError, "Node type not recognised"
+      end
 
-    # Create a match for a specified file. Use this if the presence of the file triggers the warning rather than content.
-    #
-    # @param [String] file The filename to create a match for
-    # @return [Hash] Hash with the match details
-    # @see FoodCritic::Helpers#match
-    def file_match(file)
-      {:filename => file, :matched => file, :line => 1, :column => 1}
+      (if options[:type] == :vivified
+        calls = ast.xpath(%q{//*[self::call or self::field]
+          [is_att_type(vcall/ident/@value) or
+           is_att_type(var_ref/ident/@value)][@value='.']}, AttFilter.new)
+        calls.select do |call|
+          call.xpath("aref/args_add_block").size == 0 and
+          (call.xpath("descendant::ident").size > 1 and
+           ! chef_dsl_methods.include?(call.xpath("ident/@value").to_s.to_sym))
+        end
+      else
+        type = (options[:type] == :string) ? 'tstring_content' : options[:type]
+        expr = '//*[self::aref_field or self::aref]'
+        expr += '[is_att_type(descendant::ident'
+        expr += '[not(ancestor::aref/call)]' if options[:ignore_calls]
+        expr += "/@value)]/descendant::#{type}"
+        ast.xpath(expr, AttFilter.new)
+      end
+      ).sort
     end
 
     # Does the specified recipe check for Chef Solo?
     #
     # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check.
-    # @return [Boolean] True if there is a test for Chef::Config[:solo] in the recipe
+    # @return [Boolean] True if there is a test for Chef::Config[:solo] in the
+    #   recipe
     def checks_for_chef_solo?(ast)
-      ! ast.xpath(%q{//if/aref[count(descendant::const[@value = 'Chef' or @value = 'Config']) = 2 and
-          count(descendant::ident[@value='solo']) > 0]}).empty?
+      raise_unless_xpath!(ast)
+      ! ast.xpath(%q{//if/aref[count(descendant::const[@value = 'Chef' or
+          @value = 'Config']) = 2
+          and count(descendant::ident[@value='solo']) > 0]}).empty?
     end
 
     # Is the chef-solo-search library available?
@@ -40,93 +59,144 @@ module FoodCritic
     # @param [String] recipe_path The path to the current recipe
     # @return [Boolean] True if the chef-solo-search library is available.
     def chef_solo_search_supported?(recipe_path)
-      search_libs = Dir[File.join(Pathname.new(File.join(recipe_path, '../../..')).realpath, "*/libraries/search.rb")]
+      return false if recipe_path.nil? || ! File.exists?(recipe_path)
+      cbk_tree_path = Pathname.new(File.join(recipe_path, '../../..'))
+      search_libs = Dir[File.join(cbk_tree_path.realpath, "*/libraries/search.rb")]
       search_libs.any? do |lib|
-        ! read_file(lib).xpath(%q{//class[count(descendant::const[@value='Chef' or @value='Recipe']) = 2]/
-            descendant::def/ident[@value='search']}).empty?
+        ! read_ast(lib).xpath(%q{//class[count(descendant::const[@value='Chef']
+          ) = 1]/descendant::def/ident[@value='search']}).empty?
       end
     end
 
-    # Searches performed by the specified recipe.
+    # The name of the cookbook containing the specified file.
     #
-    # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check.
-    # @return [Boolean] True if the recipe performs a search
-    def searches(ast)
-      ast.xpath("//fcall/ident[@value = 'search']")
+    # @param [String] file The file in the cookbook
+    # @return [String] The name of the containing cookbook
+    def cookbook_name(file)
+      raise ArgumentError, 'File cannot be nil or empty' if file.to_s.empty?
+      until (file.split(File::SEPARATOR) & standard_cookbook_subdirs).empty? do
+        file = File.absolute_path(File.dirname(file.to_s))
+      end
+      file = File.dirname(file) unless File.extname(file).empty?
+      File.basename(file)
     end
 
-    # Searches performed by the specified recipe that are literal strings. Searches with a query formed from a
-    # subexpression will be ignored.
+    # The dependencies declared in cookbook metadata.
     #
-    # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check.
-    # @return [Nokogiri::XML::Node] The matching nodes
-    def literal_searches(ast)
-      ast.xpath("//method_add_arg[fcall/ident/@value = 'search' and count(descendant::string_embexpr) = 0]/descendant::tstring_content")
+    # @param [Nokogiri::XML::Node] ast The metadata rb AST
+    # @return [Array] List of cookbooks depended on
+    def declared_dependencies(ast)
+      raise_unless_xpath!(ast)
+      deps = ast.xpath(%q{//command[ident/@value='depends']/
+        descendant::args_add/descendant::tstring_content})
+      # handle quoted word arrays
+      var_ref = ast.xpath(%q{//command[ident/@value='depends']/
+        descendant::var_ref/ident})
+      unless var_ref.empty?
+        deps += ast.xpath(%Q{//block_var/params/ident#{var_ref.first['value']}/
+          ancestor::method_add_block/call/descendant::tstring_content})
+      end
+      deps.map{|dep| dep['value']}
+    end
+
+    # Create a match for a specified file. Use this if the presence of the file
+    # triggers the warning rather than content.
+    #
+    # @param [String] file The filename to create a match for
+    # @return [Hash] Hash with the match details
+    # @see FoodCritic::Api#match
+    def file_match(file)
+      raise ArgumentError, "Filename cannot be nil" if file.nil?
+      {:filename => file, :matched => file, :line => 1, :column => 1}
+    end
+
+    # Find Chef resources of the specified type.
+    # TODO: Include blockless resources
+    #
+    # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check
+    # @param [Hash] options The find options
+    # @option [Symbol] :type The type of resource to look for (or :any for all
+    #   resources)
+    # @return [Array] AST nodes of Chef resources.
+    def find_resources(ast, options = {})
+      options = {:type => :any}.merge!(options)
+      return [] unless ast.respond_to?(:xpath)
+      scope_type = ''
+      scope_type = "[@value='#{options[:type]}']" unless options[:type] == :any
+      ast.xpath("//method_add_block[command/ident#{scope_type}]")
+    end
+
+    # Retrieve the recipes that are included within the given recipe AST.
+    #
+    # @param [Nokogiri::XML::Node] ast The recipe AST
+    # @return [Hash] include_recipe nodes keyed by included recipe name
+    def included_recipes(ast)
+      raise_unless_xpath!(ast)
+      # we only support literal strings, ignoring sub-expressions
+      included = ast.xpath(%q{//command[ident/@value = 'include_recipe' and
+        count(descendant::string_embexpr) = 0]/descendant::tstring_content})
+      included.inject(Hash.new([])){|h, i| h[i['value']] += [i]; h}
     end
 
     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)}
       end
     end
 
-    # Find attribute accesses by type.
+    # Searches performed by the specified recipe that are literal strings.
+    # Searches with a query formed from a subexpression will be ignored.
     #
     # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check
-    # @param [Symbol] accessed_via The approach used to access the attributes (:string, :symbol or :vivified)
-    # @param [Boolean] exclude_with_dots Exclude attribute accesses that mix strings/symbols with dot notation.
-    # @return [Array] The matching nodes if any
-    def attribute_access(ast, accessed_via, exclude_with_dots)
-        (if accessed_via == :vivified
-          calls = ast.xpath(%Q{//*[self::call or self::field][is_att_type(vcall/ident/@value) or
-            is_att_type(var_ref/ident/@value)][@value='.']}, AttFilter.new)
-          calls.select do |call|
-            call.xpath("aref/args_add_block").size == 0 and (call.xpath("descendant::ident").size > 1 and
-                  ! dsl_methods.include?(call.xpath("ident/@value").to_s.to_sym))
-          end
-        else
-          accessed_via = 'tstring_content' if accessed_via == :string
-          expr = '//*[self::aref_field or self::aref][is_att_type(descendant::ident'
-          expr += '[not(ancestor::aref/call)]' if exclude_with_dots
-          expr += "/@value)]/descendant::#{accessed_via}"
-          ast.xpath(expr, AttFilter.new)
-        end
-      ).sort
+    # @return [Array] The matching nodes
+    def literal_searches(ast)
+      return [] unless ast.respond_to?(:xpath)
+      ast.xpath("//method_add_arg[fcall/ident/@value = 'search' and
+        count(descendant::string_embexpr) = 0]/descendant::tstring_content")
     end
 
-    # Find Chef resources of the specified type.
-    # TODO: Include blockless resources
+    # Create a match from the specified node.
     #
-    # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check
-    # @param [String] type The type of resource to look for (or nil for all resources)
-    # @return [Array] AST nodes of Chef resources.
-    def find_resources(ast, type = nil)
-      ast.xpath(%Q{//method_add_block[command/ident#{type.nil? ? '' : "[@value='#{type}']"}]})
+    # @param [Nokogiri::XML::Node] node The node to create a match for
+    # @return [Hash] Hash with the matched node name and position with the recipe
+    def match(node)
+      raise_unless_xpath!(node)
+      pos = node.xpath('descendant::pos').first
+      return nil if pos.nil?
+      {:matched => node.respond_to?(:name) ? node.name : '',
+       :line => pos['line'].to_i, :column => pos['column'].to_i}
     end
 
-    # Return the type, e.g. 'package' for a given resource
+    # Does the provided string look like an Operating System command? This is a
+    # rough heuristic to be taken with a pinch of salt.
     #
-    # @param [Nokogiri::XML::Node] resource The resource AST
-    # @return [String] The type of resource
-    def resource_type(resource)
-      resource.xpath('string(command/ident/@value)')
+    # @param [String] str The string to check
+    # @return [Boolean] True if this string might be an OS command
+    def os_command?(str)
+      str.start_with?('grep ', 'which ') or # common commands
+      str.include?('|') or                  # probably a pipe, could be alternation
+      str.match(/^[\w]+$/) or               # command name only
+      str.match(/ --?[a-z]/i)               # command-line flag
     end
 
-    # Retrieve the name attribute associated with the specified resource.
+    # Read the AST for the given Ruby source file
     #
-    # @param [Nokogiri::XML::Node] resource The resource AST to lookup the name attribute under
-    # @return [String] The name attribute value
-    def resource_name(resource)
-      resource.xpath('string(command//tstring_content/@value)')
+    # @param [String] file The file to read
+    # @return [Nokogiri::XML::Node] The recipe AST
+    def read_ast(file)
+      build_xml(Ripper::SexpBuilder.new(File.read(file)).parse)
     end
 
     # Retrieve a single-valued attribute from the specified resource.
     #
+    # @param [Nokogiri::XML::Node] resource The resource AST to lookup the
+    #   attribute under
     # @param [String] name The attribute name
-    # @param [Nokogiri::XML::Node] resource The resource AST to lookup the attribute under
     # @return [String] The attribute value for the specified attribute
-    def resource_attribute(name, resource)
-      resource_attributes(resource)[name]
+    def resource_attribute(resource, name)
+      raise ArgumentError, "Attribute name cannot be empty" if name.empty?
+      resource_attributes(resource)[name.to_s]
     end
 
     # Retrieve all attributes from the specified resource.
@@ -134,8 +204,11 @@ module FoodCritic
     # @param [Nokogiri::XML::Node] resource The resource AST
     # @return [Hash] The resource attributes
     def resource_attributes(resource)
-      atts = {:name => resource_name(resource)}
-      resource.xpath('do_block/descendant::command[count(ancestor::do_block) = 1]').each do |att|
+      atts = {}
+      name = resource_name(resource)
+      atts[:name] = name unless name.empty?
+      resource.xpath('do_block/descendant::command
+                     [count(ancestor::do_block) = 1]').each do |att|
         if att.xpath('descendant::symbol').empty?
           att_value = att.xpath('string(descendant::tstring_content/@value)')
         else
@@ -146,20 +219,10 @@ module FoodCritic
       atts
     end
 
-    # Retrieve all resources of a given type
-    #
-    # @param [Nokogiri::XML::Node] ast The recipe AST
-    # @return [Hash] The matching resources
-    def resources_by_type(ast)
-      result = Hash.new{|hash, key| hash[key] = Array.new}
-      find_resources(ast).each{|resource| result[resource_type(resource)] << resource}
-      result
-    end
-
     # Retrieve the attributes as a hash for all resources of a given type.
     #
     # @param [Nokogiri::XML::Node] ast The recipe AST
-    # @return [Hash] An array of resource attributes keyed by type.
+    # @return [Hash] Resources keyed by type, with an array for each
     def resource_attributes_by_type(ast)
       result = {}
       resources_by_type(ast).each do |type,resources|
@@ -168,47 +231,75 @@ module FoodCritic
       result
     end
 
-    # Retrieve the recipes that are included within the given recipe AST.
+    # Retrieve the name attribute associated with the specified resource.
+    #
+    # @param [Nokogiri::XML::Node] resource The resource AST to lookup the name
+    #   attribute under
+    # @return [String] The name attribute value
+    def resource_name(resource)
+      raise_unless_xpath!(resource)
+      resource.xpath('string(command//tstring_content/@value)')
+    end
+
+    # Retrieve all resources of a given type
     #
     # @param [Nokogiri::XML::Node] ast The recipe AST
-    # @return [Hash] include_recipe nodes keyed by included recipe name
-    def included_recipes(ast)
-      # we only support literal strings, ignoring sub-expressions
-      included = ast.xpath(%q{//command[ident/@value = 'include_recipe' and count(descendant::string_embexpr) = 0]/
-        descendant::tstring_content})
-      Hash[included.map{|recipe|recipe['value']}.zip(included)]
+    # @return [Hash] The matching resources
+    def resources_by_type(ast)
+      raise_unless_xpath!(ast)
+      result = Hash.new{|hash, key| hash[key] = Array.new}
+      find_resources(ast).each do |resource|
+        result[resource_type(resource)] << resource
+      end
+      result
     end
 
-    # The name of the cookbook containing the specified file.
+    # Return the type, e.g. 'package' for a given resource
     #
-    # @param [String] file The file in the cookbook
-    # @return [String] The name of the containing cookbook
-    def cookbook_name(file)
-      File.basename(File.absolute_path(File.join(File.dirname(file), '..')))
+    # @param [Nokogiri::XML::Node] resource The resource AST
+    # @return [String] The type of resource
+    def resource_type(resource)
+      raise_unless_xpath!(resource)
+      type = resource.xpath('string(command/ident/@value)')
+      if type.empty?
+        raise ArgumentError, "Provided AST node is not a resource"
+      end
+      type
     end
 
-    # The dependencies declared in cookbook metadata.
+    # Does the provided string look like ruby code?
     #
-    # @param [Nokogiri::XML::Node] ast The metadata rb AST
-    # @return [Array] List of cookbooks depended on
-    def declared_dependencies(ast)
-      deps = ast.xpath("//command[ident/@value='depends']/descendant::args_add/descendant::tstring_content")
-      # handle quoted word arrays
-      var_ref = ast.xpath("//command[ident/@value='depends']/descendant::var_ref/ident")
-      deps += ast.xpath(%Q{//block_var/params/ident#{var_ref.first['value']}/ancestor::method_add_block/
-          call/descendant::tstring_content}) unless var_ref.empty?
-      deps.map{|dep| dep['value']}
+    # @param [String] str The string to check for rubiness
+    # @return [Boolean] True if this string could be syntactically valid Ruby
+    def ruby_code?(str)
+      str = str.to_s
+      return false if str.empty?
+      checker = FoodCritic::ErrorChecker.new(str)
+      checker.parse
+      ! checker.error?
     end
 
-    # If the provided node is the line / column information.
+    # Searches performed by the specified recipe.
     #
-    # @param [Nokogiri::XML::Node] node A node within the AST
-    # @return [Boolean] True if this node holds the position data
-    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)}
+    # @param [Nokogiri::XML::Node] ast The AST of the cookbook recipe to check.
+    # @return [Array] The AST nodes in the recipe where searches are performed
+    def searches(ast)
+      return [] unless ast.respond_to?(:xpath)
+      ast.xpath("//fcall/ident[@value = 'search']")
     end
 
-    # Recurse the nested arrays provided by Ripper to create a tree we can more easily apply expressions to.
+    # The list of standard cookbook sub-directories.
+    #
+    # @return [Array] The standard list of directories.
+    def standard_cookbook_subdirs
+      %w{attributes definitions files libraries providers recipes resources
+         templates}
+    end
+
+    private
+
+    # Recurse the nested arrays provided by Ripper to create a tree we can more
+    # easily apply expressions to.
     #
     # @param [Array] node The AST
     # @param [Nokogiri::XML::Document] doc The document being constructed
@@ -228,7 +319,8 @@ module FoodCritic
             xml_node.add_child(pos)
           else
             if child.respond_to?(:first)
-              n = Nokogiri::XML::Node.new(child.first.to_s.gsub(/[^a-z_]/, ''), doc)
+              n = Nokogiri::XML::Node.new(
+                child.first.to_s.gsub(/[^a-z_]/, ''), doc)
               xml_node.add_child(build_xml(child, doc, n))
             else
               xml_node['value'] = child.to_s unless child.nil?
@@ -239,34 +331,19 @@ module FoodCritic
       xml_node
     end
 
-    # Read the AST for the given Ruby file
-    #
-    # @param [String] file The file to read
-    # @return [Nokogiri::XML::Node] The recipe AST
-    def read_file(file)
-      build_xml(Ripper::SexpBuilder.new(IO.read(file)).parse)
-    end
-
-    # Does the provided string look like ruby code?
+    # If the provided node is the line / column information.
     #
-    # @param [String] str The string to check for rubiness
-    # @return [Boolean] True if this string could be syntactically valid Ruby
-    def ruby_code?(str)
-      checker = FoodCritic::ErrorChecker.new(str)
-      checker.parse
-      ! checker.error?
+    # @param [Nokogiri::XML::Node] node A node within the AST
+    # @return [Boolean] True if this node holds the position data
+    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)}
     end
 
-    # Does the provided string look like an Operating System command? This is a rough heuristic to be taken with a
-    # pinch of salt.
-    #
-    # @param [String] str The string to check
-    # @return [Boolean] True if this string might be an OS command
-    def os_command?(str)
-      str.start_with?('grep ', 'which ') or # common commands
-      str.include?('|') or                  # probably a pipe, could be alternation
-      str.match(/^[\w]+$/) or               # command name only
-      str.match(/ --?[a-z]/i)               # command-line flag
+    def raise_unless_xpath!(ast)
+      unless ast.respond_to?(:xpath)
+        raise ArgumentError, "AST must support #xpath"
+      end
     end
 
   end

data/lib/foodcritic/chef.rb

@@ -3,31 +3,50 @@ module FoodCritic
   # Encapsulates functions that previously were calls to the Chef gem.
   module Chef
 
-    def load_metadata
-      metadata_path = File.join(File.dirname(__FILE__), '..', '..', 'chef_dsl_metadata.json')
-      @dsl_metadata ||= Yajl::Parser.parse(IO.read(metadata_path), :symbolize_keys => true)
-    end
-
     # The set of methods in the Chef DSL
     #
     # @return [Array] Array of method symbols
-    def dsl_methods
+    def chef_dsl_methods
       load_metadata
       @dsl_metadata[:dsl_methods].map{|m| m.to_sym}
     end
 
-    # Is the specified attribute valid for the type of resource?
+    # Is the specified attribute valid for the type of resource? Note that this
+    # method will return true if the resource_type is not recognised.
     #
     # @param [Symbol] resource_type The type of Chef resource
     # @param [Symbol] attribute_name The attribute name
-    def attribute?(resource_type, attribute_name)
+    def resource_attribute?(resource_type, attribute_name)
+      if resource_type.to_s.empty? || attribute_name.to_s.empty?
+        raise ArgumentError, "Arguments cannot be nil or empty."
+      end
       load_metadata
       resource_attributes = @dsl_metadata[:attributes]
-      return true unless resource_attributes.include?(resource_type)
-      resource_attributes[resource_type].include?(attribute_name.to_s)
+      return true unless resource_attributes.include?(resource_type.to_sym)
+      resource_attributes[resource_type.to_sym].include?(attribute_name.to_s)
+    end
+
+    # Is this a valid Lucene query?
+    #
+    # @param [String] query The query to check for syntax errors
+    # @return [Boolean] True if the query is well-formed
+    def valid_query?(query)
+      raise ArgumentError, "Query cannot be nil or empty" if query.to_s.empty?
+      search = FoodCritic::Chef::Search.new
+      search.create_parser(search.chef_search_grammars)
+      search.parser? ? (! search.parser.parse(query.to_s).nil?) : true
     end
 
-    module Search
+    private
+
+    def load_metadata
+      metadata_path = File.join(File.dirname(__FILE__), '..', '..',
+        'chef_dsl_metadata.json')
+      @dsl_metadata ||= Yajl::Parser.parse(IO.read(metadata_path),
+        :symbolize_keys => true)
+    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
@@ -43,7 +62,7 @@ module FoodCritic
       # Create the search parser from the first loadable grammar.
       #
       # @param [Array] grammar_paths Full paths to candidate treetop grammars
-      def load_search_parser(grammar_paths)
+      def create_parser(grammar_paths)
         @search_parser ||= grammar_paths.inject(nil) do |parser,lucene_grammar|
             begin
               break parser unless parser.nil?
@@ -59,18 +78,14 @@ module FoodCritic
       # Has the search parser been loaded?
       #
       # @return [Boolean] True if the search parser has been loaded.
-      def search_parser_loaded?
+      def parser?
         ! @search_parser.nil?
       end
 
-      # Is this a valid Lucene query?
-      #
-      # @param [String] query The query to check for syntax errors
-      # @return [Boolean] True if the query is well-formed
-      def valid_query?(query)
-       load_search_parser(chef_search_grammars)
-       search_parser_loaded? ? (! @search_parser.parse(query).nil?) : true
+      def parser
+        @search_parser
       end
+
     end
   end
 

data/lib/foodcritic/command_line.rb

@@ -3,22 +3,23 @@ module FoodCritic
   # Command line parsing.
   class CommandLine
 
-    include FoodCritic::Chef::Search
-
     # Create a new instance of CommandLine
     #
     # @param [Array] args The command line arguments
     def initialize(args)
       @args = args
+      @original_args = args.dup
       @options = {}
-      @options[:fail_tags] = []; @options[:tags] = []
+      @options[:fail_tags] = []; @options[:tags] = []; @options[:include_rules] = []
       @parser = OptionParser.new do |opts|
         opts.banner = 'foodcritic [cookbook_path]'
         opts.on("-r", "--[no-]repl", "Drop into a REPL for interactive rule editing.") {|r|options[:repl] = r}
         opts.on("-t", "--tags TAGS", "Only check against rules with the specified tags.") {|t|options[:tags] << t}
         opts.on("-f", "--epic-fail TAGS", "Fail the build if any of the specified tags are matched.") {|t|options[:fail_tags] << t}
         opts.on("-C", "--[no-]context", "Show lines matched against rather than the default summary.") {|c|options[:context] = c}
+        opts.on("-I", "--include PATH", "Additional rule file path(s) to load.") {|i|options[:include_rules] << i}
         opts.on("-S", "--search-grammar PATH", "Specify grammar to use when validating search syntax.") {|s|options[:search_grammar] = s}
+        opts.on("-V", "--version", "Display version."){|v|options[:version] = true}
       end
       @parser.parse!(args) unless show_help?
     end
@@ -37,6 +38,20 @@ module FoodCritic
       @parser.help
     end
 
+    # Show the current version to the end user?
+    #
+    # @return [Boolean] True if the version should be shown.
+    def show_version?
+      @options.key?(:version) and @original_args != ['-v']
+    end
+
+    # The version string.
+    #
+    # @return [String] Current installed version.
+    def version
+      "foodcritic #{FoodCritic::VERSION}"
+    end
+
     # If the cookbook path provided is valid
     #
     # @return [Boolean] True if the path is a directory that exists.
@@ -57,8 +72,9 @@ module FoodCritic
     def valid_grammar?
       return true unless options.key?(:search_grammar)
       return false unless File.exists?(options[:search_grammar])
-      load_search_parser([options[:search_grammar]])
-      search_parser_loaded?
+      search = FoodCritic::Chef::Search.new
+      search.create_parser([options[:search_grammar]])
+      search.parser?
     end
 
     # If matches should be shown with context rather than the default summary display.

data/lib/foodcritic/domain.rb

@@ -51,7 +51,8 @@ module FoodCritic
 
   # A rule to be matched against.
   class Rule
-    attr_accessor :code, :name, :cookbook, :recipe, :provider, :resource, :tags
+    attr_accessor :code, :name, :cookbook, :recipe, :provider, :resource
+    attr_writer :tags
 
     # Create a new rule
     #
@@ -62,6 +63,10 @@ module FoodCritic
       @tags = [code]
     end
 
+    def tags
+      ['any'] + @tags
+    end
+
     # Returns a string representation of this rule.
     #
     # @return [String] Rule as a string.
@@ -70,4 +75,4 @@ module FoodCritic
     end
   end
 
-end
+end

data/lib/foodcritic/dsl.rb

@@ -7,12 +7,13 @@ module FoodCritic
   class RuleDsl
     attr_reader :rules
 
-    include Helpers
+    include Api
 
     # Define a new rule
     #
     # @param [String] code The short unique identifier for this rule, e.g. 'FC001'
-    # @param [String] name The short descriptive name of this rule presented to the end user.
+    # @param [String] name The short descriptive name of this rule presented to
+    #   the end user.
     # @param [Block] block The rule definition
     def rule(code, name, &block)
       @rules = [] if @rules.nil?
@@ -57,14 +58,19 @@ module FoodCritic
 
     # Load the ruleset
     #
-    # @param [String] filename The path to the ruleset to load
-    # @return [Array] The loaded rules, ready to be matched against provided cookbooks.
-    def self.load(filename, with_repl)
+    # @param [Array] paths The paths to the rulesets to load
+    # @return [Array] The loaded rules, ready to be matched against provided
+    #   cookbooks.
+    def self.load(paths, with_repl)
       dsl = RuleDsl.new
-      dsl.instance_eval(File.read(filename), filename)
+      paths.map do |path|
+        File.directory?(path) ? Dir["#{path}/**/*.rb"].sort : path
+      end.flatten.each do |path|
+        dsl.instance_eval(File.read(path), path)
+      end
       dsl.instance_eval { binding.pry } if with_repl
       dsl.rules
     end
   end
 
-end
+end

data/lib/foodcritic/linter.rb

@@ -8,18 +8,22 @@ module FoodCritic
   # The main entry point for linting your Chef cookbooks.
   class Linter
 
-    include FoodCritic::Helpers
+    include FoodCritic::Api
 
-    # Perform option parsing from the provided arguments and do a lint check based on those arguments.
+    # Perform option parsing from the provided arguments and do a lint check
+    # based on those arguments.
     #
     # @param [Array] args The command-line arguments to parse
-    # @return [Array] Pair - the first item is string output, the second is the exit code.
+    # @return [Array] Pair - the first item is string output, the second is the
+    #   exit code.
     def self.check(cmd_line)
       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?
         [cmd_line.help, 4]
       elsif cmd_line.valid_path?
-        review = FoodCritic::Linter.new.check(cmd_line.cookbook_path, cmd_line.options)
+        review = FoodCritic::Linter.new.check(cmd_line.cookbook_path,
+          cmd_line.options)
         [review, review.failed? ? 3 : 0]
       else
         [cmd_line.help, 2]
@@ -31,22 +35,27 @@ module FoodCritic
 
     end
 
-    # Review the cookbooks at the provided path, identifying potential improvements.
+    # Review the cookbooks at the provided path, identifying potential
+    # improvements.
     #
-    # @param [String] cookbook_path The file path to an individual cookbook directory
+    # @param [String] cookbook_path The file path to an individual cookbook
+    #   directory
     # @param [Hash] options Options to apply to the linting
     # @option options [Array] tags The tags to filter rules based on
     # @option options [Array] fail_tags The tags to fail the build on
-    # @return [FoodCritic::Review] A review of your cookbooks, with any warnings issued.
+    # @return [FoodCritic::Review] A review of your cookbooks, with any
+    #   warnings issued.
     def check(cookbook_path, options)
+      raise ArgumentError, "Cookbook path is required" if cookbook_path.nil?
       @last_cookbook_path, @last_options = cookbook_path, options
       load_rules unless defined? @rules
       warnings = []; last_dir = nil; matched_rule_tags = Set.new
 
-      active_rules = @rules.select{|rule| matching_tags?(options[:tags], rule.tags)}
+      active_rules = @rules.select{|rule| matching_tags?(options[:tags],
+        rule.tags)}
       files_to_process(cookbook_path).each do |file|
         cookbook_dir = Pathname.new(File.join(File.dirname(file), '..')).cleanpath
-        ast = read_file(file)
+        ast = read_ast(file)
         active_rules.each do |rule|
           rule_matches = matches(rule.recipe, ast, file)
           rule_matches += matches(rule.provider, ast, file) if File.basename(File.dirname(file)) == 'providers'
@@ -54,13 +63,14 @@ module FoodCritic
           rule_matches += matches(rule.cookbook, cookbook_dir) if last_dir != cookbook_dir
           rule_matches.each do |match|
             warnings << Warning.new(rule, {:filename => file}.merge(match))
-            matched_rule_tags += rule.tags
+            matched_rule_tags << rule.tags
           end
         end
         last_dir = cookbook_dir
       end
 
-      @review = Review.new(cookbook_path, warnings, should_fail_build?(options[:fail_tags], matched_rule_tags))
+      @review = Review.new(cookbook_path, warnings,
+                  should_fail_build?(options[:fail_tags], matched_rule_tags))
 
       binding.pry if options[:repl]
       @review
@@ -73,12 +83,14 @@ module FoodCritic
 
     # Load the rules from the (fairly unnecessary) DSL.
     def load_rules
-      @rules = RuleDsl.load(File.join(File.dirname(__FILE__), 'rules.rb'), @last_options[:repl])
+      @rules = RuleDsl.load([File.join(File.dirname(__FILE__), 'rules.rb')] +
+        @last_options[:include_rules], @last_options[:repl])
     end
 
     alias_method :reset_rules, :load_rules
 
-    # Convenience method to retrieve the last review. Intended to be used from the REPL.
+    # Convenience method to retrieve the last review. Intended to be used from
+    # the REPL.
     #
     # @return [Review] The last review performed.
     def review
@@ -98,29 +110,27 @@ module FoodCritic
       matches.respond_to?(:each) ? matches : []
     end
 
-    # Return the files within a cookbook tree that we are interested in trying to match rules against.
+    # Return the files within a cookbook tree that we are interested in trying
+    # to match rules against.
     #
     # @param [String] dir The cookbook directory
-    # @return [Array] The files underneath the provided directory to be processed.
+    # @return [Array] The files underneath the provided directory to be
+    #   processed.
     def files_to_process(dir)
       return [dir] unless File.directory? dir
       Dir.glob(File.join(dir, '{attributes,providers,recipes,resources}/*.rb')) +
-          Dir.glob(File.join(dir, '*/{attributes,providers,recipes,resources}/*.rb'))
+        Dir.glob(File.join(dir, '*/{attributes,providers,recipes,resources}/*.rb'))
     end
 
     # Whether to fail the build.
     #
-    # @param [Array] fail_tags The tags that should cause the build to fail, or special value 'any' for any tag.
+    # @param [Array] fail_tags The tags that should cause the build to fail, or
+    #   special value 'any' for any tag.
     # @param [Set] matched_tags The tags of warnings we have matches for
     # @return [Boolean] True if the build should be failed
     def should_fail_build?(fail_tags, matched_tags)
-      if fail_tags.empty?
-        false
-      elsif fail_tags.include? 'any'
-        true
-      else
-        matching_tags?(fail_tags, matched_tags)
-      end
+      return false if fail_tags.empty?
+      matched_tags.any?{|tags| matching_tags?(fail_tags, tags)}
     end
 
     # Evaluate the specified tags
@@ -129,7 +139,9 @@ module FoodCritic
     # @param [Array] tags Tags to match against
     # @return [Boolean] True if the tags match
     def matching_tags?(tag_expr, tags)
-      Gherkin::TagExpression.new(tag_expr).eval(tags.map{|t| Gherkin::Formatter::Model::Tag.new(t, 1)})
+      Gherkin::TagExpression.new(tag_expr).eval(tags.map do |t|
+        Gherkin::Formatter::Model::Tag.new(t, 1)
+      end)
     end
 
   end

data/lib/foodcritic/rules.rb

@@ -1,7 +1,7 @@
 rule "FC001", "Use strings in preference to symbols to access node attributes" do
   tags %w{style attributes}
   recipe do |ast|
-    attribute_access(ast, :symbol, false).map{|ar| match(ar)}
+    attribute_access(ast, :type => :symbol).map{|ar| match(ar)}
   end
 end
 
@@ -23,8 +23,8 @@ end
 rule "FC004", "Use a service resource to start and stop services" do
   tags %w{style services}
   recipe do |ast|
-    find_resources(ast, 'execute').find_all do |cmd|
-      cmd_str = (resource_attribute('command', cmd) || resource_name(cmd)).to_s
+    find_resources(ast, :type => 'execute').find_all do |cmd|
+      cmd_str = (resource_attribute(cmd, 'command') || resource_name(cmd)).to_s
       cmd_str.include?('/etc/init.d') || cmd_str.start_with?('service ') || cmd_str.start_with?('/sbin/service ') ||
           cmd_str.start_with?('start ') || cmd_str.start_with?('stop ') || cmd_str.start_with?('invoke-rc.d ')
     end.map{|cmd| match(cmd)}
@@ -58,11 +58,16 @@ rule "FC007", "Ensure recipe dependencies are reflected in cookbook metadata" do
   recipe do |ast,filename|
     metadata_path = Pathname.new(File.join(File.dirname(filename), '..', 'metadata.rb')).cleanpath
     next unless File.exists? metadata_path
-    undeclared = included_recipes(ast).keys.map{|recipe|recipe.split('::').first} - [cookbook_name(filename)] -
-        declared_dependencies(read_file(metadata_path))
-    included_recipes(ast).map do |recipe, resource|
-      match(resource) if undeclared.include?(recipe) || undeclared.any?{|u| recipe.start_with?("#{u}::")}
-    end.compact
+    undeclared = included_recipes(ast).keys.map do |recipe|
+      recipe.split('::').first
+    end - [cookbook_name(filename)] -
+        declared_dependencies(read_ast(metadata_path))
+    included_recipes(ast).map do |recipe, include_stmts|
+      if undeclared.include?(recipe) ||
+         undeclared.any?{|u| recipe.start_with?("#{u}::")}
+        include_stmts.map{|i| match(i)}
+      end
+    end.flatten.compact
   end
 end
 
@@ -71,7 +76,7 @@ rule "FC008", "Generated cookbook metadata needs updating" do
   cookbook do |filename|
     metadata_path = Pathname.new(File.join(filename, 'metadata.rb')).cleanpath
     next unless File.exists? metadata_path
-    md = read_file(metadata_path)
+    md = read_ast(metadata_path)
     {'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)
@@ -86,8 +91,12 @@ rule "FC009", "Resource attribute not recognised" do
     matches = []
     resource_attributes_by_type(ast).each do |type,resources|
       resources.each do |resource|
-        resource.keys.map{|att|att.to_sym}.reject{|att| attribute?(type.to_sym, att)}.each do |invalid_att|
-          matches << match(find_resources(ast, type).find{|res|resource_attributes(res).include?(invalid_att.to_s)})
+        resource.keys.map{|att|att.to_sym}.reject do |att|
+          resource_attribute?(type.to_sym, att)
+        end.each do |invalid_att|
+          matches << match(find_resources(ast, :type => type).find do |res|
+            resource_attributes(res).include?(invalid_att.to_s)
+          end)
         end
       end
     end
@@ -120,8 +129,8 @@ end
 rule "FC013", "Use file_cache_path rather than hard-coding tmp paths" do
   tags %w{style files}
   recipe do |ast|
-    find_resources(ast, 'remote_file').find_all do |download|
-      path = (resource_attribute('path', download) || resource_name(download)).to_s
+    find_resources(ast, :type => 'remote_file').find_all do |download|
+      path = (resource_attribute(download, 'path') || resource_name(download)).to_s
       path.start_with?('/tmp/')
     end.map{|download| match(download)}
   end
@@ -130,7 +139,7 @@ end
 rule "FC014", "Consider extracting long ruby_block to library" do
   tags %w{style libraries}
   recipe do |ast|
-    find_resources(ast, 'ruby_block').find_all do |rb|
+    find_resources(ast, :type => 'ruby_block').find_all do |rb|
       ! rb.xpath("//fcall[ident/@value='block' and count(ancestor::*) = 8]/../../do_block[count(descendant::*) > 100]").empty?
     end.map{|block| match(block)}
   end
@@ -172,9 +181,9 @@ end
 rule "FC019", "Access node attributes in a consistent manner" do
   tags %w{style attributes}
   cookbook do |cookbook_dir|
-    asts = {}; files = Dir["#{cookbook_dir}/*/*.rb"].map{|file| {:path => file, :ast => read_file(file)}}
+    asts = {}; files = Dir["#{cookbook_dir}/*/*.rb"].map{|file| {:path => file, :ast => read_ast(file)}}
     types = [:string, :symbol, :vivified].map{|type| {:access_type => type, :count => files.map do |file|
-      attribute_access(file[:ast], type, true).tap{|ast|
+      attribute_access(file[:ast], :type => type, :ignore_calls => true).tap{|ast|
         asts[type] = {:ast => ast, :path => file[:path]} if (! ast.empty?) and (! asts.has_key?(type))
       }.size
     end.inject(:+)}}.reject{|type| type[:count] == 0}

data/lib/foodcritic/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foodcritic
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,25 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-29 00:00:00.000000000 Z
+date: 2012-03-04 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: &2152841480 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.4.4
-    - - <=
-      - !ruby/object:Gem::Version
-        version: 1.6.1
-  type: :runtime
-  prerelease: false
-  version_requirements: *2152841480
 - !ruby/object:Gem::Dependency
   name: gherkin
-  requirement: &2152869780 !ruby/object:Gem::Requirement
+  requirement: &2157955580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -35,10 +21,10 @@ dependencies:
         version: 2.8.0
   type: :runtime
   prerelease: false
-  version_requirements: *2152869780
+  version_requirements: *2157955580
 - !ruby/object:Gem::Dependency
   name: gist
-  requirement: &2152867120 !ruby/object:Gem::Requirement
+  requirement: &2157954980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -46,10 +32,10 @@ dependencies:
         version: 2.0.4
   type: :runtime
   prerelease: false
-  version_requirements: *2152867120
+  version_requirements: *2157954980
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &2152882420 !ruby/object:Gem::Requirement
+  requirement: &2157954500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -57,10 +43,10 @@ dependencies:
         version: 1.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *2152882420
+  version_requirements: *2157954500
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &2152880280 !ruby/object:Gem::Requirement
+  requirement: &2157953920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -68,10 +54,10 @@ dependencies:
         version: 0.9.7.4
   type: :runtime
   prerelease: false
-  version_requirements: *2152880280
+  version_requirements: *2157953920
 - !ruby/object:Gem::Dependency
   name: pry-doc
-  requirement: &2152877780 !ruby/object:Gem::Requirement
+  requirement: &2157953460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -79,10 +65,10 @@ dependencies:
         version: 0.3.0
   type: :runtime
   prerelease: false
-  version_requirements: *2152877780
+  version_requirements: *2157953460
 - !ruby/object:Gem::Dependency
   name: rak
-  requirement: &2152876160 !ruby/object:Gem::Requirement
+  requirement: &2157952960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -90,10 +76,10 @@ dependencies:
         version: '1.4'
   type: :runtime
   prerelease: false
-  version_requirements: *2152876160
+  version_requirements: *2157952960
 - !ruby/object:Gem::Dependency
   name: treetop
-  requirement: &2152891220 !ruby/object:Gem::Requirement
+  requirement: &2157952180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -101,10 +87,10 @@ dependencies:
         version: 1.4.10
   type: :runtime
   prerelease: false
-  version_requirements: *2152891220
+  version_requirements: *2157952180
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &2152888700 !ruby/object:Gem::Requirement
+  requirement: &2157951540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -112,7 +98,7 @@ dependencies:
         version: 1.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *2152888700
+  version_requirements: *2157951540
 description: Lint tool for Opscode Chef cookbooks.
 email: 
 executables:
@@ -120,12 +106,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/foodcritic/api.rb
 - lib/foodcritic/chef.rb
 - lib/foodcritic/command_line.rb
 - lib/foodcritic/domain.rb
 - lib/foodcritic/dsl.rb
 - lib/foodcritic/error_checker.rb
-- lib/foodcritic/helpers.rb
 - lib/foodcritic/linter.rb
 - lib/foodcritic/output.rb
 - lib/foodcritic/rules.rb
@@ -154,12 +140,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3754378815808582034
+      hash: 4610293132888604111
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: foodcritic-0.11.1
+summary: foodcritic-1.0.0
 test_files: []
 has_rdoc: