rubygems-update 2.6.4 → 2.6.5

data/bundler/lib/bundler/source/git/git_proxy.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+module Bundler
+  class Source
+    class Git < Path
+      class GitNotInstalledError < GitError
+        def initialize
+          msg = String.new
+          msg << "You need to install git to be able to use gems from git repositories. "
+          msg << "For help installing git, please refer to GitHub's tutorial at https://help.github.com/articles/set-up-git"
+          super msg
+        end
+      end
+
+      class GitNotAllowedError < GitError
+        def initialize(command)
+          msg = String.new
+          msg << "Bundler is trying to run a `git #{command}` at runtime. You probably need to run `bundle install`. However, "
+          msg << "this error message could probably be more useful. Please submit a ticket at http://github.com/bundler/bundler/issues "
+          msg << "with steps to reproduce as well as the following\n\nCALLER: #{caller.join("\n")}"
+          super msg
+        end
+      end
+
+      class GitCommandError < GitError
+        def initialize(command, path = nil, extra_info = nil)
+          msg = String.new
+          msg << "Git error: command `git #{command}` in directory #{SharedHelpers.pwd} has failed."
+          msg << "\n#{extra_info}" if extra_info
+          msg << "\nIf this error persists you could try removing the cache directory '#{path}'" if path && path.exist?
+          super msg
+        end
+      end
+
+      class MissingGitRevisionError < GitError
+        def initialize(ref, repo)
+          msg = "Revision #{ref} does not exist in the repository #{repo}. Maybe you misspelled it?"
+          super msg
+        end
+      end
+
+      # The GitProxy is responsible to interact with git repositories.
+      # All actions required by the Git source is encapsulated in this
+      # object.
+      class GitProxy
+        attr_accessor :path, :uri, :ref
+        attr_writer :revision
+
+        def initialize(path, uri, ref, revision = nil, git = nil)
+          @path     = path
+          @uri      = uri
+          @ref      = ref
+          @revision = revision
+          @git      = git
+          raise GitNotInstalledError.new if allow? && !Bundler.git_present?
+        end
+
+        def revision
+          return @revision if @revision
+
+          begin
+            @revision ||= find_local_revision
+          rescue GitCommandError
+            raise MissingGitRevisionError.new(ref, uri)
+          end
+
+          @revision
+        end
+
+        def branch
+          @branch ||= allowed_in_path do
+            git("rev-parse --abbrev-ref HEAD").strip
+          end
+        end
+
+        def contains?(commit)
+          allowed_in_path do
+            result = git_null("branch --contains #{commit}")
+            $? == 0 && result =~ /^\* (.*)$/
+          end
+        end
+
+        def version
+          git("--version").sub("git version", "").strip
+        end
+
+        def checkout
+          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)}"
+            SharedHelpers.filesystem_access(path.dirname) do |p|
+              FileUtils.mkdir_p(p)
+            end
+            git_retry %(clone #{uri_escaped_with_configured_credentials} "#{path}" --bare --no-hardlinks --quiet)
+          end
+        end
+
+        def copy_to(destination, submodules = false)
+          # method 1
+          unless File.exist?(destination.join(".git"))
+            begin
+              SharedHelpers.filesystem_access(destination.dirname) do |p|
+                FileUtils.mkdir_p(p)
+              end
+              SharedHelpers.filesystem_access(destination) do |p|
+                FileUtils.rm_rf(p)
+              end
+              git_retry %(clone --no-checkout --quiet "#{path}" "#{destination}")
+              File.chmod(((File.stat(destination).mode | 0777) & ~File.umask), destination)
+            rescue Errno::EEXIST => e
+              file_path = e.message[%r{.*?(/.*)}, 1]
+              raise GitError, "Bundler could not install a gem because it needs to " \
+                "create a directory, but a file exists - #{file_path}. Please delete " \
+                "this file and try again."
+            end
+          end
+          # method 2
+          SharedHelpers.chdir(destination) do
+            git_retry %(fetch --force --quiet --tags "#{path}")
+            git "reset --hard #{@revision}"
+
+            git_retry "submodule update --init --recursive" if submodules
+          end
+        end
+
+      private
+
+        # TODO: Do not rely on /dev/null.
+        # Given that open3 is not cross platform until Ruby 1.9.3,
+        # the best solution is to pipe to /dev/null if it exists.
+        # If it doesn't, everything will work fine, but the user
+        # will get the $stderr messages as well.
+        def git_null(command)
+          git("#{command} 2>#{Bundler::NULL}", false)
+        end
+
+        def git_retry(command)
+          Bundler::Retry.new("git #{command}", GitNotAllowedError).attempts do
+            git(command)
+          end
+        end
+
+        def git(command, check_errors = true, error_msg = nil)
+          command_with_no_credentials = URICredentialsFilter.credential_filtered_string(command, uri)
+          raise GitNotAllowedError.new(command_with_no_credentials) unless allow?
+
+          out = SharedHelpers.with_clean_git_env { `git #{command}` }
+
+          stdout_with_no_credentials = URICredentialsFilter.credential_filtered_string(out, uri)
+          raise GitCommandError.new(command_with_no_credentials, path, error_msg) if check_errors && !$?.success?
+          stdout_with_no_credentials
+        end
+
+        def has_revision_cached?
+          return unless @revision
+          in_path { git("cat-file -e #{@revision}") }
+          true
+        rescue GitError
+          false
+        end
+
+        def remove_cache
+          FileUtils.rm_rf(path)
+        end
+
+        def find_local_revision
+          allowed_in_path do
+            git("rev-parse --verify #{ref}", true).strip
+          end
+        end
+
+        # Escape the URI for git commands
+        def uri_escaped_with_configured_credentials
+          remote = configured_uri_for(uri)
+          if Bundler::WINDOWS
+            # Windows quoting requires double quotes only, with double quotes
+            # inside the string escaped by being doubled.
+            '"' + remote.gsub('"') { '""' } + '"'
+          else
+            # Bash requires single quoted strings, with the single quotes escaped
+            # by ending the string, escaping the quote, and restarting the string.
+            "'" + remote.gsub("'") { "'\\''" } + "'"
+          end
+        end
+
+        # Adds credentials to the URI as Fetcher#configured_uri_for does
+        def configured_uri_for(uri)
+          if /https?:/ =~ uri
+            remote = URI(uri)
+            config_auth = Bundler.settings[remote.to_s] || Bundler.settings[remote.host]
+            remote.userinfo ||= config_auth
+            remote.to_s
+          else
+            uri
+          end
+        end
+
+        def allow?
+          @git ? @git.allow_git_ops? : true
+        end
+
+        def in_path(&blk)
+          checkout unless path.exist?
+          SharedHelpers.chdir(path, &blk)
+        end
+
+        def allowed_in_path
+          return in_path { yield } if allow?
+          raise GitError, "The git source #{uri} is not yet checked out. Please run `bundle install` before trying to start your application"
+        end
+      end
+    end
+  end
+end

data/bundler/lib/bundler/source/path.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+module Bundler
+  class Source
+    class Path < Source
+      autoload :Installer, "bundler/source/path/installer"
+
+      attr_reader :path, :options, :root_path
+      attr_writer :name
+      attr_accessor :version
+
+      DEFAULT_GLOB = "{,*,*/*}.gemspec".freeze
+
+      def initialize(options)
+        @options = options
+        @glob = options["glob"] || DEFAULT_GLOB
+
+        @allow_cached = false
+        @allow_remote = false
+
+        @root_path = options["root_path"] || Bundler.root
+
+        if options["path"]
+          @path = Pathname.new(options["path"])
+          @path = expand(@path) unless @path.relative?
+        end
+
+        @name    = options["name"]
+        @version = options["version"]
+
+        # Stores the original path. If at any point we move to the
+        # cached directory, we still have the original path to copy from.
+        @original_path = @path
+      end
+
+      def remote!
+        @allow_remote = true
+      end
+
+      def cached!
+        @allow_cached = true
+      end
+
+      def self.from_lock(options)
+        new(options.merge("path" => options.delete("remote")))
+      end
+
+      def to_lock
+        out = String.new("PATH\n")
+        out << "  remote: #{relative_path}\n"
+        out << "  glob: #{@glob}\n" unless @glob == DEFAULT_GLOB
+        out << "  specs:\n"
+      end
+
+      def to_s
+        "source at `#{@path}`"
+      end
+
+      def hash
+        [self.class, expanded_path, version].hash
+      end
+
+      def eql?(other)
+        return unless other.class == Path || other.class == Gemspec
+        expanded_path == expand(other.path) &&
+          version == other.version
+      end
+
+      alias_method :==, :eql?
+
+      def name
+        File.basename(expanded_path.to_s)
+      end
+
+      def install(spec, force = false)
+        Bundler.ui.info "Using #{version_message(spec)} from #{self}"
+        generate_bin(spec, :disable_extensions)
+        nil # no post-install message
+      end
+
+      def cache(spec, custom_path = nil)
+        app_cache_path = app_cache_path(custom_path)
+        return unless Bundler.settings[:cache_all]
+        return if expand(@original_path).to_s.index(root_path.to_s + "/") == 0
+
+        unless @original_path.exist?
+          raise GemNotFound, "Can't cache gem #{version_message(spec)} because #{self} is missing!"
+        end
+
+        FileUtils.rm_rf(app_cache_path)
+        FileUtils.cp_r("#{@original_path}/.", app_cache_path)
+        FileUtils.touch(app_cache_path.join(".bundlecache"))
+      end
+
+      def local_specs(*)
+        @local_specs ||= load_spec_files
+      end
+
+      def specs
+        if has_app_cache?
+          @path = app_cache_path
+          @expanded_path = nil # Invalidate
+        end
+        local_specs
+      end
+
+      def app_cache_dirname
+        name
+      end
+
+      def root
+        Bundler.root
+      end
+
+      def is_a_path?
+        instance_of?(Path)
+      end
+
+    private
+
+      def expanded_path
+        @expanded_path ||= expand(path)
+      end
+
+      def expand(somepath)
+        somepath.expand_path(root_path)
+      rescue ArgumentError => e
+        Bundler.ui.debug(e)
+        raise PathError, "There was an error while trying to use the path " \
+          "`#{somepath}`.\nThe error message was: #{e.message}."
+      end
+
+      def app_cache_path(custom_path = nil)
+        @app_cache_path ||= Bundler.app_cache(custom_path).join(app_cache_dirname)
+      end
+
+      def has_app_cache?
+        SharedHelpers.in_bundle? && app_cache_path.exist?
+      end
+
+      def load_spec_files
+        index = Index.new
+
+        if File.directory?(expanded_path)
+          # We sort depth-first since `<<` will override the earlier-found specs
+          Dir["#{expanded_path}/#{@glob}"].sort_by {|p| -p.split(File::SEPARATOR).size }.each do |file|
+            next unless spec = Bundler.load_gemspec(file)
+            spec.source = self
+            Bundler.rubygems.set_installed_by_version(spec)
+            # Validation causes extension_dir to be calculated, which depends
+            # on #source, so we validate here instead of load_gemspec
+            Bundler.rubygems.validate(spec)
+            index << spec
+          end
+
+          if index.empty? && @name && @version
+            index << Gem::Specification.new do |s|
+              s.name     = @name
+              s.source   = self
+              s.version  = Gem::Version.new(@version)
+              s.platform = Gem::Platform::RUBY
+              s.summary  = "Fake gemspec for #{@name}"
+              s.relative_loaded_from = "#{@name}.gemspec"
+              s.authors = ["no one"]
+              if expanded_path.join("bin").exist?
+                executables = expanded_path.join("bin").children
+                executables.reject! {|p| File.directory?(p) }
+                s.executables = executables.map {|c| c.basename.to_s }
+              end
+            end
+          end
+        else
+          message = String.new("The path `#{expanded_path}` ")
+          message << if File.exist?(expanded_path)
+                       "is not a directory."
+                     else
+                       "does not exist."
+                     end
+          raise PathError, message
+        end
+
+        index
+      end
+
+      def relative_path
+        if path.to_s.start_with?(root_path.to_s)
+          return path.relative_path_from(root_path)
+        end
+        path
+      end
+
+      def generate_bin(spec, disable_extensions = false)
+        gem_dir = Pathname.new(spec.full_gem_path)
+
+        # Some gem authors put absolute paths in their gemspec
+        # and we have to save them from themselves
+        spec.files = spec.files.map do |p|
+          next p unless p =~ /\A#{Pathname::SEPARATOR_PAT}/
+          next if File.directory?(p)
+          begin
+            Pathname.new(p).relative_path_from(gem_dir).to_s
+          rescue ArgumentError
+            p
+          end
+        end.compact
+
+        SharedHelpers.chdir(gem_dir) do
+          installer = Path::Installer.new(spec, :env_shebang => false)
+          run_hooks(:pre_install, installer)
+          build_extensions(installer) unless disable_extensions
+          installer.generate_bin
+          run_hooks(:post_install, installer)
+        end
+      rescue Gem::InvalidSpecificationException => e
+        Bundler.ui.warn "\n#{spec.name} at #{spec.full_gem_path} did not have a valid gemspec.\n" \
+                        "This prevents bundler from installing bins or native extensions, but " \
+                        "that may not affect its functionality."
+
+        if !spec.extensions.empty? && !spec.email.empty?
+          Bundler.ui.warn "If you need to use this package without installing it from a gem " \
+                          "repository, please contact #{spec.email} and ask them " \
+                          "to modify their .gemspec so it can work with `gem build`."
+        end
+
+        Bundler.ui.warn "The validation message from Rubygems was:\n  #{e.message}"
+      end
+
+      def build_extensions(installer)
+        installer.build_extensions
+        run_hooks(:post_build, installer)
+      end
+
+      def run_hooks(type, installer)
+        hooks_meth = "#{type}_hooks"
+        return unless Gem.respond_to?(hooks_meth)
+        Gem.send(hooks_meth).each do |hook|
+          result = hook.call(installer)
+          next unless result == false
+          location = " at #{$1}" if hook.inspect =~ /@(.*:\d+)/
+          message = "#{type} hook#{location} failed for #{installer.spec.full_name}"
+          raise InstallHookError, message
+        end
+      end
+    end
+  end
+end