opal-rspec 0.4.3 → 0.5.0.beta1

data/vendor_lib/rspec/core/metadata.rb

@@ -1,313 +0,0 @@
-module RSpec
-  module Core
-    # Each ExampleGroup class and Example instance owns an instance of
-    # Metadata, which is Hash extended to support lazy evaluation of values
-    # associated with keys that may or may not be used by any example or group.
-    #
-    # In addition to metadata that is used internally, this also stores
-    # user-supplied metadata, e.g.
-    #
-    #     describe Something, :type => :ui do
-    #       it "does something", :slow => true do
-    #         # ...
-    #       end
-    #     end
-    #
-    # `:type => :ui` is stored in the Metadata owned by the example group, and
-    # `:slow => true` is stored in the Metadata owned by the example. These can
-    # then be used to select which examples are run using the `--tag` option on
-    # the command line, or several methods on `Configuration` used to filter a
-    # run (e.g. `filter_run_including`, `filter_run_excluding`, etc).
-    #
-    # @see Example#metadata
-    # @see ExampleGroup.metadata
-    # @see FilterManager
-    # @see Configuration#filter_run_including
-    # @see Configuration#filter_run_excluding
-    class Metadata < Hash
-
-      def self.relative_path(line)
-        line = line.sub(File.expand_path("."), ".")
-        line = line.sub(/\A([^:]+:\d+)$/, '\\1')
-        return nil if line == '-e:1'
-        line
-      rescue SecurityError
-        nil
-      end
-
-      # @private
-      # Used internally to build a hash from an args array.
-      # Symbols are converted into hash keys with a value of `true`.
-      # This is done to support simple tagging using a symbol, rather
-      # than needing to do `:symbol => true`.
-      def self.build_hash_from(args)
-        hash = args.last.is_a?(Hash) ? args.pop : {}
-
-        while args.last.is_a?(Symbol)
-          hash[args.pop] = true
-        end
-
-        hash
-      end
-
-      module MetadataHash
-
-        # @private
-        # Supports lazy evaluation of some values. Extended by
-        # ExampleMetadataHash and GroupMetadataHash, which get mixed in to
-        # Metadata for ExampleGroups and Examples (respectively).
-        def [](key)
-          store_computed(key) unless has_key?(key)
-          super
-        end
-
-        def fetch(key, *args)
-          store_computed(key) unless has_key?(key)
-          super
-        end
-
-        private
-
-        def store_computed(key)
-          case key
-          when :location
-            store(:location, location)
-          when :file_path, :line_number
-            file_path, line_number = file_and_line_number
-            store(:file_path, file_path)
-            store(:line_number, line_number)
-          when :execution_result
-            store(:execution_result, {})
-          when :describes, :described_class
-            klass = described_class
-            store(:described_class, klass)
-            # TODO (2011-11-07 DC) deprecate :describes as a key
-            store(:describes, klass)
-          when :full_description
-            store(:full_description, full_description)
-          when :description
-            store(:description, build_description_from(*self[:description_args]))
-          when :description_args
-            store(:description_args, [])
-          end
-        end
-
-        def location
-          "#{self[:file_path]}:#{self[:line_number]}"
-        end
-
-        def file_and_line_number
-          first_caller_from_outside_rspec =~ /(.+?):(\d+)(|:\d+)/
-          return [Metadata::relative_path($1), $2.to_i]
-        end
-
-        def first_caller_from_outside_rspec
-          self[:caller].detect {|l| l !~ /\/lib\/rspec\/core/}
-        end
-
-        def method_description_after_module?(parent_part, child_part)
-          return false unless parent_part.is_a?(Module)
-          child_part =~ /^(#|::|\.)/
-        end
-
-        def build_description_from(first_part = '', *parts)
-          description, _ = parts.inject([first_part.to_s, first_part]) do |(desc, last_part), this_part|
-            this_part = this_part.to_s
-            this_part = (' ' + this_part) unless method_description_after_module?(last_part, this_part)
-            [(desc + this_part), this_part]
-          end
-
-          description
-        end
-      end
-
-      # Mixed in to Metadata for an Example (extends MetadataHash) to support
-      # lazy evaluation of some values.
-      module ExampleMetadataHash
-        include MetadataHash
-
-        def described_class
-          self[:example_group].described_class
-        end
-
-        def full_description
-          build_description_from(self[:example_group][:full_description], *self[:description_args])
-        end
-      end
-
-      # Mixed in to Metadata for an ExampleGroup (extends MetadataHash) to
-      # support lazy evaluation of some values.
-      module GroupMetadataHash
-        include MetadataHash
-
-        def described_class
-          container_stack.each do |g|
-            [:described_class, :describes].each do |key|
-              if g.has_key?(key)
-                value = g[key]
-                return value unless value.nil?
-              end
-            end
-          end
-
-          container_stack.reverse.each do |g|
-            candidate = g[:description_args].first
-            return candidate unless String === candidate || Symbol === candidate
-          end
-
-          nil
-        end
-
-        def full_description
-          build_description_from(*FlatMap.flat_map(container_stack.reverse) {|a| a[:description_args]})
-        end
-
-        def container_stack
-          @container_stack ||= begin
-                                 groups = [group = self]
-                                 while group.has_key?(:example_group)
-                                   groups << group[:example_group]
-                                   group = group[:example_group]
-                                 end
-                                 groups
-                               end
-        end
-      end
-
-      def initialize(parent_group_metadata=nil)
-        if parent_group_metadata
-          update(parent_group_metadata)
-          store(:example_group, {:example_group => parent_group_metadata[:example_group].extend(GroupMetadataHash)}.extend(GroupMetadataHash))
-        else
-          store(:example_group, {}.extend(GroupMetadataHash))
-        end
-
-        yield self if block_given?
-      end
-
-      # @private
-      def process(*args)
-        user_metadata = args.last.is_a?(Hash) ? args.pop : {}
-        ensure_valid_keys(user_metadata)
-
-        self[:example_group].store(:description_args, args)
-        self[:example_group].store(:caller, user_metadata.delete(:caller) || caller)
-
-        update(user_metadata)
-      end
-
-      # @private
-      def for_example(description, user_metadata)
-        dup.extend(ExampleMetadataHash).configure_for_example(description, user_metadata)
-      end
-
-      # @private
-      def any_apply?(filters)
-        filters.any? {|k,v| filter_applies?(k,v)}
-      end
-
-      # @private
-      def all_apply?(filters)
-        filters.all? {|k,v| filter_applies?(k,v)}
-      end
-
-      # @private
-      def filter_applies?(key, value, metadata=self)
-        return metadata.filter_applies_to_any_value?(key, value) if Array === metadata[key] && !(Proc === value)
-        return metadata.line_number_filter_applies?(value)       if key == :line_numbers
-        return metadata.location_filter_applies?(value)          if key == :locations
-        return metadata.filters_apply?(key, value)               if Hash === value
-
-        return false unless metadata.has_key?(key)
-
-        case value
-        when Regexp
-          metadata[key] =~ value
-        when Proc
-          case value.arity
-          when 0 then value.call
-          when 2 then value.call(metadata[key], metadata)
-          else value.call(metadata[key])
-          end
-        else
-          metadata[key].to_s == value.to_s
-        end
-      end
-
-      # @private
-      def filters_apply?(key, value)
-        value.all? {|k, v| filter_applies?(k, v, self[key])}
-      end
-
-      # @private
-      def filter_applies_to_any_value?(key, value)
-        self[key].any? {|v| filter_applies?(key, v, {key => value})}
-      end
-
-      # @private
-      def location_filter_applies?(locations)
-        # it ignores location filters for other files
-        line_number = example_group_declaration_line(locations)
-        line_number ? line_number_filter_applies?(line_number) : true
-      end
-
-      # @private
-      def line_number_filter_applies?(line_numbers)
-        preceding_declaration_lines = line_numbers.map {|n| RSpec.world.preceding_declaration_line(n)}
-        !(relevant_line_numbers & preceding_declaration_lines).empty?
-      end
-
-      protected
-
-      def configure_for_example(description, user_metadata)
-        store(:description_args, [description]) if description
-        store(:caller, user_metadata.delete(:caller) || caller)
-        update(user_metadata)
-      end
-
-      private
-
-      RESERVED_KEYS = [
-        :description,
-        :example_group,
-        :execution_result,
-        :file_path,
-        :full_description,
-        :line_number,
-        :location
-      ]
-
-      def ensure_valid_keys(user_metadata)
-        RESERVED_KEYS.each do |key|
-          if user_metadata.has_key?(key)
-            raise <<-EOM
-            #{"*"*50}
-:#{key} is not allowed
-
-RSpec reserves some hash keys for its own internal use,
-including :#{key}, which is used on:
-
-            #{CallerFilter.first_non_rspec_line}.
-
-Here are all of RSpec's reserved hash keys:
-
-            #{RESERVED_KEYS.join("\n  ")}
-            #{"*"*50}
-            EOM
-          end
-        end
-      end
-
-      def example_group_declaration_line(locations)
-        locations[File.expand_path(self[:example_group][:file_path])] if self[:example_group]
-      end
-
-      # TODO - make this a method on metadata - the problem is
-      # metadata[:example_group] is not always a kind of GroupMetadataHash.
-      def relevant_line_numbers(metadata=self)
-        [metadata[:line_number]] + (metadata[:example_group] ? relevant_line_numbers(metadata[:example_group]) : [])
-      end
-
-    end
-  end
-end

data/vendor_lib/rspec/core/mocking/with_absolutely_nothing.rb

@@ -1,11 +0,0 @@
-module RSpec
-  module Core
-    module MockFrameworkAdapter
-
-      def setup_mocks_for_rspec; end
-      def verify_mocks_for_rspec; end
-      def teardown_mocks_for_rspec; end
-
-    end
-  end
-end

data/vendor_lib/rspec/core/mocking/with_flexmock.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Jim Weirich on 2007-04-10.
-#  Copyright (c) 2007. All rights reserved.
-
-require 'flexmock/rspec'
-
-module RSpec
-  module Core
-    module MockFrameworkAdapter
-
-      def self.framework_name; :flexmock end
-
-      include FlexMock::MockContainer
-      def setup_mocks_for_rspec
-        # No setup required
-      end
-      def verify_mocks_for_rspec
-        flexmock_verify
-      end
-      def teardown_mocks_for_rspec
-        flexmock_close
-      end
-
-    end
-  end
-end

data/vendor_lib/rspec/core/mocking/with_rr.rb

@@ -1,27 +0,0 @@
-require 'rr'
-
-RSpec.configuration.backtrace_exclusion_patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
-
-module RSpec
-  module Core
-    module MockFrameworkAdapter
-
-      def self.framework_name; :rr end
-
-      include RR::Extensions::InstanceMethods
-
-      def setup_mocks_for_rspec
-        RR::Space.instance.reset
-      end
-
-      def verify_mocks_for_rspec
-        RR::Space.instance.verify_doubles
-      end
-
-      def teardown_mocks_for_rspec
-        RR::Space.instance.reset
-      end
-
-    end
-  end
-end

data/vendor_lib/rspec/core/mocking/with_rspec.rb

@@ -1,27 +0,0 @@
-require 'rspec/mocks'
-
-module RSpec
-  module Core
-    module MockFrameworkAdapter
-
-      def self.framework_name; :rspec end
-
-      def self.configuration
-        RSpec::Mocks.configuration
-      end
-
-      def setup_mocks_for_rspec
-        RSpec::Mocks::setup(self)
-      end
-
-      def verify_mocks_for_rspec
-        RSpec::Mocks::verify
-      end
-
-      def teardown_mocks_for_rspec
-        RSpec::Mocks::teardown
-      end
-
-    end
-  end
-end

data/vendor_lib/rspec/core/pending.rb

@@ -1,110 +0,0 @@
-module RSpec
-  module Core
-    module Pending
-      class PendingDeclaredInExample < StandardError; end
-
-      # 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.
-      begin
-        class PendingExampleFixedError < Test::Unit::AssertionFailedError; end
-      rescue
-        class PendingExampleFixedError < StandardError; end
-      end
-
-      NO_REASON_GIVEN = 'No reason given'
-      NOT_YET_IMPLEMENTED = 'Not yet implemented'
-
-      # @overload pending()
-      # @overload pending(message)
-      # @overload pending(message, &block)
-      #
-      # Stops execution of an example, and reports it as pending. Takes an
-      # optional message and block.
-      #
-      # @param [String] message optional message to add to the summary report.
-      # @param [Block] block optional block. If it fails, the example is
-      #   reported as pending. If it executes cleanly the example fails.
-      #
-      # @example
-      #
-      #     describe "an example" do
-      #       # reported as "Pending: no reason given"
-      #       it "is pending with no message" do
-      #         pending
-      #         this_does_not_get_executed
-      #       end
-      #
-      #       # reported as "Pending: something else getting finished"
-      #       it "is pending with a custom message" do
-      #         pending("something else getting finished")
-      #         this_does_not_get_executed
-      #       end
-      #
-      #       # reported as "Pending: something else getting finished"
-      #       it "is pending with a failing block" do
-      #         pending("something else getting finished") do
-      #           raise "this is the failure"
-      #         end
-      #       end
-      #
-      #       # reported as failure, saying we expected the block to fail but
-      #       # it passed.
-      #       it "is pending with a passing block" do
-      #         pending("something else getting finished") do
-      #           true.should be(true)
-      #         end
-      #       end
-      #     end
-      #
-      # @note `before(:each)` hooks are eval'd when you use the `pending`
-      #   method within an example. If you want to declare an example `pending`
-      #   and bypass the `before` hooks as well, you can pass `:pending => true`
-      #   to the `it` method:
-      #
-      #       it "does something", :pending => true do
-      #         # ...
-      #       end
-      #
-      #   or pass `:pending => "something else getting finished"` to add a
-      #   message to the summary report:
-      #
-      #       it "does something", :pending => "something else getting finished" do
-      #         # ...
-      #       end
-      def pending(*args)
-        current_example = RSpec.current_example
-
-        return self.class.before(:each) { pending(*args) } unless current_example
-
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        message = args.first || NO_REASON_GIVEN
-
-        if options[:unless] || (options.has_key?(:if) && !options[:if])
-          return block_given? ? yield : nil
-        end
-
-        current_example.metadata[:pending] = true
-        current_example.metadata[:execution_result][:pending_message] = message
-        current_example.execution_result[:pending_fixed] = false
-        if block_given?
-          begin
-            result = begin
-                       yield
-                       current_example.example_group_instance.instance_eval { verify_mocks_for_rspec }
-                     end
-            current_example.metadata[:pending] = false
-          rescue Exception => e
-            current_example.execution_result[:exception] = e
-          ensure
-            teardown_mocks_for_rspec
-          end
-          if result
-            current_example.execution_result[:pending_fixed] = true
-            raise PendingExampleFixedError.new
-          end
-        end
-        raise PendingDeclaredInExample.new(message)
-      end
-    end
-  end
-end

data/vendor_lib/rspec/core/project_initializer.rb

@@ -1,88 +0,0 @@
-module RSpec
-  module Core
-    class ProjectInitializer
-      def initialize(arg=nil)
-        @arg = arg
-      end
-
-      def run
-        create_spec_helper_file
-        create_dot_rspec_file
-
-        delete_if_confirmed("lib/tasks/rspec.rake", <<-MESSAGE)
-  If the file in lib/tasks/rspec.rake is the one generated by rspec-rails-1x,
-  you can get rid of it, as it is no longer needed with rspec-2.
-        MESSAGE
-      end
-
-      def create_dot_rspec_file
-        if File.exist?('.rspec')
-          report_exists('.rspec')
-        else
-          report_creating('.rspec')
-          File.open('.rspec','w') do |f|
-            f.write <<-CONTENT
---color
---format progress
-CONTENT
-          end
-        end
-      end
-
-      def create_spec_helper_file
-        if File.exist?('spec/spec_helper.rb')
-          report_exists('spec/spec_helper.rb')
-        else
-          report_creating('spec/spec_helper.rb')
-          FileUtils.mkdir_p('spec')
-          File.open('spec/spec_helper.rb','w') do |f|
-            f.write <<-CONTENT
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  # Limit the spec run to only specs with the focus metadata. If no specs have
-  # the filtering metadata and `run_all_when_everything_filtered = true` then
-  # all specs will run.
-  #config.filter_run :focus
-
-  # Run all specs when none match the provided filter. This works well in
-  # conjunction with `config.filter_run :focus`, as it will run the entire
-  # suite when no specs have `:filter` metadata.
-  #config.run_all_when_everything_filtered = true
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  #config.order = 'random'
-end
-CONTENT
-          end
-        end
-      end
-
-      def delete_if_confirmed(path, message)
-        if File.exist?(path)
-          puts
-          puts message
-          puts
-          puts "  delete   #{path}? [y/n]"
-          FileUtils.rm_rf(path) if gets =~ /y/i
-        end
-      end
-
-      def report_exists(file)
-        puts "   exist   #{file}"
-      end
-
-      def report_creating(file)
-        puts "  create   #{file}"
-      end
-
-    end
-  end
-end