has_finder 0.1.1

data/spec/rails/vendor/plugins/rspec/lib/spec/rake/verify_rcov.rb

@@ -0,0 +1,52 @@
+module RCov
+  # A task that can verify that the RCov coverage doesn't
+  # drop below a certain threshold. It should be run after
+  # running Spec::Rake::SpecTask.
+  class VerifyTask < Rake::TaskLib
+    # Name of the task. Defaults to :verify_rcov
+    attr_accessor :name
+    
+    # Path to the index.html file generated by RCov, which
+    # is the file containing the total coverage.
+    # Defaults to 'coverage/index.html'
+    attr_accessor :index_html
+    
+    # Whether or not to output details. Defaults to true.
+    attr_accessor :verbose
+    
+    # The threshold value (in percent) for coverage. If the 
+    # actual coverage is not equal to this value, the task will raise an 
+    # exception. 
+    attr_accessor :threshold
+    
+    # Require the threshold value be met exactly.  This is the default.
+    attr_accessor :require_exact_threshold
+    
+    def initialize(name=:verify_rcov)
+      @name = name
+      @index_html = 'coverage/index.html'
+      @verbose = true
+      @require_exact_threshold = true
+      yield self if block_given?
+      raise "Threshold must be set" if @threshold.nil?
+      define
+    end
+    
+    def define
+      desc "Verify that rcov coverage is at least #{threshold}%"
+      task @name do
+        total_coverage = nil
+
+        File.open(index_html).each_line do |line|
+          if line =~ /<tt.*>(\d+\.\d+)%<\/tt>&nbsp;<\/td>/
+            total_coverage = eval($1)
+            break
+          end
+        end
+        puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
+        raise "Coverage must be at least #{threshold}% but was #{total_coverage}%" if total_coverage < threshold
+        raise "Coverage has increased above the threshold of #{threshold}% to #{total_coverage}%. You should update your threshold value." if (total_coverage > threshold) and require_exact_threshold
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner.rb

@@ -0,0 +1,165 @@
+require 'spec/runner/formatter'
+require 'spec/runner/behaviour_runner'
+require 'spec/runner/options'
+require 'spec/runner/option_parser'
+require 'spec/runner/command_line'
+require 'spec/runner/drb_command_line'
+require 'spec/runner/backtrace_tweaker'
+require 'spec/runner/reporter'
+require 'spec/runner/extensions/object'
+require 'spec/runner/extensions/kernel'
+require 'spec/runner/spec_parser'
+
+module Spec
+  # == Behaviours and Examples
+  # 
+  # Rather than expressing examples in classes, RSpec uses a custom domain specific language to 
+  # describe Behaviours and Examples of those behaviours.
+  # 
+  # A Behaviour is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context
+  # in which you will run your executable example - a set of known objects in a known starting state.
+  # We begin be describing
+  # 
+  #   describe Account do
+  # 
+  #     before do
+  #       @account = Account.new
+  #     end
+  # 
+  #     it "should have a balance of $0" do
+  #       @account.balance.should == Money.new(0, :dollars)
+  #     end
+  # 
+  #   end
+  # 
+  # We use the before block to set up the Behaviour (given), and then the #it method to
+  # hold the example code that expresses the event (when) and the expected outcome (then).
+  # 
+  # == Helper Methods
+  # 
+  # A primary goal of RSpec is to keep the examples clear. We therefore prefer
+  # less indirection than you might see in xUnit examples and in well factored, DRY production code. We feel
+  # that duplication is OK if removing it makes it harder to understand an example without
+  # having to look elsewhere to understand its context.
+  # 
+  # That said, RSpec does support some level of encapsulating common code in helper
+  # methods that can exist within a context or within an included module.
+  # 
+  # == Setup and Teardown
+  # 
+  # You can use before and after within a Behaviour. Both methods take an optional
+  # scope argument so you can run the block before :each example or before :all examples
+  # 
+  #   describe "..." do
+  #     before :all do
+  #       ...
+  #     end
+  # 
+  #     before :each do
+  #       ...
+  #     end
+  # 
+  #     it "should do something" do
+  #       ...
+  #     end
+  # 
+  #     it "should do something else" do
+  #       ...
+  #     end
+  # 
+  #     after :each do
+  #       ...
+  #     end
+  # 
+  #     after :all do
+  #       ...
+  #     end
+  # 
+  #   end
+  # 
+  # The <tt>before :each</tt> block will run before each of the examples, once for each example. Likewise,
+  # the <tt>after :each</tt> block will run after each of the examples.
+  # 
+  # It is also possible to specify a <tt>before :all</tt> and <tt>after :all</tt>
+  # block that will run only once for each behaviour, respectively before the first <code>before :each</code>
+  # and after the last <code>after :each</code>. The use of these is generally discouraged, because it
+  # introduces dependencies between the examples. Still, it might prove useful for very expensive operations
+  # if you know what you are doing.
+  # 
+  # == Local helper methods
+  # 
+  # You can include local helper methods by simply expressing them within a context:
+  # 
+  #   describe "..." do
+  #   
+  #     it "..." do
+  #       helper_method
+  #     end
+  # 
+  #     def helper_method
+  #       ...
+  #     end
+  # 
+  #   end
+  # 
+  # == Included helper methods
+  # 
+  # You can include helper methods in multiple contexts by expressing them within
+  # a module, and then including that module in your context:
+  # 
+  #   module AccountExampleHelperMethods
+  #     def helper_method
+  #       ...
+  #     end
+  #   end
+  # 
+  #   describe "A new account" do
+  #     include AccountExampleHelperMethods
+  #     before do
+  #       @account = Account.new
+  #     end
+  # 
+  #     it "should have a balance of $0" do
+  #       helper_method
+  #       @account.balance.should eql(Money.new(0, :dollars))
+  #     end
+  #   end
+  # 
+  # == Shared behaviour
+  # 
+  # You can define a shared behaviour, that may be used on other behaviours
+  #
+  #  describe "All Editions", :shared => true do
+  #    it "all editions behaviour" ...
+  #  end
+  #
+  #  describe SmallEdition do
+  #    it_should_behave_like "All Editions"
+  #  
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
+  module Runner
+    class << self
+      def configuration # :nodoc:
+        @configuration ||= Spec::DSL::Configuration.new
+      end
+      
+      # Use this to configure various configurable aspects of
+      # RSpec:
+      #
+      #   Spec::Runner.configure do |configuration|
+      #     # Configure RSpec here
+      #   end
+      #
+      # The yielded <tt>configuration</tt> object is a
+      # Spec::DSL::Configuration instance. See its RDoc
+      # for details about what you can do with it.
+      #
+      def configure
+        yield configuration if @configuration.nil?
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner/backtrace_tweaker.rb

@@ -0,0 +1,56 @@
+module Spec
+  module Runner
+    class BacktraceTweaker
+      def clean_up_double_slashes(line)
+        line.gsub!('//','/')
+      end
+    end
+
+    class NoisyBacktraceTweaker < BacktraceTweaker
+      def tweak_backtrace(error, spec_name)
+        return if error.backtrace.nil?
+        error.backtrace.each do |line|
+          clean_up_double_slashes(line)
+        end
+      end
+    end
+
+    # Tweaks raised Exceptions to mask noisy (unneeded) parts of the backtrace
+    class QuietBacktraceTweaker < BacktraceTweaker
+      unless defined?(IGNORE_PATTERNS)
+        root_dir = File.expand_path(File.join(__FILE__, '..', '..', '..', '..'))
+        spec_files = Dir["#{root_dir}/lib/spec/*"].map do |path| 
+          subpath = path[root_dir.length..-1]
+          /#{subpath}/
+        end
+        IGNORE_PATTERNS = spec_files + [
+          /\/lib\/ruby\//,
+          /bin\/spec:/,
+          /bin\/rcov:/,
+          /lib\/rspec_on_rails/,
+          /vendor\/rails/,
+          # TextMate's Ruby and RSpec plugins
+          /Ruby\.tmbundle\/Support\/tmruby.rb:/,
+          /RSpec\.tmbundle\/Support\/lib/,
+          /temp_textmate\./,
+          /mock_frameworks\/rspec/
+        ]
+      end
+      
+      def tweak_backtrace(error, spec_name)
+        return if error.backtrace.nil?
+        error.backtrace.collect! do |line|
+          clean_up_double_slashes(line)
+          IGNORE_PATTERNS.each do |ignore|
+            if line =~ ignore
+              line = nil
+              break
+            end
+          end
+          line
+        end
+        error.backtrace.compact!
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner/behaviour_runner.rb

@@ -0,0 +1,102 @@
+module Spec
+  module Runner
+    class BehaviourRunner
+      
+      def initialize(options)
+        @behaviours = []
+        @options = options
+      end
+    
+      def add_behaviour(behaviour)
+        if !specified_examples.nil? && !specified_examples.empty? #&& behaviour.matches?(specified_examples)
+          behaviour.retain_examples_matching!(specified_examples) #if behaviour.matches?(specified_examples)
+        end
+        @behaviours << behaviour if behaviour.number_of_examples != 0 && !behaviour.shared?
+      end
+      
+      # Runs all contexts and returns the number of failures.
+      def run(paths, exit_when_done)
+        unless paths.nil? # It's nil when running single specs with ruby
+          paths = find_paths(paths)
+          sorted_paths = sort_paths(paths)
+          load_specs(sorted_paths) 
+        end
+        @options.reporter.start(number_of_examples)
+        behaviours = @options.reverse ? @behaviours.reverse : @behaviours
+        begin
+          run_behaviours(behaviours)
+        rescue Interrupt
+        ensure
+          @options.reporter.end
+        end
+        failure_count = @options.reporter.dump
+        
+        heckle if(failure_count == 0 && !@options.heckle_runner.nil?)
+        
+        if(exit_when_done)
+          exit_code = (failure_count == 0) ? 0 : 1
+          exit(exit_code)
+        end
+        failure_count
+      end
+
+      def run_behaviours(behaviours)
+        behaviours.each do |behaviour|
+          behaviour.run(@options.reporter, @options.dry_run, @options.reverse, @options.timeout)
+        end
+      end
+    
+      def number_of_examples
+        @behaviours.inject(0) {|sum, behaviour| sum + behaviour.number_of_examples}
+      end
+      
+      FILE_SORTERS = {
+        'mtime' => lambda {|file_a, file_b| File.mtime(file_b) <=> File.mtime(file_a)}
+      }
+      
+      def sorter(paths)
+        FILE_SORTERS[@options.loadby]
+      end
+      
+      def sort_paths(paths)
+        sorter = sorter(paths)
+        paths = paths.sort(&sorter) unless sorter.nil?
+        paths
+      end
+
+    private
+      
+      def find_paths(paths)
+        result = []
+        paths.each do |path|
+          if File.directory?(path)
+            result += Dir["#{path}/**/*.rb"]
+          elsif File.file?(path)
+            result << path
+          else
+            raise "File or directory not found: #{path}"
+          end
+        end
+        result
+      end
+      
+      def load_specs(paths)
+        paths.each do |path|
+          load path
+        end
+      end
+      
+      def specified_examples
+        @options.examples
+      end
+      
+      def heckle
+        heckle_runner = @options.heckle_runner
+        @options.heckle_runner = nil
+        behaviour_runner = self.class.new(@options)
+        behaviour_runner.instance_variable_set(:@behaviours, @behaviours)
+        heckle_runner.heckle_with(behaviour_runner)
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner/command_line.rb

@@ -0,0 +1,22 @@
+require 'spec/runner/option_parser'
+
+module Spec
+  module Runner
+    # Facade to run specs without having to fork a new ruby process (using `spec ...`)
+    class CommandLine
+      # Runs specs. +argv+ is the commandline args as per the spec commandline API, +err+ 
+      # and +out+ are the streams output will be written to. +exit+ tells whether or
+      # not a system exit should be called after the specs are run and
+      # +warn_if_no_files+ tells whether or not a warning (the help message)
+      # should be printed to +err+ in case no files are specified.
+      def self.run(argv, err, out, exit=true, warn_if_no_files=true)
+        old_behaviour_runner = defined?($behaviour_runner) ? $behaviour_runner : nil
+        $behaviour_runner = OptionParser.new.create_behaviour_runner(argv, err, out, warn_if_no_files)
+        return if $behaviour_runner.nil? # This is the case if we use --drb
+
+        $behaviour_runner.run(argv, exit)
+        $behaviour_runner = old_behaviour_runner
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner/drb_command_line.rb

@@ -0,0 +1,21 @@
+require "drb/drb"
+
+module Spec
+  module Runner
+    # Facade to run specs by connecting to a DRB server
+    class DrbCommandLine
+      # Runs specs on a DRB server. Note that this API is similar to that of
+      # CommandLine - making it possible for clients to use both interchangeably.
+      def self.run(argv, stderr, stdout, exit=true, warn_if_no_files=true)
+        begin
+          DRb.start_service
+          spec_server = DRbObject.new_with_uri("druby://localhost:8989")
+          spec_server.run(argv, stderr, stdout)
+        rescue DRb::DRbConnError
+          stderr.puts "No server is running"
+          exit 1 if exit
+        end
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec/lib/spec/runner/extensions/kernel.rb

@@ -0,0 +1,50 @@
+module Kernel
+  # Creates and registers an instance of a Spec::DSL::Behaviour (or a subclass).
+  # The instantiated behaviour class depends on the directory of the file
+  # calling this method. For example, Spec::Rails will use different
+  # classes for specs living in <tt>spec/models</tt>, <tt>spec/helpers</tt>, 
+  # <tt>spec/views</tt> and <tt>spec/controllers</tt>.
+  #
+  # It is also possible to override autodiscovery of the behaviour class 
+  # with an options Hash as the last argument:
+  #
+  #   describe "name", :behaviour_type => :something_special do ...
+  #
+  # The reason for using different behaviour classes is to have
+  # different matcher methods available from within the <tt>describe</tt>
+  # block.
+  #
+  # See Spec::DSL::BehaviourFactory#add_behaviour_class for details about 
+  # how to register special Spec::DSL::Behaviour implementations.
+  #
+  def describe(*args, &block)
+    raise ArgumentError if args.empty?
+    args << {} unless Hash === args.last
+    args.last[:spec_path] = caller(0)[1]
+    register_behaviour(Spec::DSL::BehaviourFactory.create(*args, &block))
+  end
+  alias :context :describe
+  
+  def respond_to(*names)
+    Spec::Matchers::RespondTo.new(*names)
+  end
+  
+private
+
+  def register_behaviour(behaviour)
+    if behaviour.shared?
+      Spec::DSL::Behaviour.add_shared_behaviour(behaviour)
+    else
+      behaviour_runner.add_behaviour(behaviour)
+    end
+  end
+
+  def behaviour_runner
+    # TODO: Figure out a better way to get this considered "covered" and keep this statement on multiple lines 
+    unless $behaviour_runner; \
+      $behaviour_runner = ::Spec::Runner::OptionParser.new.create_behaviour_runner(ARGV.dup, STDERR, STDOUT, false); \
+      at_exit { $behaviour_runner.run(nil, false) }; \
+    end
+    $behaviour_runner
+  end
+end