-lib = File.expand_path("../lib/", __FILE__)

-$:.unshift lib unless $:.include?(lib)

-require "bundler/version"

- s.required_ruby_version = ">= 1.8.7"

- s.required_rubygems_version = ">= 1.3.6"

- s.add_development_dependency "rspec", "~> 3.5"

- s.files = [

- "lib/bundler.gemspec",

- "bin/bundle",

- "bin/bundle_ruby",

- "bin/bundler",

- "lib/bundler.rb",

- "lib/bundler/capistrano.rb",

- "lib/bundler/cli.rb",

- "lib/bundler/cli/add.rb",

- "lib/bundler/cli/binstubs.rb",

- "lib/bundler/cli/cache.rb",

- "lib/bundler/cli/check.rb",

- "lib/bundler/cli/clean.rb",

- "lib/bundler/cli/common.rb",

- "lib/bundler/cli/config.rb",

- "lib/bundler/cli/console.rb",

- "lib/bundler/cli/doctor.rb",

- "lib/bundler/cli/exec.rb",

- "lib/bundler/cli/gem.rb",

- "lib/bundler/cli/info.rb",

- "lib/bundler/cli/init.rb",

- "lib/bundler/cli/inject.rb",

- "lib/bundler/cli/install.rb",

- "lib/bundler/cli/issue.rb",

- "lib/bundler/cli/lock.rb",

- "lib/bundler/cli/open.rb",

- "lib/bundler/cli/outdated.rb",

- "lib/bundler/cli/package.rb",

- "lib/bundler/cli/platform.rb",

- "lib/bundler/cli/plugin.rb",

- "lib/bundler/cli/pristine.rb",

- "lib/bundler/cli/show.rb",

- "lib/bundler/cli/update.rb",

- "lib/bundler/cli/viz.rb",

- "lib/bundler/compact_index_client.rb",

- "lib/bundler/compact_index_client/cache.rb",

- "lib/bundler/compact_index_client/updater.rb",

- "lib/bundler/constants.rb",

- "lib/bundler/current_ruby.rb",

- "lib/bundler/definition.rb",

- "lib/bundler/dep_proxy.rb",

- "lib/bundler/dependency.rb",

- "lib/bundler/deployment.rb",

- "lib/bundler/deprecate.rb",

- "lib/bundler/dsl.rb",

- "lib/bundler/endpoint_specification.rb",

- "lib/bundler/env.rb",

- "lib/bundler/environment_preserver.rb",

- "lib/bundler/errors.rb",

- "lib/bundler/feature_flag.rb",

- "lib/bundler/fetcher.rb",

- "lib/bundler/fetcher/base.rb",

- "lib/bundler/fetcher/compact_index.rb",

- "lib/bundler/fetcher/dependency.rb",

- "lib/bundler/fetcher/downloader.rb",

- "lib/bundler/fetcher/index.rb",

- "lib/bundler/friendly_errors.rb",

- "lib/bundler/gem_helper.rb",

- "lib/bundler/gem_helpers.rb",

- "lib/bundler/gem_remote_fetcher.rb",

- "lib/bundler/gem_tasks.rb",

- "lib/bundler/gem_version_promoter.rb",

- "lib/bundler/gemdeps.rb",

- "lib/bundler/graph.rb",

- "lib/bundler/index.rb",

- "lib/bundler/injector.rb",

- "lib/bundler/inline.rb",

- "lib/bundler/installer.rb",

- "lib/bundler/installer/gem_installer.rb",

- "lib/bundler/installer/parallel_installer.rb",

- "lib/bundler/installer/standalone.rb",

- "lib/bundler/lazy_specification.rb",

- "lib/bundler/lockfile_parser.rb",

- "lib/bundler/match_platform.rb",

- "lib/bundler/mirror.rb",

- "lib/bundler/plugin.rb",

- "lib/bundler/plugin/api.rb",

- "lib/bundler/plugin/api/source.rb",

- "lib/bundler/plugin/dsl.rb",

- "lib/bundler/plugin/index.rb",

- "lib/bundler/plugin/installer.rb",

- "lib/bundler/plugin/installer/git.rb",

- "lib/bundler/plugin/installer/rubygems.rb",

- "lib/bundler/plugin/source_list.rb",

- "lib/bundler/psyched_yaml.rb",

- "lib/bundler/remote_specification.rb",

- "lib/bundler/resolver.rb",

- "lib/bundler/retry.rb",

- "lib/bundler/ruby_dsl.rb",

- "lib/bundler/ruby_version.rb",

- "lib/bundler/rubygems_ext.rb",

- "lib/bundler/rubygems_gem_installer.rb",

- "lib/bundler/rubygems_integration.rb",

- "lib/bundler/runtime.rb",

- "lib/bundler/settings.rb",

- "lib/bundler/setup.rb",

- "lib/bundler/shared_helpers.rb",

- "lib/bundler/similarity_detector.rb",

- "lib/bundler/source.rb",

- "lib/bundler/source/gemspec.rb",

- "lib/bundler/source/git.rb",

- "lib/bundler/source/git/git_proxy.rb",

- "lib/bundler/source/path.rb",

- "lib/bundler/source/path/installer.rb",

- "lib/bundler/source/rubygems.rb",

- "lib/bundler/source/rubygems/remote.rb",

- "lib/bundler/source_list.rb",

- "lib/bundler/spec_set.rb",

- "lib/bundler/ssl_certs/.document",

- "lib/bundler/ssl_certs/certificate_manager.rb",

- "lib/bundler/ssl_certs/index.rubygems.org/GlobalSignRootCA.pem",

- "lib/bundler/ssl_certs/rubygems.global.ssl.fastly.net/DigiCertHighAssuranceEVRootCA.pem",

- "lib/bundler/ssl_certs/rubygems.org/AddTrustExternalCARoot.pem",

- "lib/bundler/stub_specification.rb",

- "lib/bundler/templates/Executable",

- "lib/bundler/templates/Executable.standalone",

- "lib/bundler/templates/Gemfile",

- "lib/bundler/templates/newgem/CODE_OF_CONDUCT.md.tt",

- "lib/bundler/templates/newgem/Gemfile.tt",

- "lib/bundler/templates/newgem/LICENSE.txt.tt",

- "lib/bundler/templates/newgem/README.md.tt",

- "lib/bundler/templates/newgem/Rakefile.tt",

- "lib/bundler/templates/newgem/bin/console.tt",

- "lib/bundler/templates/newgem/bin/setup.tt",

- "lib/bundler/templates/newgem/exe/newgem.tt",

- "lib/bundler/templates/newgem/ext/newgem/extconf.rb.tt",

- "lib/bundler/templates/newgem/ext/newgem/newgem.c.tt",

- "lib/bundler/templates/newgem/ext/newgem/newgem.h.tt",

- "lib/bundler/templates/newgem/gitignore.tt",

- "lib/bundler/templates/newgem/lib/newgem.rb.tt",

- "lib/bundler/templates/newgem/lib/newgem/version.rb.tt",

- "lib/bundler/templates/newgem/newgem.gemspec.tt",

- "lib/bundler/templates/newgem/rspec.tt",

- "lib/bundler/templates/newgem/spec/newgem_spec.rb.tt",

- "lib/bundler/templates/newgem/spec/spec_helper.rb.tt",

- "lib/bundler/templates/newgem/test/newgem_test.rb.tt",

- "lib/bundler/templates/newgem/test/test_helper.rb.tt",

- "lib/bundler/templates/newgem/travis.yml.tt",

- "lib/bundler/ui.rb",

- "lib/bundler/ui/rg_proxy.rb",

- "lib/bundler/ui/shell.rb",

- "lib/bundler/ui/silent.rb",

- "lib/bundler/uri_credentials_filter.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/delegates/resolution_state.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/delegates/specification_provider.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/action.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/add_edge_no_circular.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/add_vertex.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/delete_edge.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/detach_vertex_named.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/log.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/set_payload.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/tag.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/vertex.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/errors.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/gem_metadata.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/modules/specification_provider.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/modules/ui.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/resolution.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/resolver.rb",

- "lib/bundler/vendor/molinillo/lib/molinillo/state.rb",

- "lib/bundler/vendor/net-http-persistent/lib/net/http/faster.rb",

- "lib/bundler/vendor/net-http-persistent/lib/net/http/persistent.rb",

- "lib/bundler/vendor/net-http-persistent/lib/net/http/persistent/ssl_reuse.rb",

- "lib/bundler/vendor/thor/lib/thor.rb",

- "lib/bundler/vendor/thor/lib/thor/actions.rb",

- "lib/bundler/vendor/thor/lib/thor/actions/create_file.rb",

- "lib/bundler/vendor/thor/lib/thor/actions/create_link.rb",

- "lib/bundler/vendor/thor/lib/thor/actions/directory.rb",

- "lib/bundler/vendor/thor/lib/thor/actions/empty_directory.rb",

- "lib/bundler/vendor/thor/lib/thor/actions/file_manipulation.rb",

- "lib/bundler/vendor/thor/lib/thor/actions/inject_into_file.rb",

- "lib/bundler/vendor/thor/lib/thor/base.rb",

- "lib/bundler/vendor/thor/lib/thor/command.rb",

- "lib/bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access.rb",

- "lib/bundler/vendor/thor/lib/thor/core_ext/io_binary_read.rb",

- "lib/bundler/vendor/thor/lib/thor/core_ext/ordered_hash.rb",

- "lib/bundler/vendor/thor/lib/thor/error.rb",

- "lib/bundler/vendor/thor/lib/thor/group.rb",

- "lib/bundler/vendor/thor/lib/thor/invocation.rb",

- "lib/bundler/vendor/thor/lib/thor/line_editor.rb",

- "lib/bundler/vendor/thor/lib/thor/line_editor/basic.rb",

- "lib/bundler/vendor/thor/lib/thor/line_editor/readline.rb",

- "lib/bundler/vendor/thor/lib/thor/parser.rb",

- "lib/bundler/vendor/thor/lib/thor/parser/argument.rb",

- "lib/bundler/vendor/thor/lib/thor/parser/arguments.rb",

- "lib/bundler/vendor/thor/lib/thor/parser/option.rb",

- "lib/bundler/vendor/thor/lib/thor/parser/options.rb",

- "lib/bundler/vendor/thor/lib/thor/rake_compat.rb",

- "lib/bundler/vendor/thor/lib/thor/runner.rb",

- "lib/bundler/vendor/thor/lib/thor/shell.rb",

- "lib/bundler/vendor/thor/lib/thor/shell/basic.rb",

- "lib/bundler/vendor/thor/lib/thor/shell/color.rb",

- "lib/bundler/vendor/thor/lib/thor/shell/html.rb",

- "lib/bundler/vendor/thor/lib/thor/util.rb",

- "lib/bundler/vendor/thor/lib/thor/version.rb",

- "lib/bundler/vendored_molinillo.rb",

- "lib/bundler/vendored_persistent.rb",

- "lib/bundler/vendored_thor.rb",

- "lib/bundler/version.rb",

- "lib/bundler/version_ranges.rb",

- "lib/bundler/vlad.rb",

- "lib/bundler/worker.rb",

- "lib/bundler/yaml_serializer.rb"

- s.executables = %w(bundle bundler)

-require "fileutils"

-require "tmpdir"

- environment_preserver = EnvironmentPreserver.new(ENV, %w(PATH GEM_PATH))

- attr_writer :bundle_path

-

- @bundle_path ||= Pathname.new(settings.path).expand_path(root)

- SharedHelpers.major_deprecation "Bundler.environment has been removed in favor of Bundler.load"

- def cache

- bundle_path.join("cache/bundler")

- end

-

- default_gemfile.dirname.expand_path

- if ENV["BUNDLE_APP_CONFIG"]

- Pathname.new(ENV["BUNDLE_APP_CONFIG"]).expand_path(root)

- path.join(settings.app_cache_path)

- Bundler::SharedHelpers.major_deprecation("`Bundler.clean_env` has weird edge cases, use `.original_env` instead")

- # Gem.bindir doesn't always return the location that Rubygems will install

- # system binaries. If you put '-n foo' in your .gemrc, Rubygems will

- # install binstubs there instead. Unfortunately, Rubygems doesn't expose

- # the bundle path and subdirectories need to be writable for Rubygems

- @root = nil

- @settings = nil

- @setup = nil

- @bundle_path = nil

- @bin_path = nil

- eval(contents, TOPLEVEL_BINDING, path.expand_path.to_s)

- def configure_gem_path(env = ENV, settings = self.settings)

- if settings[:disable_shared_gems]

- elsif blank_home || Bundler.rubygems.gem_dir != bundle_path.to_s

- # TODO: This mkdir_p is only needed for JRuby <= 1.5 and should go away (GH #602)

- begin

- FileUtils.mkdir_p bundle_path.to_s

- rescue

- nil

- end

-

- ENV["GEM_HOME"] = File.expand_path(bundle_path, root)

- AUTO_INSTALL_CMDS = %w(show binstubs outdated exec open console licenses clean).freeze

- PARSEABLE_COMMANDS = %w(

- ).freeze

- ENV["BUNDLE_GEMFILE"] = File.expand_path(custom_gemfile)

- Bundler.settings[:retry] = options[:retry] if options[:retry]

- Bundler.settings.cli_flags_given = !options.empty?

- default_task :install

- method_option "gemspec", :type => :string, :banner => "Use the specified .gemspec to create the Gemfile"

- "Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME). Bundler will remember this value for future installs on this machine"

- method_option "binstubs", :type => :string, :lazy_default => "bin", :banner =>

- method_option "clean", :type => :boolean, :banner =>

- method_option "deployment", :type => :boolean, :banner =>

- method_option "frozen", :type => :boolean, :banner =>

- method_option "no-cache", :type => :boolean, :banner =>

- method_option "force", :type => :boolean, :banner =>

- method_option "no-prune", :type => :boolean, :banner =>

- method_option "path", :type => :string, :banner =>

- method_option "shebang", :type => :string, :banner =>

- method_option "system", :type => :boolean, :banner =>

- method_option "without", :type => :array, :banner =>

- method_option "with", :type => :array, :banner =>

- desc "update [OPTIONS]", "update the current environment"

- Bundler::SharedHelpers.major_deprecation("use `bundle show` instead of `bundle list`") if ARGV[0] == "list"

- # TODO: 2.0 remove `bundle list`

- map %w(list) => "show"

- desc "outdated GEM [OPTIONS]", "list installed gems with newer versions available"

- method_option "group", :aliases => "--group", :type => :string, :banner => "List gems from a specific group"

- method_option "groups", :aliases => "--groups", :type => :boolean, :banner => "List gems organized by groups"

- desc "cache [OPTIONS]", "Cache all the gems to vendor/cache", :hide => true

- method_option "all", :type => :boolean, :banner => "Include all sources (including path and git)."

- method_option "all-platforms", :type => :boolean, :banner => "Include gems for all platforms present in the lockfile, not only the current one"

- method_option "no-prune", :type => :boolean, :banner => "Don't remove stale gems from the cache."

- def cache

- require "bundler/cli/cache"

- Cache.new(options).run

- desc "package [OPTIONS]", "Locks and then caches all of the gems into vendor/cache"

- method_option "all", :type => :boolean, :banner => "Include all sources (including path and git)."

- map %w(pack) => :package

- into the system wide Rubygems repository.

- desc "config NAME [VALUE]", "retrieve or set a configuration value"

- desc "console [GROUP]", "Opens an IRB session with the bundle pre-loaded"

- def console(group = nil)

- # TODO: Remove for 2.0

- require "bundler/cli/console"

- Console.new(options, group).run

- Bundler.ui.info "Bundler version #{Bundler::VERSION}"

- map %w(-v --version) => :version

- desc "viz [OPTIONS]", "Generates a visual dependency graph"

- desc "gem GEM [OPTIONS]", "Creates a skeleton for creating a rubygem"

- desc "clean [OPTIONS]", "Cleans up unused gems in your bundler directory"

- desc "inject GEM VERSION", "Add the named gem, with version requirements, to the resolved Gemfile"

- SharedHelpers.major_deprecation "The `inject` command has been replaced by the `add` command"

- Env.new.write($stdout)

- desc "pristine", "Restores installed gems to pristine condition from files located in the gem cache. Gem installed from a git repository will be issued `git checkout --force`."

- def pristine

- Pristine.new.run

- desc "plugin SUBCOMMAND ...ARGS", "manage the bundler plugins"

- help_flags = %w(--help -h)

- exec_commands = %w(e ex exe exec)

- %w(help exec)

- _, _, config = @_initializer

- current_command = config[:current_command]

- command_name = current_command.name

- next unless o = current_command.options[k]

- _, _, config = @_initializer

- current_command = config[:current_command]

- Bundler.ui.warn "The latest bundler is #{latest}, but you are currently running #{current}.\nTo update, run `gem install bundler#{" --pre" if latest.prerelease?}`"

-require "bundler/cli/common"

-require "bundler/cli/common"

- Bundler.settings[:bin] = options["path"] if options["path"]

- Bundler.settings[:bin] = nil if options["path"] && options["path"].empty?

- if spec.name == "bundler"

- Bundler.ui.warn "Sorry, Bundler can only be run via Rubygems."

- elsif options[:standalone]

- installer.generate_standalone_bundler_executable_stubs(spec)

- Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")

- Bundler.settings[:no_prune] = true if options["no-prune"]

- Bundler.settings[:cache_all] = options[:all] if options.key?("all")

- if Bundler.definition.has_local_dependencies? && !Bundler.settings[:cache_all]

- if options[:path]

- Bundler.settings[:path] = File.expand_path(options[:path])

- Bundler.settings[:disable_shared_gems] = true

- end

- elsif !Bundler.default_lockfile.file? && Bundler.settings[:frozen]

- if !Bundler.settings[:path] && !options[:force]

- Bundler.ui.error "Cleaning all the gems on your system is dangerous! " \

- "If you're sure you want to remove every system gem not in this " \

- "bundle, run `bundle clean --force`."

- exit 1

- end

- return unless Bundler.settings.without.any?

- groups = Bundler.settings.without

- %w(delete local global).include?(scope)

- Bundler::SharedHelpers.major_deprecation "bundle console will be replaced " \

- RESERVED_SIGNALS = %w(SEGV BUS ILL FPE VTALRM KILL STOP).freeze

- rescue SystemExit

- executables = %w(

- )

-require "bundler/cli/common"

- if File.exist?("Gemfile")

- Bundler.ui.error "Gemfile already exists at #{SharedHelpers.pwd}/Gemfile"

- puts "Writing new Gemfile to #{SharedHelpers.pwd}/Gemfile"

- File.open("Gemfile", "wb") do |file|

- puts "Writing new Gemfile to #{SharedHelpers.pwd}/Gemfile"

- FileUtils.cp(File.expand_path("../../templates/Gemfile", __FILE__), "Gemfile")

-require "bundler/cli/common"

- [:with, :without].each do |option|

- if options[option]

- options[option] = options[option].join(":").tr(" ", ":").split(":")

- end

- end

-

- check_for_group_conflicts

-

- ENV["RB_USER_INSTALL"] = "1" if Bundler::FREEBSD

- if options[:deployment] || options[:frozen]

- flag = options[:deployment] ? "--deployment" : "--frozen"

- raise ProductionError, "The #{flag} flag requires a #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}. Please make " \

- Bundler.settings[:frozen] = "1"

- Bundler.settings.delete(:frozen)

- Bundler::SharedHelpers.major_deprecation \

- Bundler.load.cache if Bundler.app_cache.exist? && !options["no-cache"] && !Bundler.settings[:frozen]

- if Bundler.settings[:path]

- absolute_path = File.expand_path(Bundler.settings[:path])

- relative_path = absolute_path.sub(File.expand_path(".") + File::SEPARATOR, "." + File::SEPARATOR)

- Bundler.ui.confirm "Bundled gems are installed into #{relative_path}."

- else

- if Bundler.settings[:clean] && Bundler.settings[:path]

- def check_for_group_conflicts

- if options[:without] && options[:with]

- conflicting_groups = options[:without] & options[:with]

- unless conflicting_groups.empty?

- Bundler.ui.error "You can't list a group in both, --with and --without." \

- " The offending groups are: #{conflicting_groups.join(", ")}."

- exit 1

- end

- end

- if options["trust-policy"]

- unless Bundler.rubygems.security_policies.keys.include?(options["trust-policy"])

- Bundler.ui.error "Rubygems doesn't know about trust policy '#{options["trust-policy"]}'. " \

- "The known policies are: #{Bundler.rubygems.security_policies.keys.join(", ")}."

- exit 1

- end

- Bundler.settings["trust-policy"] = options["trust-policy"]

- else

- Bundler.settings["trust-policy"] = nil if Bundler.settings["trust-policy"]

- Bundler.settings.with = [] if options[:with] && options[:with].empty?

- Bundler.settings.without = [] if options[:without] && options[:without].empty?

- with = options.fetch("with", [])

- with |= Bundler.settings.with.map(&:to_s)

- without = options.fetch("without", [])

- without |= Bundler.settings.without.map(&:to_s)

- Bundler.settings[:path] = nil if options[:system]

- Bundler.settings[:path] = "vendor/bundle" if options[:deployment]

- Bundler.settings[:path] = options["path"] if options["path"]

- Bundler.settings[:path] ||= "bundle" if options["standalone"]

- Bundler.settings[:bin] = options["binstubs"] if options["binstubs"]

- Bundler.settings[:bin] = nil if options["binstubs"] && options["binstubs"].empty?

- Bundler.settings[:shebang] = options["shebang"] if options["shebang"]

- Bundler.settings[:jobs] = options["jobs"] if options["jobs"]

- Bundler.settings[:no_prune] = true if options["no-prune"]

- Bundler.settings[:no_install] = true if options["no-install"]

- Bundler.settings[:clean] = options["clean"] if options["clean"]

- Bundler.settings.without = options[:without]

- Bundler.settings.with = options[:with]

- Bundler.settings[:disable_shared_gems] = Bundler.settings[:path] ? true : nil

- Bundler.ui.info Bundler::Env.new.report

-require "bundler/cli/common"

-require "bundler/cli/common"

- Bundler.with_clean_env do

-require "bundler/cli/common"

- %w(filter-major filter-minor filter-)

- if Bundler.settings[:frozen]

- raise ProductionError, "You are trying to check outdated gems in " \

- "deployment mode. Run `bundle outdated` elsewhere.\n" \

- "\nIf this is a development machine, remove the " \

- "#{Bundler.default_gemfile} freeze" \

- "\nby running `bundle install --no-deployment`."

- Bundler.settings[:path] = File.expand_path(options[:path]) if options[:path]

- Bundler.settings[:cache_all_platforms] = options["all-platforms"] if options.key?("all-platforms")

- Bundler.settings[:cache_path] = options["cache-path"] if options.key?("cache-path")

- custom_path = Pathname.new(options[:path]) if options[:path]

- Bundler.settings[:cache_all] = options[:all] if options.key?("all")

- if Bundler.definition.has_local_dependencies? && !Bundler.settings[:cache_all]

-require "bundler/cli/common"

- FileUtils.rm_rf spec.full_gem_path

-require "bundler/cli/common"

-require "bundler/cli/common"

- if gems.empty? && sources.empty? && groups.empty? && !options[:ruby] && !options[:bundler]

- :lock_shared_dependencies => options[:conservative])

- Bundler.settings[:jobs] = opts["jobs"] if opts["jobs"]

- if Bundler.settings[:clean] && Bundler.settings[:path]

-require "digest/md5"

- name += "-#{Digest::MD5.hexdigest(name).downcase}"

-require "fileutils"

-require "tmpdir"

- Digest::MD5.hexdigest(IO.read(path))

- KNOWN_MINOR_VERSIONS = %w(

- ).freeze

- KNOWN_PLATFORMS = %w(

- ).freeze

-require "digest/sha1"

- :ruby_version

- def initialize(lockfile, dependencies, sources, unlock, ruby_version = nil, optional_groups = [])

- @unlocking = unlock == true || !unlock.empty?

- add_current_platform unless Bundler.settings[:frozen]

- local = Bundler.settings[:frozen] ? rubygems_index : index

- bundler = local.search(Gem::Dependency.new("bundler", VERSION)).last

- specs["bundler"] = bundler if bundler

- def missing_dependencies

- missing = []

- resolve.materialize(current_dependencies, missing)

- missing

- if Bundler.settings[:frozen] || (!unlocking? && nothing_changed?)

- source.dependency_names = dependency_names.dup

- dependency_names -= pinned_spec_names(source.specs)

- idx << Gem::Specification.new("ruby\0", RubyVersion.system.to_gem_version_with_level)

- idx << Gem::Specification.new("rubygems\0", Gem::VERSION)

- end

- end

- # used when frozen is enabled so we can find the bundler

- # spec, even if (say) a git gem is not checked out.

- def rubygems_index

- @rubygems_index ||= Index.build do |idx|

- sources.rubygems_sources.each do |rubygems|

- idx.add_source rubygems.specs

- preserve_unknown_sections ||= !updating_major && (Bundler.settings[:frozen] || !unlocking?)

- if Bundler.settings[:frozen]

- out = String.new

-

- sources.lock_sources.each do |source|

- # Add the source header

- out << source.to_lock

- # Find all specs for this source

- resolve.

- select {|s| source.can_lock?(s) }.

- # This needs to be sorted by full name so that

- # gems with the same name, but different platform

- # are ordered consistently

- sort_by(&:full_name).

- each do |spec|

- next if spec.name == "bundler"

- out << spec.to_lock

- end

- out << "\n"

- end

-

- out << "PLATFORMS\n"

-

- platforms.map(&:to_s).sort.each do |p|

- out << " #{p}\n"

- end

-

- out << "\n"

- out << "DEPENDENCIES\n"

-

- handled = []

- dependencies.sort_by(&:to_s).each do |dep|

- next if handled.include?(dep.name)

- out << dep.to_lock

- handled << dep.name

- end

-

- if locked_ruby_version

- out << "\nRUBY VERSION\n"

- out << " #{locked_ruby_version}\n"

- end

-

- # Record the version of Bundler that was used to create the lockfile

- out << "\nBUNDLED WITH\n"

- out << " #{locked_bundler_version}\n"

-

- out

-

- suggested_command = Bundler.settings.locations("frozen")[:global] == "1" ? "bundle config --delete frozen" : "bundle install --no-deployment"

- new_sources.reject! {|source| source.is_a_path? && source.path.exist? }

- deleted_sources.reject! {|source| source.is_a_path? && source.path.exist? }

- add_platform(current_platform) if Bundler.settings[:specific_platform]

- msg = String.new(dep.name)

- msg << " (#{dep.requirement})" unless dep.requirement == Gem::Requirement.default

- msg << " from the `#{dep.source}` source" if source && dep.source

- msg

- def converge_sources

- # Get the Rubygems sources from the Gemfile.lock

- # Get the Rubygems remotes from the Gemfile

- # If there is a Rubygems source in both

- changes |= locked_gem.replace_remotes(actual_remotes)

- frozen = Bundler.settings[:frozen]

- # if you change a Git gem to Rubygems.

- next if @unlock[:sources].include?(s.name)

- other = s.source.specs[s].first

-

- metadata_dependencies = [

- expand_dependencies(dependencies + metadata_dependencies, @remote)

- platforms = dep.gem_platforms(@platforms)

- source_requirements = {}

- next unless dep.source

- source_requirements[dep.name] = dep.source.specs

- def pinned_spec_names(specs)

- names = []

- specs.each do |s|

- # TODO: when two sources without blocks is an error, we can change

- # this check to !s.source.is_a?(Source::LocalRubygems). For now,

- # we need to ask every Rubygems for every gem name.

- if s.source.is_a?(Source::Git) || s.source.is_a?(Source::Path)

- names << s.name

- end

- names.uniq!

- names

- groups - Bundler.settings.without - @optional_groups + Bundler.settings.with

- dep = Gem::Dependency.new(locked_spec.name, ">= #{locked_spec.version}")

- requirements[locked_spec.name] = DepProxy.new(dep, locked_spec.platform)

- platforms = []

- @platforms.each do |p|

- platform = PLATFORM_MAP[p]

- next unless valid_platforms.include?(platform)

- platforms |= [platform]

- end

- platforms

-Bundler::SharedHelpers.major_deprecation "Bundler no longer integrates with " \

- if defined? ::Deprecate

- class Deprecate; end

- @skip

- expanded_gemfile_path = Pathname.new(gemfile).expand_path

- contents ||= Bundler.read_file(gemfile.to_s)

- if current.type == :development

- @dependencies.delete current

- else

- if current.type == :development

- @dependencies.delete current

- else

- raise "No sources available for #{options["type"]}"

- source = normalize_source(source)

- source = normalize_source(source)

- @sources.add_rubygems_remote(source)

- Definition.new(lockfile, @dependencies, @sources, unlock, @ruby_version, @optional_groups)

- opts = Hash === args.last ? args.pop.dup : {}

- normalize_group_options(opts, args)

- if opts["optional"]

- def install_if(*args, &blk)

- blk.call

- warn__source_change(repo_name)

- warn_deprecated_git_source(:gist, 'https://gist..com/#{repo_name}.git')

- user_name, repo_name = repo_name.split "/"

- warn_deprecated_git_source(:bitbucket, 'https://#{user_name}@bitbucket.org/#{user_name}/#{repo_name}.git')

- @valid_keys ||= %w(group groups git path glob name branch ref tag require submodules platform platforms type source install_if)

- %w(git path).each do |type|

- opts["source"] ||= @source

- opts["env"] ||= @env

- validate_keys("group #{groups}", opts, %w(optional))

- if invalid_keys.any?

- message = String.new

- message << "You passed #{invalid_keys.map {|k| ":" + k }.join(", ")} "

- message << if invalid_keys.size > 1

- "as options for #{command}, but they are invalid."

- else

- "as an option for #{command}, but it is invalid."

- end

-

- message << " Valid options are: #{valid_keys.join(", ")}."

- message << " You may be able to resolve this by upgrading Bundler to the newest version."

- raise InvalidOption, message

- end

- Bundler::SharedHelpers.major_deprecation "The source :#{source} is deprecated because HTTP " \

- def check_primary_source_safety(source)

- return unless source.rubygems_primary_remotes.any?

- # TODO: 2.0 upgrade from setting to default

- if Bundler.settings[:disable_multisource]

- raise GemfileError, "Warning: this Gemfile contains multiple primary sources. " \

- "should come from that source. To downgrade this error to a warning, run " \

- "`bundle config --delete disable_multisource`"

- Bundler::SharedHelpers.major_deprecation "Your Gemfile contains multiple primary sources. " \

- def warn__source_change(repo_name)

- Bundler::SharedHelpers.major_deprecation "The : option uses the git: protocol, which is not secure. " \

- "Bundler 2.0 will use the https: protocol, which is secure. Enable this change now by " \

- "running `bundle config .https true`."

- end

- def warn_deprecated_git_source(name, repo_string)

- # TODO: 2.0 remove deprecation

- Bundler::SharedHelpers.major_deprecation <<-EOS

-The :#{name} git source is deprecated, and will be removed in Bundler 2.0. Add this code to your Gemfile to ensure it continues to work:

- git_source(:#{name}) do |repo_name|

- "#{repo_string}"

- end

- first_line = (line_numer.zero?)

- def write(io)

- def report(options = {})

- out = String.new("## Environment\n\n```\n")

- out << "Bundler #{Bundler::VERSION}\n"

- out << "Rubygems #{Gem::VERSION}\n"

- out << "Ruby #{ruby_version}"

- out << "GEM_HOME #{ENV["GEM_HOME"]}\n" unless ENV["GEM_HOME"].nil? || ENV["GEM_HOME"].empty?

- out << "GEM_PATH #{ENV["GEM_PATH"]}\n" unless ENV["GEM_PATH"] == ENV["GEM_HOME"]

- out << "RVM #{ENV["rvm_version"]}\n" if ENV["rvm_version"]

- out << "Git #{git_version}\n"

- out << "Platform #{Gem::Platform.local}\n"

- out << "OpenSSL #{OpenSSL::OPENSSL_VERSION}\n" if defined?(OpenSSL::OPENSSL_VERSION)

- %w(rubygems-bundler open_gem).each do |name|

- specs = Bundler.rubygems.find_name(name)

- out << "#{name} (#{specs.map(&:version).join(",")})\n" unless specs.empty?

- end

-

- out << "```\n"

- out << "\n### #{Bundler.default_gemfile.relative_path_from(SharedHelpers.pwd)}\n\n"

- out << "```ruby\n" << read_file(Bundler.default_gemfile).chomp << "\n```\n"

- private

-

- def read_file(filename)

- def ruby_version

- str << ") [#{RUBY_PLATFORM}]\n"

- str << " (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION}) [#{RUBY_PLATFORM}]\n"

- def git_version

- @prefix = "BUNDLER_ORIG_"

- original_value = env[@prefix + key]

- if !value.nil? && !value.empty? && original_value.nil?

- env[@prefix + key] = value

- unless value_original.nil? || value_original.empty?

- env.delete(@prefix + key)

- define_method("#{flag}?") do

- value = Bundler.settings[flag]

-

- class << self; private :settings_flag; end

- con = Bundler::Persistent::Net::HTTP::Persistent.new "bundler", :ENV

- if Bundler.settings[:ssl_client_cert]

- pem = File.read(Bundler.settings[:ssl_client_cert])

- Bundler::Persistent::Net::HTTP::Persistent::Error, Zlib::BufError, Errno::EHOSTUNREACH

- if Bundler.settings[:ssl_ca_cert]

- if File.directory? Bundler.settings[:ssl_ca_cert]

- store.add_path Bundler.settings[:ssl_ca_cert]

- store.add_file Bundler.settings[:ssl_ca_cert]

- return nil unless md5_available?

-

- def md5_available?

- require "openssl"

- OpenSSL::Digest::MD5.digest("")

- true

- rescue LoadError

- true

- rescue OpenSSL::Digest::DigestError

- false

- end

- fetch_uri.scheme != "file" && downloader.fetch(dependency_api_uri)

- #{Bundler::Env.new.report}

- desc "Create tag #{version_tag} and build and push #{name}-#{version}.gem to Rubygems\n" \

- "To prevent publishing in Rubygems use `gem_push=no rake release`"

- allowed_push_host = nil

- if @gemspec.respond_to?(:metadata)

- allowed_push_host = @gemspec.metadata["allowed_push_host"]

- gem_command += " --host #{allowed_push_host}" if allowed_push_host

- end

- Bundler.ui.confirm "Pushed #{name} #{version} to #{allowed_push_host ? allowed_push_host : "rubygems.org."}"

- !%w(n no nil false off 0).include?(ENV["gem_push"].to_s.downcase)

- wants_prerelease = dependency.requirement.prerelease?

- wants_prerelease ||= base && base.any? {|base_spec| base_spec.version.prerelease? }

- only_prerelease = specs.all? {|spec| spec.version.prerelease? }

-

- unless wants_prerelease || only_prerelease

- found.reject! {|spec| spec.version.prerelease? }

- end

-

- if Bundler.settings[:frozen]

- # temporarily remove frozen while we inject

- frozen = Bundler.settings.delete(:frozen)

- # evaluate the Gemfile we have now

- builder = Dsl.new

- builder.eval_gemfile(gemfile_path)

- # don't inject any gems that are already in the Gemfile

- @new_deps -= builder.dependencies

- # add new deps to the end of the in-memory Gemfile

- # Set conservative versioining to false because we want to let the resolver resolve the version first

- builder.eval_gemfile("injected gems", build_gem_lines(false)) if @new_deps.any?

- # resolve to see if the new deps broke anything

- @definition = builder.to_definition(lockfile_path, {})

- @definition.resolve_remotely!

- # since nothing broke, we can add those gems to the gemfile

- append_to(gemfile_path, build_gem_lines(@options[:conservative_versioning])) if @new_deps.any?

- # since we resolved successfully, write out the lockfile

- @definition.lock(Bundler.default_lockfile)

- # return an array of the deps that we added

- return @new_deps

- ensure

- Bundler.settings[:frozen] = "1" if frozen

- ENV["BUNDLE_GEMFILE"] = "Gemfile"

- begin

- !definition.missing_specs.empty?

- rescue Bundler::GemNotFound, Bundler::GitError

- definition.instance_variable_set(:@index, nil)

- true

- end

- # Firstly, this method will check to see if Bundler.bundle_path exists

- # and if not then will create it. This is usually the location of gems

- # on the system, be it RVM or at a system path.

- # Secondly, it checks if Bundler has been configured to be "frozen"

- # Thirdly, Bundler checks if there are any dependencies specified in the Gemfile using

- # Bundler::Environment#dependencies. If there are no dependencies specified then

- # Bundler returns a warning message stating so and this method returns.

- # Fourthly, Bundler checks if the default lockfile (Gemfile.lock) exists, and if so

- # then proceeds to set up a definition based on the default gemfile (Gemfile) and the

- # default lock file (Gemfile.lock). However, this is not the case if the platform is different

- # to that which is specified in Gemfile.lock, or if there are any missing specs for the gems.

- # Finally: TODO add documentation for how the standalone process works.

- if Bundler.settings[:frozen]

- @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])

- end

- if @definition.dependencies.empty?

- Bundler.ui.warn "The Gemfile specifies no dependencies"

- lock

- return

- end

- resolve_if_need(options)

- ensure_specs_are_compatible!

- install(options)

- lock unless Bundler.settings[:frozen]

- Standalone.new(options[:standalone], @definition).generate if options[:standalone]

- bin_path = bin_path = Bundler.bin_path

- template = template = File.read(File.expand_path("../templates/Executable", __FILE__))

- relative_gemfile_path = relative_gemfile_path = Bundler.default_gemfile.relative_path_from(bin_path)

- ruby_command = ruby_command = Thor::Util.ruby_command

- next if executable == "bundle"

-

- standalone_path = standalone_path = Bundler.root.join(Bundler.settings[:path]).relative_path_from(bin_path)

- ruby_command = ruby_command = Thor::Util.ruby_command

- executable_path = executable_path = Pathname(spec.full_gem_path).join(spec.bindir, executable).relative_path_from(bin_path)

- Bundler.rubygems.load_plugins

- jobs = 1

- jobs = [Bundler.settings[:jobs].to_i - 1, 1].max if can_install_in_parallel?

- Bundler.ui.warn "Rubygems #{Gem::VERSION} is not threadsafe, so your "\

- "gems will be installed one at a time. Upgrade to Rubygems 2.1.0 " \

- raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " \

- def resolve_if_need(options)

- if !options["update"] && !options["force"] && !Bundler.settings[:inline] && Bundler.default_lockfile.file?

- local = Bundler.ui.silence do

- begin

- tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)

- true unless tmpdef.new_platform? || tmpdef.missing_dependencies.any?

- rescue BundlerError

- end

- end

- return if local

- # Returns max number of threads machine can handle with a min of 1

- def self.max_threads

- [Bundler.settings[:jobs].to_i - 1, 1].max

- end

-

- enqueue_specs

- process_specs until @specs.all?(&:installed?) || @specs.any?(&:failed?)

- def worker_pool

- @worker_pool ||= Bundler::Worker.new @size, "Parallel Installer", lambda { |spec_install, worker_num|

- gem_installer = Bundler::GemInstaller.new(

- spec_install.spec, @installer, @standalone, worker_num, @force

- )

- success, message = gem_installer.install_from_spec

- if success && !message.nil?

- spec_install.post_install_message = message

- elsif !success

- spec_install.state = :failed

- spec_install.error = "#{message}\n\n#{require_tree_for_spec(spec_install.spec)}"

- end

- spec_install

- }

- end

-

- # Dequeue a spec and save its post-install message and then enqueue the

- # remaining specs.

- # Some specs might've had to wait til this spec was installed to be

- # processed so the call to `enqueue_specs` is important after every

- # dequeue.

- def process_specs

- spec = worker_pool.deq

- spec.state = :installed unless spec.failed?

- enqueue_specs

- end

-

- def handle_error

- errors = @specs.select(&:failed?).map(&:error)

- if exception = errors.find {|e| e.is_a?(Bundler::BundlerError) }

- raise exception

- end

- raise Bundler::InstallError, errors.map(&:to_s).join("\n\n")

- end

-

- search_object = Bundler.settings[:specific_platform] || Bundler.settings[:force_ruby_platform] ? self : Dependency.new(name, version)

- @sources << @rubygems_aggregate

- Array(@opts["remote"]).each do |url|

- @rubygems_aggregate.add_remote(url)

- @current_source = @rubygems_aggregate

- (@mirrors[config.uri] = @mirrors[config.uri] || Mirror.new)

- mirror = (@mirrors[URI(uri.to_s.downcase)] || @mirrors[URI(uri.to_s).host] || Mirror.new(uri)).validate!(@prober)

- config_line.match(%r{^mirror\.(all|.+?)(\.fallback_timeout)?\/?$}).captures

-require "digest/sha1"

- Digest::SHA1.hexdigest(uri)

-

- if options[:git]

- install_git(names, version, options)

- else

- sources = options[:source] || Bundler.rubygems.sources

- install_rubygems(names, version, sources)

- def initialize

- @path_sources = []

- @git_sources = []

- @rubygems_aggregate = Plugin::Installer::Rubygems.new

- @rubygems_sources = []

- end

-

- path_sources + git_sources + rubygems_sources

-

- class Molinillo::VersionConflict

- def printable_dep(dep)

- if dep.is_a?(Bundler::Dependency)

- DepProxy.new(dep, dep.platforms.join(", ")).to_s.strip

- else

- dep.to_s

- end

- end

-

- def message

- conflicts.sort.reduce(String.new) do |o, (name, conflict)|

- o << %(\nBundler could not find compatible versions for gem "#{name}":\n)

- if conflict.locked_requirement

- o << %( In snapshot (#{Bundler.default_lockfile.basename}):\n)

- o << %( #{printable_dep(conflict.locked_requirement)}\n)

- o << %(\n)

- end

- o << %( In Gemfile:\n)

- trees = conflict.requirement_trees

-

- maximal = 1.upto(trees.size).map do |size|

- trees.map(&:last).flatten(1).combination(size).to_a

- end.flatten(1).select do |deps|

- Bundler::VersionRanges.empty?(*Bundler::VersionRanges.for_many(deps.map(&:requirement)))

- end.min_by(&:size)

- trees.reject! {|t| !maximal.include?(t.last) } if maximal

-

- o << trees.sort_by {|t| t.reverse.map(&:name) }.map do |tree|

- t = String.new

- depth = 2

- tree.each do |req|

- t << " " * depth << req.to_s

- unless tree.last == req

- if spec = conflict.activated_by_name[req.name]

- t << %( was resolved to #{spec.version}, which)

- end

- t << %( depends on)

- end

- t << %(\n)

- depth += 1

- end

- t

- end.join("\n")

-

- if name == "bundler"

- o << %(\n Current Bundler version:\n bundler (#{Bundler::VERSION}))

- other_bundler_required = !conflict.requirement.requirement.satisfied_by?(Gem::Version.new Bundler::VERSION)

- end

-

- if name == "bundler" && other_bundler_required

- o << "\n"

- o << "This Gemfile requires a different version of Bundler.\n"

- o << "Perhaps you need to update Bundler by running `gem install bundler`?\n"

- end

- if conflict.locked_requirement

- o << "\n"

- o << %(Running `bundle update` will rebuild your snapshot from scratch, using only\n)

- o << %(the gems in your Gemfile, which may resolve the conflict.\n)

- elsif !conflict.existing

- o << "\n"

- if conflict.requirement_trees.first.size > 1

- o << "Could not find gem '#{conflict.requirement}', which is required by "

- o << "gem '#{conflict.requirement_trees.first[-2]}', in any of the sources."

- else

- o << "Could not find gem '#{conflict.requirement}' in any of the sources\n"

- end

- end

- o

- end.strip

- end

- end

-

- class SpecGroup < Array

- include GemHelpers

-

- attr_reader :activated

-

- def initialize(a)

- super

- @required_by = []

- @activated_platforms = []

- @dependencies = nil

- @specs = Hash.new do |specs, platform|

- specs[platform] = select_best_platform_match(self, platform)

- end

- end

-

- def initialize_copy(o)

- super

- @activated_platforms = o.activated.dup

- end

-

- def to_specs

- @activated_platforms.map do |p|

- next unless s = @specs[p]

- lazy_spec = LazySpecification.new(name, version, s.platform, source)

- lazy_spec.dependencies.replace s.dependencies

- lazy_spec

- end.compact

- end

-

- def activate_platform!(platform)

- return unless for?(platform)

- return if @activated_platforms.include?(platform)

- @activated_platforms << platform

- end

-

- def name

- @name ||= first.name

- end

-

- def version

- @version ||= first.version

- end

-

- def source

- @source ||= first.source

- end

-

- def for?(platform)

- spec = @specs[platform]

- !spec.nil?

- end

-

- def to_s

- "#{name} (#{version})"

- end

-

- def dependencies_for_activated_platforms

- dependencies = @activated_platforms.map {|p| __dependencies[p] }

- metadata_dependencies = @activated_platforms.map do |platform|

- metadata_dependencies(@specs[platform], platform)

- end

- dependencies.concat(metadata_dependencies).flatten

- end

-

- def platforms_for_dependency_named(dependency)

- __dependencies.select {|_, deps| deps.map(&:name).include? dependency }.keys

- end

-

- private

-

- def __dependencies

- @dependencies = Hash.new do |dependencies, platform|

- dependencies[platform] = []

- if spec = @specs[platform]

- spec.dependencies.each do |dep|

- next if dep.type == :development

- dependencies[platform] << DepProxy.new(dep, platform)

- end

- end

- dependencies[platform]

- end

- end

-

- def metadata_dependencies(spec, platform)

- return [] unless spec

- # Only allow endpoint specifications since they won't hit the network to

- # fetch the full gemspec when calling required_ruby_version

- return [] if !spec.is_a?(EndpointSpecification) && !spec.is_a?(Gem::Specification)

- dependencies = []

- if !spec.required_ruby_version.nil? && !spec.required_ruby_version.none?

- dependencies << DepProxy.new(Gem::Dependency.new("ruby\0", spec.required_ruby_version), platform)

- end

- if !spec.required_rubygems_version.nil? && !spec.required_rubygems_version.none?

- dependencies << DepProxy.new(Gem::Dependency.new("rubygems\0", spec.required_rubygems_version), platform)

- end

- dependencies

- end

- end

- raise VersionConflict.new(e.conflicts.keys.uniq, e.message)

- groups << SpecGroup.new(specs)

- @source_requirements[dependency.name] || @index

- activated.vertex_named(name).payload ? 0 : 1,

- activated.vertex_named(name).payload ? 0 : search_for(dependency).count,

- next if requirement.name == "bundler"

- if (base = @base[requirement.name]) && !base.empty?

- " #{requirement.name} #{requirement.requirement}\n\n" \

- "The bundle currently has #{requirement.name} locked at #{version}.\n" \

- "Try running `bundle update #{requirement.name}`\n\n" \

- elsif requirement.source

- name = requirement.name

- specs = @source_requirements[name][name]

- message = String.new("Could not find gem '#{requirement}' in #{requirement.source}.\n")

- "Source contains '#{name}' at: #{formatted_versions_with_platforms(versions_with_platforms)}"

- "Source does not contain any versions of '#{requirement}'"

- cache_message = begin

- " or in gems cached in #{Bundler.settings.app_cache_path}" if Bundler.app_cache.exist?

- rescue GemfileNotFound

- nil

- end

- version_platform_str << " #{platform}" unless platform.nil?

- # Not available before Rubygems 2.0.0, ignore

- attr_accessor :source, :groups

- instance_variables.reject {|p| ["@source", "@groups"].include?(p.to_s) }

- # Backport of performance enhancement added to Rubygems 1.4

- digest = Digest::SHA256.new

- dirs << Gem.spec_cache_dir if Gem.respond_to?(:spec_cache_dir) # Not in Rubygems 2.0.3 or earlier

- %w(cache doc gems specifications)

- # this is a no-op outside of Rubygems 1.8

- # TODO: This is for older versions of Rubygems... should we support the

- # Maybe the newer implementation will work on older Rubygems?

- %w(High Medium Low AlmostNo No).map {|level| "#{level}Security" }

- # TODO: delete this in 2.0, it's a backwards compatibility shim

- # see https://.com/bundler/bundler/issues/5102

- kernel_class.send(:public, :gem)

- unless spec.name == name

- Bundler::SharedHelpers.major_deprecation \

- "Bundler is using a binstub that was created for a different gem.\n" \

- # Replace or hook into Rubygems to provide a bundlerized view

- # This backports the correct segment generation code from Rubygems 1.4+

- # by monkeying it into the method in Rubygems 1.3.6 and 1.3.7.

- # Rubygems 1.8+

- # Rubygems 1.4 through 1.6

- # Rubygems versions lower than 1.7 use SourceIndex#from_gems_in

- # Rubygems versions 1.3.6 and 1.3.7

- # Rubygems 1.7

- # Rubygems 1.8.5-1.8.19

- # Rubygems 1.8.0 to 1.8.4

- # Rubygems [>= 1.8.0, < 1.8.5] has a bug that changes Gem.dir whenever

- # Rubygems 1.8.20+

- # Rubygems 1.8.20 and adds the skip_validation parameter, so that's

- # Rubygems 2.0

- else # Rubygems 1.3.6 and 1.3.7

-require "digest/sha1"

- @definition.ensure_equivalent_gemfile_and_lockfile if Bundler.settings[:frozen]

- # Store original MANPATH for restoration later in with_clean_env()

- ENV["BUNDLER_ORIG_MANPATH"] = ENV["MANPATH"]

-

- ENV["MANPATH"] = manuals.concat(

- BOOL_KEYS = %w(

- ).freeze

-

- NUMBER_KEYS = %w(

- ).freeze

- attr_accessor :cli_flags_given

-

- @cli_flags_given = false

- value = @temporary.fetch(name) do

- def []=(key, value)

- if cli_flags_given

- Bundler::SharedHelpers.major_deprecation \

- alias_method :set_local, :[]=

- existing = Hash[update.map {|k, _| [k, @temporary[k]] }]

- @temporary.update(update)

- existing.each {|k, v| v.nil? ? @temporary.delete(k) : @temporary[k] = v }

- def delete(key)

- @local_config.delete(key_for(key))

- end

-

- env_keys = ENV.keys.select {|k| k =~ /BUNDLE_.*/ }

- keys = @global_config.keys | @local_config.keys | env_keys

- mirrors.parse(k, self[k]) if k =~ /^mirror\./

- def without=(array)

- set_array(:without, array)

- end

- def with=(array)

- set_array(:with, array)

- def without

- get_array(:without)

- end

- def with

- get_array(:with)

- end

- # @local_config["BUNDLE_PATH"] should be prioritized over ENV["BUNDLE_PATH"]

- def path

- key = key_for(:path)

- path = ENV[key] || @global_config[key]

- return path if path && !@local_config.key?(key)

- if path = self[:path]

- "#{path}/#{Bundler.ruby_scope}"

- else

- Bundler.rubygems.gem_dir

- !@local_config.key?(key_for(:path))

- @app_cache_path ||= begin

- path = self[:cache_path] || "vendor/cache"

- raise InvalidOption, "Cache path must be relative to the bundle path" if path.start_with?("/")

- path

- end

- private

- split_specfic_setting_for(name)[0]

- def specfic_gem_for(name)

- split_specfic_setting_for(name)[1]

- def split_specfic_setting_for(name)

- def is_num(value)

- NUMBER_KEYS.include?(value.to_s)

- def get_array(key)

- self[key] ? self[key].split(":").map(&:to_sym) : []

- def set_array(key, array)

- self[key] = (array.empty? ? nil : array.join(":")) if array

- def set_key(key, value, hash, file)

- key = key_for(key)

- unless hash[key] == value

- hash[key] = value

- hash.delete(key) if value.nil?

- SharedHelpers.filesystem_access(file) do |p|

- FileUtils.mkdir_p(p.dirname)

- require "bundler/yaml_serializer"

- p.open("w") {|f| f.write(YAMLSerializer.dump(hash)) }

- end

- end

- value

- if value.nil?

- value

- uri = "#{uri}/" unless uri =~ %r{/\Z}

- uri

- def default_gemfile

- Pathname.new(gemfile).untaint

- keys = %w(GIT_DIR GIT_WORK_TREE)

- def major_deprecation(message)

- ui.warn("[DEPRECATED FOR #{Bundler::VERSION.split(".").first.to_i + 1}.0] #{message}")

- deprecate_gemfile(find_gemfile) if find_gemfile == find_file("Gemfile")

- major_deprecation("Bundler will only support ruby >= 2.0, you are running #{RUBY_VERSION}")

- major_deprecation("Bundler will only support rubygems >= 2.0, you are running #{Bundler.rubygems.version}")

- return unless Bundler.bundle_path.to_s.include?(File::PATH_SEPARATOR)

- message = "Your bundle path contains a '#{File::PATH_SEPARATOR}', " \

- "bundle path to not include '#{File::PATH_SEPARATOR}'." \

- def find_gemfile

- find_file("Gemfile", "gems.rb")

- ENV["BUNDLE_BIN_PATH"] = Bundler.rubygems.bin_path("bundler", "bundle", VERSION)

- ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../exe/bundle", __FILE__)

- ENV["BUNDLE_BIN_PATH"] = File.expand_path("../../../../bin/bundle", __FILE__)

- ENV["BUNDLE_GEMFILE"] = find_gemfile.to_s

- ENV["BUNDLER_VERSION"] = Bundler::VERSION

- ENV["PATH"] = paths.uniq.join(File::PATH_SEPARATOR)

- ENV["RUBYOPT"] = rubyopt.join(" ")

- ENV["RUBYLIB"] = rubylib.uniq.join(File::PATH_SEPARATOR)

- def deprecate_gemfile(gemfile)

- return unless gemfile && File.basename(gemfile) == "Gemfile"

- Bundler::SharedHelpers.major_deprecation \

- "gems.rb and gems.locked will be preferred to Gemfile and Gemfile.lock."

- end

-

-require "fileutils"

-require "digest/sha1"

- %w(ref branch tag revision).each {|k| options[k] = options[k].to_s if options[k] }

- %w(ref branch tag submodules).each do |opt|

- Bundler.ui.info "Using #{version_message(spec)} from #{self}"

- if requires_checkout? && !@copied && !force

- elsif force

- git_proxy.copy_to(install_path, submodules)

- return unless Bundler.settings[:cache_all]

- git_scope = "#{base_name}-#{uri_hash}"

-

- if Bundler.requires_sudo?

- Bundler.user_bundle_path.join("cache/git", git_scope)

- Bundler.cache.join("git", git_scope)

- end

- Digest::SHA1.hexdigest(input)

- rescue GitError

- Bundler.ui.warn "Using cached git data because of network errors"

- raise MissingGitRevisionError.new(ref, uri)

- if path.exist?

- return if has_revision_cached?

- Bundler.ui.info "Fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"

- in_path do

- git_retry %(fetch --force --quiet --tags #{uri_escaped_with_configured_credentials} "refs/heads/*:refs/heads/*")

- end

- else

- Bundler.ui.info "Fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"

- Bundler::Retry.new("`git #{command}`", GitNotAllowedError).attempts do

- Bundler.ui.info "Using #{version_message(spec)} from #{self}"

- return unless Bundler.settings[:cache_all]

- def is_a_path?

- instance_of?(Path)

- end

-

- :build_args => options[:build_args]

- Bundler.ui.warn "The validation message from Rubygems was:\n #{e.message}"

- remote_names = remotes.map(&:to_s).join(", ")

- "rubygems repository #{remote_names}"

- if installed?(spec) && (!force || spec.name.eql?("bundler"))

- Bundler.ui.info "Using #{version_message(spec)}"

- :bundler_expected_checksum => spec.respond_to?(:checksum) && spec.checksum

- def replace_remotes(other_remotes)

- remote_nouser = remote.dup.tap {|uri| uri.user = uri.password = nil }.to_s

- @installed_specs ||= begin

- idx = Index.new

- have_bundler = false

- if spec.name == "bundler"

- next unless spec.version.to_s == VERSION

- have_bundler = true

- end

-

- # Always have bundler locally

- unless have_bundler

- # We're running bundler directly from the source

- # so, let's create a fake gemspec for it (it's a path)

- # gemspec

- bundler = Gem::Specification.new do |s|

- s.name = "bundler"

- s.version = VERSION

- s.platform = Gem::Platform::RUBY

- s.source = self

- s.authors = ["bundler team"]

- s.loaded_from = File.expand_path("..", __FILE__)

- end

- idx << bundler

- end

- idx

- end

- idx

- index_fetchers.each do |f|

- Bundler.ui.info "Fetching source index from #{f.uri}"

- idx.use f.specs_with_retry(nil, self)

- end

- # about 100 gems, we treat all sites as non-api for speed.

- if allow_api

- api_fetchers.each do |f|

- Bundler.ui.info "Fetching gem metadata from #{f.uri}", Bundler.ui.debug?

- idx.use f.specs_with_retry(dependency_names, self)

- Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over

- end

-

- # Suppose the gem Foo depends on the gem Bar. Foo exists in Source A. Bar has some versions that exist in both

- # sources A and B. At this point, the API request will have found all the versions of Bar in source A,

- # but will not have found any versions of Bar from source B, which is a problem if the requested version

- # of Foo specifically depends on a version of Bar that is only found in source B. This ensures that for

- # each spec we found, we add all possible versions from all sources to the index.

- loop do

- idxcount = idx.size

- api_fetchers.each do |f|

- Bundler.ui.info "Fetching version metadata from #{f.uri}", Bundler.ui.debug?

- idx.use f.specs_with_retry(idx.dependency_names, self), true

- Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over

- end

- break if idxcount == idx.size

- end

-

- if api_fetchers.any?

- # it's possible that gems from one source depend on gems from some

- # other source, so now we download gemspecs and iterate over those

- # dependencies, looking for gems we don't have info on yet.

- unmet = idx.unmet_dependency_names

-

- # if there are any cross-site gems we missed, get them now

- api_fetchers.each do |f|

- Bundler.ui.info "Fetching dependency metadata from #{f.uri}", Bundler.ui.debug?

- idx.use f.specs_with_retry(unmet, self)

- Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over

- end if unmet.any?

- else

- allow_api = false

- end

- end

- unless allow_api

- api_fetchers.each do |f|

- Bundler.ui.info "Fetching source index from #{f.uri}"

- idx.use f.specs_with_retry(nil, self)

- end

- uri = spec.remote.uri

- Bundler.ui.confirm("Fetching #{version_message(spec)}")

- Bundler.rubygems.download_gem(spec, uri, download_path)

- uri_digest = Digest::MD5.hexdigest(uri_parts.compact.join("."))

- :plugin_sources

- @path_sources = []

- @git_sources = []

- @plugin_sources = []

- @rubygems_aggregate = Source::Rubygems.new

- @rubygems_sources = []

- @rubygems_sources + [@rubygems_aggregate]

- path_sources + git_sources + plugin_sources + rubygems_sources

- source_list_for(source).find {|s| source == s }

- lock_sources = (path_sources + git_sources + plugin_sources).sort_by(&:to_s)

- lock_sources << combine_rubygems_sources

- replacement_rubygems =

- # Return true if there were changes

- lock_sources.to_set != replacement_sources.to_set ||

- rubygems_remotes.to_set != replacement_rubygems.remotes.to_set

- materialized = self.for(deps, [], false, true, missing_specs).to_a

- set.each do |s|

- next if arr.any? {|s2| s2.name == s.name && s2.version == s.version && s2.platform == s.platform }

- arr << s

-require "fileutils"

-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

-/Gemfile.lock

- spec.summary = %q{TODO: Write a short summary, because Rubygems requires one.}

-require "spec_helper"

-

- LEVELS = %w(silent error warn confirm info debug).freeze

- if options["no-color"] || !STDOUT.tty?

- tell_me(msg, :yellow, newline) if level("warn")

- tell_me(msg, :red, newline) if level("error")

- parent_node = vertex_named(parent_name)

- add_edge(parent_node, vertex, requirement)

- incoming_edges.map(&:requirement) + explicit_requirements

- vertices += vertices.map(&:recursive_predecessors).flatten(1)

- vertices += vertices.map(&:recursive_successors).flatten(1)

- # @param [Array<DependencyGraph::Vertex>] nodes the nodes in the dependency

- def initialize(nodes)

- super "There is a circular dependency between #{nodes.map(&:name).join(' and ')}"

- @dependencies = nodes.map(&:payload).to_set

- def initialize(conflicts)

- conflicts.values.flatten.map(&:requirements).flatten.each do |conflicting|

- VERSION = '0.5.7'.freeze

- output.puts debug_info.split("\n").map { |s| ' ' * depth + s }

- # @attr [Object] possibility the spec that was unable to be activated due

- # to a conflict

- :possibility,

- :activated_by_name

- break unless state.requirements.any? || state.requirement

- activated.freeze

- create_conflict if state.is_a? PossibilityState

- unwind_for_conflict until possibility && state.is_a?(DependencyState)

- original_requested.each { |r| dg.add_vertex(name_for(r), nil, true).tap { |v| v.explicit_requirements << r } }

- initial_requirement && search_for(initial_requirement),

- {}

- debug(depth) { "Unwinding for conflict: #{requirement} to #{state_index_for_unwind / 2}" }

- sliced_states = states.slice!((state_index_for_unwind + 1)..-1)

- raise VersionConflict.new(c) unless state

- # @return [Integer] The index to which the resolution should unwind in the

- # case of conflict.

- def state_index_for_unwind

- current_requirement = requirement

- existing_requirement = requirement_for_existing_name(name)

- index = -1

- [current_requirement, existing_requirement].each do |r|

- until r.nil?

- current_state = find_state_for(r)

- if state_any?(current_state)

- current_index = states.index(current_state)

- index = current_index if current_index > index

- break

- r = parent_of(r)

- index

- return nil unless activated.vertex_named(name).payload

- states.reverse_each.find { |i| requirement == i.requirement && i.is_a?(DependencyState) }

- end

-

- # @return [Boolean] whether or not the given state has any possibilities

- # left.

- def state_any?(state)

- state && state.possibilities.any?

- def create_conflict

- vertex.incoming_edges.each { |edge| (requirements[edge.origin.payload] ||= []).unshift(edge.requirement) }

- activated.each { |v| activated_by_name[v.name] = v.payload if v.payload }

- vertex.payload,

- activated_by_name

- existing_node = activated.vertex_named(name)

- if existing_node.payload

- debug(depth) { "Found existing spec (#{existing_node.payload})" }

- attempt_to_activate_existing_spec(existing_node)

- else

- attempt_to_activate_new_spec

- end

- end

-

- # Attempts to activate the current {#possibility} (given that it has

- # already been activated)

- # @return [void]

- def attempt_to_activate_existing_spec(existing_node)

- existing_spec = existing_node.payload

- if requirement_satisfied_by?(requirement, activated, existing_spec)

- new_requirements = requirements.dup

- push_state_for_requirements(new_requirements, false)

- return if attempt_to_swap_possibility

- create_conflict

- debug(depth) { "Unsatisfied by existing spec (#{existing_node.payload})" }

- unwind_for_conflict

- end

- end

-

- # Attempts to swp the current {#possibility} with the already-activated

- # spec with the given name

- # @return [Boolean] Whether the possibility was swapped into {#activated}

- def attempt_to_swap_possibility

- activated.tag(:swap)

- vertex = activated.vertex_named(name)

- activated.set_payload(name, possibility)

- if !vertex.requirements.

- all? { |r| requirement_satisfied_by?(r, activated, possibility) } ||

- !new_spec_satisfied?

- activated.rewind_to(:swap)

- return

- end

- fixup_swapped_children(vertex)

- activate_spec

- end

-

- # Ensures there are no orphaned successors to the given {vertex}.

- # @param [DependencyGraph::Vertex] vertex the vertex to fix up.

- # @return [void]

- def fixup_swapped_children(vertex) # rubocop:disable Metrics/CyclomaticComplexity

- payload = vertex.payload

- deps = dependencies_for(payload).group_by(&method(:name_for))

- vertex.outgoing_edges.each do |outgoing_edge|

- requirement = outgoing_edge.requirement

- parent_index = @parents_of[requirement].last

- succ = outgoing_edge.destination

- matching_deps = Array(deps[succ.name])

- dep_matched = matching_deps.include?(requirement)

-

- # only push the current index when it was originally required by the

- # same named spec

- if parent_index && states[parent_index].name == name

- @parents_of[requirement].push(states.size - 1)

-

- if matching_deps.empty? && !succ.root? && succ.predecessors.to_a == [vertex]

- debug(depth) { "Removing orphaned spec #{succ.name} after swapping #{name}" }

- succ.requirements.each { |r| @parents_of.delete(r) }

-

- removed_names = activated.detach_vertex_named(succ.name).map(&:name)

- requirements.delete_if do |r|

- # the only removed vertices are those with no other requirements,

- # so it's safe to delete only based upon name here

- removed_names.include?(name_for(r))

- end

- elsif !dep_matched

- debug(depth) { "Removing orphaned dependency #{requirement} after swapping #{name}" }

- # also reset if we're removing the edge, but only if its parent has

- # already been fixed up

- @parents_of[requirement].push(states.size - 1) if @parents_of[requirement].empty?

-

- activated.delete_edge(outgoing_edge)

- requirements.delete(requirement)

- # Attempts to activate the current {#possibility} (given that it hasn't

- # already been activated)

- def attempt_to_activate_new_spec

- if new_spec_satisfied?

- activate_spec

- # @return [Boolean] whether the current spec is satisfied as a new

- # possibility.

- def new_spec_satisfied?

- unless requirement_satisfied_by?(requirement, activated, possibility)

- debug(depth) { 'Unsatisfied by requested spec' }

- return false

- end

-

- locked_requirement = locked_requirement_named(name)

-

- locked_spec_satisfied = !locked_requirement ||

- requirement_satisfied_by?(locked_requirement, activated, possibility)

- debug(depth) { 'Unsatisfied by locked spec' } unless locked_spec_satisfied

-

- locked_spec_satisfied

- def activate_spec

- # @param [Object] activated_spec the specification that has just been

- def require_nested_dependencies_for(activated_spec)

- nested_dependencies = dependencies_for(activated_spec)

- activated.add_child_vertex(name_for(d), nil, [name_for(activated_spec)], d)

- new_requirement = new_requirements.shift

- possibilities = new_requirement ? search_for(new_requirement) : []

- new_requirement, possibilities, depth, conflicts.dup

- # pushed, and the node in {#activated} is removed, and we continue

- # @attr [Set<Object>] conflicts unresolved conflicts

- :conflicts

- new(nil, [], DependencyGraph.new, nil, nil, 0, Set.new)

- conflicts.dup

- # block is given. Returns all responses recieved.

-require "digest/md5"

- :filename => Digest::MD5.hexdigest(name + as),

-# frozen_string_literal: true

- VERSION = "1.15.4" unless defined?(::Bundler::VERSION)

- (.*) # key

- indent, key, _, val = match.captures

- if val.empty?