geminfo 0.1.0 → 0.1.1

data/path/gems/rspec-support-3.3.0/lib/rspec/support/recursive_const_methods.rb

@@ -1,76 +0,0 @@
-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/path/gems/rspec-support-3.3.0/lib/rspec/support/ruby_features.rb

@@ -1,118 +0,0 @@
-require 'rbconfig'
-
-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 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/path/gems/rspec-support-3.3.0/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 :focus
-  c.run_all_when_everything_filtered = true
-  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/path/gems/rspec-support-3.3.0/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/path/gems/rspec-support-3.3.0/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/path/gems/rspec-support-3.3.0/lib/rspec/support/spec/in_sub_process.rb

@@ -1,52 +0,0 @@
-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 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
-        # 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/path/gems/rspec-support-3.3.0/lib/rspec/support/spec/library_wide_checks.rb

@@ -1,145 +0,0 @@
-require 'rspec/support/spec/shell_out'
-
-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
-
-  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
-
-    # Ignore bundler warning.
-    stderr = stderr.split("\n").reject { |l| l =~ %r{bundler/source/rubygems} }.join("\n")
-    [stdout, 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
-
-  # 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
-
-  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