dchelimsky-rspec 1.1.10

data/lib/spec/rake/spectask.rb

@@ -0,0 +1,227 @@
+#!/usr/bin/env ruby
+
+# Define a task library for running RSpec contexts.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Spec
+  module Rake
+
+    # A Rake task that runs a set of specs.
+    #
+    # Example:
+    #
+    #   Spec::Rake::SpecTask.new do |t|
+    #     t.warning = true
+    #     t.rcov = true
+    #   end
+    #
+    # This will create a task that can be run with:
+    #
+    #   rake spec
+    #
+    # If rake is invoked with a "SPEC=filename" command line option,
+    # then the list of spec files will be overridden to include only the
+    # filename specified on the command line.  This provides an easy way
+    # to run just one spec.
+    #
+    # If rake is invoked with a "SPEC_OPTS=options" command line option,
+    # then the given options will override the value of the +spec_opts+
+    # attribute.
+    #
+    # If rake is invoked with a "RCOV_OPTS=options" command line option,
+    # then the given options will override the value of the +rcov_opts+
+    # attribute.
+    #
+    # Examples:
+    #
+    #   rake spec                                      # run specs normally
+    #   rake spec SPEC=just_one_file.rb                # run just one spec file.
+    #   rake spec SPEC_OPTS="--diff"                   # enable diffing
+    #   rake spec RCOV_OPTS="--aggregate myfile.txt"   # see rcov --help for details
+    #
+    # Each attribute of this task may be a proc. This allows for lazy evaluation,
+    # which is sometimes handy if you want to defer the evaluation of an attribute value
+    # until the task is run (as opposed to when it is defined).
+    #
+    # This task can also be used to run existing Test::Unit tests and get RSpec
+    # output, for example like this:
+    #
+    #   require 'rubygems'
+    #   require 'spec/rake/spectask'
+    #   Spec::Rake::SpecTask.new do |t|
+    #     t.ruby_opts = ['-rtest/unit']
+    #     t.spec_files = FileList['test/**/*_test.rb']
+    #   end
+    #
+    class SpecTask < ::Rake::TaskLib
+      class << self
+        def attr_accessor(*names)
+          super(*names)
+          names.each do |name|
+            module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs
+          end
+        end
+      end
+
+      # Name of spec task. (default is :spec)
+      attr_accessor :name
+
+      # Array of directories to be added to $LOAD_PATH before running the
+      # specs. Defaults to ['<the absolute path to RSpec's lib directory>']
+      attr_accessor :libs
+
+      # If true, requests that the specs be run with the warning flag set.
+      # E.g. warning=true implies "ruby -w" used to run the specs. Defaults to false.
+      attr_accessor :warning
+
+      # Glob pattern to match spec files. (default is 'spec/**/*_spec.rb')
+      # Setting the SPEC environment variable overrides this.
+      attr_accessor :pattern
+
+      # Array of commandline options to pass to RSpec. Defaults to [].
+      # Setting the SPEC_OPTS environment variable overrides this.
+      attr_accessor :spec_opts
+
+      # Whether or not to use RCov (default is false)
+      # See http://eigenclass.org/hiki.rb?rcov
+      attr_accessor :rcov
+
+      # Array of commandline options to pass to RCov. Defaults to ['--exclude', 'lib\/spec,bin\/spec'].
+      # Ignored if rcov=false
+      # Setting the RCOV_OPTS environment variable overrides this.
+      attr_accessor :rcov_opts
+
+      # Directory where the RCov report is written. Defaults to "coverage"
+      # Ignored if rcov=false
+      attr_accessor :rcov_dir
+
+      # Array of commandline options to pass to ruby. Defaults to [].
+      attr_accessor :ruby_opts
+
+      # Whether or not to fail Rake when an error occurs (typically when specs fail).
+      # Defaults to true.
+      attr_accessor :fail_on_error
+
+      # A message to print to stderr when there are failures.
+      attr_accessor :failure_message
+
+      # Where RSpec's output is written. Defaults to $stdout.
+      # DEPRECATED. Use --format FORMAT:WHERE in spec_opts.
+      attr_accessor :out
+
+      # Explicitly define the list of spec files to be included in a
+      # spec.  +spec_files+ is expected to be an array of file names (a
+      # FileList is acceptable).  If both +pattern+ and +spec_files+ are
+      # used, then the list of spec files is the union of the two.
+      # Setting the SPEC environment variable overrides this.
+      attr_accessor :spec_files
+
+      # Use verbose output. If this is set to true, the task will print
+      # the executed spec command to stdout. Defaults to false.
+      attr_accessor :verbose
+
+      # Defines a new task, using the name +name+.
+      def initialize(name=:spec)
+        @name = name
+        @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
+        @pattern = nil
+        @spec_files = nil
+        @spec_opts = []
+        @warning = false
+        @ruby_opts = []
+        @fail_on_error = true
+        @rcov = false
+        @rcov_opts = ['--exclude', 'lib\/spec,bin\/spec,config\/boot.rb']
+        @rcov_dir = "coverage"
+
+        yield self if block_given?
+        @pattern = 'spec/**/*_spec.rb' if pattern.nil? && spec_files.nil?
+        define
+      end
+
+      def define # :nodoc:
+        spec_script = File.expand_path(File.dirname(__FILE__) + '/../../../bin/spec')
+
+        lib_path = libs.join(File::PATH_SEPARATOR)
+        actual_name = Hash === name ? name.keys.first : name
+        unless ::Rake.application.last_comment
+          desc "Run specs" + (rcov ? " using RCov" : "")
+        end
+        task name do
+          RakeFileUtils.verbose(verbose) do
+            unless spec_file_list.empty?
+              # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- examples [spec_opts]
+              # or
+              # ruby [ruby_opts] -Ilib bin/spec examples [spec_opts]
+              cmd_parts = [RUBY]
+              cmd_parts += ruby_opts
+              cmd_parts << %[-I"#{lib_path}"]
+              cmd_parts << "-S rcov" if rcov
+              cmd_parts << "-w" if warning
+              cmd_parts << rcov_option_list
+              cmd_parts << %[-o "#{rcov_dir}"] if rcov
+              cmd_parts << %["#{spec_script}"]
+              cmd_parts << "--" if rcov
+              cmd_parts += spec_file_list.collect { |fn| %["#{fn}"] }
+              cmd_parts << spec_option_list
+              if out
+                cmd_parts << %[> "#{out}"]
+                STDERR.puts "The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead."
+              end
+              cmd = cmd_parts.join(" ")
+              puts cmd if verbose
+              unless system(cmd)
+                STDERR.puts failure_message if failure_message
+                raise("Command #{cmd} failed") if fail_on_error
+              end
+            end
+          end
+        end
+
+        if rcov
+          desc "Remove rcov products for #{actual_name}"
+          task paste("clobber_", actual_name) do
+            rm_r rcov_dir rescue nil
+          end
+
+          clobber_task = paste("clobber_", actual_name)
+          task :clobber => [clobber_task]
+
+          task actual_name => clobber_task
+        end
+        self
+      end
+
+      def rcov_option_list # :nodoc:
+        return "" unless rcov
+        ENV['RCOV_OPTS'] || rcov_opts.join(" ") || ""
+      end
+
+      def spec_option_list # :nodoc:
+        STDERR.puts "RSPECOPTS is DEPRECATED and will be removed in a future version. Use SPEC_OPTS instead." if ENV['RSPECOPTS']
+        ENV['SPEC_OPTS'] || ENV['RSPECOPTS'] || spec_opts.join(" ") || ""
+      end
+
+      def evaluate(o) # :nodoc:
+        case o
+          when Proc then o.call
+          else o
+        end
+      end
+
+      def spec_file_list # :nodoc:
+        if ENV['SPEC']
+          FileList[ ENV['SPEC'] ]
+        else
+          result = []
+          result += spec_files.to_a if spec_files
+          result += FileList[ pattern ].to_a if pattern
+          FileList[result]
+        end
+      end
+
+    end
+  end
+end

data/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 = 0
+
+        File.open(index_html).each_line do |line|
+          if line =~ /<tt class='coverage_total'>\s*(\d+\.\d+)%\s*<\/tt>/
+            total_coverage = $1.to_f
+            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/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)
+        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/*"].map do |path| 
+          subpath = path[root_dir.length..-1]
+          /#{subpath}/
+        end
+        IGNORE_PATTERNS = spec_files + [
+          /\/lib\/ruby\//,
+          /bin\/spec:/,
+          /bin\/rcov:/,
+          /lib\/rspec-rails/,
+          /vendor\/rails/,
+          # TextMate's Ruby and RSpec plugins
+          /Ruby\.tmbundle\/Support\/tmruby.rb:/,
+          /RSpec\.tmbundle\/Support\/lib/,
+          /temp_textmate\./,
+          /mock_frameworks\/rspec/,
+          /spec_server/
+        ]
+      end
+      
+      def tweak_backtrace(error)
+        return if error.backtrace.nil?
+        error.backtrace.collect! do |message|
+          clean_up_double_slashes(message)
+          kept_lines = message.split("\n").select do |line|
+            IGNORE_PATTERNS.each do |ignore|
+              break if line =~ ignore
+            end
+          end
+          kept_lines.empty?? nil : kept_lines.join("\n")
+        end
+        error.backtrace.compact!
+      end
+    end
+  end
+end

data/lib/spec/runner/class_and_arguments_parser.rb

@@ -0,0 +1,16 @@
+module Spec
+  module Runner
+    class ClassAndArgumentsParser
+      class << self
+        def parse(s)
+          if s =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/
+            arg = $2 == "" ? nil : $2
+            [$1, arg]
+          else
+            raise "Couldn't parse #{s.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/command_line.rb

@@ -0,0 +1,17 @@
+require 'spec/runner/option_parser'
+
+module Spec
+  module Runner
+    class CommandLine
+      class << self
+        def run(tmp_options=Spec::Runner.options)
+          orig_options = Spec::Runner.options
+          Spec::Runner.use tmp_options
+          tmp_options.run_examples
+        ensure
+          Spec::Runner.use orig_options
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/drb_command_line.rb

@@ -0,0 +1,20 @@
+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(options)
+        begin
+          DRb.start_service
+          spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989")
+          spec_server.run(options.argv, options.error_stream, options.output_stream)
+        rescue DRb::DRbConnError => e
+          options.error_stream.puts "No server is running"
+        end
+      end
+    end
+  end
+end

data/lib/spec/runner/example_group_runner.rb

@@ -0,0 +1,59 @@
+module Spec
+  module Runner
+    class ExampleGroupRunner
+      def initialize(options)
+        @options = options
+      end
+
+      def load_files(files)
+        # It's important that loading files (or choosing not to) stays the
+        # responsibility of the ExampleGroupRunner. Some implementations (like)
+        # the one using DRb may choose *not* to load files, but instead tell
+        # someone else to do it over the wire.
+        files.each do |file|
+          load file
+        end
+      end
+
+      def run
+        prepare
+        success = true
+        example_groups.each do |example_group|
+          success = success & example_group.run
+        end
+        return success
+      ensure
+        finish
+      end
+
+      protected
+      def prepare
+        reporter.start(number_of_examples)
+        example_groups.reverse! if reverse
+      end
+
+      def finish
+        reporter.end
+        reporter.dump
+      end
+
+      def reporter
+        @options.reporter
+      end
+
+      def reverse
+        @options.reverse
+      end
+
+      def example_groups
+        @options.example_groups
+      end
+
+      def number_of_examples
+        @options.number_of_examples
+      end
+    end
+    # TODO: BT - Deprecate BehaviourRunner?
+    BehaviourRunner = ExampleGroupRunner
+  end
+end