riess 0.0.8

data/vendor/rspec-0.8.2/lib/spec/mocks/methods.rb

@@ -0,0 +1,40 @@
+module Spec
+  module Mocks
+    module Methods
+      def should_receive(sym, opts={}, &block)
+        __mock_handler.add_message_expectation(opts[:expected_from] || caller(1)[0], sym, opts, &block)
+      end
+
+      def should_not_receive(sym, &block)
+        __mock_handler.add_negative_message_expectation(caller(1)[0], sym, &block)
+      end
+      
+      def stub!(sym)
+        __mock_handler.add_stub(caller(1)[0], sym)
+      end
+      
+      def received_message?(sym, *args, &block) #:nodoc:
+        __mock_handler.received_message?(sym, *args, &block)
+      end
+      
+      def __verify #:nodoc:
+        __mock_handler.verify
+      end
+
+      def __reset_mock #:nodoc:
+        __mock_handler.reset
+      end
+
+      def method_missing(sym, *args, &block) #:nodoc:
+        __mock_handler.instance_eval {@messages_received << [sym, args, block]}
+        super(sym, *args, &block)
+      end
+      
+      private
+
+      def __mock_handler
+        @mock_handler ||= MockHandler.new(self, @name, @options)
+      end
+    end
+  end
+end

data/vendor/rspec-0.8.2/lib/spec/mocks/mock.rb

@@ -0,0 +1,26 @@
+module Spec
+  module Mocks
+    class Mock
+      include Methods
+
+      # Creates a new mock with a +name+ (that will be used in error messages only)
+      # == Options:
+      # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
+      def initialize(name, options={})
+        @name = name
+        @options = options
+      end
+
+      def method_missing(sym, *args, &block)
+        __mock_handler.instance_eval {@messages_received << [sym, args, block]}
+        begin
+          return self if __mock_handler.null_object?
+          super(sym, *args, &block)
+        rescue NoMethodError
+          __mock_handler.raise_unexpected_message_error sym, *args
+        end
+      end
+      
+    end
+  end
+end

data/vendor/rspec-0.8.2/lib/spec/mocks/mock_handler.rb

@@ -0,0 +1,166 @@
+module Spec
+  module Mocks
+    class MockHandler
+      DEFAULT_OPTIONS = {
+        :null_object => false,
+        :auto_verify => true
+      }
+
+      def initialize(target, name, options={})
+        @target = target
+        @name = name
+        @error_generator = ErrorGenerator.new target, name
+        @expectation_ordering = OrderGroup.new @error_generator
+        @expectations = []
+        @messages_received = []
+        @stubs = []
+        @proxied_methods = []
+        @options = options ? DEFAULT_OPTIONS.dup.merge(options) : DEFAULT_OPTIONS
+      end
+
+      def null_object?
+        @options[:null_object]
+      end
+
+      def add_message_expectation(expected_from, sym, opts={}, &block)
+        __add expected_from, sym, block
+        @expectations << MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil, 1, opts)
+        @expectations.last
+      end
+
+      def add_negative_message_expectation(expected_from, sym, &block)
+        __add expected_from, sym, block
+        @expectations << NegativeMessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, block_given? ? block : nil)
+        @expectations.last
+      end
+
+      def add_stub(expected_from, sym)
+        __add expected_from, sym, nil
+        @stubs.unshift MethodStub.new(@error_generator, @expectation_ordering, expected_from, sym, nil)
+        @stubs.first
+      end
+
+      def verify #:nodoc:
+        begin
+          verify_expectations
+        ensure
+          reset
+        end
+      end
+
+      def reset
+        clear_expectations
+        clear_stubs
+        reset_proxied_methods
+        clear_proxied_methods
+      end
+
+      def received_message?(sym, *args, &block)
+        return true if @messages_received.find {|array| array == [sym, args, block]}
+        return false
+      end
+
+      def has_negative_expectation?(sym)
+        @expectations.detect {|expectation| expectation.negative_expectation_for?(sym)}
+      end
+
+      def message_received(sym, *args, &block)
+        if expectation = find_matching_expectation(sym, *args)
+          expectation.invoke(args, block)
+        elsif stub = find_matching_method_stub(sym)
+          stub.invoke([], block)
+        elsif expectation = find_almost_matching_expectation(sym, *args)
+          raise_unexpected_message_args_error(expectation, *args) unless has_negative_expectation?(sym) unless null_object?
+        else
+          @target.send :method_missing, sym, *args, &block
+        end
+      end
+
+      def raise_unexpected_message_args_error(expectation, *args)
+        @error_generator.raise_unexpected_message_args_error expectation, *args
+      end
+
+      def raise_unexpected_message_error(sym, *args)
+        @error_generator.raise_unexpected_message_error sym, *args
+      end
+      
+      private
+
+      def __add(expected_from, sym, block)
+        # TODO - this is the only reference in the 'spec/mocks' to the Runner
+        current_spec = Runner::Specification.current
+        current_spec.after_teardown {verify} if current_spec && @options[:auto_verify]
+        define_expected_method(sym)
+      end
+      
+      def define_expected_method(sym)
+        if target_responds_to?(sym) && !@proxied_methods.include?(sym)
+          @proxied_methods << sym
+          metaclass.__send__(:alias_method, munge(sym), sym)
+        end
+
+        metaclass_eval(<<-EOF, __FILE__, __LINE__)
+          def #{sym}(*args, &block)
+            __mock_handler.message_received :#{sym}, *args, &block
+          end
+        EOF
+      end
+
+      def target_responds_to?(sym)
+        return @target.send(munge(:respond_to?),sym) if @already_proxied_respond_to
+        return @already_proxied_respond_to = true if sym == :respond_to?
+        return @target.respond_to?(sym)
+      end
+
+      def munge(sym)
+        "proxied_by_rspec__#{sym.to_s}".to_sym
+      end
+
+      def clear_expectations
+        @expectations.clear
+      end
+
+      def clear_stubs
+        @stubs.clear
+      end
+
+      def clear_proxied_methods
+        @proxied_methods.clear
+      end
+
+      def metaclass_eval(str, filename, lineno)
+        metaclass.class_eval(str, filename, lineno)
+      end
+      
+      def metaclass
+        (class << @target; self; end)
+      end
+
+      def verify_expectations
+        @expectations.each do |expectation|
+          expectation.verify_messages_received
+        end
+      end
+
+      def reset_proxied_methods
+        @proxied_methods.each do |sym|
+          metaclass.__send__(:alias_method, sym, munge(sym))
+          metaclass.__send__(:undef_method, munge(sym))
+        end
+      end
+
+      def find_matching_expectation(sym, *args)
+        @expectations.find {|expectation| expectation.matches(sym, args)}
+      end
+
+      def find_almost_matching_expectation(sym, *args)
+        @expectations.find {|expectation| expectation.matches_name_but_not_args(sym, args)}
+      end
+
+      def find_matching_method_stub(sym)
+        @stubs.find {|stub| stub.matches(sym, [])}
+      end
+
+    end
+  end
+end

data/vendor/rspec-0.8.2/lib/spec/mocks/order_group.rb

@@ -0,0 +1,29 @@
+module Spec
+  module Mocks
+    class OrderGroup
+      def initialize error_generator
+        @error_generator = error_generator
+        @ordering = Array.new
+      end
+      
+      def register(expectation)
+        @ordering << expectation
+      end
+      
+      def ready_for?(expectation)
+        return @ordering.first == expectation
+      end
+      
+      def consume
+        @ordering.shift
+      end
+      
+      def handle_order_constraint expectation
+        return unless @ordering.include? expectation
+        return consume if ready_for?(expectation)
+        @error_generator.raise_out_of_order_error expectation.sym
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+#!/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 RSpec contexts.
+    #
+    # 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
+    #
+    class SpecTask < ::Rake::TaskLib
+
+      # 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')
+      attr_accessor :pattern
+
+      # Array of commandline options to pass to RSpec. Defaults to [].
+      attr_accessor :spec_opts
+
+      # Where RSpec's output is written. Defaults to STDOUT.
+      attr_accessor :out
+
+      # 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
+      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 stdout when there are failures.
+      attr_accessor :failure_message
+
+      # Explicitly define the list of spec files to be included in a
+      # spec.  +list+ 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.
+      def spec_files=(list)
+        @spec_files = list
+      end
+
+      # Create a specing task.
+      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 = []
+        @out = nil
+        @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
+        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 RSpec for #{actual_name}" + (@rcov ? " using RCov" : "")
+        end
+        task @name do
+          RakeFileUtils.verbose(@verbose) do
+            ruby_opts = @ruby_opts.clone
+            ruby_opts.push( "-I\"#{lib_path}\"" )
+            ruby_opts.push( "-S rcov" ) if @rcov
+            ruby_opts.push( "-w" ) if @warning
+
+            redirect = @out.nil? ? "" : " > \"#{@out}\""
+
+            unless spec_file_list.empty?
+              # ruby [ruby_opts] -Ilib -S rcov [rcov_opts] bin/spec -- [spec_opts] examples
+              # or
+              # ruby [ruby_opts] -Ilib bin/spec [spec_opts] examples
+              begin
+                ruby(
+                  ruby_opts.join(" ") + " " + 
+                  rcov_option_list +
+                  (@rcov ? %[ -o "#{@rcov_dir}" ] : "") + 
+                  '"' + spec_script + '"' + " " +
+                  (@rcov ? "-- " : "") + 
+                  spec_file_list.collect { |fn| %["#{fn}"] }.join(' ') + " " + 
+                  spec_option_list + " " +
+                  redirect
+                )
+              rescue => e
+                 puts @failure_message if @failure_message
+                 raise e 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['RCOVOPTS'] || @rcov_opts.join(" ") || ""
+      end
+
+      def spec_option_list # :nodoc:
+        ENV['RSPECOPTS'] || @spec_opts.join(" ") || ""
+      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-0.8.2/lib/spec/rake/verify_rcov.rb

@@ -0,0 +1,47 @@
+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
+    
+    def initialize(name=:verify_rcov)
+      @name = name
+      @index_html = 'coverage/index.html'
+      @verbose = 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
+      end
+    end
+  end
+end