pupu 0.0.1

data/vendor/rspec/lib/spec/rake/spectask.rb

@@ -0,0 +1,230 @@
+#!/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 '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
+      def self.attr_accessor(*names)
+        super(*names)
+        names.each do |name|
+          module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs
+        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
+
+      # Explicitly define the path to the ruby binary, or its proxy (e.g. multiruby)
+      attr_accessor :ruby_cmd
+
+      # Defines a new task, using the name +name+.
+      def initialize(name=:spec)
+        @name = name
+        @libs = ['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.join(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 || 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:
+        if rcov
+          ENV['RCOV_OPTS'] || rcov_opts.join(" ") || ""
+        else
+          ""
+        end
+      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/vendor/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 = 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/vendor/rspec/lib/spec/ruby.rb

@@ -0,0 +1,9 @@
+module Spec
+  module Ruby
+    class << self
+      def version
+        RUBY_VERSION
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'spec/runner/configuration'
+require 'spec/runner/options'
+require 'spec/runner/option_parser'
+require 'spec/runner/example_group_runner'
+require 'spec/runner/command_line'
+require 'spec/runner/drb_command_line'
+require 'spec/runner/backtrace_tweaker'
+require 'spec/runner/reporter'
+require 'spec/runner/line_number_query'
+require 'spec/runner/class_and_arguments_parser'
+require 'spec/runner/extensions/kernel'
+
+module Spec
+  module Runner
+    
+    class ExampleGroupCreationListener
+      def register_example_group(klass)
+        Spec::Runner.options.add_example_group klass
+      end
+    end
+    
+    Spec::Example::ExampleGroupFactory.example_group_creation_listeners << ExampleGroupCreationListener.new
+    
+    class << self
+      def configuration # :nodoc:
+        @configuration ||= Spec::Runner::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::Runner::Configuration instance. See its RDoc
+      # for details about what you can do with it.
+      #
+      def configure
+        yield configuration
+      end
+      
+      def autorun # :nodoc:
+        at_exit {exit run unless $!}
+      end
+
+      def options # :nodoc:
+        @options ||= begin
+          parser = ::Spec::Runner::OptionParser.new($stderr, $stdout)
+          parser.order!(ARGV)
+          parser.options
+        end
+      end
+    
+      def use options
+        @options = options
+      end
+
+      def run
+        options.examples_run? || options.run_examples
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Spec
+  module Runner
+    class BacktraceTweaker
+      def initialize(*patterns)
+        @ignore_patterns = []
+      end
+
+      def clean_up_double_slashes(line)
+        line.gsub!('//','/')
+      end
+
+      def ignore_patterns(*patterns)
+        # do nothing. Only QuietBacktraceTweaker ignores patterns.
+      end
+
+      def ignored_patterns
+        []
+      end
+
+      def tweak_backtrace(error)
+        return if error.backtrace.nil?
+        tweaked = error.backtrace.collect do |message|
+          clean_up_double_slashes(message)
+          kept_lines = message.split("\n").select do |line|
+            ignored_patterns.each do |ignore|
+              break if line =~ ignore
+            end
+          end
+          kept_lines.empty?? nil : kept_lines.join("\n")
+        end
+        error.set_backtrace(tweaked.select {|line| line})
+      end
+    end
+
+    class NoisyBacktraceTweaker < BacktraceTweaker
+    end
+
+    # Tweaks raised Exceptions to mask noisy (unneeded) parts of the backtrace
+    class QuietBacktraceTweaker < BacktraceTweaker
+      unless defined?(IGNORE_PATTERNS)
+        spec_files = Dir["lib/*"].map do |path| 
+          subpath = path[1..-1]
+          /#{subpath}/
+        end
+        IGNORE_PATTERNS = spec_files + [
+          /\/rspec-[^\/]*\/lib\/spec\//,
+          /\/spork-[^\/]*\/lib\/spork\//,
+          /\/lib\/ruby\//,
+          /bin\/spec:/,
+          /bin\/spork:/,
+          /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 initialize(*patterns)
+        super
+        ignore_patterns(*patterns)
+      end
+
+      def ignore_patterns(*patterns)
+        @ignore_patterns += patterns.flatten.map { |pattern| Regexp.new(pattern) }
+      end
+
+      def ignored_patterns
+        IGNORE_PATTERNS + @ignore_patterns
+      end
+    end
+  end
+end

data/vendor/rspec/lib/spec/runner/class_and_arguments_parser.rb

@@ -0,0 +1,14 @@
+module Spec
+  module Runner
+    class ClassAndArgumentsParser
+      def self.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