opal-rspec 0.4.0.beta3 → 0.4.0.beta4

data/vendor_lib/rspec/core/ordering.rb

@@ -0,0 +1,154 @@
+module RSpec
+  module Core
+    if defined?(::Random)
+      RandomNumberGenerator = ::Random
+    else
+      require 'rspec/core/backport_random'
+      RandomNumberGenerator = RSpec::Core::Backports::Random
+    end
+
+    # @private
+    module Ordering
+      # @private
+      # The default global ordering (defined order).
+      class Identity
+        def order(items)
+          items
+        end
+      end
+
+      # @private
+      # Orders items randomly.
+      class Random
+        def initialize(configuration)
+          @configuration = configuration
+          @used = false
+        end
+
+        def used?
+          @used
+        end
+
+        def order(items)
+          @used = true
+          rng = RandomNumberGenerator.new(@configuration.seed)
+          shuffle items, rng
+        end
+
+        if RUBY_VERSION > '1.9.3'
+          def shuffle(list, rng)
+            list.shuffle(:random => rng)
+          end
+        else
+          def shuffle(list, rng)
+            shuffled = list.dup
+            shuffled.size.times do |i|
+              j = i + rng.rand(shuffled.size - i)
+              next if i == j
+              shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+            end
+
+            shuffled
+          end
+        end
+      end
+
+      # @private
+      # Orders items based on a custom block.
+      class Custom
+        def initialize(callable)
+          @callable = callable
+        end
+
+        def order(list)
+          @callable.call(list)
+        end
+      end
+
+      # @private
+      # Stores the different ordering strategies.
+      class Registry
+        def initialize(configuration)
+          @configuration = configuration
+          @strategies    = {}
+
+          register(:random,  Random.new(configuration))
+
+          identity = Identity.new
+          register(:defined, identity)
+
+          # The default global ordering is --defined.
+          register(:global, identity)
+        end
+
+        def fetch(name, &fallback)
+          @strategies.fetch(name, &fallback)
+        end
+
+        def register(sym, strategy)
+          @strategies[sym] = strategy
+        end
+
+        def used_random_seed?
+          @strategies[:random].used?
+        end
+      end
+
+      # @private
+      # Manages ordering configuration.
+      #
+      # @note This is not intended to be used externally. Use
+      #       the APIs provided by `RSpec::Core::Configuration` instead.
+      class ConfigurationManager
+        attr_reader :seed, :ordering_registry
+
+        def initialize
+          @ordering_registry = Registry.new(self)
+          @seed = rand(0xFFFF)
+          @seed_forced = false
+          @order_forced = false
+        end
+
+        def seed_used?
+          ordering_registry.used_random_seed?
+        end
+
+        def seed=(seed)
+          return if @seed_forced
+          register_ordering(:global, ordering_registry.fetch(:random))
+          @seed = seed.to_i
+        end
+
+        def order=(type)
+          order, seed = type.to_s.split(':')
+          @seed = seed = seed.to_i if seed
+
+          ordering_name = if order.include?('rand')
+            :random
+          elsif order == 'defined'
+            :defined
+          end
+
+          register_ordering(:global, ordering_registry.fetch(ordering_name)) if ordering_name
+        end
+
+        def force(hash)
+          if hash.has_key?(:seed)
+            self.seed = hash[:seed]
+            @seed_forced  = true
+            @order_forced = true
+          elsif hash.has_key?(:order)
+            self.order = hash[:order]
+            @order_forced = true
+          end
+        end
+
+        def register_ordering(name, strategy = Custom.new(Proc.new { |l| yield l }))
+          return if @order_forced && name == :global
+          ordering_registry.register(name, strategy)
+        end
+      end
+    end
+  end
+end
+

data/vendor_lib/rspec/core/pending.rb

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,88 @@
+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

data/vendor_lib/rspec/core/rake_task.rb

@@ -0,0 +1,128 @@
+require 'rspec/support/warnings'
+require 'rake'
+require 'rake/tasklib'
+require 'shellwords'
+
+module RSpec
+  module Core
+    class RakeTask < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      # Name of task.
+      #
+      # default:
+      #   :spec
+      attr_accessor :name
+
+      # Glob pattern to match files.
+      #
+      # default:
+      #   'spec/**/*_spec.rb'
+      attr_accessor :pattern
+
+      # Whether or not to fail Rake when an error occurs (typically when examples fail).
+      #
+      # default:
+      #   true
+      attr_accessor :fail_on_error
+
+      # A message to print to stderr when there are failures.
+      attr_accessor :failure_message
+
+      # Use verbose output. If this is set to true, the task will print the
+      # executed spec command to stdout.
+      #
+      # default:
+      #   true
+      attr_accessor :verbose
+
+      # Command line options to pass to ruby.
+      #
+      # default:
+      #   nil
+      attr_accessor :ruby_opts
+
+      # Path to rspec
+      #
+      # default:
+      #   'rspec'
+      attr_accessor :rspec_path
+
+      # Command line options to pass to rspec.
+      #
+      # default:
+      #   nil
+      attr_accessor :rspec_opts
+
+      # @deprecated
+      # Use rspec_opts instead.
+      #
+      # Command line options to pass to rspec.
+      #
+      # default:
+      #   nil
+      def spec_opts=(opts)
+        RSpec.deprecate('RSpec::Core::RakeTask#spec_opts=', :replacement => 'rspec_opts=')
+        @rspec_opts = opts
+      end
+
+      def initialize(*args, &task_block)
+        setup_ivars(args)
+
+        desc "Run RSpec code examples" unless ::Rake.application.last_comment
+
+        task name, *args do |_, task_args|
+          RakeFileUtils.send(:verbose, verbose) do
+            task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block
+            run_task verbose
+          end
+        end
+      end
+
+      def setup_ivars(args)
+        @name = args.shift || :spec
+        @ruby_opts, @rspec_opts = nil, nil, nil
+        @verbose, @fail_on_error = true, true
+
+        @rspec_path = 'rspec'
+        @pattern    = './spec{,/*/**}/*_spec.rb'
+      end
+
+      def run_task(verbose)
+        command = spec_command
+
+        begin
+          puts command if verbose
+          success = system(command)
+        rescue
+          puts failure_message if failure_message
+        end
+        abort("#{command} failed") if fail_on_error unless success
+      end
+
+    private
+
+      def files_to_run
+        if ENV['SPEC']
+          FileList[ ENV['SPEC'] ].sort
+        else
+          FileList[ pattern ].sort.map(&:shellescape)
+        end
+      end
+
+      def spec_command
+        cmd_parts = []
+        cmd_parts << RUBY
+        cmd_parts << ruby_opts
+        cmd_parts << "-S" << rspec_path
+        cmd_parts << files_to_run
+        cmd_parts << rspec_opts
+        cmd_parts.flatten.reject(&blank).join(" ")
+      end
+
+      def blank
+        lambda {|s| s.nil? || s == ""}
+      end
+    end
+  end
+end

data/vendor_lib/rspec/core/reporter.rb

@@ -0,0 +1,132 @@
+module RSpec::Core
+  class Reporter
+    NOTIFICATIONS = %W[start message example_group_started example_group_finished example_started
+                       example_passed example_failed example_pending start_dump dump_pending
+                       dump_failures dump_summary seed close stop deprecation deprecation_summary].map(&:to_sym)
+
+    def initialize(configuration, *formatters)
+      @configuration = configuration
+      @listeners = Hash.new { |h,k| h[k] = [] }
+      formatters.each do |formatter|
+        register_listener(formatter, *NOTIFICATIONS)
+      end
+      @example_count = @failure_count = @pending_count = 0
+      @duration = @start = nil
+    end
+
+    # @api
+    # @param [Object] An obect that wishes to be notified of reporter events
+    # @param [Array] Array of symbols represents the events a listener wishes to subscribe too
+    #
+    # Registers a listener to a list of notifications. The reporter will send notification of
+    # events to all registered listeners
+    def register_listener(listener, *notifications)
+      notifications.each do |notification|
+        @listeners[notification.to_sym] << listener if listener.respond_to?(notification)
+      end
+      true
+    end
+
+    def registered_listeners(notification)
+      @listeners[notification]
+    end
+
+    # @api
+    # @overload report(count, &block)
+    # @overload report(count, &block)
+    # @param [Integer] count the number of examples being run
+    # @param [Block] block yields itself for further reporting.
+    #
+    # Initializes the report run and yields itself for further reporting. The
+    # block is required, so that the reporter can manage cleaning up after the
+    # run.
+    #
+    # @example
+    #
+    #     reporter.report(group.examples.size) do |r|
+    #       example_groups.map {|g| g.run(r) }
+    #     end
+    #
+    def report(expected_example_count)
+      start(expected_example_count)
+      begin
+        yield self
+      ensure
+        finish
+      end
+    end
+
+    def start(expected_example_count)
+      @start = RSpec::Core::Time.now
+      notify :start, expected_example_count
+    end
+
+    def message(message)
+      notify :message, message
+    end
+
+    def example_group_started(group)
+      notify :example_group_started, group unless group.descendant_filtered_examples.empty?
+    end
+
+    def example_group_finished(group)
+      notify :example_group_finished, group unless group.descendant_filtered_examples.empty?
+    end
+
+    def example_started(example)
+      @example_count += 1
+      notify :example_started, example
+    end
+
+    def example_passed(example)
+      notify :example_passed, example
+    end
+
+    def example_failed(example)
+      @failure_count += 1
+      notify :example_failed, example
+    end
+
+    def example_pending(example)
+      @pending_count += 1
+      notify :example_pending, example
+    end
+
+    def deprecation(message)
+      notify :deprecation, message
+    end
+
+    def finish
+      begin
+        stop
+        notify :start_dump
+        notify :dump_pending
+        notify :dump_failures
+        notify :dump_summary, @duration, @example_count, @failure_count, @pending_count
+        notify :deprecation_summary
+        notify :seed, @configuration.seed if seed_used?
+      ensure
+        notify :close
+      end
+    end
+
+    alias_method :abort, :finish
+
+    def stop
+      @duration = (RSpec::Core::Time.now - @start).to_f if @start
+      notify :stop
+    end
+
+    def notify(event, *args, &block)
+      registered_listeners(event).each do |formatter|
+        formatter.send(event, *args, &block)
+      end
+    end
+
+  private
+
+    def seed_used?
+      @configuration.seed && @configuration.seed_used?
+    end
+  end
+end

data/vendor_lib/rspec/core/ruby_project.rb

@@ -0,0 +1,44 @@
+# This is borrowed (slightly modified) from Scott Taylor's
+# project_path project:
+#   http://github.com/smtlaissezfaire/project_path
+
+require 'pathname'
+
+module RSpec
+  module Core
+    module RubyProject
+      def add_to_load_path(*dirs)
+        dirs.map {|dir| add_dir_to_load_path(File.join(root, dir))}
+      end
+
+      def add_dir_to_load_path(dir)
+        $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+      end
+
+      def root
+        @project_root ||= determine_root
+      end
+
+      def determine_root
+        find_first_parent_containing('spec') || '.'
+      end
+
+      def find_first_parent_containing(dir)
+        ascend_until {|path| File.exists?(File.join(path, dir))}
+      end
+
+      def ascend_until
+        Pathname(File.expand_path('.')).ascend do |path|
+          return path if yield(path)
+        end
+      end
+
+      module_function :add_to_load_path
+      module_function :add_dir_to_load_path
+      module_function :root
+      module_function :determine_root
+      module_function :find_first_parent_containing
+      module_function :ascend_until
+    end
+  end
+end