foodcritic 0.1.0

data/bin/foodcritic

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'foodcritic'
+unless ARGV.length == 1 and Dir.exists?(ARGV[0])
+  STDERR.puts 'foodcritic [cookbook_path]'
+  exit 1
+end
+review = FoodCritic::Linter.new.check(ARGV[0])
+puts review unless review.warnings.empty?

data/lib/foodcritic.rb

@@ -0,0 +1,5 @@
+require 'foodcritic/domain'
+require 'foodcritic/helpers'
+require 'foodcritic/dsl'
+require 'foodcritic/linter'
+require 'foodcritic/version'

data/lib/foodcritic/domain.rb

@@ -0,0 +1,52 @@
+module FoodCritic
+
+  # A warning of a possible issue
+  class Warning
+    attr_reader :rule, :match
+
+    # Create a new warning
+    #
+    # @param [FoodCritic::Rule] rule The rule which raised this warning
+    # @param [Hash] match The match data
+    # @option match [String] :filename The filename the warning was raised against
+    # @option match [Integer] :line The identified line
+    # @option match [Integer] :column The identified column
+    def initialize(rule, match={})
+      @rule, @match = rule, match
+    end
+  end
+
+  # The collected warnings (if any) raised against a cookbook tree.
+  class Review
+
+    attr_reader :warnings
+
+    # Create a new review
+    #
+    # @param [Array] warnings The warnings raised in this review
+    def initialize(warnings)
+      @warnings = warnings
+    end
+
+    # Returns a string representation of this review.
+    #
+    # @return [String] Review as a string, this representation is liable to change.
+    def to_s
+      @warnings.map { |w| "#{w.rule.code}: #{w.rule.name}: #{w.match[:filename]}:#{w.match[:line]}" }.sort.uniq.join("\n")
+    end
+  end
+
+  # A rule to be matched against.
+  class Rule
+    attr_accessor :code, :name, :description, :recipe
+
+    # Create 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.
+    def initialize(code, name)
+      @code, @name = code, name
+    end
+  end
+
+end

data/lib/foodcritic/dsl.rb

@@ -0,0 +1,44 @@
+module FoodCritic
+
+  # The DSL methods exposed for defining rules.
+  class RuleDsl
+    attr_reader :rules
+    include Helpers
+
+    # 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 [Block] block The rule definition
+    def rule(code, name, &block)
+      @rules = [] if @rules.nil?
+      @rules << Rule.new(code, name)
+      yield self
+    end
+
+    # Set the rule description
+    #
+    # @param [String] description Set the rule description.
+    def description(description)
+      rules.last.description = description
+    end
+
+    # Define a matcher that will be passed the AST with this method.
+    #
+    # @param [block] block Your implemented matcher that returns a match Hash.
+    def recipe(&block)
+      rules.last.recipe = block
+    end
+
+    # 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)
+      dsl = RuleDsl.new
+      dsl.instance_eval(File.read(filename), filename)
+      dsl.rules
+    end
+  end
+
+end

data/lib/foodcritic/helpers.rb

@@ -0,0 +1,106 @@
+module FoodCritic
+
+  # Helper methods that form part of the Rules DSL.
+  module Helpers
+
+    # Given an AST type and parsed tree, return the matching subset.
+    #
+    # @param [Symbol] type The type of AST node to look for
+    # @param [Array] node The parsed AST (or part there-of)
+    # @return [Array] Matching nodes
+    def ast(type, node)
+      result = []
+      result = [node] if node.first == type
+      node.each { |n| result += ast(type, n) if n.respond_to?(:each) }
+      result
+    end
+
+    # Does the specified recipe check for Chef Solo?
+    #
+    # @param [Array] ast The AST of the cookbook recipe to check.
+    # @return [Boolean] True if there is a test for Chef::Config[:solo] in the recipe
+    def checks_for_chef_solo?(ast)
+      arefs = ast(:aref, ast)
+      arefs.any? do |aref|
+        ast(:@const, aref).map { |const| const[1] } == ['Chef', 'Config'] and
+            ast(:@ident, ast(:symbol, aref)).map { |sym| sym.drop(1).first }.include? 'solo'
+      end
+    end
+
+    # Find Chef resources of the specified type.
+    # TODO: Include blockless resources
+    #
+    # @param [Array] ast The AST of the cookbook recipe to check
+    # @param [String] type The type of resource to look for (or nil for all resources)
+    def find_resources(ast, type = nil)
+      ast(:method_add_block, ast).find_all do |resource|
+        resource[1][0] == :command and resource[1][1][0] == :@ident and (type.nil? || resource[1][1][1] == type)
+      end
+    end
+
+    # Return the type, e.g. 'package' for a given resource
+    #
+    # @param [Array] resource The resource AST
+    # @return [String] The type of resource
+    def resource_type(resource)
+      resource[1][1][1]
+    end
+
+    # Retrieve the name attribute associated with the specified resource.
+    #
+    # @param [Array] resource The resource AST to lookup the name attribute under
+    def resource_name(resource)
+      ast(:@tstring_content, resource[1]).flatten[1]
+    end
+
+    # Retrieve a single-valued attribute from the specified resource.
+    #
+    # @param [String] name The attribute name
+    # @param [Array] resource The resource AST to lookup the attribute under
+    # @return [String] The attribute value for the specified attribute
+    def resource_attribute(name, resource)
+      cmd = ast(:command, ast(:do_block, resource))
+      atts = cmd.find_all { |att| ast(:@ident, att).flatten.drop(1).first == name }
+      value = ast(:@tstring_content, atts).flatten.drop(1)
+      unless value.empty?
+        return value.first
+      end
+      nil
+    end
+
+    # Retrieve all attributes from the specified resource.
+    #
+    # @param [Array] resource The resource AST
+    # @return [Hash] The resource attributes
+    def resource_attributes(resource)
+      atts = {:name => resource_name(resource)}
+      ast(:command, ast(:do_block, resource)).find_all{|cmd| cmd.first == :command}.each do |cmd|
+        atts[cmd[1][1]] = ast(:@tstring_content, cmd[2]).flatten[1] || ast(:@ident, cmd[2]).flatten[1]
+      end
+      atts
+    end
+
+    # Retrieve all resources of a given type
+    #
+    # @param [Array] ast The recipe AST
+    # @return [Array] 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 [Array] ast The recipe AST
+    # @return [Hash] An array of resource attributes keyed by type.
+    def resource_attributes_by_type(ast)
+      result = {}
+      resources_by_type(ast).each do |type,resources|
+        result[type] = resources.map{|resource| resource_attributes(resource)}
+      end
+      result
+    end
+  end
+
+end

data/lib/foodcritic/linter.rb

@@ -0,0 +1,47 @@
+require 'ripper'
+
+module FoodCritic
+
+  # The main entry point for linting your Chef cookbooks.
+  class Linter
+
+    # Create a new Linter, loading any defined rules.
+    def initialize
+      load_rules
+    end
+
+    # Review the cookbooks at the provided path, identifying potential improvements.
+    #
+    # @param [String] cookbook_path The file path to an individual cookbook directory
+    # @return [FoodCritic::Review] A review of your cookbooks, with any warnings issued.
+    def check(cookbook_path)
+      warnings = []
+      files_to_process(cookbook_path).each do |file|
+        ast = Ripper::SexpBuilder.new(IO.read(file)).parse
+        @rules.each do |rule|
+          rule.recipe.yield(ast).each do |match|
+            warnings << Warning.new(rule, match.merge({:filename => file}))
+          end
+        end
+      end
+      Review.new(warnings)
+    end
+
+    private
+
+    # Load the rules from the (fairly unnecessary) DSL.
+    def load_rules
+      @rules = RuleDsl.load(File.join(File.dirname(__FILE__), 'rules.rb'))
+    end
+
+    # 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.
+    def files_to_process(dir)
+      return [dir] unless File.directory? dir
+      Dir.glob(File.join(dir, '{attributes,recipes}/*.rb')) + Dir.glob(File.join(dir, '*/{attributes,recipes}/*.rb'))
+    end
+
+  end
+end

data/lib/foodcritic/rules.rb

@@ -0,0 +1,82 @@
+rule "FC001", "Use symbols in preference to strings to access node attributes" do
+  description "When accessing node attributes you should use a symbol for a key rather than a string literal."
+  recipe do |ast|
+    matches = []
+    attribute_refs = %w{node default override set normal}
+    aref_fields = self.ast(:aref, ast) + self.ast(:aref_field, ast)
+    aref_fields.each do |field|
+      is_node_aref = attribute_refs.include? self.ast(:@ident, field).flatten.drop(1).first
+      if is_node_aref
+        literal_strings = self.ast(:@tstring_content, field)
+        literal_strings.each do |str|
+          matches << {:matched => str[1], :line => str[2].first, :column => str[2].last}
+        end
+      end
+    end
+    matches
+  end
+end
+
+rule "FC002", "Avoid string interpolation where not required" do
+  description "When setting a resource value avoid string interpolation where not required."
+  recipe do |ast|
+    matches = []
+    self.ast(:string_literal, ast).each do |literal|
+      embed_expr = self.ast(:string_embexpr, literal)
+      if embed_expr.size == 1
+        literal[1].reject! { |expr| expr == embed_expr.first }
+        if self.ast(:@tstring_content, literal).empty?
+          self.ast(:@ident, embed_expr).map { |ident| ident.flatten.drop(1) }.each do |ident|
+            matches << {:matched => ident[0], :line => ident[1], :column => ident[2]}
+          end
+        end
+      end
+    end
+    matches
+  end
+end
+
+rule "FC003", "Check whether you are running with chef server before using server-specific features" do
+  description "Ideally your cookbooks should be usable without requiring chef server."
+  recipe do |ast|
+    matches = []
+    function_calls = self.ast(:@ident, self.ast(:fcall, ast)).map { |fcall| fcall.drop(1).flatten }
+    searches = function_calls.find_all { |fcall| fcall.first == 'search' }
+    unless searches.empty? || checks_for_chef_solo?(ast)
+      searches.each { |s| matches << {:matched => s[0], :line => s[1], :column => s[2]} }
+    end
+    matches
+  end
+end
+
+rule "FC004", "Use a service resource to start and stop services" do
+  description "Avoid use of execute to control services - use the service resource instead."
+  recipe do |ast|
+    matches = []
+    find_resources(ast, 'execute').find_all do |cmd|
+      cmd_str = resource_attribute('command', cmd)
+      cmd_str = resource_name(cmd) if cmd_str.nil?
+      cmd_str.include?('/etc/init.d') || cmd_str.start_with?('service ') || cmd_str.start_with?('/sbin/service ')
+    end.each do |service_cmd|
+      exec = ast(:@ident, service_cmd).first.drop(1).flatten
+      matches << {:matched => exec[0], :line => exec[1], :column => exec[2]}
+    end
+    matches
+  end
+end
+
+rule "FC005", "Avoid repetition of resource declarations" do
+  description "Where you have a lot of resources that vary in only a single attribute wrap them in a loop for brevity."
+  recipe do |ast|
+    matches = []
+    # do all of the attributes for all resources of a given type match apart aside from one?
+    resource_attributes_by_type(ast).each do |type, resource_atts|
+        sorted_atts = resource_atts.map{|atts| atts.to_a.sort{|x,y| x.first.to_s <=> y.first.to_s }}
+        if sorted_atts.all?{|att| (att - sorted_atts.inject{|atts,a| atts & a}).length == 1}
+          first_resource = ast(:@ident, find_resources(ast, type).first).first[2]
+          matches << {:matched => type, :line => first_resource[0], :column => first_resource[1]}
+        end
+    end
+    matches
+  end
+end

data/lib/foodcritic/version.rb

@@ -0,0 +1,3 @@
+module FoodCritic
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: foodcritic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Crump
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-30 00:00:00.000000000 Z
+dependencies: []
+description: Lint tool for Opscode Chef cookbooks.
+email: 
+executables:
+- foodcritic
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/foodcritic/domain.rb
+- lib/foodcritic/dsl.rb
+- lib/foodcritic/helpers.rb
+- lib/foodcritic/linter.rb
+- lib/foodcritic/rules.rb
+- lib/foodcritic/version.rb
+- lib/foodcritic.rb
+- bin/foodcritic
+homepage: http://acrmp.github.com/foodcritic
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3064369866529469522
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: foodcritic-0.1.0
+test_files: []
+has_rdoc: