riess 0.0.8

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

@@ -0,0 +1,25 @@
+module Spec
+  module Runner
+    class SpecMatcher
+
+      attr_writer :spec_desc
+      def initialize(context_desc, spec_desc=nil)
+        @context_desc = context_desc
+        @spec_desc = spec_desc
+      end
+      
+      def matches?(desc)
+        desc =~ /(^#{context_regexp} #{spec_regexp}$|^#{context_regexp}$|^#{spec_regexp}$)/
+      end
+      
+      private
+        def context_regexp
+          Regexp.escape(@context_desc)
+        end
+        
+        def spec_regexp
+          Regexp.escape(@spec_desc)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Spec
+  module Runner
+    # Parses a spec file and finds the nearest spec for a given line number.
+    class SpecParser
+      def spec_name_for(io, line_number)
+        source  = io.read
+        context = context_at_line(source, line_number)
+        spec    = spec_at_line(source, line_number)
+        if context && spec
+          "#{context} #{spec}"
+        elsif context
+          context
+        else
+          nil
+        end
+      end
+
+    protected
+
+      def context_at_line(source, line_number)
+        find_above(source, line_number, /^\s*context\s+['|"](.*)['|"]/)
+      end
+
+      def spec_at_line(source, line_number)
+        find_above(source, line_number, /^\s*specify\s+['|"](.*)['|"]/)
+      end
+
+      def find_above(source, line_number, pattern)
+        lines_above_reversed(source, line_number).each do |line| 
+          return $1 if line =~ pattern
+        end
+        nil
+      end
+
+      def lines_above_reversed(source, line_number)
+        lines = source.split("\n")
+      	lines[0...line_number].reverse
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Spec
+  module Runner
+    class SpecShouldRaiseHandler
+      def initialize(file_and_line_number, opts)
+        @file_and_line_number = file_and_line_number
+        @options = opts
+        @expected_error_class = determine_error_class(opts)
+        @expected_error_message = determine_error_message(opts)
+      end
+  
+      def determine_error_class(opts)
+        if candidate = opts[:should_raise]
+          if candidate.is_a?(Class)
+            return candidate
+          elsif candidate.is_a?(Array)
+            return candidate[0]
+          else
+            return Exception
+          end
+        end
+      end
+  
+      def determine_error_message(opts)
+        if candidate = opts[:should_raise]
+          if candidate.is_a?(Array)
+            return candidate[1]
+          end
+        end
+        return nil
+      end
+  
+      def build_message(exception=nil)
+        if @expected_error_message.nil?
+          message = "specify block expected #{@expected_error_class.to_s}"
+        else
+          message = "specify block expected #{@expected_error_class.new(@expected_error_message.to_s).inspect}"
+        end
+        message << " but raised #{exception.inspect}" if exception
+        message << " but nothing was raised" unless exception
+        message << "\n"
+        message << @file_and_line_number
+      end
+  
+      def error_matches?(error)
+        return false unless error.kind_of?(@expected_error_class)
+        unless @expected_error_message.nil?
+          if @expected_error_message.is_a?(Regexp)
+            return false unless error.message =~ @expected_error_message
+          else
+            return false unless error.message == @expected_error_message
+          end
+        end
+        return true
+      end
+
+      def handle(errors)
+        if @expected_error_class
+          if errors.empty?
+            errors << Spec::Expectations::ExpectationNotMetError.new(build_message)
+          else
+            error_to_remove = errors.detect do |error|
+              error_matches?(error)
+            end
+            if error_to_remove.nil?
+              errors.insert(0,Spec::Expectations::ExpectationNotMetError.new(build_message(errors[0])))
+            else
+              errors.delete(error_to_remove)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Spec
+  module Runner
+    class Specification
+
+      class << self
+        attr_accessor :current, :generated_description
+        protected :current=
+
+        callback_events :before_setup, :after_teardown
+      end
+
+      attr_reader :spec_block
+      callback_events :before_setup, :after_teardown
+
+      def initialize(name, opts={}, &spec_block)
+        @from = caller(0)[3]
+        @description = name
+        @options = opts
+        @spec_block = spec_block
+        @description_generated_callback = lambda { |desc| @generated_description = desc }
+      end
+
+      def run(reporter, setup_block, teardown_block, dry_run, execution_context)
+        reporter.spec_started(name) if reporter
+        return reporter.spec_finished(name) if dry_run
+
+        errors = []
+        begin
+          set_current
+          setup_ok = setup_spec(execution_context, errors, &setup_block)
+          spec_ok = execute_spec(execution_context, errors) if setup_ok
+          teardown_ok = teardown_spec(execution_context, errors, &teardown_block)
+        ensure
+          clear_current
+        end
+
+        SpecShouldRaiseHandler.new(@from, @options).handle(errors)
+        reporter.spec_finished(name, errors.first, failure_location(setup_ok, spec_ok, teardown_ok)) if reporter
+      end
+      
+      def matches?(matcher, description)
+        matcher.spec_desc = name
+        matcher.matches?(description)
+      end
+      
+      private
+      def name
+        @description == :__generate_description ? generated_description : @description
+      end
+      
+      def generated_description
+        @generated_description || "NAME NOT GENERATED"
+      end
+      
+      def setup_spec(execution_context, errors, &setup_block)
+        notify_before_setup(errors)
+        execution_context.instance_eval(&setup_block) if setup_block
+        return errors.empty?
+      rescue => e
+        errors << e
+        return false
+      end
+
+      def execute_spec(execution_context, errors)
+        begin
+          execution_context.instance_eval(&spec_block)
+          return true
+        rescue Exception => e
+          errors << e
+          return false
+        end
+      end
+
+      def teardown_spec(execution_context, errors, &teardown_block)
+        execution_context.instance_eval(&teardown_block) if teardown_block
+        notify_after_teardown(errors)
+        return errors.empty?
+      rescue => e
+        errors << e
+        return false
+      end
+
+      def notify_before_setup(errors)
+        notify_class_callbacks(:before_setup, self, &append_errors(errors))
+        notify_callbacks(:before_setup, self, &append_errors(errors))
+      end
+      
+      def notify_after_teardown(errors)
+        notify_callbacks(:after_teardown, self, &append_errors(errors))
+        notify_class_callbacks(:after_teardown, self, &append_errors(errors))
+      end
+      
+      def append_errors(errors)
+        proc {|error| errors << error}
+      end
+      
+      def set_current
+        Spec::Matchers.description_generated(&@description_generated_callback)
+        self.class.send(:current=, self)
+      end
+
+      def clear_current
+        Spec::Matchers.unregister_callback(:description_generated, @description_generated_callback)
+        self.class.send(:current=, nil)
+      end
+
+      def failure_location(setup_ok, spec_ok, teardown_ok)
+        return 'setup' unless setup_ok
+        return name unless spec_ok
+        return 'teardown' unless teardown_ok
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'fileutils'
+
+module Spec
+  class Translator
+    def translate_dir(from, to)
+      from = File.expand_path(from)
+      to = File.expand_path(to)
+      if File.directory?(from)
+        FileUtils.mkdir_p(to) unless File.directory?(to)
+        Dir["#{from}/*"].each do |sub_from|
+          path = sub_from[from.length+1..-1]
+          sub_to = File.join(to, path)
+          translate_dir(sub_from, sub_to)
+        end
+      else
+        translate_file(from, to)
+      end
+    end
+    
+    def translate_file(from, to)
+      translation = ""
+      File.open(from) do |io|
+        io.each_line do |line|
+          translation << translate(line)
+        end
+      end
+      File.open(to, "w") do |io|
+        io.write(translation)
+      end
+    end
+
+    def translate(line)
+      return line if line =~ /(should_not|should)_receive/
+      
+      if line =~ /(.*\.)(should_not|should)(?:_be)(?!_)(.*)/m
+        pre = $1
+        should = $2
+        post = $3
+        be_or_equal = post =~ /(<|>)/ ? "be" : "equal"
+        
+        return "#{pre}#{should} #{be_or_equal}#{post}"
+      end
+      
+      if line =~ /(.*\.)(should_not|should)_(?!not)(.*)/m
+        pre = $1
+        should = $2
+        post = $3
+        
+        post.gsub!(/^raise/, 'raise_error')
+        post.gsub!(/^throw/, 'throw_symbol')
+        
+        unless standard_matcher?(post)
+          post = "be_#{post}"
+        end
+        
+        line = "#{pre}#{should} #{post}"
+      end
+
+      line
+    end
+    
+    def standard_matcher?(matcher)
+      patterns = [
+        /^be/, 
+        /^be_close/,
+        /^eql/, 
+        /^equal/, 
+        /^has/, 
+        /^have/, 
+        /^change/, 
+        /^include/,
+        /^match/, 
+        /^raise_error/, 
+        /^respond_to/, 
+        /^satisfy/, 
+        /^throw_symbol/,
+        # Extra ones that we use in spec_helper
+        /^pass/,
+        /^fail/,
+        /^fail_with/,
+      ]
+      matched = patterns.detect{ |p| matcher =~ p }
+      !matched.nil?
+    end
+    
+  end
+end

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

@@ -0,0 +1,30 @@
+module Spec
+  module VERSION
+    def self.build_tag
+      tag = "REL_" + [MAJOR, MINOR, TINY].join('_')
+      if defined?(RELEASE_CANDIDATE)
+        tag << "_" << RELEASE_CANDIDATE
+      end
+      tag
+    end
+
+    unless defined? MAJOR
+      MAJOR  = 0
+      MINOR  = 8
+      TINY   = 2
+      # RELEASE_CANDIDATE = "RC1"
+      
+      # RANDOM_TOKEN: 0.375509844656552
+      REV = "$LastChangedRevision: 1560 $".match(/LastChangedRevision: (\d+)/)[1]
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+      FULL_VERSION = "#{STRING} (r#{REV})"
+      TAG = build_tag
+
+      NAME   = "RSpec"
+      URL    = "http://rspec.rubyforge.org/"  
+    
+      DESCRIPTION = "#{NAME}-#{FULL_VERSION} - BDD for Ruby\n#{URL}"
+    end
+  end
+end

data/vendor/rspec-0.8.2/spec/spec/callback/callback_container_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "A CallbackContainer instance" do
+  setup do
+    @container = Callback::CallbackContainer.new
+  end
+
+  specify "should define and call callbacks" do
+    @container.define(:foo) {:bar}
+    @container.define(:foo) {:baz}
+    @container.notify(:foo).should == [:bar, :baz]
+  end
+
+  specify "should undefine callbacks" do
+    callback_to_undefine = @container.define(:foo) {:bar}
+    @container.define(:foo) {:baz}
+    @container.undefine(:foo, callback_to_undefine)
+    @container.notify(:foo).should == [:baz]
+  end
+  
+  specify "should clear all callbacks" do
+    @container.define(:foo) {:bar}
+    @container.define(:baz) {1}
+    @container.clear
+    @container.notify(:foo).should == []
+  end
+end

data/vendor/rspec-0.8.2/spec/spec/callback/module_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "A Module" do
+  specify "should provide callback_events and notify_callbacks methods" do
+    the_class = Class.new do
+      callback_events :foo
+    end
+
+    the_obj = the_class.new
+    the_obj.foo { :bar }
+    the_obj.notify_callbacks(:foo).should == [:bar]
+  end
+
+  specify "should support defining multiple callback_events with one call to callback_events" do
+    the_class = Class.new do
+      callback_events :foo, :bar
+    end
+
+    the_obj = the_class.new
+    the_obj.foo { 1 }
+    the_obj.bar { 2 }
+    the_obj.notify_callbacks(:foo).should == [1]
+    the_obj.notify_callbacks(:bar).should == [2]
+  end
+
+  specify "should provide unregister_callback method" do
+    the_class = Class.new do
+      callback_events :foo
+    end
+
+    the_obj = the_class.new
+    bar_proc = proc {:bar}
+    the_obj.foo &bar_proc
+    the_obj.unregister_callback(:foo, bar_proc)
+    the_obj.notify_callbacks(:foo).should == []
+  end
+end

data/vendor/rspec-0.8.2/spec/spec/callback/object_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+context "An Object" do
+  setup do
+    @callback_object = Object.new
+  end
+
+  specify "should be defined as a block and notified" do
+    specify_registration_and_notification do |callback_key, expected_callback|
+      @callback_object.register_callback(callback_key, &expected_callback)
+    end
+  end
+
+  specify "should be defined as a proc and notified" do
+    specify_registration_and_notification do |callback_key, expected_callback|
+      @callback_object.register_callback(callback_key, expected_callback)
+    end
+  end
+
+  specify "define should require callback with the call method" do
+    proc do
+      specify_registration_and_notification do |callback_key, expected_callback|
+        @callback_object.register_callback(callback_key)
+      end
+    end.should_raise(RuntimeError, "You must define the callback that accepts the call method.")
+  end
+
+  specify "should undefine a proc" do
+    specify_unregistration do |callback_key, callback|
+      @callback_object.unregister_callback callback_key, callback
+    end
+  end
+
+  specify "undefine should require callback with the call method" do
+    proc do
+      specify_unregistration do |callback_key, expected_callback|
+        @callback_object.unregister_callback(callback_key, nil)
+      end
+    end.should_raise(RuntimeError, "You may only undefine callbacks that use the call method.")
+  end
+  
+  specify "should handle errors" do
+    @callback_object.register_callback(:error_callback) do
+      raise "First Error"
+    end
+
+    @callback_object.register_callback(:error_callback) do
+      raise "Second Error"
+    end
+
+    error_messages = []
+    @callback_object.notify_callbacks(:error_callback) do |e|
+      error_messages << e.message
+    end
+
+    error_messages.should_eql ["First Error", "Second Error"]
+  end
+
+  specify "should not fail with nothing to notify" do
+    @callback_object.notify_callbacks(:foobar, :argument)
+  end
+
+  protected
+  def specify_registration_and_notification
+    callback_key = :create
+    passed_callback_argument = nil
+    expected_callback = proc do |callback_argument|
+      passed_callback_argument = callback_argument
+    end
+
+    returned_callback = yield(callback_key, expected_callback)
+    returned_callback.should_equal expected_callback
+
+    expected_argument = Object.new
+    @callback_object.notify_callbacks(callback_key, expected_argument)
+    passed_callback_argument.should_equal expected_argument
+  end
+
+  def specify_unregistration
+    callback_key = :create
+    callback_called = false
+    callback = @callback_object.register_callback(callback_key) do
+      callback_called = true
+    end
+
+    yield(callback_key, callback)
+    @callback_object.notify_callbacks(callback_key)
+    callback_called.should_equal false
+  end
+end