rubygems-update 3.0.3 → 3.4.12

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub/version_union.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Bundler::PubGrub
+  class VersionUnion
+    attr_reader :ranges
+
+    def self.normalize_ranges(ranges)
+      ranges = ranges.flat_map do |range|
+        range.ranges
+      end
+
+      ranges.reject!(&:empty?)
+
+      return [] if ranges.empty?
+
+      mins, ranges = ranges.partition { |r| !r.min }
+      original_ranges = mins + ranges.sort_by { |r| [r.min, r.include_min ? 0 : 1] }
+      ranges = [original_ranges.shift]
+      original_ranges.each do |range|
+        if ranges.last.contiguous_to?(range)
+          ranges << ranges.pop.span(range)
+        else
+          ranges << range
+        end
+      end
+
+      ranges
+    end
+
+    def self.union(ranges, normalize: true)
+      ranges = normalize_ranges(ranges) if normalize
+
+      if ranges.size == 0
+        VersionRange.empty
+      elsif ranges.size == 1
+        ranges[0]
+      else
+        new(ranges)
+      end
+    end
+
+    def initialize(ranges)
+      raise ArgumentError unless ranges.all? { |r| r.instance_of?(VersionRange) }
+      @ranges = ranges
+    end
+
+    def hash
+      ranges.hash
+    end
+
+    def eql?(other)
+      ranges.eql?(other.ranges)
+    end
+
+    def include?(version)
+      !!ranges.bsearch {|r| r.compare_version(version) }
+    end
+
+    def select_versions(all_versions)
+      versions = []
+      ranges.inject(all_versions) do |acc, range|
+        _, matching, higher = range.partition_versions(acc)
+        versions.concat matching
+        higher
+      end
+      versions
+    end
+
+    def intersects?(other)
+      my_ranges = ranges.dup
+      other_ranges = other.ranges.dup
+
+      my_range = my_ranges.shift
+      other_range = other_ranges.shift
+      while my_range && other_range
+        if my_range.intersects?(other_range)
+          return true
+        end
+
+        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
+          other_range = other_ranges.shift
+        else
+          my_range = my_ranges.shift
+        end
+      end
+    end
+    alias_method :allows_any?, :intersects?
+
+    def allows_all?(other)
+      my_ranges = ranges.dup
+
+      my_range = my_ranges.shift
+
+      other.ranges.all? do |other_range|
+        while my_range
+          break if my_range.allows_all?(other_range)
+          my_range = my_ranges.shift
+        end
+
+        !!my_range
+      end
+    end
+
+    def empty?
+      false
+    end
+
+    def any?
+      false
+    end
+
+    def intersect(other)
+      my_ranges = ranges.dup
+      other_ranges = other.ranges.dup
+      new_ranges = []
+
+      my_range = my_ranges.shift
+      other_range = other_ranges.shift
+      while my_range && other_range
+        new_ranges << my_range.intersect(other_range)
+
+        if !my_range.max || other_range.empty? || (other_range.max && other_range.max < my_range.max)
+          other_range = other_ranges.shift
+        else
+          my_range = my_ranges.shift
+        end
+      end
+      new_ranges.reject!(&:empty?)
+      VersionUnion.union(new_ranges, normalize: false)
+    end
+
+    def upper_invert
+      ranges.last.upper_invert
+    end
+
+    def invert
+      ranges.map(&:invert).inject(:intersect)
+    end
+
+    def union(other)
+      VersionUnion.union([self, other])
+    end
+
+    def to_s
+      output = []
+
+      ranges = self.ranges.dup
+      while !ranges.empty?
+        ne = []
+        range = ranges.shift
+        while !ranges.empty? && ranges[0].min.to_s == range.max.to_s
+          ne << range.max
+          range = range.span(ranges.shift)
+        end
+
+        ne.map! {|x| "!= #{x}" }
+        if ne.empty?
+          output << range.to_s
+        elsif range.any?
+          output << ne.join(', ')
+        else
+          output << "#{range}, #{ne.join(', ')}"
+        end
+      end
+
+      output.join(" OR ")
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        self.ranges == other.ranges
+    end
+  end
+end

data/bundler/lib/bundler/vendor/pub_grub/lib/pub_grub.rb

@@ -0,0 +1,31 @@
+require_relative "pub_grub/package"
+require_relative "pub_grub/static_package_source"
+require_relative "pub_grub/term"
+require_relative "pub_grub/version_range"
+require_relative "pub_grub/version_constraint"
+require_relative "pub_grub/version_union"
+require_relative "pub_grub/version_solver"
+require_relative "pub_grub/incompatibility"
+require_relative 'pub_grub/solve_failure'
+require_relative 'pub_grub/failure_writer'
+require_relative 'pub_grub/version'
+
+module Bundler::PubGrub
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger || default_logger
+    end
+
+    private
+
+    def default_logger
+      require "logger"
+
+      logger = ::Logger.new(STDERR)
+      logger.level = $DEBUG ? ::Logger::DEBUG : ::Logger::WARN
+      @logger = logger
+    end
+  end
+end

data/bundler/lib/bundler/vendor/thor/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz, Eric Hodel, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bundler/lib/bundler/vendor/thor/lib/thor/actions/create_file.rb

@@ -1,4 +1,4 @@
-require "bundler/vendor/thor/lib/thor/actions/empty_directory"
+require_relative "empty_directory"
 
 class Bundler::Thor
   module Actions

data/bundler/lib/bundler/vendor/thor/lib/thor/actions/create_link.rb

@@ -1,4 +1,4 @@
-require "bundler/vendor/thor/lib/thor/actions/create_file"
+require_relative "create_file"
 
 class Bundler::Thor
   module Actions
@@ -33,7 +33,8 @@ class Bundler::Thor
       # Boolean:: true if it is identical, false otherwise.
       #
       def identical?
-        exists? && File.identical?(render, destination)
+        source = File.expand_path(render, File.dirname(destination))
+        exists? && File.identical?(source, destination)
       end
 
       def invoke!

data/bundler/lib/bundler/vendor/thor/lib/thor/actions/directory.rb

@@ -1,4 +1,4 @@
-require "bundler/vendor/thor/lib/thor/actions/empty_directory"
+require_relative "empty_directory"
 
 class Bundler::Thor
   module Actions
@@ -56,7 +56,7 @@ class Bundler::Thor
       attr_reader :source
 
       def initialize(base, source, destination = nil, config = {}, &block)
-        @source = File.expand_path(base.find_in_source_paths(source.to_s))
+        @source = File.expand_path(Dir[Util.escape_globs(base.find_in_source_paths(source.to_s))].first)
         @block  = block
         super(base, destination, {:recursive => true}.merge(config))
       end
@@ -96,22 +96,12 @@ class Bundler::Thor
         end
       end
 
-      if RUBY_VERSION < "2.0"
-        def file_level_lookup(previous_lookup)
-          File.join(previous_lookup, "{*,.[a-z]*}")
-        end
-
-        def files(lookup)
-          Dir[lookup]
-        end
-      else
-        def file_level_lookup(previous_lookup)
-          File.join(previous_lookup, "*")
-        end
+      def file_level_lookup(previous_lookup)
+        File.join(previous_lookup, "*")
+      end
 
-        def files(lookup)
-          Dir.glob(lookup, File::FNM_DOTMATCH)
-        end
+      def files(lookup)
+        Dir.glob(lookup, File::FNM_DOTMATCH)
       end
     end
   end

data/bundler/lib/bundler/vendor/thor/lib/thor/actions/file_manipulation.rb

@@ -23,14 +23,14 @@ class Bundler::Thor
       destination = args.first || source
       source = File.expand_path(find_in_source_paths(source.to_s))
 
-      create_file destination, nil, config do
+      resulting_destination = create_file destination, nil, config do
         content = File.binread(source)
         content = yield(content) if block
         content
       end
       if config[:mode] == :preserve
         mode = File.stat(source).mode
-        chmod(destination, mode, config)
+        chmod(resulting_destination, mode, config)
       end
     end
 
@@ -60,6 +60,9 @@ class Bundler::Thor
     # destination. If a block is given instead of destination, the content of
     # the url is yielded and used as location.
     #
+    # +get+ relies on open-uri, so passing application user input would provide
+    # a command injection attack vector.
+    #
     # ==== Parameters
     # source<String>:: the address of the given content.
     # destination<String>:: the relative path to the destination root.
@@ -77,14 +80,14 @@ class Bundler::Thor
       config = args.last.is_a?(Hash) ? args.pop : {}
       destination = args.first
 
-      if source =~ %r{^https?\://}
+      render = if source =~ %r{^https?\://}
         require "open-uri"
+        URI.send(:open, source) { |input| input.binmode.read }
       else
         source = File.expand_path(find_in_source_paths(source.to_s))
+        open(source) { |input| input.binmode.read }
       end
 
-      render = open(source) { |input| input.binmode.read }
-
       destination ||= if block_given?
         block.arity == 1 ? yield(render) : yield
       else
@@ -117,7 +120,13 @@ class Bundler::Thor
       context = config.delete(:context) || instance_eval("binding")
 
       create_file destination, nil, config do
-        content = CapturableERB.new(::File.binread(source), nil, "-", "@output_buffer").tap do |erb|
+        match = ERB.version.match(/(\d+\.\d+\.\d+)/)
+        capturable_erb = if match && match[1] >= "2.2.0" # Ruby 2.6+
+          CapturableERB.new(::File.binread(source), :trim_mode => "-", :eoutvar => "@output_buffer")
+        else
+          CapturableERB.new(::File.binread(source), nil, "-", "@output_buffer")
+        end
+        content = capturable_erb.tap do |erb|
           erb.filename = source
         end.result(context)
         content = yield(content) if block
@@ -201,9 +210,9 @@ class Bundler::Thor
     #
     # ==== Examples
     #
-    #   inject_into_class "app/controllers/application_controller.rb", ApplicationController, "  filter_parameter :password\n"
+    #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController", "  filter_parameter :password\n"
     #
-    #   inject_into_class "app/controllers/application_controller.rb", ApplicationController do
+    #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do
     #     "  filter_parameter :password\n"
     #   end
     #
@@ -224,9 +233,9 @@ class Bundler::Thor
     #
     # ==== Examples
     #
-    #   inject_into_module "app/helpers/application_helper.rb", ApplicationHelper, "  def help; 'help'; end\n"
+    #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper", "  def help; 'help'; end\n"
     #
-    #   inject_into_module "app/helpers/application_helper.rb", ApplicationHelper do
+    #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper" do
     #     "  def help; 'help'; end\n"
     #   end
     #
@@ -242,7 +251,8 @@ class Bundler::Thor
     # path<String>:: path of the file to be changed
     # flag<Regexp|String>:: the regexp or string to be replaced
     # replacement<String>:: the replacement, can be also given as a block
-    # config<Hash>:: give :verbose => false to not log the status.
+    # config<Hash>:: give :verbose => false to not log the status, and
+    #                :force => true, to force the replacement regardles of runner behavior.
     #
     # ==== Example
     #
@@ -253,9 +263,10 @@ class Bundler::Thor
     #   end
     #
     def gsub_file(path, flag, *args, &block)
-      return unless behavior == :invoke
       config = args.last.is_a?(Hash) ? args.pop : {}
 
+      return unless behavior == :invoke || config.fetch(:force, false)
+
       path = File.expand_path(path, destination_root)
       say_status :gsub, relative_to_original_destination_root(path), config.fetch(:verbose, true)
 
@@ -301,7 +312,7 @@ class Bundler::Thor
     def comment_lines(path, flag, *args)
       flag = flag.respond_to?(:source) ? flag.source : flag
 
-      gsub_file(path, /^(\s*)([^#|\n]*#{flag})/, '\1# \2', *args)
+      gsub_file(path, /^(\s*)([^#\n]*#{flag})/, '\1# \2', *args)
     end
 
     # Removes a file at the given location.
@@ -320,7 +331,7 @@ class Bundler::Thor
       path = File.expand_path(path, destination_root)
 
       say_status :remove, relative_to_original_destination_root(path), config.fetch(:verbose, true)
-      if !options[:pretend] && File.exist?(path)
+      if !options[:pretend] && (File.exist?(path) || File.symlink?(path))
         require "fileutils"
         ::FileUtils.rm_rf(path)
       end

data/bundler/lib/bundler/vendor/thor/lib/thor/actions/inject_into_file.rb

@@ -1,4 +1,4 @@
-require "bundler/vendor/thor/lib/thor/actions/empty_directory"
+require_relative "empty_directory"
 
 class Bundler::Thor
   module Actions
@@ -21,9 +21,14 @@ class Bundler::Thor
     #     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
     #   end
     #
+    WARNINGS = { unchanged_no_flag: 'File unchanged! The supplied flag value not found!' }
+
     def insert_into_file(destination, *args, &block)
       data = block_given? ? block : args.shift
-      config = args.shift
+
+      config = args.shift || {}
+      config[:after] = /\z/ unless config.key?(:before) || config.key?(:after)
+
       action InjectIntoFile.new(self, destination, data, config)
     end
     alias_method :inject_into_file, :insert_into_file
@@ -45,8 +50,6 @@ class Bundler::Thor
       end
 
       def invoke!
-        say_status :invoke
-
         content = if @behavior == :after
           '\0' + replacement
         else
@@ -54,7 +57,11 @@ class Bundler::Thor
         end
 
         if exists?
-          replace!(/#{flag}/, content, config[:force])
+          if replace!(/#{flag}/, content, config[:force])
+            say_status(:invoke)
+          else
+            say_status(:unchanged, warning: WARNINGS[:unchanged_no_flag], color: :red)
+          end
         else
           unless pretend?
             raise Bundler::Thor::Error, "The file #{ destination } does not appear to exist"
@@ -78,7 +85,7 @@ class Bundler::Thor
 
     protected
 
-      def say_status(behavior)
+      def say_status(behavior, warning: nil, color: nil)
         status = if behavior == :invoke
           if flag == /\A/
             :prepend
@@ -87,21 +94,24 @@ class Bundler::Thor
           else
             :insert
           end
+        elsif warning
+          warning
         else
           :subtract
         end
 
-        super(status, config[:verbose])
+        super(status, (color || config[:verbose]))
       end
 
       # Adds the content to the file.
       #
       def replace!(regexp, string, force)
-        return if pretend?
         content = File.read(destination)
         if force || !content.include?(replacement)
-          content.gsub!(regexp, string)
-          File.open(destination, "wb") { |file| file.write(content) }
+          success = content.gsub!(regexp, string)
+
+          File.open(destination, "wb") { |file| file.write(content) } unless pretend?
+          success
         end
       end
     end

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

@@ -1,17 +1,16 @@
-require "uri"
-require "bundler/vendor/thor/lib/thor/core_ext/io_binary_read"
-require "bundler/vendor/thor/lib/thor/actions/create_file"
-require "bundler/vendor/thor/lib/thor/actions/create_link"
-require "bundler/vendor/thor/lib/thor/actions/directory"
-require "bundler/vendor/thor/lib/thor/actions/empty_directory"
-require "bundler/vendor/thor/lib/thor/actions/file_manipulation"
-require "bundler/vendor/thor/lib/thor/actions/inject_into_file"
+require_relative "actions/create_file"
+require_relative "actions/create_link"
+require_relative "actions/directory"
+require_relative "actions/empty_directory"
+require_relative "actions/file_manipulation"
+require_relative "actions/inject_into_file"
 
 class Bundler::Thor
   module Actions
     attr_accessor :behavior
 
     def self.included(base) #:nodoc:
+      super(base)
       base.extend ClassMethods
     end
 
@@ -113,8 +112,10 @@ class Bundler::Thor
     # the script started).
     #
     def relative_to_original_destination_root(path, remove_dot = true)
-      path = path.dup
-      if path.gsub!(@destination_stack[0], ".")
+      root = @destination_stack[0]
+      if path.start_with?(root) && [File::SEPARATOR, File::ALT_SEPARATOR, nil, ''].include?(path[root.size..root.size])
+        path = path.dup
+        path[0...root.size] = '.'
         remove_dot ? (path[2..-1] || "") : path
       else
         path
@@ -160,6 +161,8 @@ class Bundler::Thor
     # to the block you provide. The path is set back to the previous path when
     # the method exits.
     #
+    # Returns the value yielded by the block.
+    #
     # ==== Parameters
     # dir<String>:: the directory to move to.
     # config<Hash>:: give :verbose => true to log and use padding.
@@ -178,16 +181,18 @@ class Bundler::Thor
         FileUtils.mkdir_p(destination_root)
       end
 
+      result = nil
       if pretend
         # In pretend mode, just yield down to the block
-        block.arity == 1 ? yield(destination_root) : yield
+        result = block.arity == 1 ? yield(destination_root) : yield
       else
         require "fileutils"
-        FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
+        FileUtils.cd(destination_root) { result = block.arity == 1 ? yield(destination_root) : yield }
       end
 
       @destination_stack.pop
       shell.padding -= 1 if verbose
+      result
     end
 
     # Goes to the root and execute the given block.
@@ -217,7 +222,8 @@ class Bundler::Thor
       shell.padding += 1 if verbose
 
       contents = if is_uri
-        open(path, "Accept" => "application/x-thor-template", &:read)
+        require "open-uri"
+        URI.open(path, "Accept" => "application/x-thor-template", &:read)
       else
         open(path, &:read)
       end
@@ -252,9 +258,22 @@ class Bundler::Thor
 
       say_status :run, desc, config.fetch(:verbose, true)
 
-      unless options[:pretend]
-        config[:capture] ? `#{command}` : system(command.to_s)
+      return if options[:pretend]
+
+      env_splat = [config[:env]] if config[:env]
+
+      if config[:capture]
+        require "open3"
+        result, status = Open3.capture2e(*env_splat, command.to_s)
+        success = status.success?
+      else
+        result = system(*env_splat, command.to_s)
+        success = result
       end
+
+      abort if !success && config.fetch(:abort_on_failure, self.class.exit_on_failure?)
+
+      result
     end
 
     # Executes a ruby script (taking into account WIN32 platform quirks).