opal-rspec 0.6.2 → 0.7.0.rc.1

data/rspec-core/lib/rspec/core/option_parser.rb

@@ -1,222 +0,0 @@
-# http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html
-require 'optparse'
-
-module RSpec::Core
-  # @private
-  class Parser
-    def self.parse(args)
-      new.parse(args)
-    end
-
-    def parse(args)
-      return {} if args.empty?
-
-      options = args.delete('--tty') ? { :tty => true } : {}
-      begin
-        parser(options).parse!(args)
-      rescue OptionParser::InvalidOption => e
-        abort "#{e.message}\n\nPlease use --help for a listing of valid options"
-      end
-
-      options
-    end
-
-    def parser(options)
-      OptionParser.new do |parser|
-        parser.banner = "Usage: rspec [options] [files or directories]\n\n"
-
-        parser.on('-I PATH', 'Specify PATH to add to $LOAD_PATH (may be used more than once).') do |dir|
-          options[:libs] ||= []
-          options[:libs] << dir
-        end
-
-        parser.on('-r', '--require PATH', 'Require a file.') do |path|
-          options[:requires] ||= []
-          options[:requires] << path
-        end
-
-        parser.on('-O', '--options PATH', 'Specify the path to a custom options file.') do |path|
-          options[:custom_options_file] = path
-        end
-
-        parser.on('--order TYPE[:SEED]', 'Run examples by the specified order type.',
-                  '  [defined] examples and groups are run in the order they are defined',
-                  '  [rand]    randomize the order of groups and examples',
-                  '  [random]  alias for rand',
-                  '  [random:SEED] e.g. --order random:123') do |o|
-          options[:order] = o
-        end
-
-        parser.on('--seed SEED', Integer, 'Equivalent of --order rand:SEED.') do |seed|
-          options[:order] = "rand:#{seed}"
-        end
-
-        parser.on('--fail-fast', 'Abort the run on first failure.') do |_o|
-          options[:fail_fast] = true
-        end
-
-        parser.on('--no-fail-fast', 'Do not abort the run on first failure.') do |_o|
-          options[:fail_fast] = false
-        end
-
-        parser.on('--failure-exit-code CODE', Integer, 'Override the exit code used when there are failing specs.') do |code|
-          options[:failure_exit_code] = code
-        end
-
-        parser.on('--dry-run', 'Print the formatter output of your suite without',
-                  '  running any examples or hooks') do |_o|
-          options[:dry_run] = true
-        end
-
-        parser.on('-X', '--[no-]drb', 'Run examples via DRb.') do |o|
-          options[:drb] = o
-        end
-
-        parser.on('--drb-port PORT', 'Port to connect to the DRb server.') do |o|
-          options[:drb_port] = o.to_i
-        end
-
-        parser.on('--init', 'Initialize your project with RSpec.') do |_cmd|
-          RSpec::Support.require_rspec_core "project_initializer"
-          ProjectInitializer.new.run
-          exit
-        end
-
-        parser.separator("\n  **** Output ****\n\n")
-
-        parser.on('-f', '--format FORMATTER', 'Choose a formatter.',
-                  '  [p]rogress (default - dots)',
-                  '  [d]ocumentation (group and example names)',
-                  '  [h]tml',
-                  '  [j]son',
-                  '  custom formatter class name') do |o|
-          options[:formatters] ||= []
-          options[:formatters] << [o]
-        end
-
-        parser.on('-o', '--out FILE',
-                  'Write output to a file instead of $stdout. This option applies',
-                  '  to the previously specified --format, or the default format',
-                  '  if no format is specified.'
-                 ) do |o|
-          options[:formatters] ||= [['progress']]
-          options[:formatters].last << o
-        end
-
-        parser.on('--deprecation-out FILE', 'Write deprecation warnings to a file instead of $stderr.') do |file|
-          options[:deprecation_stream] = file
-        end
-
-        parser.on('-b', '--backtrace', 'Enable full backtrace.') do |_o|
-          options[:full_backtrace] = true
-        end
-
-        parser.on('-c', '--[no-]color', '--[no-]colour', 'Enable color in the output.') do |o|
-          options[:color] = o
-        end
-
-        parser.on('-p', '--[no-]profile [COUNT]', 'Enable profiling of examples and list the slowest examples (default: 10).') do |argument|
-          options[:profile_examples] = if argument.nil?
-                                         true
-                                       elsif argument == false
-                                         false
-                                       else
-                                         begin
-                                           Integer(argument)
-                                         rescue ArgumentError
-                                           RSpec.warning "Non integer specified as profile count, seperate " \
-                                                       "your path from options with -- e.g. " \
-                                                       "`rspec --profile -- #{argument}`",
-                                                         :call_site => nil
-                                           true
-                                         end
-                                       end
-        end
-
-        parser.on('-w', '--warnings', 'Enable ruby warnings') do
-          $VERBOSE = true
-        end
-
-        parser.separator <<-FILTERING
-
-  **** Filtering/tags ****
-
-    In addition to the following options for selecting specific files, groups,
-    or examples, you can select a single example by appending the line number to
-    the filename:
-
-      rspec path/to/a_spec.rb:37
-
-FILTERING
-
-        parser.on('-P', '--pattern PATTERN', 'Load files matching pattern (default: "spec/**/*_spec.rb").') do |o|
-          options[:pattern] = o
-        end
-
-        parser.on('--exclude-pattern PATTERN', 'Load files except those matching pattern. Opposite effect of --pattern.') do |o|
-          options[:exclude_pattern] = o
-        end
-
-        parser.on('-e', '--example STRING', "Run examples whose full nested names include STRING (may be",
-                  "  used more than once)") do |o|
-          (options[:full_description] ||= []) << Regexp.compile(Regexp.escape(o))
-        end
-
-        parser.on('-t', '--tag TAG[:VALUE]',
-                  'Run examples with the specified tag, or exclude examples',
-                  'by adding ~ before the tag.',
-                  '  - e.g. ~slow',
-                  '  - TAG is always converted to a symbol') do |tag|
-          filter_type = tag =~ /^~/ ? :exclusion_filter : :inclusion_filter
-
-          name, value = tag.gsub(/^(~@|~|@)/, '').split(':', 2)
-          name = name.to_sym
-
-          options[filter_type] ||= {}
-          options[filter_type][name] = case value
-                                       when  nil        then true # The default value for tags is true
-                                       when 'true'      then true
-                                       when 'false'     then false
-                                       when 'nil'       then nil
-                                       when /^:/        then value[1..-1].to_sym
-                                       when /^\d+$/     then Integer(value)
-                                       when /^\d+.\d+$/ then Float(value)
-                                       else
-                                         value
-                                       end
-        end
-
-        parser.on('--default-path PATH', 'Set the default path where RSpec looks for examples (can',
-                  '  be a path to a file or a directory).') do |path|
-          options[:default_path] = path
-        end
-
-        parser.separator("\n  **** Utility ****\n\n")
-
-        parser.on('-v', '--version', 'Display the version.') do
-          puts RSpec::Core::Version::STRING
-          exit
-        end
-
-        # these options would otherwise be confusing to users, so we forcibly prevent them from executing
-        # --I is too similar to -I
-        # -d was a shorthand for --debugger, which is removed, but now would trigger --default-path
-        invalid_options = %w[-d --I]
-
-        parser.on_tail('-h', '--help', "You're looking at it.") do
-          # removing the blank invalid options from the output
-          puts parser.to_s.gsub(/^\s+(#{invalid_options.join('|')})\s*$\n/, '')
-          exit
-        end
-
-        # this prevents usage of the invalid_options
-        invalid_options.each do |option|
-          parser.on(option) do
-            raise OptionParser::InvalidOption.new
-          end
-        end
-
-      end
-    end
-  end
-end

data/rspec-core/lib/rspec/core/ordering.rb

@@ -1,155 +0,0 @@
-module RSpec
-  module Core
-    if defined?(::Random)
-      # @private
-      RandomNumberGenerator = ::Random
-    else
-      RSpec::Support.require_rspec_core "backport_random"
-      # @private
-      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.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.key?(:seed)
-            self.seed = hash[:seed]
-            @seed_forced  = true
-            @order_forced = true
-          elsif hash.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/rspec-core/lib/rspec/core/pending.rb

@@ -1,163 +0,0 @@
-module RSpec
-  module Core
-    # Provides methods to mark examples as pending. These methods are available to be
-    # called from within any example or hook.
-    module Pending
-      # Raised in the middle of an example to indicate that it should be marked as skipped.
-      class SkipDeclaredInExample < StandardError
-        attr_reader :argument
-
-        def initialize(argument)
-          @argument = argument
-        end
-      end
-
-      # If Test::Unit is loaded, 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
-
-      # @private
-      NO_REASON_GIVEN = 'No reason given'
-
-      # @private
-      NOT_YET_IMPLEMENTED = 'Not yet implemented'
-
-      # @overload pending()
-      # @overload pending(message)
-      #
-      # Marks an example as pending. The rest of the example will still be
-      # executed, and if it passes the example will fail to indicate that the
-      # pending can be removed.
-      #
-      # @param message [String] optional message to add to the summary report.
-      #
-      # @example
-      #     describe "an example" do
-      #       # reported as "Pending: no reason given"
-      #       it "is pending with no message" do
-      #         pending
-      #         raise "broken"
-      #       end
-      #
-      #       # reported as "Pending: something else getting finished"
-      #       it "is pending with a custom message" do
-      #         pending("something else getting finished")
-      #         raise "broken"
-      #       end
-      #     end
-      #
-      # @note `before(:example)` 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(message=nil)
-        current_example = RSpec.current_example
-
-        if block_given?
-          raise ArgumentError, <<-EOS.gsub(/^\s+\|/, '')
-            |The semantics of `RSpec::Core::Pending#pending` have changed in
-            |RSpec 3.  In RSpec 2.x, it caused the example to be skipped. In
-            |RSpec 3, the rest of the example is still run but is expected to
-            |fail, and will be marked as a failure (rather than as pending) if
-            |the example passes.
-            |
-            |Passing a block within an example is now deprecated. Marking the
-            |example as pending provides the same behavior in RSpec 3 which was
-            |provided only by the block in RSpec 2.x.
-            |
-            |Move the code in the block provided to `pending` into the rest of
-            |the example body.
-            |
-            |Called from #{CallerFilter.first_non_rspec_line}.
-            |
-          EOS
-        elsif current_example
-          Pending.mark_pending! current_example, message
-        else
-          raise "`pending` may not be used outside of examples, such as in " \
-                "before(:context). Maybe you want `skip`?"
-        end
-      end
-
-      # @overload skip()
-      # @overload skip(message)
-      #
-      # Marks an example as pending and skips execution.
-      #
-      # @param message [String] optional message to add to the summary report.
-      #
-      # @example
-      #     describe "an example" do
-      #       # reported as "Pending: no reason given"
-      #       it "is skipped with no message" do
-      #         skip
-      #       end
-      #
-      #       # reported as "Pending: something else getting finished"
-      #       it "is skipped with a custom message" do
-      #         skip "something else getting finished"
-      #       end
-      #     end
-      def skip(message=nil)
-        current_example = RSpec.current_example
-
-        Pending.mark_skipped!(current_example, message) if current_example
-
-        raise SkipDeclaredInExample.new(message)
-      end
-
-      # @private
-      #
-      # Mark example as skipped
-      #
-      # @param example [RSpec::Core::Example] the example to mark as skipped
-      # @param message_or_bool [Boolean, String] the message to use, or true
-      def self.mark_skipped!(example, message_or_bool)
-        Pending.mark_pending! example, message_or_bool
-        example.metadata[:skip] = true
-      end
-
-      # @private
-      #
-      # Mark example as pending
-      #
-      # @param example [RSpec::Core::Example] the example to mark as pending
-      # @param message_or_bool [Boolean, String] the message to use, or true
-      def self.mark_pending!(example, message_or_bool)
-        message = if !message_or_bool || !(String === message_or_bool)
-                    NO_REASON_GIVEN
-                  else
-                    message_or_bool
-                  end
-
-        example.metadata[:pending] = true
-        example.execution_result.pending_message = message
-        example.execution_result.pending_fixed = false
-      end
-
-      # @private
-      #
-      # Mark example as fixed
-      #
-      # @param example [RSpec::Core::Example] the example to mark as fixed
-      def self.mark_fixed!(example)
-        example.execution_result.pending_fixed = true
-      end
-    end
-  end
-end