foodcritic 15.0.0 → 15.1.0

data/features/support/command_helpers.rb

@@ -1,418 +0,0 @@
-module FoodCritic
-
-  # Helpers for asserting that the correct warnings are displayed.
-  #
-  # Unless the environment variable FC_FORK_PROCESS is set to 'true' then the features will be run in the same process.
-  module CommandHelpers
-
-    require "minitest"
-    include MiniTest::Assertions
-
-    attr_writer :assertions
-    def assertions
-      @assertions ||= 0
-    end
-
-    # The warning codes and messages displayed to the end user.
-    WARNINGS = {
-      "FC001" => "Use strings in preference to symbols to access node attributes",
-      "FC002" => "Avoid string interpolation where not required",
-      "FC004" => "Use a service resource to start and stop services",
-      "FC005" => "Avoid repetition of resource declarations",
-      "FC006" => "Mode should be quoted or fully specified when setting file permissions",
-      "FC007" => "Ensure recipe dependencies are reflected in cookbook metadata",
-      "FC008" => "Generated cookbook metadata needs updating",
-      "FC009" => "Resource attribute not recognised",
-      "FC010" => "Invalid search syntax",
-      "FC011" => "Missing README in markdown format",
-      "FC013" => "Use file_cache_path rather than hard-coding tmp paths",
-      "FC014" => "Consider extracting long ruby_block to library",
-      "FC015" => "Consider converting definition to a Custom Resource",
-      "FC016" => "LWRP does not declare a default action",
-      "FC018" => "LWRP uses deprecated notification syntax",
-      "FC019" => "Access node attributes in a consistent manner",
-      "FC021" => "Resource condition in provider may not behave as expected",
-      "FC022" => "Resource condition within loop may not behave as expected",
-      "FC024" => "Consider adding platform equivalents",
-      "FC027" => "Resource sets internal attribute",
-      "FC028" => "Incorrect #platform? usage",
-      "FC029" => "No leading cookbook name in recipe metadata",
-      "FC030" => "Cookbook contains debugger breakpoints",
-      "FC031" => "Cookbook without metadata.rb file",
-      "FC032" => "Invalid notification timing",
-      "FC033" => "Missing template file",
-      "FC034" => "Unused template variables",
-      "FC037" => "Invalid notification action",
-      "FC038" => "Invalid resource action",
-      "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",
-      "FC043" => "Prefer new notification syntax",
-      "FC044" => "Avoid bare attribute keys",
-      "FC045" => "Metadata does not contain cookbook name",
-      "FC046" => "Attribute assignment uses assign unless nil",
-      "FC047" => "Attribute assignment does not specify precedence",
-      "FC049" => "Role name does not match containing file name",
-      "FC050" => "Name includes invalid characters",
-      "FC051" => "Template partials loop indefinitely",
-      "FC052" => 'Metadata uses the deprecated "suggests" keyword',
-      "FC053" => 'Metadata uses the deprecated "recommends" keyword',
-      "FC055" => "Ensure maintainer is set in metadata",
-      "FC056" => "Ensure maintainer_email is set in metadata",
-      "FC058" => "Library provider declares use_inline_resources and declares #action_<name> methods",
-      "FC060" => "LWRP provider declares use_inline_resources and declares #action_<name> methods",
-      "FC061" => "Valid cookbook versions are of the form x.y or x.y.z",
-      "FC062" => "Cookbook should have version metadata",
-      "FC063" => "Cookbook incorrectly depends on itself",
-      "FC064" => "Ensure issues_url is set in metadata",
-      "FC065" => "Ensure source_url is set in metadata",
-      "FC066" => "Ensure chef_version is set in metadata",
-      "FC067" => "Ensure at least one platform supported in metadata",
-      "FC068" => "Ensure license is set in metadata",
-      "FC069" => "Ensure standardized license defined in metadata",
-      "FC070" => "Ensure supports metadata defines valid platforms",
-      "FC071" => "Missing LICENSE file",
-      "FCTEST001" => "Test Rule",
-    }
-
-    # If the cucumber features should run foodcritic in the same process or spawn a separate process.
-    def self.running_in_process?
-      ! (ENV.has_key?("FC_FORK_PROCESS") && ENV["FC_FORK_PROCESS"] == true.to_s)
-    end
-
-    # Capture an error expected when calling a command.
-    def capture_error
-      yield
-      @error = all_output unless last_exit_status == 0
-    rescue => @error
-    end
-
-    # Return the last error captured
-    #
-    # @return [String] The last error captured
-    def last_error
-      @error.respond_to?(:message) ? @error.message : @error
-    end
-
-    # Expect a line of context
-    #
-    # @param [Number] line_no The line number
-    # @param [String] text The text of the matching line
-    def expect_line_shown(line_no, text)
-      expect_output %r{^ +#{Regexp.escape(line_no.to_s)}\|#{Regexp.escape(text)}$}
-    end
-
-    # Expect a warning to be included in the command output.
-    #
-    # @param [String] code The warning code to check for.
-    # @param [Hash] options The warning options.
-    # @option options [Integer] :line The line number the warning should appear on - nil for any line.
-    # @option options [Boolean] :expect_warning If false then assert that a warning is NOT present
-    # @option options [String] :file The path to the file the warning should be raised against
-    # @option options [Symbol] :file_type Alternative to specifying file name. One of: :attributes, :definition,
-    #   :metadata, :provider, :resource
-    def expect_warning(code, options = {})
-      if options.has_key?(:file_type)
-        options[:file] = { :attributes => "attributes/default.rb", :definition => "definitions/apache_site.rb",
-                           :metadata => "metadata.rb", :provider => "providers/site.rb",
-                           :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]}: #{options[:file]}:#{options[:line]}#{"\n" if ! options[:line].nil?}"
-      end
-      options[:expect_warning] ? expect_output(warning) : expect_no_output(warning)
-    end
-
-    # Expect a warning not to be included in the command output.
-    #
-    # @see CommandHelpers#expect_warning
-    def expect_no_warning(code, options = { :expect_warning => false })
-      expect_warning(code, options)
-    end
-
-    # Expect a command line option / switch to be included in the usage.
-    #
-    # @param [String] short_switch The short version of the switch
-    # @param [String] long_switch The long descriptive version of the switch
-    # @param [String] description The description of the switch
-    def expect_usage_option(short_switch, long_switch, description)
-      expected_switch = "-#{Regexp.escape(short_switch)}, --#{Regexp.escape(long_switch)}[ ]+#{Regexp.escape(description)}"
-      expect_output(Regexp.new(expected_switch))
-    end
-
-    def has_test_warnings?(output)
-      output.split("\n").grep(/FC[0-9]+:/).map do |warn|
-        File.basename(File.dirname(warn.split(":").take(3).last.strip))
-      end.include?("test")
-    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]"
-
-      usage_options.each do |option|
-        expect_usage_option(option[:short], option[:long], option[:description])
-      end
-
-      if is_exit_zero
-        assert_no_error_occurred
-      else
-        assert_error_occurred
-      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 based on tags. Default of 'any' to fail on all warnings." },
-
-        { :short => "l", :long => "list",
-          :description => "List all enabled rules and their descriptions." },
-
-        { :short => "t", :long => "tags TAGS",
-          :description => "Check against (or exclude ~) 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." },
-
-        { :short => "X", :long => "exclude PATH",
-          :description => "Exclude path(s) from being linted. PATH is relative to the cookbook, not an absolute PATH. Default test/**/*,spec/**/*,features/**/*" },
-
-      ]
-    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.
-  module InProcessHelpers
-
-    # Assert that the output contains the specified warning.
-    #
-    # @param [String] output The warning to check for.
-    def expect_output(output)
-      if output.respond_to?(:~)
-        @review.must_match(output)
-      else
-        @review.must_include(output)
-      end
-    end
-
-    # Assert that the output does not contain the specified warning.
-    #
-    # @param [String] output The output to check for.
-    def expect_no_output(output)
-      if output.respond_to?(:~)
-        @review.wont_match(output)
-      else
-        @review.wont_include(output)
-      end
-    end
-
-    # Assert that an error occurred following a lint check.
-    def assert_error_occurred
-      @status.wont_equal 0
-    end
-
-    # Assert that no error occurred following a lint check.
-    def assert_no_error_occurred
-      @status.must_equal 0
-    end
-
-    # Assert that warnings have not been raised against the test code which
-    # should have been excluded from linting.
-    def assert_no_test_warnings
-      refute has_test_warnings?(@review)
-    end
-
-    # Assert that warnings have been raised against the test code which
-    # shouldn't have been excluded from linting.
-    def assert_test_warnings
-      assert has_test_warnings?(@review)
-    end
-
-    # Run a lint check with the provided command line arguments.
-    #
-    # @param [Array] cmd_args The command line arguments.
-    def run_lint(cmd_args)
-      cd "." do
-        show_context = cmd_args.include?("-C")
-        review, @status = FoodCritic::Linter.run(CommandLine.new(cmd_args))
-        @review =
-          if review.nil? || (review.respond_to?(:warnings) && review.warnings.empty?)
-            ""
-          elsif show_context
-            ContextOutput.new.output(review)
-          else
-            "#{review}\n"
-          end
-      end
-    end
-
-  end
-
-  # For use with steps that use bundler and rake. These will always be run
-  # via Aruba.
-  module BuildHelpers
-
-    # Assert the build outcome
-    #
-    # @param [Boolean] success True if the build should succeed
-    # @param [Array] warnings The warnings expected
-    def assert_build_result(success, warnings)
-      success ? assert_no_error_occurred : assert_error_occurred
-      warnings.each do |code|
-        expect_warning(code, :warning_only => true)
-      end
-    end
-
-    # Assert that warnings have not been raised against the test code which
-    # should have been excluded from linting.
-    def assert_no_test_warnings
-      refute has_test_warnings?(all_output)
-    end
-
-    # Assert that warnings have been raised against the test code which
-    # shouldn't have been excluded from linting.
-    def assert_test_warnings
-      assert has_test_warnings?(all_output)
-    end
-
-    # The available tasks for this build
-    #
-    # @return [Array] Task name and description
-    def build_tasks
-      all_output.split("\n").map do |task|
-        next unless task.start_with? "rake"
-        task.split("#").map { |t| t.strip.sub(/^rake /, "") }
-      end.compact
-    end
-
-    # List the defined Rake tasks
-    def list_available_build_tasks
-      cd "cookbooks/example"
-      unset_bundler_env_vars
-      run_simple "bundle exec rake -T"
-    end
-
-    # Run a build for a Rakefile that uses the lint rake task
-    def run_build
-      cd "cookbooks/example"
-      run_simple "bundle exec rake", false
-    end
-
-    # We want to avoid traversing vendored gems because of the unnecessary
-    # performance hit and because gems may contain deeply-nested code which
-    # will blow the stack on parsing.
-    def vendor_gems
-      cd "cookbooks/example"
-      unset_bundler_env_vars
-      run_simple "bundle install --path vendor/bundle"
-      cd "../.."
-    end
-
-  end
-
-  # Helpers used when features are executed out of process.
-  module ArubaHelpers
-
-    include BuildHelpers
-
-    # Assert that the output contains the specified warning.
-    #
-    # @param [String] output The output to check for.
-    def expect_output(output)
-      if output.respond_to?(:~)
-        assert_matching_output(output.to_s, all_output)
-      else
-        assert_partial_output(output, all_output)
-      end
-    end
-
-    # Assert that the output does not contain the specified warning.
-    #
-    # @param [String] output The output to check for.
-    def expect_no_output(output)
-      if output.respond_to?(:~)
-        assert_matching_output('^((?!#{output}).)*$', all_output)
-      else
-        assert_no_partial_output(output, all_output)
-      end
-    end
-
-    # Assert that an error occurred following a lint check.
-    def assert_error_occurred
-      assert_not_exit_status 0
-    end
-
-    # Assert that no error occurred following a lint check.
-    def assert_no_error_occurred
-      assert_exit_status(0)
-    end
-
-    # Run a lint check with the provided command line arguments.
-    #
-    # @param [Array] cmd_args The command line arguments.
-    def run_lint(cmd_args)
-      run_simple(unescape("foodcritic #{cmd_args.join(' ')}"), false)
-    end
-  end
-
-end
-
-World(FoodCritic::CommandHelpers)
-if FoodCritic::CommandHelpers.running_in_process?
-  World(FoodCritic::InProcessHelpers)
-else
-  World(FoodCritic::ArubaHelpers)
-end

data/features/support/cookbook_helpers.rb

@@ -1,599 +0,0 @@
-module FoodCritic
-
-  # Helper cookbook methods for use in your steps.
-  module CookbookHelpers
-
-    # Create an attributes file that references attributes with symbols
-    #
-    # @param [String] type The type of node attribute to write
-    def attributes_with_symbols(type)
-      write_attributes %Q{#{type}[:apache][:dir] = "/etc/apache2"}
-    end
-
-    # Create a Gemfile for a cookbook
-    def buildable_gemfile
-      write_file "cookbooks/example/Gemfile", %q{
-        source 'https://rubygems.org/'
-        gem 'rake'
-        gem 'foodcritic', :path => '../../../..'
-      }
-    end
-
-    # Create a cookbook that declares dependencies on external recipes.
-    #
-    # @param [Symbol] declaration_type The type of declaration - :brace or :bracket
-    def cookbook_declares_dependencies(declaration_type)
-      write_recipe %q{
-        include_recipe "foo::default"
-        include_recipe "bar::default"
-        include_recipe "baz::default"
-      }
-      if declaration_type == :brace
-        write_metadata %q{
-          %w{foo bar baz}.each{|cookbook| depends cookbook}
-        }
-      else
-        write_metadata %q{
-          %w{foo bar baz}.each do |cb|
-            depends cb
-          end
-        }
-      end
-    end
-
-    # Create a cookbook that will match the specified rules.
-    #
-    # @param [Array] codes The codes to match. Only FC002, FC004 and FC005 and FC006 are supported.
-    def cookbook_that_matches_rules(codes)
-      recipe = ""
-      codes.each do |code|
-        if code == "FC002"
-          recipe += %q{
-            directory "#{node['base_dir']}" do
-              action :create
-            end
-          }
-        elsif code == "FC004"
-          recipe += %q{
-            execute "stop-jetty" do
-              command "/etc/init.d/jetty6 stop"
-              action :run
-            end
-          }
-        elsif code == "FC005"
-          recipe += %q{
-            package 'erlang-base' do
-              action :upgrade
-            end
-            package 'erlang-corba' do
-              action :upgrade
-            end
-            package 'erlang-another' do
-              action :upgrade
-            end
-          }
-        elsif code == "FC006"
-          recipe += %q{
-            directory "/var/lib/foo" do
-              mode 644
-              action :create
-            end
-          }
-        end
-      end
-      write_recipe(recipe)
-      write_file("cookbooks/example/recipes/server.rb", "")
-      write_readme("Hello World") # Don't trigger FC011
-      write_metadata(%q{
-        name 'example'
-        maintainer 'A Maintainer'
-        maintainer_email 'maintainer@example.com'
-        version '0.0.1'
-        issues_url 'http://github.com/foo/bar_cookbook/issues'
-        source_url 'http://github.com/foo/bar_cookbook'
-      }.strip)
-    end
-
-    # Create a cookbook with a custom resource
-    #
-    # @author Tim Smith - tsmith@chef.io
-    # @since 10.1.1
-    def cookbook_with_custom_resource
-      write_resource("site", %Q{
-        property :name, String, name_property: true
-        property :variables, Hash, default: {}
-
-        action :create do
-          log "Here is where I would create a " + thing
-        end
-
-        action_class do
-          def thing
-            return "site"
-          end
-        end
-      })
-    end
-
-    # Create a cookbook with a LRWP
-    #
-    # @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,
-               :use_inline_resources => false }.merge!(lwrp)
-      ruby_default_action = %q{
-        def initialize(*args)
-          super
-          @action = :create
-        end
-      }.strip
-      write_resource("site", %Q{
-        actions :create
-        attribute :name, :kind_of => String, :name_attribute => true
-        #{ruby_default_action if lwrp[:default_action] == :ruby_default_action}
-        #{'default_action :create' if lwrp[:default_action] == :dsl_default_action}
-      })
-      notifications = { :does_notify => "new_resource.updated_by_last_action(true)",
-                        :does_notify_without_parens => "new_resource.updated_by_last_action true",
-                        :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]]}
-        end
-      })
-    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
-    # @param [String] email The maintainer email address
-    def cookbook_with_maintainer(name, email)
-      write_recipe %q{
-        #
-        # Cookbook Name:: example
-        # Recipe:: default
-        #
-        # Copyright 2011, YOUR_COMPANY_NAME
-        #
-        # All rights reserved - Do Not Redistribute
-        #
-      }
-
-      fields = {}
-      fields["maintainer"] = name unless name.nil?
-      fields["maintainer_email"] = email unless email.nil?
-      write_metadata %Q{
-        #{fields.map { |field, value| %Q{#{field}\t"#{value}"} }.join("\n")}
-        license          "All rights reserved"
-        description      "Installs/Configures example"
-        long_description IO.read(File.join(File.dirname(__FILE__), 'README.rdoc'))
-        version          "0.0.1"
-      }
-    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
-      write_file "cookbooks/example/test/attributes/default_spec.rb", %q{
-        describe 'Example::Attributes::Default' do
-        end
-      }
-    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
-    # @param [Hash] options Task options
-    # @option options [String] :name Task name
-    # @option options [String] :files Files to process
-    # @option options [String] :options The options to set on the rake task
-    def rakefile(task, options)
-      rakefile_content = "task :default => []"
-      task_def = case task
-        when :no_block then "FoodCritic::Rake::LintTask.new"
-        else %Q{
-          FoodCritic::Rake::LintTask.new do |t|
-            #{"t.name = '#{options[:name]}'" if options[:name]}
-            #{"t.files = #{options[:files]}" if options[:files]}
-            #{"t.options = #{options[:options]}" if options[:options]}
-          end
-        }
-      end
-      if task_def
-        rakefile_content = %Q{
-          require 'foodcritic'
-          task :default => [:#{options[:name] ? options[:name] : 'foodcritic'}]
-          #{task_def}
-        }
-      end
-      write_file "cookbooks/example/Rakefile", rakefile_content
-    end
-
-    # Create a recipe that downloads a file
-    #
-    # @param [Symbol] path_type The type of path, one of: :tmp_dir, :chef_file_cache_dir, :home_dir
-    def recipe_downloads_file(path_type)
-      download_path = { :tmp_dir => "/tmp/large-file.tar.gz",
-                        :tmp_dir_expr => '/tmp/#{file}',
-                        :home_dir => "/home/ernie/large-file.tar.gz",
-                        :chef_file_cache_dir => '#{Chef::Config[:file_cache_path]}/large-file.tar.gz' }[path_type]
-      write_recipe %Q{
-        remote_file "#{download_path}" do
-          source "http://www.example.org/large-file.tar.gz"
-        end
-      }
-    end
-
-    # Install a gem using the specified approach.
-    #
-    # @param [Symbol] type The type of approach, one of :simple, :compile_time,
-    #   :compile_time_from_array, :compile_time_from_word_list
-    # @param [Symbol] action Either :install or :upgrade
-    def recipe_installs_gem(type, action = :install)
-      case type
-        when :simple
-          write_recipe %Q{
-            gem_package "bluepill" do
-              action :#{action}
-             end
-          }.strip
-        when :compile_time
-          write_recipe %Q{
-            r = gem_package "mysql" do
-              action :nothing
-            end
-
-            r.run_action(:#{action})
-            Gem.clear_paths
-          }.strip
-        when :compile_time_from_array
-          write_recipe %Q{
-            ['foo', 'bar', 'baz'].each do |pkg|
-              r = gem_package pkg do
-                action :nothing
-              end
-              r.run_action(:#{action})
-            end
-          }.strip
-        when :compile_time_from_word_list
-          write_recipe %Q{
-            %w{foo bar baz}.each do |pkg|
-              r = gem_package pkg do
-                action :nothing
-              end
-              r.run_action(:#{action})
-            end
-          }.strip
-        else
-          raise "Unrecognised type: #{type}"
-      end
-    end
-
-    # Create a recipe that declares a resource with the specified file mode.
-    #
-    # @param [String] type The type of resource (file, template)
-    # @param [String] mode The file mode as a string
-    # @param [String] comment Comment that may specify to exclude a match
-    def recipe_resource_with_mode(type, mode, comment = "")
-      source_att = type == "template" ? 'source "foo.erb"' : ""
-      write_recipe %Q{
-        #{type} "/tmp/something" do #{comment}
-          #{source_att}
-          owner "root"
-          group "root"
-          mode #{mode}
-          action :create
-        end
-      }
-    end
-
-    # Create a recipe with an external dependency on another cookbook.
-    #
-    # @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,
-              :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'}"
-      }
-    end
-
-    # Create a recipe with a directory resource
-    #
-    # @param [Symbol] path_expr_type The type of path expression, one of: :compound_symbols, :interpolated_string,
-    #   :interpolated_symbol, :interpolated_symbol_and_literal, :literal_and_interpolated_symbol, :string_literal.
-    def recipe_with_dir_path(path_expr_type)
-      path = { :compound_symbols => '#{node[:base_dir]}#{node[:sub_dir]}', :interpolated_string => %q{#{node['base_dir']}},
-               :interpolated_symbol => '#{node[:base_dir]}', :interpolated_symbol_and_literal => '#{node[:base_dir]}/sub_dir',
-               :literal_and_interpolated_symbol => 'base_dir/#{node[:sub_dir]}', :string_literal => "/var/lib/foo" }[path_expr_type]
-      write_recipe %Q{
-        directory "#{path}" do
-          owner "root"
-          group "root"
-          mode "0755"
-          action :create
-        end
-      }
-    end
-
-    # Create a recipe with the specified resource type and attribute names.
-    #
-    # @param [String] type The type of resource
-    # @param [Array] attribute_names The attributes to declare on this resource
-    def recipe_with_resource(type, attribute_names)
-      write_recipe %Q{
-        #{type} "resource-name" do
-          #{attribute_names.join(" 'foo'\n")} 'bar'
-        end
-      }
-    end
-
-    # Create a recipe with a ruby_block resource.
-    #
-    # @param [Symbol] length A :short or :long block, or :both
-    def recipe_with_ruby_block(length)
-      recipe = ""
-      if length == :short || length == :both
-        recipe << %q{
-          ruby_block "subexpressions" do
-	    block do
-	      rc = Chef::Util::FileEdit.new("/foo/bar.conf")
-              rc.search_file_replace_line(/^search/, "search #{node["foo"]["bar"]} compute-1.internal")
-              rc.search_file_replace_line(/^domain/, "domain #{node["foo"]["bar"]}")
-              rc.write_file
-            end
-            action :create
-          end
-        }
-      end
-      if length == :long || length == :both
-        recipe << %q{
-          ruby_block "too_long" do
-            block do
-              begin
-                do_something('with argument')
-                do_something_else('with another argument')
-                foo = Foo.new('bar')
-                foo.activate_turbo_boost
-                foo.each do |thing|
-                  case thing
-                  when "fee"
-                    puts 'Fee'
-                  when "fi"
-                    puts 'Fi'
-                  when "fo"
-                    puts 'Fo'
-                  else
-                    puts "Fum"
-                  end
-                end
-              rescue Some::Exception
-                Chef::Log.warn "Problem activating the turbo boost"
-              end
-            end
-            action :create
-          end
-        }
-      end
-      write_recipe(recipe)
-    end
-
-    # Create a recipe that performs a search of the specified type.
-    #
-    # @param [Symbol] type The type of search. One of: :invalid_syntax, :valid_syntax, :with_subexpression.
-    def recipe_with_search(type)
-      search = { :invalid_syntax => "run_list:recipe[foo::bar]", :valid_syntax => 'run_list:recipe\[foo\:\:bar\]',
-                 :with_subexpression => %q{roles:#{node['foo']['role']}} }[type]
-      write_recipe %Q{
-        search(:node, "#{search}") do |matching_node|
-          puts matching_node.to_s
-        end
-      }
-    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
-    # @param [String] to_version The to version
-    def rule_with_version_constraint(from_version, to_version)
-      constraint = if from_version && to_version
-                     %Q{
-                       applies_to do |version|
-                         version >= gem_version("#{from_version}") && version <= gem_version("#{to_version}")
-                       end
-                     }
-                   elsif from_version
-                     %Q{
-                       applies_to do |version|
-                         version >= gem_version("#{from_version}")
-                       end
-                     }
-                   elsif to_version
-                     %Q{
-                       applies_to do |version|
-                         version <= gem_version("#{to_version}")
-                       end
-                     }
-      end
-      write_rule %Q{
-        rule "FCTEST001", "Test Rule" do
-          #{constraint}
-          recipe do |ast, filename|
-            [file_match(filename)]
-          end
-        end
-      }
-    end
-
-    # Return the provided string or nil if 'unspecified'
-    #
-    # @param [String] str The string
-    # @return [String] The string or nil if 'unspecified'
-    def nil_if_unspecified(str)
-      str == "unspecified" ? nil : str
-    end
-
-    # Create a README with the provided content.
-    #
-    # @param [String] content The recipe content.
-    # @param [String] cookbook_name Optional name of the cookbook.
-    def write_readme(content, cookbook_name = "example")
-      write_file "cookbooks/#{cookbook_name}/README.md", content.strip
-    end
-
-    # Create a recipe with the provided content.
-    #
-    # @param [String] content The recipe content.
-    # @param [String] cookbook_name Optional name of the cookbook.
-    def write_recipe(content, cookbook_name = "example")
-      write_file "cookbooks/#{cookbook_name}/recipes/default.rb", content.strip
-    end
-
-    # Create a rule with the provided content.
-    #
-    # @param [String] content The rule content.
-    def write_rule(content)
-      write_file "rules/test.rb", content.strip
-    end
-
-    # Create attributes with the provided content.
-    #
-    # @param [String] content The attributes content.
-    def write_attributes(content)
-      write_file "cookbooks/example/attributes/default.rb", content.strip
-    end
-
-    # Create a definition with the provided content.
-    #
-    # @param [String] name The definition name.
-    # @param [String] content The definition content.
-    def write_definition(name, content)
-      write_file "cookbooks/example/definitions/#{name}.rb", content.strip
-    end
-
-    # Create a library with the provided content.
-    #
-    # @param [String] name The library name.
-    # @param [String] content The library content.
-    def write_library(name, content)
-      write_file "cookbooks/example/libraries/#{name}.rb", content.strip
-    end
-
-    # Create metdata with the provided content.
-    #
-    # @param [String] content The metadata content.
-    def write_metadata(content)
-      write_file "cookbooks/example/metadata.rb", content.strip
-    end
-
-    # Create a resource with the provided content.
-    #
-    # @param [String] name The resource name.
-    # @param [String] content The resource content.
-    def write_resource(name, content)
-      write_file "cookbooks/example/resources/#{name}.rb", content.strip
-    end
-
-    # Create a provider with the provided content.
-    #
-    # @param [String] name The resource name.
-    # @param [String] content The resource content.
-    def write_provider(name, content)
-      write_file "cookbooks/example/providers/#{name}.rb", content.strip
-    end
-
-  end
-
-end
-
-World(FoodCritic::CookbookHelpers)