bundler 1.14.6 → 1.15.0.pre.1

data/lib/bundler/vendor/thor/lib/thor/shell.rb

@@ -9,7 +9,7 @@ class Bundler::Thor
       # it will use a colored log, otherwise it will use a basic one without color.
       #
       def shell
-        @shell ||= if ENV["THOR_SHELL"] && ENV["THOR_SHELL"].size > 0
+        @shell ||= if ENV["THOR_SHELL"] && !ENV["THOR_SHELL"].empty?
           Bundler::Thor::Shell.const_get(ENV["THOR_SHELL"])
         elsif RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ && !ENV["ANSICON"]
           Bundler::Thor::Shell::Basic

data/lib/bundler/vendor/thor/lib/thor/shell/basic.rb

@@ -3,14 +3,17 @@ require "io/console" if RUBY_VERSION > "1.9.2"
 
 class Bundler::Thor
   module Shell
-    class Basic # rubocop:disable ClassLength
+    class Basic
       attr_accessor :base
       attr_reader   :padding
 
       # Initialize base, mute and padding to nil.
       #
       def initialize #:nodoc:
-        @base, @mute, @padding, @always_force = nil, false, 0, false
+        @base = nil
+        @mute = false
+        @padding = 0
+        @always_force = false
       end
 
       # Mute everything that's inside given block
@@ -24,7 +27,7 @@ class Bundler::Thor
 
       # Check if base is muted
       #
-      def mute? # rubocop:disable TrivialAccessors
+      def mute?
         @mute
       end
 
@@ -34,6 +37,15 @@ class Bundler::Thor
         @padding = [0, value].max
       end
 
+      # Sets the output padding while executing a block and resets it.
+      #
+      def indent(count = 1)
+        orig_padding = padding
+        self.padding = padding + count
+        yield
+        self.padding = orig_padding
+      end
+
       # Asks something to the user and receives a response.
       #
       # If asked to limit the correct responses, you can pass in an
@@ -148,7 +160,9 @@ class Bundler::Thor
       def print_table(array, options = {}) # rubocop:disable MethodLength
         return if array.empty?
 
-        formats, indent, colwidth = [], options[:indent].to_i, options[:colwidth]
+        formats = []
+        indent = options[:indent].to_i
+        colwidth = options[:colwidth]
         options[:truncate] = terminal_width if options[:truncate] == true
 
         formats << "%-#{colwidth + 2}s" if colwidth
@@ -161,12 +175,12 @@ class Bundler::Thor
         start.upto(colcount - 1) do |index|
           maxima = array.map { |row| row[index] ? row[index].to_s.size : 0 }.max
           maximas << maxima
-          if index == colcount - 1
-            # Don't output 2 trailing spaces when printing the last column
-            formats << "%-s"
-          else
-            formats << "%-#{maxima + 2}s"
-          end
+          formats << if index == colcount - 1
+                       # Don't output 2 trailing spaces when printing the last column
+                       "%-s"
+                     else
+                       "%-#{maxima + 2}s"
+                     end
         end
 
         formats[0] = formats[0].insert(0, " " * indent)
@@ -178,15 +192,15 @@ class Bundler::Thor
           row.each_with_index do |column, index|
             maxima = maximas[index]
 
-            if column.is_a?(Numeric)
+            f = if column.is_a?(Numeric)
               if index == row.size - 1
                 # Don't output 2 trailing spaces when printing the last column
-                f = "%#{maxima}s"
+                "%#{maxima}s"
               else
-                f = "%#{maxima}s  "
+                "%#{maxima}s  "
               end
             else
-              f = formats[index]
+              formats[index]
             end
             sentence << f % column.to_s
           end
@@ -211,7 +225,7 @@ class Bundler::Thor
         paras = message.split("\n\n")
 
         paras.map! do |unwrapped|
-          unwrapped.strip.gsub(/\n/, " ").squeeze(" ").gsub(/.{1,#{width}}(?:\s|\Z)/) { ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n") }
+          unwrapped.strip.tr("\n", " ").squeeze(" ").gsub(/.{1,#{width}}(?:\s|\Z)/) { ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n") }
         end
 
         paras.each do |para|
@@ -230,7 +244,7 @@ class Bundler::Thor
       # destination<String>:: the destination file to solve conflicts
       # block<Proc>:: an optional block that returns the value to be used in diff
       #
-      def file_collision(destination) # rubocop:disable MethodLength
+      def file_collision(destination)
         return true if @always_force
         options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
 
@@ -249,7 +263,7 @@ class Bundler::Thor
             return @always_force = true
           when is?(:quit)
             say "Aborting..."
-            fail SystemExit
+            raise SystemExit
           when is?(:diff)
             show_diff(destination, yield) if block_given?
             say "Retrying..."
@@ -262,10 +276,10 @@ class Bundler::Thor
       # This code was copied from Rake, available under MIT-LICENSE
       # Copyright (c) 2003, 2004 Jim Weirich
       def terminal_width
-        if ENV["THOR_COLUMNS"]
-          result = ENV["THOR_COLUMNS"].to_i
+        result = if ENV["THOR_COLUMNS"]
+          ENV["THOR_COLUMNS"].to_i
         else
-          result = unix? ? dynamic_width : 80
+          unix? ? dynamic_width : 80
         end
         result < 10 ? 80 : result
       rescue
@@ -284,7 +298,7 @@ class Bundler::Thor
       # Apply color to the given string with optional bold. Disabled in the
       # Bundler::Thor::Shell::Basic class.
       #
-      def set_color(string, *args) #:nodoc:
+      def set_color(string, *) #:nodoc:
         string
       end
 
@@ -353,11 +367,11 @@ class Bundler::Thor
       end
 
       def dynamic_width_stty
-        %x(stty size 2>/dev/null).split[1].to_i
+        `stty size 2>/dev/null`.split[1].to_i
       end
 
       def dynamic_width_tput
-        %x(tput cols 2>/dev/null).to_i
+        `tput cols 2>/dev/null`.to_i
       end
 
       def unix?
@@ -370,7 +384,7 @@ class Bundler::Thor
           if chars.length <= width
             chars.join
           else
-            ( chars[0, width - 3].join) + "..."
+            chars[0, width - 3].join + "..."
           end
         end
       end
@@ -381,7 +395,8 @@ class Bundler::Thor
         end
       else
         def as_unicode
-          old, $KCODE = $KCODE, "U"
+          old = $KCODE
+          $KCODE = "U"
           yield
         ensure
           $KCODE = old
@@ -391,7 +406,7 @@ class Bundler::Thor
       def ask_simply(statement, color, options)
         default = options[:default]
         message = [statement, ("(#{default})" if default), nil].uniq.join(" ")
-        message = prepare_message(message, color)
+        message = prepare_message(message, *color)
         result = Bundler::Thor::LineEditor.readline(message, options)
 
         return unless result

data/lib/bundler/vendor/thor/lib/thor/shell/color.rb

@@ -134,7 +134,7 @@ class Bundler::Thor
       # for diff.
       #
       def diff_lcs_loaded? #:nodoc:
-        return true  if defined?(Diff::LCS)
+        return true if defined?(Diff::LCS)
         return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
 
         @diff_lcs_loaded = begin

data/lib/bundler/vendor/thor/lib/thor/shell/html.rb

@@ -51,13 +51,13 @@ class Bundler::Thor
       def set_color(string, *colors)
         if colors.all? { |color| color.is_a?(Symbol) || color.is_a?(String) }
           html_colors = colors.map { |color| lookup_color(color) }
-          "<span style=\"#{html_colors.join("; ")};\">#{string}</span>"
+          "<span style=\"#{html_colors.join('; ')};\">#{string}</span>"
         else
           color, bold = colors
           html_color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
           styles = [html_color]
           styles << BOLD if bold
-          "<span style=\"#{styles.join("; ")};\">#{string}</span>"
+          "<span style=\"#{styles.join('; ')};\">#{string}</span>"
         end
       end
 
@@ -68,7 +68,7 @@ class Bundler::Thor
       #
       # TODO: Implement #ask for Bundler::Thor::Shell::HTML
       def ask(statement, color = nil)
-        fail NotImplementedError, "Implement #ask for Bundler::Thor::Shell::HTML"
+        raise NotImplementedError, "Implement #ask for Bundler::Thor::Shell::HTML"
       end
 
     protected
@@ -111,7 +111,7 @@ class Bundler::Thor
       # for diff.
       #
       def diff_lcs_loaded? #:nodoc:
-        return true  if defined?(Diff::LCS)
+        return true if defined?(Diff::LCS)
         return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
 
         @diff_lcs_loaded = begin

data/lib/bundler/vendor/thor/lib/thor/util.rb

@@ -64,7 +64,7 @@ class Bundler::Thor
         new_constants = Bundler::Thor::Base.subclasses.dup
         Bundler::Thor::Base.subclasses.replace(old_constants)
 
-        new_constants.map! { |c| c.namespace }
+        new_constants.map!(&:namespace)
         new_constants.compact!
         new_constants
       end
@@ -72,7 +72,7 @@ class Bundler::Thor
       # Returns the thor classes declared inside the given class.
       #
       def thor_classes_in(klass)
-        stringfied_constants = klass.constants.map { |c| c.to_s }
+        stringfied_constants = klass.constants.map(&:to_s)
         Bundler::Thor::Base.subclasses.select do |subclass|
           next unless subclass.name
           stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ""))
@@ -103,7 +103,7 @@ class Bundler::Thor
       #
       def camel_case(str)
         return str if str !~ /_/ && str =~ /[A-Z]+.*/
-        str.split("_").map { |i| i.capitalize }.join
+        str.split("_").map(&:capitalize).join
       end
 
       # Receives a namespace and tries to retrieve a Bundler::Thor or Bundler::Thor::Group class
@@ -135,7 +135,8 @@ class Bundler::Thor
           klass   = Bundler::Thor::Util.find_by_namespace(pieces.join(":"))
         end
         unless klass # look for a Bundler::Thor::Group with the right name
-          klass, command = Bundler::Thor::Util.find_by_namespace(namespace), nil
+          klass = Bundler::Thor::Util.find_by_namespace(namespace)
+          command = nil
         end
         if !klass && fallback # try a command in the default namespace
           command = namespace
@@ -163,7 +164,7 @@ class Bundler::Thor
         end
       end
 
-      def user_home # rubocop:disable MethodLength
+      def user_home
         @@user_home ||= if ENV["HOME"]
           ENV["HOME"]
         elsif ENV["USERPROFILE"]
@@ -188,7 +189,7 @@ class Bundler::Thor
       # Returns the root where thor files are located, depending on the OS.
       #
       def thor_root
-        File.join(user_home, ".thor").gsub(/\\/, "/")
+        File.join(user_home, ".thor").tr('\\', "/")
       end
 
       # Returns the files in the thor root. On Windows thor_root will be something
@@ -216,7 +217,7 @@ class Bundler::Thor
       # Return the path to the ruby interpreter taking into account multiple
       # installations and windows extensions.
       #
-      def ruby_command # rubocop:disable MethodLength
+      def ruby_command
         @ruby_command ||= begin
           ruby_name = RbConfig::CONFIG["ruby_install_name"]
           ruby = File.join(RbConfig::CONFIG["bindir"], ruby_name)

data/lib/bundler/vendor/thor/lib/thor/version.rb

@@ -1,3 +1,3 @@
 class Bundler::Thor
-  VERSION = "0.19.1"
+  VERSION = "0.19.4"
 end

data/lib/bundler/version.rb

@@ -7,5 +7,18 @@ module Bundler
   # We're doing this because we might write tests that deal
   # with other versions of bundler and we are unsure how to
   # handle this better.
-  VERSION = "1.14.6" unless defined?(::Bundler::VERSION)
+  VERSION = "1.15.0.pre.1" unless defined?(::Bundler::VERSION)
+
+  def self.overwrite_loaded_gem_version
+    begin
+      require "rubygems"
+    rescue LoadError
+      return
+    end
+    return unless bundler_spec = Gem.loaded_specs["bundler"]
+    return if bundler_spec.version == VERSION
+    bundler_spec.version = Bundler::VERSION
+  end
+  private_class_method :overwrite_loaded_gem_version
+  overwrite_loaded_gem_version
 end

data/lib/bundler/version_ranges.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+module Bundler
+  module VersionRanges
+    NEq = Struct.new(:version)
+    ReqR = Struct.new(:left, :right)
+    class ReqR
+      Endpoint = Struct.new(:version, :inclusive)
+      def to_s
+        "#{left.inclusive ? "[" : "("}#{left.version}, #{right.version}#{right.inclusive ? "]" : ")"}"
+      end
+      INFINITY = Object.new.freeze
+      ZERO = Gem::Version.new("0.a")
+
+      def cover?(v)
+        return false if left.inclusive && left.version > v
+        return false if !left.inclusive && left.version >= v
+
+        if right.version != INFINITY
+          return false if right.inclusive && right.version < v
+          return false if !right.inclusive && right.version <= v
+        end
+
+        true
+      end
+
+      def empty?
+        left.version == right.version && !(left.inclusive && right.inclusive)
+      end
+
+      def single?
+        left.version == right.version
+      end
+
+      UNIVERSAL = ReqR.new(ReqR::Endpoint.new(Gem::Version.new("0.a"), true), ReqR::Endpoint.new(ReqR::INFINITY, false)).freeze
+    end
+
+    def self.for_many(requirements)
+      requirements = requirements.map(&:requirements).flatten(1).map {|r| r.join(" ") }
+      requirements << ">= 0.a" if requirements.empty?
+      requirement = Gem::Requirement.new(requirements)
+      self.for(requirement)
+    end
+
+    def self.for(requirement)
+      ranges = requirement.requirements.map do |op, v|
+        case op
+        when "=" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(v, true))
+        when "!=" then NEq.new(v)
+        when ">=" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(ReqR::INFINITY, false))
+        when ">" then ReqR.new(ReqR::Endpoint.new(v, false), ReqR::Endpoint.new(ReqR::INFINITY, false))
+        when "<" then ReqR.new(ReqR::Endpoint.new(ReqR::ZERO, true), ReqR::Endpoint.new(v, false))
+        when "<=" then ReqR.new(ReqR::Endpoint.new(ReqR::ZERO, true), ReqR::Endpoint.new(v, true))
+        when "~>" then ReqR.new(ReqR::Endpoint.new(v, true), ReqR::Endpoint.new(v.bump, false))
+        else raise "unknown version op #{op} in requirement #{requirement}"
+        end
+      end.uniq
+      ranges, neqs = ranges.partition {|r| !r.is_a?(NEq) }
+
+      [ranges.sort_by {|range| [range.left.version, range.left.inclusive ? 0 : 1] }, neqs.map(&:version)]
+    end
+
+    def self.empty?(ranges, neqs)
+      !ranges.reduce(ReqR::UNIVERSAL) do |last_range, curr_range|
+        next false unless last_range
+        next false if curr_range.single? && neqs.include?(curr_range.left.version)
+        next curr_range if last_range.right.version == ReqR::INFINITY
+        case last_range.right.version <=> curr_range.left.version
+        when 1 then next curr_range
+        when 0 then next(last_range.right.inclusive && curr_range.left.inclusive && !neqs.include?(curr_range.left.version) && curr_range)
+        when -1 then next false
+        end
+      end
+    end
+  end
+end

data/lib/bundler/worker.rb

@@ -27,7 +27,7 @@ module Bundler
       @func = func
       @size = size
       @threads = nil
-      trap("INT") { abort_threads }
+      SharedHelpers.trap("INT") { abort_threads }
     end
 
     # Enqueue a request to be executed in the worker pool
@@ -76,6 +76,7 @@ module Bundler
 
     def abort_threads
       return unless @threads
+      Bundler.ui.debug("\n#{caller.join("\n")}")
       @threads.each(&:exit)
       exit 1
     end

data/man/bundle-check.ronn

@@ -0,0 +1,26 @@
+bundle-check(1) -- Verifies if dependencies are satisfied by installed gems
+===========================================================================
+
+## SYNOPSIS
+
+`bundle check` [--dry-run]
+               [--gemfile=FILE]
+               [--path=PATH]
+
+## DESCRIPTION
+
+`check` searches the local machine for each of the gems requested in the
+Gemfile. If all gems are found, Bundler prints a success message and exits with
+a status of 0.
+
+If not, the first missing gem is listed and Bundler exits status 1.
+
+## OPTIONS
+
+* `--dry-run`:
+  Locks the `Gemfile(5)` before running the command.
+* `--gemfile`:
+  Use the specified gemfile instead of the `Gemfile(5)`
+* `--path`:
+  Specify a different path than the system default ($BUNDLE_PATH or $GEM_HOME).
+  Bundler will remember this value for future installs on this machine.

data/man/bundle-clean.ronn

@@ -0,0 +1,18 @@
+bundle-clean(1) -- Cleans up unused gems in your bundler directory
+==================================================================
+
+## SYNOPSIS
+
+`bundle clean` [--dry-run] [--force]
+
+## DESCRIPTION
+
+This command will remove all unused gems in your bundler directory. This is
+useful when you have made many changes to your gem dependencies.
+
+## OPTIONS
+
+* `--dry-run`:
+  Print the changes, but do not clean the unused gems.
+* `--force`:
+  Force a clean even if `--path` is not set.