merb-core 1.0.15 → 1.1.0.pre

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/example/example_group_methods.rb

@@ -0,0 +1,368 @@
+module Spec
+  module Example
+
+    module ExampleGroupMethods
+      include Spec::Example::BeforeAndAfterHooks
+
+      class << self
+        attr_accessor :matcher_class
+
+        def description_text(*args)
+          args.inject("") do |result, arg|
+            result << " " unless (result == "" || arg.to_s =~ /^(\s|\.|#)/)
+            result << arg.to_s
+          end
+        end
+      end
+
+      attr_reader :description_text, :description_options, :spec_path
+      alias :options :description_options
+      
+      def description_args
+        @description_args ||= []
+      end
+
+      def inherited(klass)
+        super
+        klass.register {}
+        Spec::Runner.register_at_exit_hook
+      end
+      
+      # Makes the describe/it syntax available from a class. For example:
+      #
+      #   class StackSpec < Spec::ExampleGroup
+      #     describe Stack, "with no elements"
+      #
+      #     before
+      #       @stack = Stack.new
+      #     end
+      #
+      #     it "should raise on pop" do
+      #       lambda{ @stack.pop }.should raise_error
+      #     end
+      #   end
+      #
+      def describe(*args, &example_group_block)
+        args << {} unless Hash === args.last
+        if example_group_block
+          options = args.last
+          options[:spec_path] = eval("caller(0)[1]", example_group_block) unless options[:spec_path]
+          if options[:shared]
+            create_shared_example_group(args, example_group_block)
+          else
+            create_nested_example_group(args, example_group_block)
+          end
+        else
+          set_description(*args)
+        end
+      end
+      alias :context :describe
+      
+      def create_shared_example_group(args, example_group_block)
+        SharedExampleGroup.new(*args, &example_group_block)
+      end
+      
+      def create_nested_example_group(args, example_group_block)
+        self.subclass("Subclass") do
+          describe(*args)
+          module_eval(&example_group_block)
+        end
+      end
+      
+      # Use this to pull in examples from shared example groups.
+      # See Spec::Runner for information about shared example groups.
+      def it_should_behave_like(*shared_example_groups)
+        shared_example_groups.each do |group|
+          include_shared_example_group(group)
+        end
+      end
+      
+      # :call-seq:
+      #   predicate_matchers[matcher_name] = method_on_object
+      #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
+      #
+      # Dynamically generates a custom matcher that will match
+      # a predicate on your class. RSpec provides a couple of these
+      # out of the box:
+      #
+      #   exist (or state expectations)
+      #     File.should exist("path/to/file")
+      #
+      #   an_instance_of (for mock argument constraints)
+      #     mock.should_receive(:message).with(an_instance_of(String))
+      #
+      # == Examples
+      #
+      #   class Fish
+      #     def can_swim?
+      #       true
+      #     end
+      #   end
+      #
+      #   describe Fish do
+      #     predicate_matchers[:swim] = :can_swim?
+      #     it "should swim" do
+      #       Fish.new.should swim
+      #     end
+      #   end
+      def predicate_matchers
+        @predicate_matchers ||= {:an_instance_of => :is_a?}
+      end
+
+      # Creates an instance of the current example group class and adds it to
+      # a collection of examples of the current example group.
+      def example(description=nil, options={}, &implementation)
+        e = new(description, options, &implementation)
+        example_objects << e
+        e
+      end
+
+      alias_method :it, :example
+      alias_method :specify, :example
+
+      # Use this to temporarily disable an example.
+      def xexample(description=nil, opts={}, &block)
+        Kernel.warn("Example disabled: #{description}")
+      end
+      
+      alias_method :xit, :xexample
+      alias_method :xspecify, :xexample
+
+      def run
+        examples = examples_to_run
+        reporter.add_example_group(self) unless examples_to_run.empty?
+        return true if examples.empty?
+        return dry_run(examples) if dry_run?
+
+        plugin_mock_framework
+        define_methods_from_predicate_matchers
+
+        success, before_all_instance_variables = run_before_all
+        success, after_all_instance_variables  = execute_examples(success, before_all_instance_variables, examples)
+        success                                = run_after_all(success, after_all_instance_variables)
+      end
+
+      def description
+        result = ExampleGroupMethods.description_text(*description_parts)
+        if result.nil? || result == ""
+          return to_s
+        else
+          result
+        end
+      end
+
+      def described_type
+        description_parts.find {|part| part.is_a?(Module)}
+      end
+
+      def description_parts #:nodoc:
+        parts = []
+        each_ancestor_example_group_class do |example_group_class|
+          parts << example_group_class.description_args
+        end
+        parts.flatten.compact
+      end
+
+      def set_description(*args)
+        args, options = args_and_options(*args)
+        @description_args = args
+        @description_options = options
+        @description_text = ExampleGroupMethods.description_text(*args)
+        @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
+        self
+      end
+      
+      def examples #:nodoc:
+        examples = example_objects.dup
+        add_method_examples(examples)
+        Spec::Runner.options.reverse ? examples.reverse : examples
+      end
+
+      def number_of_examples #:nodoc:
+        examples.length
+      end
+
+      # Only used from RSpec's own examples
+      def reset # :nodoc:
+        @before_all_parts = nil
+        @after_all_parts = nil
+        @before_each_parts = nil
+        @after_each_parts = nil
+      end
+
+      def register(&registration_binding_block)
+        @registration_binding_block = registration_binding_block
+        Spec::Runner.options.add_example_group self
+      end
+
+      def unregister #:nodoc:
+        Spec::Runner.options.remove_example_group self
+      end
+
+      def registration_backtrace
+        eval("caller", @registration_binding_block)
+      end
+
+      def run_before_each(example)
+        each_ancestor_example_group_class do |example_group_class|
+          example.eval_each_fail_fast(example_group_class.before_each_parts)
+        end
+      end
+
+      def run_after_each(example)
+        each_ancestor_example_group_class(:superclass_first) do |example_group_class|
+          example.eval_each_fail_slow(example_group_class.after_each_parts)
+        end
+      end
+
+    private
+      def dry_run(examples)
+        examples.each do |example|
+          Spec::Runner.options.reporter.example_started(example)
+          Spec::Runner.options.reporter.example_finished(example)
+        end
+        return true
+      end
+
+      def run_before_all
+        before_all = new("before(:all)")
+        begin
+          each_ancestor_example_group_class do |example_group_class|
+            before_all.eval_each_fail_fast(example_group_class.before_all_parts)
+          end
+          return [true, before_all.instance_variable_hash]
+        rescue Exception => e
+          reporter.failure(before_all, e)
+          return [false, before_all.instance_variable_hash]
+        end
+      end
+
+      def execute_examples(success, instance_variables, examples)
+        return [success, instance_variables] unless success
+
+        after_all_instance_variables = instance_variables
+        examples.each do |example_group_instance|
+          success &= example_group_instance.execute(Spec::Runner.options, instance_variables)
+          after_all_instance_variables = example_group_instance.instance_variable_hash
+        end
+        return [success, after_all_instance_variables]
+      end
+
+      def run_after_all(success, instance_variables)
+        after_all = new("after(:all)")
+        after_all.set_instance_variables_from_hash(instance_variables)
+        each_ancestor_example_group_class(:superclass_first) do |example_group_class|
+          after_all.eval_each_fail_slow(example_group_class.after_all_parts)
+        end
+        return success
+      rescue Exception => e
+        reporter.failure(after_all, e)
+        return false
+      end
+
+      def examples_to_run
+        all_examples = examples
+        return all_examples unless specified_examples?
+        all_examples.reject do |example|
+          matcher = ExampleGroupMethods.matcher_class.
+            new(description.to_s, example.description)
+          !matcher.matches?(specified_examples)
+        end
+      end
+
+      def specified_examples?
+        specified_examples && !specified_examples.empty?
+      end
+
+      def specified_examples
+        Spec::Runner.options.examples
+      end
+
+      def reporter
+        Spec::Runner.options.reporter
+      end
+
+      def dry_run?
+        Spec::Runner.options.dry_run
+      end
+
+      def example_objects
+        @example_objects ||= []
+      end
+
+      def each_ancestor_example_group_class(superclass_last=false)
+        classes = []
+        current_class = self
+        while is_example_group_class?(current_class)
+          superclass_last ? classes << current_class : classes.unshift(current_class)
+          current_class = current_class.superclass
+        end
+        
+        classes.each do |example_group|
+          yield example_group
+        end
+      end
+
+      def is_example_group_class?(klass)
+        klass.kind_of?(ExampleGroupMethods) && klass.included_modules.include?(ExampleMethods)
+      end
+
+      def plugin_mock_framework
+        case mock_framework = Spec::Runner.configuration.mock_framework
+        when Module
+          include mock_framework
+        else
+          require Spec::Runner.configuration.mock_framework
+          include Spec::Plugins::MockFramework
+        end
+      end
+
+      def define_methods_from_predicate_matchers # :nodoc:
+        all_predicate_matchers = predicate_matchers.merge(
+          Spec::Runner.configuration.predicate_matchers
+        )
+        all_predicate_matchers.each_pair do |matcher_method, method_on_object|
+          define_method matcher_method do |*args|
+            eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
+          end
+        end
+      end
+
+      def add_method_examples(examples)
+        instance_methods.sort.each do |method_name|
+          if example_method?(method_name)
+            examples << new(method_name) do
+              __send__(method_name)
+            end
+          end
+        end
+      end
+
+      def example_method?(method_name)
+        should_method?(method_name)
+      end
+
+      def should_method?(method_name)
+        !(method_name =~ /^should(_not)?$/) &&
+        method_name =~ /^should/ && (
+          [-1,0].include?(instance_method(method_name).arity)
+        )
+      end
+
+      def include_shared_example_group(shared_example_group)
+        case shared_example_group
+        when SharedExampleGroup
+          include shared_example_group
+        else
+          example_group = SharedExampleGroup.find_shared_example_group(shared_example_group)
+          unless example_group
+            raise RuntimeError.new("Shared Example Group '#{shared_example_group}' can not be found")
+          end
+          include(example_group)
+        end
+      end
+
+    end
+
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/example/example_matcher.rb

@@ -0,0 +1,44 @@
+module Spec
+  module Example
+    class ExampleMatcher
+      def initialize(example_group_description, example_name)
+        @example_group_description = example_group_description
+        @example_name = example_name
+      end
+      
+      def matches?(specified_examples)
+        specified_examples.each do |specified_example|
+          return true if matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
+        end
+        false
+      end
+      
+      protected
+      def matches_literal_example?(specified_example)
+        specified_example =~ /(^#{example_group_regex} #{example_regexp}$|^#{example_group_regex}$|^#{example_group_with_before_all_regexp}$|^#{example_regexp}$)/
+      end
+
+      def matches_example_not_considering_modules?(specified_example)
+        specified_example =~ /(^#{example_group_regex_not_considering_modules} #{example_regexp}$|^#{example_group_regex_not_considering_modules}$|^#{example_regexp}$)/
+      end
+
+      def example_group_regex
+        Regexp.escape(@example_group_description)
+      end
+
+      def example_group_with_before_all_regexp
+        Regexp.escape("#{@example_group_description} before(:all)")
+      end
+
+      def example_group_regex_not_considering_modules
+        Regexp.escape(@example_group_description.split('::').last)
+      end
+
+      def example_regexp
+        Regexp.escape(@example_name)
+      end
+    end
+
+    ExampleGroupMethods.matcher_class = ExampleMatcher
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/example/example_methods.rb

@@ -0,0 +1,105 @@
+module Spec
+  module Example
+    module ExampleMethods
+      
+      extend ModuleReopeningFix
+      
+      def execute(options, instance_variables)
+        options.reporter.example_started(self)
+        set_instance_variables_from_hash(instance_variables)
+        
+        execution_error = nil
+        Timeout.timeout(options.timeout) do
+          begin
+            before_each_example
+            eval_block
+          rescue Exception => e
+            execution_error ||= e
+          end
+          begin
+            after_each_example
+          rescue Exception => e
+            execution_error ||= e
+          end
+        end
+
+        options.reporter.example_finished(self, execution_error)
+        success = execution_error.nil? || ExamplePendingError === execution_error
+      end
+
+      def instance_variable_hash
+        instance_variables.inject({}) do |variable_hash, variable_name|
+          variable_hash[variable_name] = instance_variable_get(variable_name)
+          variable_hash
+        end
+      end
+
+      def violated(message="")
+        raise Spec::Expectations::ExpectationNotMetError.new(message)
+      end
+
+      def eval_each_fail_fast(procs) #:nodoc:
+        procs.each do |proc|
+          instance_eval(&proc)
+        end
+      end
+
+      def eval_each_fail_slow(procs) #:nodoc:
+        first_exception = nil
+        procs.each do |proc|
+          begin
+            instance_eval(&proc)
+          rescue Exception => e
+            first_exception ||= e
+          end
+        end
+        raise first_exception if first_exception
+      end
+
+      def description
+        @_defined_description || ::Spec::Matchers.generated_description || "NO NAME"
+      end
+      
+      def options
+        @_options
+      end
+
+      def __full_description
+        "#{self.class.description} #{self.description}"
+      end
+      
+      def set_instance_variables_from_hash(ivars)
+        ivars.each do |variable_name, value|
+          # Ruby 1.9 requires variable.to_s on the next line
+          unless ['@_implementation', '@_defined_description', '@_matcher_description', '@method_name'].include?(variable_name.to_s)
+            instance_variable_set variable_name, value
+          end
+        end
+      end
+
+      def eval_block
+        instance_eval(&@_implementation)
+      end
+
+      def implementation_backtrace
+        eval("caller", @_implementation)
+      end
+      
+      protected
+      include Matchers
+      include Pending
+      
+      def before_each_example
+        setup_mocks_for_rspec
+        self.class.run_before_each(self)
+      end
+
+      def after_each_example
+        self.class.run_after_each(self)
+        verify_mocks_for_rspec
+      ensure
+        teardown_mocks_for_rspec
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/example/module_reopening_fix.rb

@@ -0,0 +1,21 @@
+module Spec
+  module Example
+    # This is a fix for ...Something in Ruby 1.8.6??... (Someone fill in here please - Aslak)
+    module ModuleReopeningFix
+      def child_modules
+        @child_modules ||= []
+      end
+
+      def included(mod)
+        child_modules << mod
+      end
+
+      def include(mod)
+        super
+        child_modules.each do |child_module|
+          child_module.__send__(:include, mod)
+        end
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/example/pending.rb

@@ -0,0 +1,18 @@
+module Spec
+  module Example      
+    module Pending
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Spec::Example::ExamplePendingError.new(message)
+          end
+          raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
+        else
+          raise Spec::Example::ExamplePendingError.new(message)
+        end
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/example/shared_example_group.rb

@@ -0,0 +1,52 @@
+module Spec
+  module Example
+    class SharedExampleGroup < Module
+      module ClassMethods
+        def add_shared_example_group(new_example_group)
+          guard_against_redefining_existing_example_group(new_example_group)
+          shared_example_groups << new_example_group
+        end
+
+        def find_shared_example_group(example_group_description)
+          shared_example_groups.find do |b|
+            b.description == example_group_description
+          end
+        end
+
+        def shared_example_groups
+          @shared_example_groups ||= []
+        end
+
+        private
+        def guard_against_redefining_existing_example_group(new_example_group)
+          existing_example_group = find_shared_example_group(new_example_group.description)
+          return unless existing_example_group
+          return if new_example_group.equal?(existing_example_group)
+          return if spec_path(new_example_group) == spec_path(existing_example_group)
+          raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
+        end
+
+        def spec_path(example_group)
+          File.expand_path(example_group.spec_path)
+        end
+      end
+
+      extend ClassMethods
+      include ExampleGroupMethods
+
+      def initialize(*args, &example_group_block)
+        describe(*args)
+        @example_group_block = example_group_block
+        self.class.add_shared_example_group(self)
+      end
+
+      def included(mod) # :nodoc:
+        mod.module_eval(&@example_group_block)
+      end
+
+      def each_ancestor_example_group_class(superclass_last=false)
+        yield self
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/example.rb

@@ -0,0 +1,12 @@
+require 'timeout'
+require 'spec/example/before_and_after_hooks'
+require 'spec/example/pending'
+require 'spec/example/module_reopening_fix'
+require 'spec/example/example_group_methods'
+require 'spec/example/example_methods'
+require 'spec/example/example_group'
+require 'spec/example/shared_example_group'
+require 'spec/example/example_group_factory'
+require 'spec/example/errors'
+require 'spec/example/configuration'
+require 'spec/example/example_matcher'

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/expectations/differs/default.rb

@@ -0,0 +1,66 @@
+begin
+  require 'rubygems'
+  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
+  require 'diff/lcs/hunk'
+rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
+
+require 'pp'
+
+module Spec
+  module Expectations
+    module Differs
+
+      # TODO add some rdoc
+      class Default
+        def initialize(options)
+          @options = options
+        end
+
+        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+        def diff_as_string(data_new, data_old)
+          data_old = data_old.split(/\n/).map! { |e| e.chomp }
+          data_new = data_new.split(/\n/).map! { |e| e.chomp }
+          output = ""
+          diffs = Diff::LCS.diff(data_old, data_new)
+          return output if diffs.empty?
+          oldhunk = hunk = nil  
+          file_length_difference = 0
+          diffs.each do |piece|
+            begin
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
+                                         file_length_difference)
+              file_length_difference = hunk.file_length_difference      
+              next unless oldhunk      
+              # Hunks may overlap, which is why we need to be careful when our
+              # diff includes lines of context. Otherwise, we might print
+              # redundant lines.
+              if (context_lines > 0) and hunk.overlaps?(oldhunk)
+                hunk.unshift(oldhunk)
+              else
+                output << oldhunk.diff(format)
+              end
+            ensure
+              oldhunk = hunk
+              output << "\n"
+            end
+          end  
+          #Handle the last remaining hunk
+          output << oldhunk.diff(format) << "\n"
+        end  
+
+        def diff_as_object(target,expected)
+          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
+        end
+
+        protected
+        def format
+          @options.diff_format
+        end
+
+        def context_lines
+          @options.context_lines
+        end
+      end
+    end
+  end
+end

data/spec10/public/webrat/test_app/gems/gems/rspec-1.1.11/lib/spec/expectations/errors.rb

@@ -0,0 +1,12 @@
+module Spec
+  module Expectations
+    # If Test::Unit is loaed, we'll use its error as baseclass, so that Test::Unit
+    # will report unmet RSpec expectations as failures rather than errors.
+    superclass = ['Test::Unit::AssertionFailedError', '::StandardError'].map do |c|
+      eval(c) rescue nil
+    end.compact.first
+    
+    class ExpectationNotMetError < superclass
+    end
+  end
+end