Module: Bundler::SharedHelpers
- Extended by:
- SharedHelpers
- Included in:
- Runtime, SharedHelpers
- Defined in:
- lib/bundler/shared_helpers.rb
Instance Method Summary collapse
- #chdir(dir, &blk) ⇒ Object
- #const_get_safely(constant_name, namespace) ⇒ Object
- #default_bundle_dir ⇒ Object
- #default_gemfile ⇒ Object
- #default_lockfile ⇒ Object
- #digest(name) ⇒ Object
- #ensure_same_dependencies(spec, old_deps, new_deps) ⇒ Object
-
#filesystem_access(path, action = :write) { ... } ⇒ Object
Rescues permissions errors raised by file system operations (ie. Errno:EACCESS, Errno::EAGAIN) and raises more friendly errors instead.
- #in_bundle? ⇒ Boolean
- #major_deprecation(major_version, message, print_caller_location: false) ⇒ Object
- #md5_available? ⇒ Boolean
- #pretty_dependency(dep, print_source = false) ⇒ Object
- #print_major_deprecations! ⇒ Object
- #pwd ⇒ Object
- #root ⇒ Object
- #set_bundle_environment ⇒ Object
- #set_env(key, value) ⇒ Object
- #trap(signal, override = false, &block) ⇒ Object
- #with_clean_git_env(&block) ⇒ Object
- #write_to_gemfile(gemfile_path, contents) ⇒ Object
Instance Method Details
#chdir(dir, &blk) ⇒ Object
50 51 52 53 54 |
# File 'lib/bundler/shared_helpers.rb', line 50 def chdir(dir, &blk) Bundler.rubygems.ext_lock.synchronize do Dir.chdir dir, &blk end end |
#const_get_safely(constant_name, namespace) ⇒ Object
120 121 122 123 124 125 |
# File 'lib/bundler/shared_helpers.rb', line 120 def const_get_safely(constant_name, namespace) const_in_namespace = namespace.constants.include?(constant_name.to_s) || namespace.constants.include?(constant_name.to_sym) return nil unless const_in_namespace namespace.const_get(constant_name) end |
#default_bundle_dir ⇒ Object
34 35 36 37 38 39 40 41 42 43 44 |
# File 'lib/bundler/shared_helpers.rb', line 34 def default_bundle_dir bundle_dir = find_directory(".bundle") return nil unless bundle_dir bundle_dir = Pathname.new(bundle_dir) global_bundle_dir = Bundler.user_home.join(".bundle") return nil if bundle_dir == global_bundle_dir bundle_dir end |
#default_gemfile ⇒ Object
19 20 21 22 23 |
# File 'lib/bundler/shared_helpers.rb', line 19 def default_gemfile gemfile = find_gemfile raise GemfileNotFound, "Could not locate Gemfile" unless gemfile Pathname.new(gemfile).tap{|x| x.untaint if RUBY_VERSION < "2.7" }. end |
#default_lockfile ⇒ Object
25 26 27 28 29 30 31 32 |
# File 'lib/bundler/shared_helpers.rb', line 25 def default_lockfile gemfile = default_gemfile case gemfile.basename.to_s when "gems.rb" then Pathname.new(gemfile.sub(/.rb$/, ".locked")) else Pathname.new("#{gemfile}.lock") end.tap{|x| x.untaint if RUBY_VERSION < "2.7" } end |
#digest(name) ⇒ Object
206 207 208 209 |
# File 'lib/bundler/shared_helpers.rb', line 206 def digest(name) require "digest" Digest(name) end |
#ensure_same_dependencies(spec, old_deps, new_deps) ⇒ Object
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 |
# File 'lib/bundler/shared_helpers.rb', line 162 def ensure_same_dependencies(spec, old_deps, new_deps) new_deps = new_deps.reject {|d| d.type == :development } old_deps = old_deps.reject {|d| d.type == :development } without_type = proc {|d| Gem::Dependency.new(d.name, d.requirements_list.sort) } new_deps.map!(&without_type) old_deps.map!(&without_type) extra_deps = new_deps - old_deps return if extra_deps.empty? Bundler.ui.debug "#{spec.full_name} from #{spec.remote} has either corrupted API or lockfile dependencies" \ " (was expecting #{old_deps.map(&:to_s)}, but the real spec has #{new_deps.map(&:to_s)})" raise APIResponseMismatchError, "Downloading #{spec.full_name} revealed dependencies not in the API or the lockfile (#{extra_deps.join(", ")})." \ "\nEither installing with `--full-index` or running `bundle update #{spec.name}` should fix the problem." end |
#filesystem_access(path, action = :write) { ... } ⇒ Object
Rescues permissions errors raised by file system operations (ie. Errno:EACCESS, Errno::EAGAIN) and raises more friendly errors instead.
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 |
# File 'lib/bundler/shared_helpers.rb', line 102 def filesystem_access(path, action = :write, &block) yield(path.dup.tap{|x| x.untaint if RUBY_VERSION < "2.7" }) rescue Errno::EACCES raise PermissionError.new(path, action) rescue Errno::EAGAIN raise TemporaryResourceError.new(path, action) rescue Errno::EPROTO raise VirtualProtocolError.new rescue Errno::ENOSPC raise NoSpaceOnDeviceError.new(path, action) rescue *[const_get_safely(:ENOTSUP, Errno)].compact raise OperationNotSupportedError.new(path, action) rescue Errno::EEXIST, Errno::ENOENT raise rescue SystemCallError => e raise GenericSystemCallError.new(e, "There was an error accessing `#{path}`.") end |
#in_bundle? ⇒ Boolean
46 47 48 |
# File 'lib/bundler/shared_helpers.rb', line 46 def in_bundle? find_gemfile end |
#major_deprecation(major_version, message, print_caller_location: false) ⇒ Object
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 |
# File 'lib/bundler/shared_helpers.rb', line 127 def major_deprecation(major_version, , print_caller_location: false) if print_caller_location caller_location = caller_locations(2, 2).first = "#{} (called at #{caller_location.path}:#{caller_location.lineno})" end bundler_major_version = Bundler.bundler_major_version if bundler_major_version > major_version require_relative "errors" raise DeprecatedError, "[REMOVED] #{}" end return unless bundler_major_version >= major_version && prints_major_deprecations? Bundler.ui.warn("[DEPRECATED] #{}") end |
#md5_available? ⇒ Boolean
193 194 195 196 197 198 199 200 201 202 203 204 |
# File 'lib/bundler/shared_helpers.rb', line 193 def md5_available? return @md5_available if defined?(@md5_available) @md5_available = begin require "openssl" OpenSSL::Digest.digest("MD5", "") true rescue LoadError true rescue OpenSSL::Digest::DigestError false end end |
#pretty_dependency(dep, print_source = false) ⇒ Object
180 181 182 183 184 185 186 187 188 189 190 191 |
# File 'lib/bundler/shared_helpers.rb', line 180 def pretty_dependency(dep, print_source = false) msg = String.new(dep.name) msg << " (#{dep.requirement})" unless dep.requirement == Gem::Requirement.default if dep.is_a?(Bundler::Dependency) platform_string = dep.platforms.join(", ") msg << " " << platform_string if !platform_string.empty? && platform_string != Gem::Platform::RUBY end msg << " from the `#{dep.source}` source" if print_source && dep.source msg end |
#print_major_deprecations! ⇒ Object
143 144 145 146 147 148 149 150 151 152 153 |
# File 'lib/bundler/shared_helpers.rb', line 143 def print_major_deprecations! multiple_gemfiles = search_up(".") do |dir| gemfiles = gemfile_names.select {|gf| File.file? File.(gf, dir) } next if gemfiles.empty? break gemfiles.size != 1 end return unless multiple_gemfiles = "Multiple gemfiles (gems.rb and Gemfile) detected. " \ "Make sure you remove Gemfile and Gemfile.lock since bundler is ignoring them in favor of gems.rb and gems.rb.locked." Bundler.ui.warn end |
#pwd ⇒ Object
56 57 58 59 60 |
# File 'lib/bundler/shared_helpers.rb', line 56 def pwd Bundler.rubygems.ext_lock.synchronize do Pathname.pwd end end |
#root ⇒ Object
13 14 15 16 17 |
# File 'lib/bundler/shared_helpers.rb', line 13 def root gemfile = find_gemfile raise GemfileNotFound, "Could not locate Gemfile" unless gemfile Pathname.new(gemfile).tap{|x| x.untaint if RUBY_VERSION < "2.7" }..parent end |
#set_bundle_environment ⇒ Object
75 76 77 78 79 80 |
# File 'lib/bundler/shared_helpers.rb', line 75 def set_bundle_environment set_bundle_variables set_path set_rubyopt set_rubylib end |
#set_env(key, value) ⇒ Object
278 279 280 281 282 283 284 285 286 |
# File 'lib/bundler/shared_helpers.rb', line 278 def set_env(key, value) raise ArgumentError, "new key #{key}" unless EnvironmentPreserver::BUNDLER_KEYS.include?(key) orig_key = "#{EnvironmentPreserver::BUNDLER_PREFIX}#{key}" orig = ENV[key] orig ||= EnvironmentPreserver::INTENTIONALLY_NIL ENV[orig_key] ||= orig ENV[key] = value end |
#trap(signal, override = false, &block) ⇒ Object
155 156 157 158 159 160 |
# File 'lib/bundler/shared_helpers.rb', line 155 def trap(signal, override = false, &block) prior = Signal.trap(signal) do block.call prior.call unless override end end |
#with_clean_git_env(&block) ⇒ Object
62 63 64 65 66 67 68 69 70 71 72 73 |
# File 'lib/bundler/shared_helpers.rb', line 62 def with_clean_git_env(&block) keys = %w[GIT_DIR GIT_WORK_TREE] old_env = keys.inject({}) do |h, k| h.update(k => ENV[k]) end keys.each {|key| ENV.delete(key) } block.call ensure keys.each {|key| ENV[key] = old_env[key] } end |
#write_to_gemfile(gemfile_path, contents) ⇒ Object
211 212 213 |
# File 'lib/bundler/shared_helpers.rb', line 211 def write_to_gemfile(gemfile_path, contents) filesystem_access(gemfile_path) {|g| File.open(g, "w") {|file| file.puts contents } } end |