riess 0.0.8

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

@@ -0,0 +1,132 @@
+require 'spec/runner/formatter'
+require 'spec/runner/context'
+require 'spec/runner/context_eval'
+require 'spec/runner/specification'
+require 'spec/runner/execution_context'
+require 'spec/runner/context_runner'
+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/spec_matcher'
+require 'spec/runner/extensions/object'
+require 'spec/runner/extensions/kernel'
+require 'spec/runner/spec_should_raise_handler'
+require 'spec/runner/spec_parser'
+
+module Spec
+  # == Contexts and Specifications
+  # 
+  # Rather than expressing examples in classes, RSpec uses a custom domain specific language to express
+  # examples using contexts and specifications.
+  # 
+  # A context 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.
+  # 
+  #   context "A new account" do
+  # 
+  #     setup do
+  #       @account = Account.new
+  #     end
+  # 
+  #     specify "should have a balance of $0" do
+  #       @account.balance.should_eql Money.new(0, :dollars)
+  #     end
+  # 
+  #   end
+  # 
+  # We use the setup block to set up the context (given), and then the specify 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 setup, teardown, context_setup and context_teardown within a context:
+  # 
+  #   context "..." do
+  #     context_setup do
+  #       ...
+  #     end
+  # 
+  #     setup do
+  #       ...
+  #     end
+  # 
+  #     specify "number one" do
+  #       ...
+  #     end
+  # 
+  #     specify "number two" do
+  #       ...
+  #     end
+  # 
+  #     teardown do
+  #       ...
+  #     end
+  # 
+  #     context_teardown do
+  #       ...
+  #     end
+  # 
+  #   end
+  # 
+  # The <tt>setup</tt> block will run before each of the specs, once for each spec. Likewise,
+  # the <tt>teardown</tt> block will run after each of the specs.
+  # 
+  # It is also possible to specify a <tt>context_setup</tt> and <tt>context_teardown</tt>
+  # block that will run only once for each context, respectively before the first <code>setup</code>
+  # and after the last <code>teardown</code>. The use of these is generally discouraged, because it
+  # introduces dependencies between the specs. 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:
+  # 
+  #   context "..." do
+  #   
+  #     specify "..." 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
+  # 
+  #   context "A new account" do
+  #     include AccountExampleHelperMethods
+  #     setup do
+  #       @account = Account.new
+  #     end
+  # 
+  #     specify "should have a balance of $0" do
+  #       helper_method
+  #       @account.balance.should eql(Money.new(0, :dollars))
+  #     end
+  #   end
+  module Runner
+  end
+end

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

@@ -0,0 +1,55 @@
+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\./
+        ]
+      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/vendor/rspec-0.8.2/lib/spec/runner/command_line.rb

@@ -0,0 +1,34 @@
+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_context_runner = defined?($context_runner) ? $context_runner : nil
+        $context_runner = OptionParser.new.create_context_runner(argv, err, out, warn_if_no_files)
+        return if $context_runner.nil? # This is the case if we use --drb
+
+        # If ARGV is a glob, it will actually each over each one of the matching files.
+        argv.each do |file_or_dir|
+          if File.directory?(file_or_dir)
+            Dir["#{file_or_dir}/**/*.rb"].each do |file| 
+              load file
+            end
+          elsif File.file?(file_or_dir)
+            load file_or_dir
+          else
+            raise "File or directory not found: #{file_or_dir}"
+          end
+        end
+        $context_runner.run(exit)
+        $context_runner = old_context_runner
+      end
+    end
+  end
+end

data/vendor/rspec-0.8.2/lib/spec/runner/context.rb

@@ -0,0 +1,154 @@
+module Spec
+  module Runner
+    class ContextEvalModule < Module
+    end
+    class Context
+      module InstanceMethods
+        def initialize(description, &context_block)
+          @description = description
+
+          @context_eval_module = ContextEvalModule.new
+          @context_eval_module.extend ContextEval::ModuleMethods
+          @context_eval_module.include ContextEval::InstanceMethods
+          before_context_eval
+          @context_eval_module.class_eval(&context_block)
+        end
+
+        def before_context_eval
+        end
+
+        def inherit_context_eval_module_from(klass)
+          @context_eval_module.inherit klass
+        end
+        alias :inherit :inherit_context_eval_module_from
+        
+        def include(mod)
+          @context_eval_module.include(mod)
+        end
+
+        def run(reporter, dry_run=false)
+          reporter.add_context(@description)
+          prepare_execution_context_class
+          errors = run_context_setup(reporter, dry_run)
+
+          specifications.each do |specification|
+            specification_execution_context = execution_context(specification)
+            specification_execution_context.copy_instance_variables_from(@once_only_execution_context_instance, []) unless context_setup_block.nil?
+            specification.run(reporter, setup_block, teardown_block, dry_run, specification_execution_context)
+          end unless errors.length > 0
+          
+          run_context_teardown(reporter, dry_run)
+        end
+
+        def number_of_specs
+          specifications.length
+        end
+
+        def matches?(full_description)
+          matcher ||= SpecMatcher.new(@description)
+          specifications.each do |spec|
+            return true if spec.matches?(matcher, full_description)
+          end
+          return false
+        end
+
+        def run_single_spec(full_description)
+          return if @description == full_description
+          matcher = SpecMatcher.new(@description)
+          specifications.reject! do |spec|
+            !spec.matches?(matcher, full_description)
+          end
+        end
+
+        def methods
+          my_methods = super
+          my_methods |= @context_eval_module.methods
+          my_methods
+        end
+
+        protected
+
+        def method_missing(*args)
+          @context_eval_module.method_missing(*args)
+        end
+
+        def context_setup_block
+          @context_eval_module.send :context_setup_block
+        end
+
+        def context_teardown_block
+          @context_eval_module.send :context_teardown_block
+        end
+
+        def specifications
+          @context_eval_module.send :specifications
+        end
+
+        def setup_block
+          @context_eval_module.send :setup_block
+        end
+
+        def teardown_block
+          @context_eval_module.send :teardown_block
+        end
+
+        def prepare_execution_context_class
+          weave_in_context_modules
+          execution_context_class
+        end
+
+        def weave_in_context_modules
+          mods = context_modules
+          context_eval_module = @context_eval_module
+          execution_context_class.class_eval do
+            include context_eval_module
+            mods.each do |mod|
+              include mod
+            end
+          end
+        end
+
+        def context_modules
+          @context_eval_module.send :context_modules
+        end
+
+        def execution_context_class
+          @context_eval_module.send :execution_context_class
+        end
+
+        def execution_context specification
+          execution_context_class.new(specification)
+        end
+
+        def run_context_setup(reporter, dry_run)
+          errors = []
+          unless dry_run
+            begin
+              @once_only_execution_context_instance = execution_context(nil)
+              @once_only_execution_context_instance.instance_eval(&context_setup_block)
+            rescue => e
+              errors << e
+              location = "context_setup"
+              reporter.spec_finished(location, e, location) if reporter
+            end
+          end
+          errors
+        end
+        
+        def run_context_teardown(reporter, dry_run)
+          unless dry_run
+            begin 
+              @once_only_execution_context_instance ||= execution_context(nil) 
+              @once_only_execution_context_instance.instance_eval(&context_teardown_block) 
+            rescue => e
+              location = "context_teardown"
+              reporter.spec_finished(location, e, location) if reporter
+            end
+          end
+        end
+
+      end
+      include InstanceMethods
+    end
+  end
+end

data/vendor/rspec-0.8.2/lib/spec/runner/context_eval.rb

@@ -0,0 +1,142 @@
+module Spec
+  module Runner
+    module ContextEval
+      module ModuleMethods
+        def inherit(klass)
+          @context_superclass = klass
+          derive_execution_context_class_from_context_superclass
+        end
+
+        def include(mod)
+          context_modules << mod
+          mod.send :included, self
+        end
+        
+        def context_setup(&block)
+          context_setup_parts << block
+        end
+
+        def context_teardown(&block)
+          context_teardown_parts << block
+        end
+
+        def setup(&block)
+          setup_parts << block
+        end
+
+        def teardown(&block)
+          teardown_parts << block
+        end
+
+        def specify(spec_name=:__generate_description, opts={}, &block)
+          specifications << Specification.new(spec_name, opts, &block)
+        end
+
+        def methods
+          my_methods = super
+          my_methods |= context_superclass.methods
+          my_methods
+        end
+      
+      protected
+
+        def method_missing(method_name, *args)
+          if context_superclass.respond_to?(method_name)
+            return execution_context_class.send(method_name, *args)
+          end
+          super
+        end
+
+      private
+
+        def context_setup_block
+          parts = context_setup_parts.dup
+          add_context_superclass_method(:context_setup, parts)
+          create_block_from_parts(parts)
+        end
+
+        def context_teardown_block
+          parts = context_teardown_parts.dup
+          add_context_superclass_method(:context_teardown, parts)
+          create_block_from_parts(parts)
+        end
+
+        def setup_block
+          parts = setup_parts.dup
+          add_context_superclass_method(:setup, parts)
+          create_block_from_parts(parts)
+        end
+        
+        def teardown_block
+          parts = teardown_parts.dup
+          add_context_superclass_method(:teardown, parts)
+          create_block_from_parts(parts)
+        end
+
+        def execution_context_class
+          @execution_context_class ||= derive_execution_context_class_from_context_superclass
+        end
+
+        def derive_execution_context_class_from_context_superclass
+          @execution_context_class = Class.new(context_superclass)
+          @execution_context_class.class_eval do
+            include ::Spec::Runner::ExecutionContext::InstanceMethods
+          end
+        end
+
+        def context_superclass
+          @context_superclass ||= Object
+        end
+
+        def context_modules
+          @context_modules ||= [Spec::Matchers, Spec::Mocks]
+        end
+        
+        def specifications
+          @specifications ||= []
+        end
+
+        def context_setup_parts
+          @context_setup_parts ||= []
+        end
+
+        def context_teardown_parts
+          @context_teardown_parts ||= []
+        end
+
+        def setup_parts
+          @setup_parts ||= []
+        end
+
+        def teardown_parts
+          @teardown_parts ||= []
+        end
+
+        def add_context_superclass_method sym, parts
+          superclass_method = begin
+            context_superclass.instance_method(sym)
+          rescue
+            nil
+          end
+          parts.unshift superclass_method if superclass_method
+        end
+
+        def create_block_from_parts(parts)
+          proc do
+            parts.each do |part|
+              if part.is_a?(UnboundMethod)
+                part.bind(self).call
+              else
+                instance_eval(&part)
+              end
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+      end
+      
+    end
+  end
+end