qiita_org 0.1.35 → 0.1.37

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/spec.rb

@@ -1,81 +0,0 @@
-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/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/spec/deprecation_helpers.rb

@@ -1,64 +0,0 @@
-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/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/spec/formatting_support.rb

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

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/spec/in_sub_process.rb

@@ -1,69 +0,0 @@
-module RSpec
-  module Support
-    module InSubProcess
-      if Process.respond_to?(:fork) && !(Ruby.jruby? && RUBY_VERSION == '1.8.7')
-
-        UnmarshableObject = Struct.new(:error)
-
-        # Useful as a way to isolate a global change to a subprocess.
-
-        # rubocop:disable MethodLength
-        def in_sub_process(prevent_warnings=true)
-          exception_reader, exception_writer = IO.pipe
-          result_reader, result_writer = IO.pipe
-
-          pid = Process.fork do
-            warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
-
-            begin
-              result = yield
-              warning_preventer.verify_no_warnings! if prevent_warnings
-              # rubocop:disable Lint/HandleExceptions
-            rescue Support::AllExceptionsExceptOnesWeMustNotRescue => exception
-              # rubocop:enable Lint/HandleExceptions
-            end
-
-            exception_writer.write marshal_dump_with_unmarshable_object_handling(exception)
-            exception_reader.close
-            exception_writer.close
-
-            result_writer.write marshal_dump_with_unmarshable_object_handling(result)
-            result_reader.close
-            result_writer.close
-
-            exit! # prevent at_exit hooks from running (e.g. minitest)
-          end
-
-          exception_writer.close
-          result_writer.close
-          Process.waitpid(pid)
-
-          exception = Marshal.load(exception_reader.read)
-          exception_reader.close
-          raise exception if exception
-
-          result = Marshal.load(result_reader.read)
-          result_reader.close
-          result
-        end
-        # rubocop:enable MethodLength
-        alias :in_sub_process_if_possible :in_sub_process
-
-        def marshal_dump_with_unmarshable_object_handling(object)
-          Marshal.dump(object)
-        rescue TypeError => error
-          Marshal.dump(UnmarshableObject.new(error))
-        end
-      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/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/spec/library_wide_checks.rb

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

data/.bandle/ruby/2.7.0/gems/rspec-support-3.9.3/lib/rspec/support/spec/shell_out.rb

@@ -1,89 +0,0 @@
-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
-        # popen3 doesn't provide the exit status so we fake it out.
-        FakeProcessStatus = Struct.new(:exitstatus)
-
-        def shell_out(*command)
-          stdout = stderr = nil
-
-          Open3.popen3(*command) do |_in, out, err|
-            stdout = out.read
-            stderr = err.read
-          end
-
-          status = FakeProcessStatus.new(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
-
-      def strip_known_warnings(input)
-        input.split("\n").reject do |l|
-          # Ignore bundler warning.
-          l =~ %r{bundler/source/rubygems} ||
-          # Ignore bundler + rubygems warning.
-          l =~ %r{site_ruby/\d\.\d\.\d/rubygems} ||
-          l =~ %r{jruby-\d\.\d\.\d\.\d/lib/ruby/stdlib/rubygems} ||
-          # This is required for windows for some reason
-          l =~ %r{lib/bundler/rubygems} ||
-          # This is a JRuby file that generates warnings on 9.0.3.0
-          l =~ %r{lib/ruby/stdlib/jar} ||
-          # This is a JRuby file that generates warnings on 9.1.7.0
-          l =~ %r{org/jruby/RubyKernel\.java} ||
-          # Remove blank lines
-          l == "" || l.nil?
-        end.join("\n")
-      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