bundler 2.0.2

data/lib/bundler/cli/add.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Add
+    def initialize(options, gems)
+      @gems = gems
+      @options = options
+      @options[:group] = @options[:group].split(",").map(&:strip) if !@options[:group].nil? && !@options[:group].empty?
+    end
+
+    def run
+      raise InvalidOption, "You can not specify `--strict` and `--optimistic` at the same time." if @options[:strict] && @options[:optimistic]
+
+      # raise error when no gems are specified
+      raise InvalidOption, "Please specify gems to add." if @gems.empty?
+
+      version = @options[:version].nil? ? nil : @options[:version].split(",").map(&:strip)
+
+      unless version.nil?
+        version.each do |v|
+          raise InvalidOption, "Invalid gem requirement pattern '#{v}'" unless Gem::Requirement::PATTERN =~ v.to_s
+        end
+      end
+
+      dependencies = @gems.map {|g| Bundler::Dependency.new(g, version, @options) }
+
+      Injector.inject(dependencies,
+        :conservative_versioning => @options[:version].nil?, # Perform conservative versioning only when version is not specified
+        :optimistic => @options[:optimistic],
+        :strict => @options[:strict])
+
+      Installer.install(Bundler.root, Bundler.definition) unless @options["skip-install"]
+    end
+  end
+end

data/lib/bundler/cli/binstubs.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Binstubs
+    attr_reader :options, :gems
+    def initialize(options, gems)
+      @options = options
+      @gems = gems
+    end
+
+    def run
+      Bundler.definition.validate_runtime!
+      path_option = options["path"]
+      path_option = nil if path_option && path_option.empty?
+      Bundler.settings.set_command_option :bin, path_option if options["path"]
+      Bundler.settings.set_command_option_if_given :shebang, options["shebang"]
+      installer = Installer.new(Bundler.root, Bundler.definition)
+
+      installer_opts = { :force => options[:force], :binstubs_cmd => true }
+
+      if options[:all]
+        raise InvalidOption, "Cannot specify --all with specific gems" unless gems.empty?
+        @gems = Bundler.definition.specs.map(&:name)
+        installer_opts.delete(:binstubs_cmd)
+      elsif gems.empty?
+        Bundler.ui.error "`bundle binstubs` needs at least one gem to run."
+        exit 1
+      end
+
+      gems.each do |gem_name|
+        spec = Bundler.definition.specs.find {|s| s.name == gem_name }
+        unless spec
+          raise GemNotFound, Bundler::CLI::Common.gem_not_found_message(
+            gem_name, Bundler.definition.specs
+          )
+        end
+
+        if options[:standalone]
+          next Bundler.ui.warn("Sorry, Bundler can only be run via RubyGems.") if gem_name == "bundler"
+          Bundler.settings.temporary(:path => (Bundler.settings[:path] || Bundler.root)) do
+            installer.generate_standalone_bundler_executable_stubs(spec)
+          end
+        else
+          installer.generate_bundler_executable_stubs(spec, installer_opts)
+        end
+      end
+    end
+  end
+end

data/lib/bundler/cli/cache.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Cache
+    attr_reader :options
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.definition.validate_runtime!
+      Bundler.definition.resolve_with_cache!
+      setup_cache_all
+      Bundler.settings.set_command_option_if_given :cache_all_platforms, options["all-platforms"]
+      Bundler.load.cache
+      Bundler.settings.set_command_option_if_given :no_prune, options["no-prune"]
+      Bundler.load.lock
+    rescue GemNotFound => e
+      Bundler.ui.error(e.message)
+      Bundler.ui.warn "Run `bundle install` to install missing gems."
+      exit 1
+    end
+
+  private
+
+    def setup_cache_all
+      Bundler.settings.set_command_option_if_given :cache_all, options[:all]
+
+      if Bundler.definition.has_local_dependencies? && !Bundler.feature_flag.cache_all?
+        Bundler.ui.warn "Your Gemfile contains path and git dependencies. If you want "    \
+          "to package them as well, please pass the --all flag. This will be the default " \
+          "on Bundler 2.0."
+      end
+    end
+  end
+end

data/lib/bundler/cli/check.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Check
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      Bundler.settings.set_command_option_if_given :path, options[:path]
+
+      begin
+        definition = Bundler.definition
+        definition.validate_runtime!
+        not_installed = definition.missing_specs
+      rescue GemNotFound, VersionConflict
+        Bundler.ui.error "Bundler can't satisfy your Gemfile's dependencies."
+        Bundler.ui.warn "Install missing gems with `bundle install`."
+        exit 1
+      end
+
+      if not_installed.any?
+        Bundler.ui.error "The following gems are missing"
+        not_installed.each {|s| Bundler.ui.error " * #{s.name} (#{s.version})" }
+        Bundler.ui.warn "Install missing gems with `bundle install`"
+        exit 1
+      elsif !Bundler.default_lockfile.file? && Bundler.frozen_bundle?
+        Bundler.ui.error "This bundle has been frozen, but there is no #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} present"
+        exit 1
+      else
+        Bundler.load.lock(:preserve_unknown_sections => true) unless options[:"dry-run"]
+        Bundler.ui.info "The Gemfile's dependencies are satisfied"
+      end
+    end
+  end
+end

data/lib/bundler/cli/clean.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Clean
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      require_path_or_force unless options[:"dry-run"]
+      Bundler.load.clean(options[:"dry-run"])
+    end
+
+  protected
+
+    def require_path_or_force
+      return unless Bundler.use_system_gems? && !options[:force]
+      raise InvalidOption, "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`."
+    end
+  end
+end

data/lib/bundler/cli/common.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Bundler
+  module CLI::Common
+    def self.output_post_install_messages(messages)
+      return if Bundler.settings["ignore_messages"]
+      messages.to_a.each do |name, msg|
+        print_post_install_message(name, msg) unless Bundler.settings["ignore_messages.#{name}"]
+      end
+    end
+
+    def self.print_post_install_message(name, msg)
+      Bundler.ui.confirm "Post-install message from #{name}:"
+      Bundler.ui.info msg
+    end
+
+    def self.output_without_groups_message
+      return if Bundler.settings[:without].empty?
+      Bundler.ui.confirm without_groups_message
+    end
+
+    def self.without_groups_message
+      groups = Bundler.settings[:without]
+      group_list = [groups[0...-1].join(", "), groups[-1..-1]].
+        reject {|s| s.to_s.empty? }.join(" and ")
+      group_str = (groups.size == 1) ? "group" : "groups"
+      "Gems in the #{group_str} #{group_list} were not installed."
+    end
+
+    def self.select_spec(name, regex_match = nil)
+      specs = []
+      regexp = Regexp.new(name) if regex_match
+
+      Bundler.definition.specs.each do |spec|
+        return spec if spec.name == name
+        specs << spec if regexp && spec.name =~ regexp
+      end
+
+      case specs.count
+      when 0
+        raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+      when 1
+        specs.first
+      else
+        ask_for_spec_from(specs)
+      end
+    rescue RegexpError
+      raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+    end
+
+    def self.ask_for_spec_from(specs)
+      if !$stdout.tty? && ENV["BUNDLE_SPEC_RUN"].nil?
+        raise GemNotFound, gem_not_found_message(name, Bundler.definition.dependencies)
+      end
+
+      specs.each_with_index do |spec, index|
+        Bundler.ui.info "#{index.succ} : #{spec.name}", true
+      end
+      Bundler.ui.info "0 : - exit -", true
+
+      num = Bundler.ui.ask("> ").to_i
+      num > 0 ? specs[num - 1] : nil
+    end
+
+    def self.gem_not_found_message(missing_gem_name, alternatives)
+      require "bundler/similarity_detector"
+      message = "Could not find gem '#{missing_gem_name}'."
+      alternate_names = alternatives.map {|a| a.respond_to?(:name) ? a.name : a }
+      suggestions = SimilarityDetector.new(alternate_names).similar_word_list(missing_gem_name)
+      message += "\nDid you mean #{suggestions}?" if suggestions
+      message
+    end
+
+    def self.ensure_all_gems_in_lockfile!(names, locked_gems = Bundler.locked_gems)
+      locked_names = locked_gems.specs.map(&:name).uniq
+      names.-(locked_names).each do |g|
+        raise GemNotFound, gem_not_found_message(g, locked_names)
+      end
+    end
+
+    def self.configure_gem_version_promoter(definition, options)
+      patch_level = patch_level_options(options)
+      raise InvalidOption, "Provide only one of the following options: #{patch_level.join(", ")}" unless patch_level.length <= 1
+      definition.gem_version_promoter.tap do |gvp|
+        gvp.level = patch_level.first || :major
+        gvp.strict = options[:strict] || options["update-strict"]
+      end
+    end
+
+    def self.patch_level_options(options)
+      [:major, :minor, :patch].select {|v| options.keys.include?(v.to_s) }
+    end
+
+    def self.clean_after_install?
+      clean = Bundler.settings[:clean]
+      return clean unless clean.nil?
+      clean ||= Bundler.feature_flag.auto_clean_without_path? && Bundler.settings[:path].nil?
+      clean &&= !Bundler.use_system_gems?
+      clean
+    end
+  end
+end

data/lib/bundler/cli/config.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Config
+    attr_reader :name, :options, :scope, :thor
+    attr_accessor :args
+
+    def initialize(options, args, thor)
+      @options = options
+      @args = args
+      @thor = thor
+      @name = peek = args.shift
+      @scope = "global"
+      return unless peek && peek.start_with?("--")
+      @name = args.shift
+      @scope = peek[2..-1]
+    end
+
+    def run
+      unless name
+        confirm_all
+        return
+      end
+
+      unless valid_scope?(scope)
+        Bundler.ui.error "Invalid scope --#{scope} given. Please use --local or --global."
+        exit 1
+      end
+
+      if scope == "delete"
+        Bundler.settings.set_local(name, nil)
+        Bundler.settings.set_global(name, nil)
+        return
+      end
+
+      if args.empty?
+        if options[:parseable]
+          if value = Bundler.settings[name]
+            Bundler.ui.info("#{name}=#{value}")
+          end
+          return
+        end
+
+        confirm(name)
+        return
+      end
+
+      Bundler.ui.info(message) if message
+      Bundler.settings.send("set_#{scope}", name, new_value)
+    end
+
+  private
+
+    def confirm_all
+      if @options[:parseable]
+        thor.with_padding do
+          Bundler.settings.all.each do |setting|
+            val = Bundler.settings[setting]
+            Bundler.ui.info "#{setting}=#{val}"
+          end
+        end
+      else
+        Bundler.ui.confirm "Settings are listed in order of priority. The top value will be used.\n"
+        Bundler.settings.all.each do |setting|
+          Bundler.ui.confirm "#{setting}"
+          show_pretty_values_for(setting)
+          Bundler.ui.confirm ""
+        end
+      end
+    end
+
+    def confirm(name)
+      Bundler.ui.confirm "Settings for `#{name}` in order of priority. The top value will be used"
+      show_pretty_values_for(name)
+    end
+
+    def new_value
+      pathname = Pathname.new(args.join(" "))
+      if name.start_with?("local.") && pathname.directory?
+        pathname.expand_path.to_s
+      else
+        args.join(" ")
+      end
+    end
+
+    def message
+      locations = Bundler.settings.locations(name)
+      if @options[:parseable]
+        "#{name}=#{new_value}" if new_value
+      elsif scope == "global"
+        if locations[:local]
+          "Your application has set #{name} to #{locations[:local].inspect}. " \
+            "This will override the global value you are currently setting"
+        elsif locations[:env]
+          "You have a bundler environment variable for #{name} set to " \
+            "#{locations[:env].inspect}. This will take precedence over the global value you are setting"
+        elsif locations[:global] && locations[:global] != args.join(" ")
+          "You are replacing the current global value of #{name}, which is currently " \
+            "#{locations[:global].inspect}"
+        end
+      elsif scope == "local" && locations[:local] != args.join(" ")
+        "You are replacing the current local value of #{name}, which is currently " \
+          "#{locations[:local].inspect}"
+      end
+    end
+
+    def show_pretty_values_for(setting)
+      thor.with_padding do
+        Bundler.settings.pretty_values_for(setting).each do |line|
+          Bundler.ui.info line
+        end
+      end
+    end
+
+    def valid_scope?(scope)
+      %w[delete local global].include?(scope)
+    end
+  end
+end

data/lib/bundler/cli/console.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Bundler
+  class CLI::Console
+    attr_reader :options, :group
+    def initialize(options, group)
+      @options = options
+      @group = group
+    end
+
+    def run
+      Bundler::SharedHelpers.major_deprecation 3, "bundle console will be replaced " \
+                           "by `bin/console` generated by `bundle gem <name>`"
+
+      group ? Bundler.require(:default, *(group.split.map!(&:to_sym))) : Bundler.require
+      ARGV.clear
+
+      console = get_console(Bundler.settings[:console] || "irb")
+      console.start
+    end
+
+    def get_console(name)
+      require name
+      get_constant(name)
+    rescue LoadError
+      Bundler.ui.error "Couldn't load console #{name}, falling back to irb"
+      require "irb"
+      get_constant("irb")
+    end
+
+    def get_constant(name)
+      const_name = {
+        "pry"  => :Pry,
+        "ripl" => :Ripl,
+        "irb"  => :IRB,
+      }[name]
+      Object.const_get(const_name)
+    rescue NameError
+      Bundler.ui.error "Could not find constant #{const_name}"
+      exit 1
+    end
+  end
+end