etude_for_ruby 0.1.0 → 0.1.4

data/vendor/bundle/ruby/2.2.0/gems/rspec-support-3.5.0/lib/rspec/support/ruby_features.rb

@@ -0,0 +1,149 @@
+require 'rbconfig'
+RSpec::Support.require_rspec_support "comparable_version"
+
+module RSpec
+  module Support
+    # @api private
+    #
+    # Provides query methods for different OS or OS features.
+    module OS
+      module_function
+
+      def windows?
+        !!(RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
+      end
+
+      def windows_file_path?
+        ::File::ALT_SEPARATOR == '\\'
+      end
+    end
+
+    # @api private
+    #
+    # Provides query methods for different rubies
+    module Ruby
+      module_function
+
+      def jruby?
+        RUBY_PLATFORM == 'java'
+      end
+
+      def rbx?
+        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      end
+
+      def non_mri?
+        !mri?
+      end
+
+      def mri?
+        !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
+      end
+    end
+
+    # @api private
+    #
+    # Provides query methods for ruby features that differ among
+    # implementations.
+    module RubyFeatures
+      module_function
+
+      def optional_and_splat_args_supported?
+        Method.method_defined?(:parameters)
+      end
+
+      def caller_locations_supported?
+        respond_to?(:caller_locations, true)
+      end
+
+      if Exception.method_defined?(:cause)
+        def supports_exception_cause?
+          true
+        end
+      else
+        def supports_exception_cause?
+          false
+        end
+      end
+
+      ripper_requirements = [ComparableVersion.new(RUBY_VERSION) >= '1.9.2']
+
+      ripper_requirements.push(false) if Ruby.rbx?
+
+      if Ruby.jruby?
+        ripper_requirements.push(ComparableVersion.new(JRUBY_VERSION) >= '1.7.5')
+        # Ripper on JRuby 9.0.0.0.rc1 or later reports wrong line number.
+        ripper_requirements.push(ComparableVersion.new(JRUBY_VERSION) < '9.0.0.0.rc1')
+      end
+
+      if ripper_requirements.all?
+        def ripper_supported?
+          true
+        end
+      else
+        def ripper_supported?
+          false
+        end
+      end
+
+      if Ruby.mri?
+        def kw_args_supported?
+          RUBY_VERSION >= '2.0.0'
+        end
+
+        def required_kw_args_supported?
+          RUBY_VERSION >= '2.1.0'
+        end
+
+        def supports_rebinding_module_methods?
+          RUBY_VERSION.to_i >= 2
+        end
+      else
+        # RBX / JRuby et al support is unknown for keyword arguments
+        # rubocop:disable Lint/Eval
+        begin
+          eval("o = Object.new; def o.m(a: 1); end;"\
+               " raise SyntaxError unless o.method(:m).parameters.include?([:key, :a])")
+
+          def kw_args_supported?
+            true
+          end
+        rescue SyntaxError
+          def kw_args_supported?
+            false
+          end
+        end
+
+        begin
+          eval("o = Object.new; def o.m(a: ); end;"\
+               "raise SyntaxError unless o.method(:m).parameters.include?([:keyreq, :a])")
+
+          def required_kw_args_supported?
+            true
+          end
+        rescue SyntaxError
+          def required_kw_args_supported?
+            false
+          end
+        end
+
+        begin
+          Module.new { def foo; end }.instance_method(:foo).bind(Object.new)
+
+          def supports_rebinding_module_methods?
+            true
+          end
+        rescue TypeError
+          def supports_rebinding_module_methods?
+            false
+          end
+        end
+        # rubocop:enable Lint/Eval
+      end
+
+      def module_prepends_supported?
+        Module.method_defined?(:prepend) || Module.private_method_defined?(:prepend)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rspec-support-3.5.0/lib/rspec/support/spec.rb

@@ -0,0 +1,81 @@
+require 'rspec/support'
+require 'rspec/support/spec/in_sub_process'
+
+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
+  c.include RSpec::Support::InSubProcess
+
+  unless defined?(Debugger) # debugger causes warnings when used
+    c.before do
+      warning_preventer.reset!
+    end
+
+    c.after do
+      warning_preventer.verify_no_warnings!
+    end
+  end
+
+  if c.files_to_run.one?
+    c.full_backtrace = true
+    c.default_formatter = 'doc'
+  end
+
+  c.filter_run_when_matching :focus
+
+  c.example_status_persistence_file_path = "./spec/examples.txt"
+
+  c.define_derived_metadata :failing_on_appveyor do |meta|
+    meta[:pending] ||= "This spec fails on AppVeyor and needs someone to fix it."
+  end if ENV['APPVEYOR']
+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'
+        return if RUBY_ENGINE != 'ruby' || RSpec::Support::OS.windows?
+
+        # 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/vendor/bundle/ruby/2.2.0/gems/rspec-support-3.5.0/lib/rspec/support/spec/deprecation_helpers.rb

@@ -0,0 +1,64 @@
+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 expect_no_warnings
+    expect(::Kernel).not_to receive(:warn)
+  end
+
+  def allow_warning
+    allow(::Kernel).to receive(:warn)
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rspec-support-3.5.0/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/vendor/bundle/ruby/2.2.0/gems/rspec-support-3.5.0/lib/rspec/support/spec/in_sub_process.rb

@@ -0,0 +1,52 @@
+module RSpec
+  module Support
+    module InSubProcess
+      if Process.respond_to?(:fork) && !(Ruby.jruby? && RUBY_VERSION == '1.8.7')
+
+        # Useful as a way to isolate a global change to a subprocess.
+
+        # rubocop:disable MethodLength
+        def in_sub_process(prevent_warnings=true)
+          readme, writeme = IO.pipe
+
+          pid = Process.fork do
+            exception = nil
+            warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
+
+            begin
+              yield
+              warning_preventer.verify_no_warnings! if prevent_warnings
+            rescue Support::AllExceptionsExceptOnesWeMustNotRescue => 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
+        # rubocop:enable MethodLength
+        alias :in_sub_process_if_possible :in_sub_process
+      else
+        def in_sub_process(*)
+          skip "This spec requires forking to work properly, " \
+               "and your platform does not support forking"
+        end
+
+        def in_sub_process_if_possible(*)
+          yield
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/rspec-support-3.5.0/lib/rspec/support/spec/library_wide_checks.rb

@@ -0,0 +1,150 @@
+require 'rspec/support/spec/shell_out'
+
+module RSpec
+  module Support
+    module WhitespaceChecks
+      # This malformed whitespace detection logic has been borrowed from bundler:
+      # https://github.com/bundler/bundler/blob/v1.8.0/spec/quality_spec.rb
+      def check_for_tab_characters(filename)
+        failing_lines = []
+        File.readlines(filename).each_with_index do |line, number|
+          failing_lines << number + 1 if line =~ /\t/
+        end
+
+        return if failing_lines.empty?
+        "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
+      end
+
+      def check_for_extra_spaces(filename)
+        failing_lines = []
+        File.readlines(filename).each_with_index do |line, number|
+          next if line =~ /^\s+#.*\s+\n$/
+          failing_lines << number + 1 if line =~ /\s+\n$/
+        end
+
+        return if failing_lines.empty?
+        "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
+      end
+    end
+  end
+end
+
+RSpec.shared_examples_for "library wide checks" do |lib, options|
+  consider_a_test_env_file = options.fetch(:consider_a_test_env_file, /MATCHES NOTHING/)
+  allowed_loaded_feature_regexps = options.fetch(:allowed_loaded_feature_regexps, [])
+  preamble_for_lib = options[:preamble_for_lib]
+  preamble_for_spec = "require 'rspec/core'; require 'spec_helper'"
+  skip_spec_files = options.fetch(:skip_spec_files, /MATCHES NOTHING/)
+
+  include RSpec::Support::ShellOut
+  include RSpec::Support::WhitespaceChecks
+
+  define_method :files_to_require_for do |sub_dir|
+    slash         = File::SEPARATOR
+    lib_path_re   = /#{slash + lib}[^#{slash}]*#{slash}lib/
+    load_path     = $LOAD_PATH.grep(lib_path_re).first
+    directory     = load_path.sub(/lib$/, sub_dir)
+    files         = Dir["#{directory}/**/*.rb"]
+    extract_regex = /#{Regexp.escape(directory) + 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
+
+  def command_from(code_lines)
+    code_lines.join("\n")
+  end
+
+  def load_all_files(files, preamble, postamble=nil)
+    requires = files.map { |f| "require '#{f}'" }
+    command  = command_from(Array(preamble) + requires + Array(postamble))
+
+    stdout, stderr, status = with_env 'NO_COVERAGE' => '1' do
+      options = %w[ -w ]
+      options << "--disable=gem" if RUBY_VERSION.to_f >= 1.9 && RSpec::Support::Ruby.mri?
+      run_ruby_with_current_load_path(command, *options)
+    end
+
+    [stdout, strip_known_warnings(stderr), status.exitstatus]
+  end
+
+  define_method :load_all_lib_files do
+    files = all_lib_files - lib_test_env_files
+    preamble  = ['orig_loaded_features = $".dup', preamble_for_lib]
+    postamble = ['puts(($" - orig_loaded_features).join("\n"))']
+
+    @loaded_feature_lines, stderr, exitstatus = load_all_files(files, preamble, postamble)
+    ["", stderr, exitstatus]
+  end
+
+  define_method :load_all_spec_files do
+    files = files_to_require_for("spec") + lib_test_env_files
+    files = files.reject { |f| f =~ skip_spec_files }
+    load_all_files(files, preamble_for_spec)
+  end
+
+  attr_reader :all_lib_files, :lib_test_env_files,
+              :lib_file_results, :spec_file_results
+
+  before(:context) do
+    @all_lib_files           = files_to_require_for("lib")
+    @lib_test_env_files      = all_lib_files.grep(consider_a_test_env_file)
+
+    @lib_file_results, @spec_file_results = [
+      # Load them in parallel so it's faster...
+      Thread.new { load_all_lib_files  },
+      Thread.new { load_all_spec_files }
+    ].map(&:join).map(&:value)
+  end
+
+  def have_successful_no_warnings_output
+    eq ["", "", 0]
+  end
+
+  it "issues no warnings when loaded", :slow do
+    expect(lib_file_results).to have_successful_no_warnings_output
+  end
+
+  it "issues no warnings when the spec files are loaded", :slow do
+    expect(spec_file_results).to have_successful_no_warnings_output
+  end
+
+  it 'only loads a known set of stdlibs so gem authors are forced ' \
+     'to load libs they use to have passing specs', :slow do
+    loaded_features = @loaded_feature_lines.split("\n")
+    if RUBY_VERSION == '1.8.7'
+      # On 1.8.7, $" returns the relative require path if that was used
+      # to require the file. LIB_REGEX will not match the relative version
+      # since it has a `/lib` prefix. Here we deal with this by expanding
+      # relative files relative to the $LOAD_PATH dir (lib).
+      Dir.chdir("lib") { loaded_features.map! { |f| File.expand_path(f) } }
+    end
+
+    loaded_features.reject! { |feature| RSpec::CallerFilter::LIB_REGEX =~ feature }
+    loaded_features.reject! { |feature| allowed_loaded_feature_regexps.any? { |r| r =~ feature } }
+
+    expect(loaded_features).to eq([])
+  end
+
+  RSpec::Matchers.define :be_well_formed do
+    match do |actual|
+      actual.empty?
+    end
+
+    failure_message do |actual|
+      actual.join("\n")
+    end
+  end
+
+  it "has no malformed whitespace", :slow do
+    error_messages = []
+    `git ls-files -z`.split("\x0").each do |filename|
+      error_messages << check_for_tab_characters(filename)
+      error_messages << check_for_extra_spaces(filename)
+    end
+    expect(error_messages.compact).to be_well_formed
+  end
+end