foodcritic 2.1.0 → 2.2.0

data/features/support/command_helpers.rb

@@ -0,0 +1,312 @@
+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
+
+    # The warning codes and messages displayed to the end user.
+    WARNINGS = {
+      'FC002' => 'Avoid string interpolation where not required',
+      'FC003' => 'Check whether you are running with chef server before using server-specific features',
+      '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',
+      'FC012' => 'Use Markdown for README rather than RDoc',
+      '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 LWRP',
+      'FC016' => 'LWRP does not declare a default action',
+      'FC017' => 'LWRP does not notify when updated',
+      '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',
+      'FC023' => 'Prefer conditional attributes',
+      'FC024' => 'Consider adding platform equivalents',
+      'FC025' => 'Prefer chef_gem to compile-time gem install',
+      'FC026' => 'Conditional execution block attribute contains only string',
+      '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 file',
+      'FC032' => 'Invalid notification timing',
+      'FC033' => 'Missing template',
+      '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' => 'Consider setting cookbook name in metadata',
+      'FC046' => 'Attribute assignment uses assign unless nil',
+      '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') and ENV['FC_FORK_PROCESS'] == true.to_s)
+    end
+
+    # Capture an error expected when calling a command.
+    def capture_error
+      begin
+        yield
+        @error = all_output unless last_exit_status == 0
+      rescue => @error
+      end
+    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)
+      if options[:warning_only]
+        warning = "#{code}: #{WARNINGS[code]}"
+      else
+        warning = "#{code}: #{WARNINGS[code]}: cookbooks/example/#{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
+
+    # Assert that the usage message is displayed.
+    #
+    # @param [Boolean] is_exit_zero The exit code to check for.
+    def usage_displayed(is_exit_zero)
+      expect_output 'foodcritic [cookbook_paths]'
+      expect_usage_option('c', 'chef-version VERSION', 'Only check against rules valid for this version of Chef.')
+      expect_usage_option('f', 'epic-fail TAGS',
+        "Fail the build if any of the specified tags are matched ('any' -> fail on any match).")
+      expect_usage_option('t', 'tags TAGS', 'Only check against rules with the specified tags.')
+      expect_usage_option('C', '[no-]context', 'Show lines matched against rather than the default summary.')
+      expect_usage_option('I', 'include PATH', 'Additional rule file path(s) to load.')
+      expect_usage_option('S', 'search-grammar PATH', 'Specify grammar to use when validating search syntax.')
+      expect_usage_option('V', 'version', 'Display the foodcritic version.')
+      if is_exit_zero
+        assert_no_error_occurred
+      else
+        assert_error_occurred
+      end
+    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.should match(output)
+      else
+        @review.should 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.should_not match(output)
+      else
+        @review.should_not include(output)
+      end
+    end
+
+    # Assert that an error occurred following a lint check.
+    def assert_error_occurred
+      @status.should_not == 0
+    end
+
+    # Assert that no error occurred following a lint check.
+    def assert_no_error_occurred
+      @status.should == 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)
+      in_current_dir do
+        show_context = cmd_args.include?('-C')
+        review, @status = FoodCritic::Linter.check(CommandLine.new(cmd_args))
+        @review =
+          if review.nil? || (review.respond_to?(:warnings) && review.warnings.empty?)
+            ''
+          elsif show_context
+            ContextOutput.new.output(review)
+          else
+            "#{review.to_s}\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
+      all_output.split("\n").grep(/FC[0-9]+:/).map do |warn|
+        File.basename(File.dirname(warn.split(':').take(3).last.strip))
+      end.should_not include 'test'
+    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

@@ -0,0 +1,495 @@
+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 :rubygems
+        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, FC003 and FC004 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 == 'FC003'
+          recipe += %Q{nodes = search(:node, "hostname:[* TO *]")\n}
+        elsif code == 'FC004'
+          recipe += %q{
+            execute "stop-jetty" do
+              command "/etc/init.d/jetty6 stop"
+              action :run
+            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('name "example"') # Don't trigger FC031
+    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
+    def cookbook_with_lwrp(lwrp)
+      lwrp = {:default_action => false, :notifies => :does_not_notify}.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{
+        action :create do
+          log "Here is where I would create a site"
+          #{notifications[lwrp[:notifies]]}
+        end
+      })
+    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 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
+
+    # 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
+          fail "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 that controls a service using the specified method.
+    #
+    # @param [Symbol] method How to start the service, one of: :init_d, :invoke_rc_d, :upstart, :service, :service_full_path.
+    # @param [Boolean] do_sleep Whether to prefix the service cmd with a bash sleep
+    # @param [Symbol] action The action to take (start, stop, reload, restart)
+    def recipe_controls_service(method = :service, do_sleep = false, action = :start)
+      cmds = {:init_d => "/etc/init.d/foo #{action}", :invoke_rc_d => "invoke-rc.d foo #{action}", :upstart => "#{action} foo",
+              :service => "service foo #{action}", :service_full_path => "/sbin/service foo #{action}"}
+      write_recipe %Q{
+        execute "#{action}-foo-service" do
+          command "#{do_sleep ? 'sleep 5; ' : ''}#{cmds[method]}"
+          action :run
+        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
+    def recipe_with_dependency(dep)
+      dep = {:is_scoped => true, :is_declared => true}.merge!(dep)
+      write_recipe %Q{
+        include_recipe 'foo#{dep[:is_scoped] ? '::default' : ''}'
+      }
+      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 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)