opal-connect-rspec 0.5.0

data/rspec-support/lib/rspec/support/os.rb

@@ -0,0 +1,18 @@
+module RSpec
+  module Support
+    # @api private
+    #
+    # Provides query methods for different OS or OS features.
+    module OS
+      def windows?
+        RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+      end
+      module_function :windows?
+
+      def windows_file_path?
+        ::File::ALT_SEPARATOR == '\\'
+      end
+      module_function :windows_file_path?
+    end
+  end
+end

data/rspec-support/lib/rspec/support/recursive_const_methods.rb

@@ -0,0 +1,76 @@
+module RSpec
+  module Support
+    # Provides recursive constant lookup methods useful for
+    # constant stubbing.
+    module RecursiveConstMethods
+      # We only want to consider constants that are defined directly on a
+      # particular module, and not include top-level/inherited constants.
+      # Unfortunately, the constant API changed between 1.8 and 1.9, so
+      # we need to conditionally define methods to ignore the top-level/inherited
+      # constants.
+      #
+      # Given:
+      #   class A; B = 1; end
+      #   class C < A; end
+      #
+      # On 1.8:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => false
+      #   - C.constants # => ["B"]
+      #   - None of these methods accept the extra `inherit` argument
+      # On 1.9:
+      #   - C.const_get("Hash") # => ::Hash
+      #   - C.const_defined?("Hash") # => true
+      #   - C.const_get("Hash", false) # => raises NameError
+      #   - C.const_defined?("Hash", false) # => false
+      #   - C.constants # => [:B]
+      #   - C.constants(false) #=> []
+      if Module.method(:const_defined?).arity == 1
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          return mod.const_get(const_name) if const_defined_on?(mod, const_name)
+
+          raise NameError, "uninitialized constant #{mod.name}::#{const_name}"
+        end
+
+        def constants_defined_on(mod)
+          mod.constants.select { |c| const_defined_on?(mod, c) }
+        end
+      else
+        def const_defined_on?(mod, const_name)
+          mod.const_defined?(const_name, false)
+        end
+
+        def get_const_defined_on(mod, const_name)
+          mod.const_get(const_name, false)
+        end
+
+        def constants_defined_on(mod)
+          mod.constants(false)
+        end
+      end
+
+      def recursive_const_get(const_name)
+        normalize_const_name(const_name).split('::').inject(Object) do |mod, name|
+          get_const_defined_on(mod, name)
+        end
+      end
+
+      def recursive_const_defined?(const_name)
+        parts = normalize_const_name(const_name).split('::')
+        parts.inject([Object, '']) do |(mod, full_name), name|
+          yield(full_name, name) if block_given? && !(Module === mod)
+          return false unless const_defined_on?(mod, name)
+          [get_const_defined_on(mod, name), [mod, name].join('::')]
+        end
+      end
+
+      def normalize_const_name(const_name)
+        const_name.sub(/\A::/, '')
+      end
+    end
+  end
+end

data/rspec-support/lib/rspec/support/ruby_features.rb

@@ -0,0 +1,45 @@
+module RSpec
+  module Support
+    # @api private
+    #
+    # Provides query methods for different rubies
+    module Ruby
+      def jruby?
+        RUBY_PLATFORM == 'java'
+      end
+      module_function :jruby?
+    end
+
+    # @api private
+    #
+    # Provides query methods for ruby features that differ among
+    # implementations.
+    module RubyFeatures
+      def optional_and_splat_args_supported?
+        Method.method_defined?(:parameters)
+      end
+      module_function :optional_and_splat_args_supported?
+
+      def kw_args_supported?
+        RUBY_VERSION >= '2.0.0' && RUBY_ENGINE != 'rbx' && RUBY_ENGINE != 'jruby'
+      end
+      module_function :kw_args_supported?
+
+      def required_kw_args_supported?
+        RUBY_VERSION >= '2.1.0' && RUBY_ENGINE != 'rbx' && RUBY_ENGINE != 'jruby'
+      end
+      module_function :required_kw_args_supported?
+
+      def module_prepends_supported?
+        Module.method_defined?(:prepend) || Module.private_method_defined?(:prepend)
+      end
+      module_function :module_prepends_supported?
+
+      def supports_rebinding_module_methods?
+        # RBX and JRuby don't yet support this.
+        RUBY_VERSION.to_i >= 2 && RUBY_ENGINE != 'rbx' && RUBY_ENGINE != 'jruby'
+      end
+      module_function :supports_rebinding_module_methods?
+    end
+  end
+end

data/rspec-support/lib/rspec/support/spec.rb

@@ -0,0 +1,72 @@
+require 'rspec/support'
+RSpec::Support.require_rspec_support "spec/deprecation_helpers"
+RSpec::Support.require_rspec_support "spec/with_isolated_stderr"
+RSpec::Support.require_rspec_support "spec/stderr_splitter"
+RSpec::Support.require_rspec_support "spec/formatting_support"
+RSpec::Support.require_rspec_support "spec/with_isolated_directory"
+RSpec::Support.require_rspec_support "ruby_features"
+
+warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
+
+RSpec.configure do |c|
+  c.include RSpecHelpers
+  c.include RSpec::Support::WithIsolatedStdErr
+  c.include RSpec::Support::FormattingSupport
+
+  unless defined?(Debugger) # debugger causes warnings when used
+    c.before do
+      warning_preventer.reset!
+    end
+
+    c.after do |example|
+      warning_preventer.verify_example!(example)
+    end
+  end
+
+  if c.files_to_run.one?
+    c.full_backtrace = true
+    c.default_formatter = 'doc'
+  end
+
+  c.filter_run :focus
+  c.run_all_when_everything_filtered = true
+end
+
+module RSpec
+  module Support
+    module Spec
+      def self.setup_simplecov(&block)
+        # Simplecov emits some ruby warnings when loaded, so silence them.
+        old_verbose, $VERBOSE = $VERBOSE, false
+
+        return if ENV['NO_COVERAGE'] || RUBY_VERSION < '1.9.3' || RUBY_ENGINE != 'ruby'
+
+        # Don't load it when we're running a single isolated
+        # test file rather than the whole suite.
+        return if RSpec.configuration.files_to_run.one?
+
+        require 'simplecov'
+        start_simplecov(&block)
+      rescue LoadError
+        warn "Simplecov could not be loaded"
+      ensure
+        $VERBOSE = old_verbose
+      end
+
+      def self.start_simplecov(&block)
+        SimpleCov.start do
+          add_filter "./bundle/"
+          add_filter "./tmp/"
+          add_filter do |source_file|
+            # Filter out `spec` directory except when it is under `lib`
+            # (as is the case in rspec-support)
+            source_file.filename.include?('/spec/') && !source_file.filename.include?('/lib/')
+          end
+
+          instance_eval(&block) if block
+        end
+      end
+      private_class_method :start_simplecov
+    end
+  end
+end

data/rspec-support/lib/rspec/support/spec/deprecation_helpers.rb

@@ -0,0 +1,60 @@
+module RSpecHelpers
+  def expect_no_deprecation
+    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
+  end
+
+  def expect_deprecation_with_call_site(file, line, snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      expect(options[:call_site]).to include([file, line].join(':'))
+      expect(options[:deprecated]).to match(snippet)
+    end
+  end
+
+  def expect_deprecation_without_call_site(snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      expect(options[:call_site]).to eq nil
+      expect(options[:deprecated]).to match(snippet)
+    end
+  end
+
+  def expect_warn_deprecation_with_call_site(file, line, snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      message = options[:message]
+      expect(message).to match(snippet)
+      expect(message).to include([file, line].join(':'))
+    end
+  end
+
+  def expect_warn_deprecation(snippet=//)
+    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
+      message = options[:message]
+      expect(message).to match(snippet)
+    end
+  end
+
+  def allow_deprecation
+    allow(RSpec.configuration.reporter).to receive(:deprecation)
+  end
+
+  def expect_no_deprecations
+    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
+  end
+
+  def expect_warning_without_call_site(expected=//)
+    expect(::Kernel).to receive(:warn) do |message|
+      expect(message).to match expected
+      expect(message).to_not match(/Called from/)
+    end
+  end
+
+  def expect_warning_with_call_site(file, line, expected=//)
+    expect(::Kernel).to receive(:warn) do |message|
+      expect(message).to match expected
+      expect(message).to match(/Called from #{file}:#{line}/)
+    end
+  end
+
+  def allow_warning
+    allow(::Kernel).to receive(:warn)
+  end
+end

data/rspec-support/lib/rspec/support/spec/formatting_support.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Support
+    module FormattingSupport
+      def dedent(string)
+        string.gsub(/^\s+\|/, '').chomp
+      end
+    end
+  end
+end

data/rspec-support/lib/rspec/support/spec/in_sub_process.rb

@@ -0,0 +1,43 @@
+module RSpec
+  module Support
+    module InSubProcess
+      if Process.respond_to?(:fork) && !(RUBY_PLATFORM == 'java' && RUBY_VERSION == '1.8.7')
+        # Useful as a way to isolate a global change to a subprocess.
+
+        # rubocop:disable MethodLength
+        def in_sub_process
+          readme, writeme = IO.pipe
+
+          pid = Process.fork do
+            exception = nil
+            begin
+              yield
+            rescue Exception => e
+              exception = e
+            end
+
+            writeme.write Marshal.dump(exception)
+
+            readme.close
+            writeme.close
+            exit! # prevent at_exit hooks from running (e.g. minitest)
+          end
+
+          writeme.close
+          Process.waitpid(pid)
+
+          exception = Marshal.load(readme.read)
+          readme.close
+
+          raise exception if exception
+        end
+      else
+        def in_sub_process
+          skip "This spec requires forking to work properly, " \
+               "and your platform does not support forking"
+        end
+      end
+      # rubocop:enable MethodLength
+    end
+  end
+end

data/rspec-support/lib/rspec/support/spec/prevent_load_time_warnings.rb

@@ -0,0 +1,44 @@
+require 'rspec/support/spec/shell_out'
+
+module RSpec
+  module Support
+    module WarningsPrevention
+      def files_to_require_for(lib)
+        slash         = File::SEPARATOR
+        lib_path_re   = /#{slash + lib}[^#{slash}]*#{slash}lib/
+        load_path     = $LOAD_PATH.grep(lib_path_re).first
+        files         = Dir["#{load_path}/**/*.rb"]
+        extract_regex = /#{Regexp.escape(load_path) + File::SEPARATOR}(.+)\.rb$/
+
+        # We sort to ensure the files are loaded in a consistent order, regardless
+        # of OS. Otherwise, it could load in a different order on Travis than
+        # locally, and potentially trigger a "circular require considered harmful"
+        # warning or similar.
+        files.sort.map { |file| file[extract_regex, 1] }
+      end
+    end
+  end
+end
+
+RSpec.shared_examples_for "a library that issues no warnings when loaded" do |lib, *preamble_stmnts|
+  include RSpec::Support::ShellOut
+  include RSpec::Support::WarningsPrevention
+
+  it "issues no warnings when loaded", :slow do
+    # We want to explicitly load every file because each lib has some files that
+    # aren't automatically loaded, instead being delayed based on an autoload
+    # (such as for rspec-expectations' matchers) or based on a config option
+    # (e.g. `config.mock_with :rr` => 'rspec/core/mocking_adapters/rr').
+    statements = preamble_stmnts + files_to_require_for(lib).map do |file|
+      "require '#{file}'"
+    end
+
+    command = statements.join("; ")
+
+    stdout, stderr, status = run_ruby_with_current_load_path(command, "-w")
+
+    expect(stdout).to eq("")
+    expect(stderr).to eq("")
+    expect(status.exitstatus).to eq(0)
+  end
+end

data/rspec-support/lib/rspec/support/spec/shell_out.rb

@@ -0,0 +1,69 @@
+require 'open3'
+require 'rake/file_utils'
+require 'shellwords'
+
+module RSpec
+  module Support
+    module ShellOut
+      def with_env(vars)
+        original = ENV.to_hash
+        vars.each { |k, v| ENV[k] = v }
+
+        begin
+          yield
+        ensure
+          ENV.replace(original)
+        end
+      end
+
+      if Open3.respond_to?(:capture3) # 1.9+
+        def shell_out(*command)
+          stdout, stderr, status = Open3.capture3(*command)
+          return stdout, filter(stderr), status
+        end
+      else # 1.8.7
+        def shell_out(*command)
+          stdout = stderr = nil
+
+          Open3.popen3(*command) do |_in, out, err|
+            stdout = out.read
+            stderr = err.read
+          end
+
+          # popen3 doesn't provide the exit status so we fake it out.
+          status = instance_double(Process::Status, :exitstatus => 0)
+          return stdout, filter(stderr), status
+        end
+      end
+
+      def run_ruby_with_current_load_path(ruby_command, *flags)
+        command = [
+          FileUtils::RUBY,
+          "-I#{$LOAD_PATH.map(&:shellescape).join(File::PATH_SEPARATOR)}",
+          "-e", ruby_command, *flags
+        ]
+
+        # Unset these env vars because `ruby -w` will issue warnings whenever
+        # they are set to non-default values.
+        with_env 'RUBY_GC_HEAP_FREE_SLOTS' => nil, 'RUBY_GC_MALLOC_LIMIT' => nil,
+                 'RUBY_FREE_MIN' => nil do
+          shell_out(*command)
+        end
+      end
+
+    private
+
+      if Ruby.jruby?
+        def filter(output)
+          output.each_line.reject do |line|
+            line.include?("lib/ruby/shared/rubygems/defaults/jruby")
+          end.join($/)
+        end
+      else
+        def filter(output)
+          output
+        end
+      end
+    end
+  end
+end