opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/core/runner.rb

@@ -0,0 +1,97 @@
+module RSpec
+  module Core
+    class Runner
+
+      # Register an at_exit hook that runs the suite.
+      def self.autorun
+        return if autorun_disabled? || installed_at_exit? || running_in_drb?
+        at_exit do
+          # Don't bother running any specs and just let the program terminate
+          # if we got here due to an unrescued exception (anything other than
+          # SystemExit, which is raised when somebody calls Kernel#exit).
+          next unless $!.nil? || $!.kind_of?(SystemExit)
+
+          # We got here because either the end of the program was reached or
+          # somebody called Kernel#exit.  Run the specs and then override any
+          # existing exit status with RSpec's exit status if any specs failed.
+          status = run(ARGV, $stderr, $stdout).to_i
+          exit status if status != 0
+        end
+        @installed_at_exit = true
+      end
+      AT_EXIT_HOOK_BACKTRACE_LINE = "#{__FILE__}:#{__LINE__ - 2}:in `autorun'"
+
+      def self.disable_autorun!
+        @autorun_disabled = true
+      end
+
+      def self.autorun_disabled?
+        @autorun_disabled ||= false
+      end
+
+      def self.installed_at_exit?
+        @installed_at_exit ||= false
+      end
+
+      def self.running_in_drb?
+        begin
+          if defined?(DRb) && DRb.current_server
+            require 'socket'
+            require 'uri'
+
+            local_ipv4 = IPSocket.getaddress(Socket.gethostname)
+
+            local_drb = ["127.0.0.1", "localhost", local_ipv4].any? { |addr| addr == URI(DRb.current_server.uri).host }
+          end
+        rescue DRb::DRbServerNotFound
+        ensure
+          return local_drb || false
+        end
+      end
+
+      def self.trap_interrupt
+        trap('INT') do
+          exit!(1) if RSpec.wants_to_quit
+          RSpec.wants_to_quit = true
+          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+        end
+      end
+
+      # Run a suite of RSpec examples.
+      #
+      # This is used internally by RSpec to run a suite, but is available
+      # for use by any other automation tool.
+      #
+      # If you want to run this multiple times in the same process, and you
+      # want files like spec_helper.rb to be reloaded, be sure to load `load`
+      # instead of `require`.
+      #
+      # #### Parameters
+      # * +args+ - an array of command-line-supported arguments
+      # * +err+ - error stream (Default: $stderr)
+      # * +out+ - output stream (Default: $stdout)
+      #
+      # #### Returns
+      # * +Fixnum+ - exit status code (0/1)
+      def self.run(args, err=$stderr, out=$stdout)
+        trap_interrupt
+        options = ConfigurationOptions.new(args)
+        options.parse_options
+
+        if options.options[:drb]
+          require 'rspec/core/drb_command_line'
+          begin
+            DRbCommandLine.new(options).run(err, out)
+          rescue DRb::DRbConnError
+            err.puts "No DRb server is running. Running in local process instead ..."
+            CommandLine.new(options).run(err, out)
+          end
+        else
+          CommandLine.new(options).run(err, out)
+        end
+      ensure
+        RSpec.reset
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/shared_context.rb

@@ -0,0 +1,53 @@
+module RSpec
+  module Core
+    # Exposes {ExampleGroup}-level methods to a module, so you can include that
+    # module in an {ExampleGroup}.
+    #
+    # @example
+    #
+    #     module LoggedInAsAdmin
+    #       extend RSpec::Core::SharedContext
+    #       before(:each) do
+    #         log_in_as :admin
+    #       end
+    #     end
+    #
+    #     describe "admin section" do
+    #       include LoggedInAsAdmin
+    #       # ...
+    #     end
+    module SharedContext
+      # @api private
+      def included(group)
+        __shared_context_recordings.each do |recording|
+          recording.playback_onto(group)
+        end
+      end
+
+      # @api private
+      def __shared_context_recordings
+        @__shared_context_recordings ||= []
+      end
+
+      Recording = Struct.new(:method_name, :args, :block) do
+        def playback_onto(group)
+          group.__send__(method_name, *args, &block)
+        end
+      end
+
+      # @api private
+      def self.record(methods)
+        methods.each do |meth|
+          define_method(meth) do |*args, &block|
+            __shared_context_recordings << Recording.new(meth, args, block)
+          end
+        end
+      end
+
+      record [:describe, :context] + Hooks.instance_methods(false) +
+        MemoizedHelpers::ClassMethods.instance_methods(false)
+    end
+  end
+
+  SharedContext = Core::SharedContext
+end

data/vendor_lib/rspec/core/shared_example_group/collection.rb

@@ -0,0 +1,27 @@
+module RSpec
+  module Core
+    module SharedExampleGroup
+      class Collection
+
+        def initialize(sources, examples)
+          @sources, @examples = sources, examples
+        end
+
+        def [](key)
+          fetch_examples(key)
+        end
+
+        private
+
+          def fetch_examples(key)
+            @examples[source_for key][key]
+          end
+
+          def source_for(key)
+            @sources.reverse.find { |source| @examples[source].has_key? key }
+          end
+
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/shared_example_group.rb

@@ -0,0 +1,146 @@
+module RSpec
+  module Core
+    module SharedExampleGroup
+      # @overload shared_examples(name, &block)
+      # @overload shared_examples(name, tags, &block)
+      #
+      # Wraps the `block` in a module which can then be included in example
+      # groups using `include_examples`, `include_context`, or
+      # `it_behaves_like`.
+      #
+      # @param [String] name to match when looking up this shared group
+      # @param block to be eval'd in a nested example group generated by `it_behaves_like`
+      #
+      # @example
+      #
+      #   shared_examples "auditable" do
+      #     it "stores an audit record on save!" do
+      #       lambda { auditable.save! }.should change(Audit, :count).by(1)
+      #     end
+      #   end
+      #
+      #   class Account do
+      #     it_behaves_like "auditable" do
+      #       def auditable; Account.new; end
+      #     end
+      #   end
+      #
+      # @see ExampleGroup.it_behaves_like
+      # @see ExampleGroup.include_examples
+      # @see ExampleGroup.include_context
+      def shared_examples(*args, &block)
+        SharedExampleGroup.registry.add_group(self, *args, &block)
+      end
+
+      alias_method :shared_context,      :shared_examples
+      alias_method :share_examples_for,  :shared_examples
+      alias_method :shared_examples_for, :shared_examples
+
+      def shared_example_groups
+        SharedExampleGroup.registry.shared_example_groups_for('main', *ancestors[0..-1])
+      end
+
+      module TopLevelDSL
+        def shared_examples(*args, &block)
+          SharedExampleGroup.registry.add_group('main', *args, &block)
+        end
+
+        alias_method :shared_context,      :shared_examples
+        alias_method :share_examples_for,  :shared_examples
+        alias_method :shared_examples_for, :shared_examples
+
+        def shared_example_groups
+          SharedExampleGroup.registry.shared_example_groups_for('main')
+        end
+      end
+
+      def self.registry
+        @registry ||= Registry.new
+      end
+
+      # @private
+      #
+      # Used internally to manage the shared example groups and
+      # constants. We want to limit the number of methods we add
+      # to objects we don't own (main and Module) so this allows
+      # us to have helper methods that don't get added to those
+      # objects.
+      class Registry
+        def add_group(source, *args, &block)
+          ensure_block_has_source_location(block, CallerFilter.first_non_rspec_line)
+
+          if key? args.first
+            key = args.shift
+            warn_if_key_taken source, key, block
+            add_shared_example_group source, key, block
+          end
+
+          unless args.empty?
+            mod = Module.new
+            (class << mod; self; end).send :define_method, :extended  do |host|
+              host.class_eval(&block)
+            end
+            RSpec.configuration.extend mod, *args
+          end
+        end
+
+        def shared_example_groups_for(*sources)
+          Collection.new(sources, shared_example_groups)
+        end
+
+        def shared_example_groups
+          @shared_example_groups ||= Hash.new { |hash,key| hash[key] = Hash.new }
+        end
+
+        def clear
+          shared_example_groups.clear
+        end
+
+      private
+
+        def add_shared_example_group(source, key, block)
+          shared_example_groups[source][key] = block
+        end
+
+        def key?(candidate)
+          [String, Symbol, Module].any? { |cls| cls === candidate }
+        end
+
+        def warn_if_key_taken(source, key, new_block)
+          return unless existing_block = example_block_for(source, key)
+
+          RSpec.warn_with <<-WARNING.gsub(/^ +\|/, ''), :call_site => nil
+            |WARNING: Shared example group '#{key}' has been previously defined at:
+            |  #{formatted_location existing_block}
+            |...and you are now defining it at:
+            |  #{formatted_location new_block}
+            |The new definition will overwrite the original one.
+          WARNING
+        end
+
+        def formatted_location(block)
+          block.source_location.join ":"
+        end
+
+        def example_block_for(source, key)
+          shared_example_groups[source][key]
+        end
+
+        if Proc.method_defined?(:source_location)
+          def ensure_block_has_source_location(block, caller_line); end
+        else # for 1.8.7
+          def ensure_block_has_source_location(block, caller_line)
+            block.extend Module.new {
+              define_method :source_location do
+                caller_line.split(':')
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+extend RSpec::Core::SharedExampleGroup::TopLevelDSL
+Module.send(:include, RSpec::Core::SharedExampleGroup::TopLevelDSL)

data/vendor_lib/rspec/core/version.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Core
+    module Version
+      STRING = '3.0.0.beta1'
+    end
+  end
+end

data/vendor_lib/rspec/core/warnings.rb

@@ -0,0 +1,22 @@
+module RSpec
+
+  # @private
+  #
+  # Used internally to print deprecation warnings
+  def self.deprecate(deprecated, data = {})
+    RSpec.configuration.reporter.deprecation(
+      {
+        :deprecated => deprecated,
+        :call_site => CallerFilter.first_non_rspec_line
+      }.merge(data)
+    )
+  end
+
+  # @private
+  #
+  # Used internally to print deprecation warnings
+  def self.warn_deprecation(message)
+    RSpec.configuration.reporter.deprecation :message => message
+  end
+
+end

data/vendor_lib/rspec/core/world.rb

@@ -0,0 +1,131 @@
+module RSpec
+  module Core
+    class World
+
+      include RSpec::Core::Hooks
+
+      attr_reader :example_groups, :filtered_examples
+      attr_accessor :wants_to_quit
+
+      def initialize(configuration=RSpec.configuration)
+        @configuration = configuration
+        @example_groups = []
+        @filtered_examples = Hash.new { |hash,group|
+          hash[group] = begin
+            examples = group.examples.dup
+            examples = filter_manager.prune(examples)
+            examples.uniq!
+            examples
+          end
+        }
+      end
+
+      def ordered_example_groups
+        ordering_strategy = @configuration.ordering_registry.fetch(:global)
+        ordering_strategy.order(@example_groups)
+      end
+
+      def reset
+        example_groups.clear
+        SharedExampleGroup.registry.clear
+      end
+
+      def filter_manager
+        @configuration.filter_manager
+      end
+
+      def register(example_group)
+        example_groups << example_group
+        example_group
+      end
+
+      def inclusion_filter
+        @configuration.inclusion_filter
+      end
+
+      def exclusion_filter
+        @configuration.exclusion_filter
+      end
+
+      def configure_group(group)
+        @configuration.configure_group(group)
+      end
+
+      def example_count
+        FlatMap.flat_map(example_groups) {|g| g.descendants}.
+          inject(0) {|sum, g| sum + g.filtered_examples.size}
+      end
+
+      def preceding_declaration_line(filter_line)
+        declaration_line_numbers.sort.inject(nil) do |highest_prior_declaration_line, line|
+          line <= filter_line ? line : highest_prior_declaration_line
+        end
+      end
+
+      def reporter
+        @configuration.reporter
+      end
+
+      def announce_filters
+        filter_announcements = []
+
+        announce_inclusion_filter filter_announcements
+        announce_exclusion_filter filter_announcements
+
+        unless filter_manager.empty?
+          if filter_announcements.length == 1
+            reporter.message("Run options: #{filter_announcements[0]}")
+          else
+            reporter.message("Run options:\n  #{filter_announcements.join("\n  ")}")
+          end
+        end
+
+        if @configuration.run_all_when_everything_filtered? && example_count.zero?
+          reporter.message("#{everything_filtered_message}; ignoring #{inclusion_filter.description}")
+          filtered_examples.clear
+          inclusion_filter.clear
+        end
+
+        if example_count.zero?
+          example_groups.clear
+          if filter_manager.empty?
+            reporter.message("No examples found.")
+          elsif exclusion_filter.empty_without_conditional_filters?
+            message = everything_filtered_message
+            if @configuration.run_all_when_everything_filtered?
+              message << "; ignoring #{inclusion_filter.description}"
+            end
+            reporter.message(message)
+          elsif inclusion_filter.empty?
+            reporter.message(everything_filtered_message)
+          end
+        end
+      end
+
+      def everything_filtered_message
+        "\nAll examples were filtered out"
+      end
+
+      def announce_inclusion_filter(announcements)
+        unless inclusion_filter.empty?
+          announcements << "include #{inclusion_filter.description}"
+        end
+      end
+
+      def announce_exclusion_filter(announcements)
+        unless exclusion_filter.empty_without_conditional_filters?
+          announcements << "exclude #{exclusion_filter.description}"
+        end
+      end
+
+    private
+
+      def declaration_line_numbers
+        @line_numbers ||= example_groups.inject([]) do |lines, g|
+          lines + g.declaration_line_numbers
+        end
+      end
+
+    end
+  end
+end

data/vendor_lib/rspec/core.rb

@@ -0,0 +1,203 @@
+require_rspec = if defined?(require_relative)
+  lambda do |path|
+    require_relative path
+  end
+else # for 1.8.7
+  lambda do |path|
+    require "rspec/#{path}"
+  end
+end
+
+require 'set'
+require 'time'
+require 'rbconfig'
+
+require_rspec['core/version']
+
+require 'rspec/support/caller_filter'
+require 'rspec/core/warnings'
+require 'rspec/support/warnings'
+
+require_rspec['core/flat_map']
+require_rspec['core/filter_manager']
+require_rspec['core/dsl']
+require_rspec['core/reporter']
+
+require_rspec['core/hooks']
+require_rspec['core/memoized_helpers']
+require_rspec['core/metadata']
+require_rspec['core/pending']
+require_rspec['core/formatters']
+require_rspec['core/ordering']
+
+require_rspec['core/world']
+require_rspec['core/configuration']
+require_rspec['core/option_parser']
+require_rspec['core/configuration_options']
+require_rspec['core/command_line']
+require_rspec['core/runner']
+require_rspec['core/example']
+require_rspec['core/shared_example_group/collection']
+require_rspec['core/shared_example_group']
+require_rspec['core/example_group']
+
+module RSpec
+  autoload :SharedContext, 'rspec/core/shared_context'
+
+  # @private
+  def self.wants_to_quit
+  # Used internally to determine what to do when a SIGINT is received
+    world.wants_to_quit
+  end
+
+  # @private
+  # Used internally to determine what to do when a SIGINT is received
+  def self.wants_to_quit=(maybe)
+    world.wants_to_quit=(maybe)
+  end
+
+  # @private
+  # Internal container for global non-configuration data
+  def self.world
+    @world ||= RSpec::Core::World.new
+  end
+
+  # @private
+  # Used internally to set the global object
+  def self.world=(new_world)
+    @world = new_world
+  end
+
+  # @private
+  # Used internally to ensure examples get reloaded between multiple runs in
+  # the same process.
+  def self.reset
+    @world = nil
+    @configuration = nil
+  end
+
+  # Returns the global [Configuration](RSpec/Core/Configuration) object. While you
+  # _can_ use this method to access the configuration, the more common
+  # convention is to use [RSpec.configure](RSpec#configure-class_method).
+  #
+  # @example
+  #     RSpec.configuration.drb_port = 1234
+  # @see RSpec.configure
+  # @see Core::Configuration
+  def self.configuration
+    if block_given?
+      RSpec.warn_deprecation <<-WARNING
+
+*****************************************************************
+DEPRECATION WARNING
+
+* RSpec.configuration with a block is deprecated and has no effect.
+* please use RSpec.configure with a block instead.
+
+Called from #{CallerFilter.first_non_rspec_line}
+*****************************************************************
+
+WARNING
+    end
+    @configuration ||= RSpec::Core::Configuration.new
+  end
+
+  # @private
+  # Used internally to set the global object
+  def self.configuration=(new_configuration)
+    @configuration = new_configuration
+  end
+
+  # Yields the global configuration to a block.
+  # @yield [Configuration] global configuration
+  #
+  # @example
+  #     RSpec.configure do |config|
+  #       config.add_formatter 'documentation'
+  #     end
+  # @see Core::Configuration
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  # @private
+  # Used internally to clear remaining groups when fail_fast is set
+  def self.clear_remaining_example_groups
+    world.example_groups.clear
+  end
+
+  # The example being executed.
+  #
+  # The primary audience for this method is library authors who need access
+  # to the example currently being executed and also want to support all
+  # versions of RSpec 2 and 3.
+  #
+  # @example
+  #
+  #     RSpec.configure do |c|
+  #       # context.example is deprecated, but RSpec.current_example is not
+  #       # available until RSpec 3.0.
+  #       fetch_current_example = RSpec.respond_to?(:current_example) ?
+  #         proc { RSpec.current_example } : proc { |context| context.example }
+  #
+  #       c.before(:each) do
+  #         example = fetch_current_example.call(self)
+  #
+  #         # ...
+  #       end
+  #     end
+  #
+  def self.current_example
+    Thread.current[:_rspec_current_example]
+  end
+
+  # Set the current example being executed.
+  # @api private
+  def self.current_example=(example)
+    Thread.current[:_rspec_current_example] = example
+  end
+
+  # @private
+  def self.windows_os?
+    RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+  end
+
+  module Core
+    # @private
+    # This avoids issues with reporting time caused by examples that
+    # change the value/meaning of Time.now without properly restoring
+    # it.
+    class Time
+      class << self
+        define_method(:now, &::Time.method(:now))
+      end
+    end
+
+    # @private path to executable file
+    def self.path_to_executable
+      @path_to_executable ||= File.expand_path('../../../exe/rspec', __FILE__)
+    end
+  end
+
+  MODULES_TO_AUTOLOAD = {
+    :Matchers     => "rspec/expectations",
+    :Expectations => "rspec/expectations",
+    :Mocks        => "rspec/mocks"
+  }
+
+  def self.const_missing(name)
+    # Load rspec-expectations when RSpec::Matchers is referenced. This allows
+    # people to define custom matchers (using `RSpec::Matchers.define`) before
+    # rspec-core has loaded rspec-expectations (since it delays the loading of
+    # it to allow users to configure a different assertion/expectation
+    # framework). `autoload` can't be used since it works with ruby's built-in
+    # require (e.g. for files that are available relative to a load path dir),
+    # but not with rubygems' extended require.
+    #
+    # As of rspec 2.14.1, we no longer require `rspec/mocks` and
+    # `rspec/expectations` when `rspec` is required, so we want
+    # to make them available as an autoload. For more info, see:
+    require MODULES_TO_AUTOLOAD.fetch(name) { return super }
+    ::RSpec.const_get(name)
+  end
+end