Class: Bundler::RubygemsIntegration

Inherits:
Object
  • Object
show all
Defined in:
lib/bundler/rubygems_integration.rb

Direct Known Subclasses

Future, Legacy, Modern

Defined Under Namespace

Classes: AlmostModern, Ancient, Future, Legacy, Modern, MoreFuture, MoreModern, Transitional

Constant Summary

EXT_LOCK =
Gem::Ext::Builder::CHDIR_MONITOR

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initializeRubygemsIntegration

Returns a new instance of RubygemsIntegration



22
23
24
# File 'lib/bundler/rubygems_integration.rb', line 22

def initialize
  @replaced_methods = {}
end

Class Method Details

.provides?(req_str) ⇒ Boolean

Returns:

  • (Boolean)


18
19
20
# File 'lib/bundler/rubygems_integration.rb', line 18

def self.provides?(req_str)
  Gem::Requirement.new(req_str).satisfied_by?(version)
end

.versionObject



14
15
16
# File 'lib/bundler/rubygems_integration.rb', line 14

def self.version
  @version ||= Gem::Version.new(Gem::VERSION)
end

Instance Method Details

#backport_base_dirObject

This backports base_dir which replaces installation path Rubygems 1.8+



516
517
518
519
520
521
# File 'lib/bundler/rubygems_integration.rb', line 516

def backport_base_dir
  redefine_method(Gem::Specification, :base_dir) do
    return Gem.dir unless loaded_from
    File.dirname File.dirname loaded_from
  end
end

#backport_cache_fileObject



523
524
525
526
527
528
529
530
531
# File 'lib/bundler/rubygems_integration.rb', line 523

def backport_cache_file
  redefine_method(Gem::Specification, :cache_dir) do
    @cache_dir ||= File.join base_dir, "cache"
  end

  redefine_method(Gem::Specification, :cache_file) do
    @cache_file ||= File.join cache_dir, "#{full_name}.gem"
  end
end

#backport_segment_generationObject

This backports the correct segment generation code from Rubygems 1.4+ by monkeypatching it into the method in Rubygems 1.3.6 and 1.3.7.



497
498
499
500
501
502
503
# File 'lib/bundler/rubygems_integration.rb', line 497

def backport_segment_generation
  redefine_method(Gem::Version, :segments) do
    @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
      /^\d+$/ =~ s ? s.to_i : s
    end
  end
end

#backport_spec_fileObject



533
534
535
536
537
538
539
540
541
# File 'lib/bundler/rubygems_integration.rb', line 533

def backport_spec_file
  redefine_method(Gem::Specification, :spec_dir) do
    @spec_dir ||= File.join base_dir, "specifications"
  end

  redefine_method(Gem::Specification, :spec_file) do
    @spec_file ||= File.join spec_dir, "#{full_name}.gemspec"
  end
end

#backport_yaml_initializeObject

This backport fixes the marshaling of @segments.



506
507
508
509
510
511
512
# File 'lib/bundler/rubygems_integration.rb', line 506

def backport_yaml_initialize
  redefine_method(Gem::Version, :yaml_initialize) do |_, map|
    @version = map["version"]
    @segments = nil
    @hash = nil
  end
end

#bin_path(gem, bin, ver) ⇒ Object



189
190
191
# File 'lib/bundler/rubygems_integration.rb', line 189

def bin_path(gem, bin, ver)
  Gem.bin_path(gem, bin, ver)
end

#binstubs_call_gem?Boolean

Returns:

  • (Boolean)


331
332
333
# File 'lib/bundler/rubygems_integration.rb', line 331

def binstubs_call_gem?
  true
end

#build(spec, skip_validation = false) ⇒ Object



291
292
293
294
# File 'lib/bundler/rubygems_integration.rb', line 291

def build(spec, skip_validation = false)
  require "rubygems/builder"
  Gem::Builder.new(spec).build
end

#build_argsObject



34
35
36
# File 'lib/bundler/rubygems_integration.rb', line 34

def build_args
  Gem::Command.build_args
end

#build_args=(args) ⇒ Object



38
39
40
# File 'lib/bundler/rubygems_integration.rb', line 38

def build_args=(args)
  Gem::Command.build_args = args
end

#build_gem(gem_dir, spec) ⇒ Object



296
297
298
# File 'lib/bundler/rubygems_integration.rb', line 296

def build_gem(gem_dir, spec)
  build(spec)
end

#clear_pathsObject



185
186
187
# File 'lib/bundler/rubygems_integration.rb', line 185

def clear_paths
  Gem.clear_paths
end

#config_mapObject



177
178
179
# File 'lib/bundler/rubygems_integration.rb', line 177

def config_map
  Gem::ConfigMap
end

#configurationObject



100
101
102
103
104
105
106
107
108
109
110
# File 'lib/bundler/rubygems_integration.rb', line 100

def configuration
  require "bundler/psyched_yaml"
  Gem.configuration
rescue Gem::SystemExitException, LoadError => e
  Bundler.ui.error "#{e.class}: #{e.message}"
  Bundler.ui.trace e
  raise
rescue YamlLibrarySyntaxError => e
  raise YamlSyntaxError.new(e, "Your RubyGems configuration, which is " \
    "usually located in ~/.gemrc, contains invalid YAML syntax.")
end

#download_gem(spec, uri, path) ⇒ Object



300
301
302
303
304
305
306
# File 'lib/bundler/rubygems_integration.rb', line 300

def download_gem(spec, uri, path)
  uri = Bundler.settings.mirror_for(uri)
  fetcher = Gem::RemoteFetcher.new(configuration[:http_proxy])
  Bundler::Retry.new("download gem #{uri}", Gem::RemoteFetcher::FetchError).attempts do
    fetcher.download(spec, uri, path)
  end
end

#ext_lockObject



219
220
221
# File 'lib/bundler/rubygems_integration.rb', line 219

def ext_lock
  EXT_LOCK
end

#fetch_all_remote_specs(remote) ⇒ Object

TODO: This is for older versions of Rubygems… should we support the X-Gemfile-Source header on these old versions? Maybe the newer implementation will work on older Rubygems? It seems difficult to keep this implementation and still send the header.



240
241
242
243
244
245
246
247
248
249
250
251
# File 'lib/bundler/rubygems_integration.rb', line 240

def fetch_all_remote_specs(remote)
  old_sources = Bundler.rubygems.sources
  Bundler.rubygems.sources = [remote.uri.to_s]
  # Fetch all specs, minus prerelease specs
  spec_list = fetch_specs(true, false)
  # Then fetch the prerelease specs
  fetch_prerelease_specs.each {|k, v| spec_list[k].concat(v) }

  spec_list.values.first
ensure
  Bundler.rubygems.sources = old_sources
end

#fetch_prerelease_specsObject



230
231
232
233
234
# File 'lib/bundler/rubygems_integration.rb', line 230

def fetch_prerelease_specs
  fetch_specs(false, true)
rescue Gem::RemoteFetcher::FetchError
  {} # if we can't download them, there aren't any
end

#fetch_specs(all, pre, &blk) ⇒ Object



223
224
225
226
227
228
# File 'lib/bundler/rubygems_integration.rb', line 223

def fetch_specs(all, pre, &blk)
  require "rubygems/spec_fetcher"
  specs = Gem::SpecFetcher.new.list(all, pre)
  specs.each { yield } if block_given?
  specs
end

#gem_bindirObject



141
142
143
# File 'lib/bundler/rubygems_integration.rb', line 141

def gem_bindir
  Gem.bindir
end

#gem_cacheObject



161
162
163
# File 'lib/bundler/rubygems_integration.rb', line 161

def gem_cache
  gem_path.map {|p| File.expand_path("cache", p) }
end

#gem_dirObject



137
138
139
# File 'lib/bundler/rubygems_integration.rb', line 137

def gem_dir
  Gem.dir
end

#gem_from_path(path, policy = nil) ⇒ Object



269
270
271
272
# File 'lib/bundler/rubygems_integration.rb', line 269

def gem_from_path(path, policy = nil)
  require "rubygems/format"
  Gem::Format.from_file_by_path(path, policy)
end

#gem_pathObject



149
150
151
# File 'lib/bundler/rubygems_integration.rb', line 149

def gem_path
  Gem.path
end

#inflate(obj) ⇒ Object



120
121
122
# File 'lib/bundler/rubygems_integration.rb', line 120

def inflate(obj)
  Gem.inflate(obj)
end

#install_with_build_args(args) ⇒ Object



265
266
267
# File 'lib/bundler/rubygems_integration.rb', line 265

def install_with_build_args(args)
  with_build_args(args) { yield }
end

#load_path_insert_indexObject



42
43
44
# File 'lib/bundler/rubygems_integration.rb', line 42

def load_path_insert_index
  Gem.load_path_insert_index
end

#load_pluginsObject



211
212
213
# File 'lib/bundler/rubygems_integration.rb', line 211

def load_plugins
  Gem.load_plugins if Gem.respond_to?(:load_plugins)
end

#loaded_gem_pathsObject



198
199
200
201
202
203
204
205
206
207
208
209
# File 'lib/bundler/rubygems_integration.rb', line 198

def loaded_gem_paths
  # RubyGems 2.2+ can put binary extension into dedicated folders,
  # therefore use RubyGems facilities to obtain their load paths.
  if Gem::Specification.method_defined? :full_require_paths
    loaded_gem_paths = Gem.loaded_specs.map {|_, s| s.full_require_paths }
    loaded_gem_paths.flatten
  else
    $LOAD_PATH.select do |p|
      Bundler.rubygems.gem_path.any? {|gp| p =~ /^#{Regexp.escape(gp)}/ }
    end
  end
end

#loaded_specs(name) ⇒ Object



46
47
48
# File 'lib/bundler/rubygems_integration.rb', line 46

def loaded_specs(name)
  Gem.loaded_specs[name]
end

#mark_loaded(spec) ⇒ Object



50
51
52
53
54
55
56
57
# File 'lib/bundler/rubygems_integration.rb', line 50

def mark_loaded(spec)
  if spec.respond_to?(:activated=)
    current = Gem.loaded_specs[spec.name]
    current.activated = false if current
    spec.activated = true
  end
  Gem.loaded_specs[spec.name] = spec
end

#marshal_spec_dirObject



173
174
175
# File 'lib/bundler/rubygems_integration.rb', line 173

def marshal_spec_dir
  Gem::MARSHAL_SPEC_DIR
end

#method_visibility(klass, method) ⇒ Object



574
575
576
577
578
579
580
581
582
# File 'lib/bundler/rubygems_integration.rb', line 574

def method_visibility(klass, method)
  if klass.private_method_defined?(method)
    :private
  elsif klass.protected_method_defined?(method)
    :protected
  else
    :public
  end
end

#path(obj) ⇒ Object



91
92
93
# File 'lib/bundler/rubygems_integration.rb', line 91

def path(obj)
  obj.to_s
end

#platformsObject



95
96
97
98
# File 'lib/bundler/rubygems_integration.rb', line 95

def platforms
  return [Gem::Platform::RUBY] if Bundler.settings[:force_ruby_platform]
  Gem.platforms
end

#post_reset_hooksObject



157
158
159
# File 'lib/bundler/rubygems_integration.rb', line 157

def post_reset_hooks
  Gem.post_reset_hooks
end

#preserve_pathsObject



193
194
195
196
# File 'lib/bundler/rubygems_integration.rb', line 193

def preserve_paths
  # this is a no-op outside of Rubygems 1.8
  yield
end

#provides?(req_str) ⇒ Boolean

Returns:

  • (Boolean)


30
31
32
# File 'lib/bundler/rubygems_integration.rb', line 30

def provides?(req_str)
  self.class.provides?(req_str)
end

#read_binary(path) ⇒ Object



116
117
118
# File 'lib/bundler/rubygems_integration.rb', line 116

def read_binary(path)
  Gem.read_binary(path)
end

#redefine_method(klass, method, unbound_method = nil, &block) ⇒ Object



553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
# File 'lib/bundler/rubygems_integration.rb', line 553

def redefine_method(klass, method, unbound_method = nil, &block)
  visibility = method_visibility(klass, method)
  begin
    if (instance_method = klass.instance_method(method)) && method != :initialize
      # doing this to ensure we also get private methods
      klass.send(:remove_method, method)
    end
  rescue NameError
    # method isn't defined
    nil
  end
  @replaced_methods[[method, klass]] = instance_method
  if unbound_method
    klass.send(:define_method, method, unbound_method)
    klass.send(visibility, method)
  elsif block
    klass.send(:define_method, method, &block)
    klass.send(visibility, method)
  end
end

#replace_bin_path(specs, specs_by_name) ⇒ Object

Used to make bin stubs that are not created by bundler work under bundler. The new Gem.bin_path only considers gems in specs



409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
# File 'lib/bundler/rubygems_integration.rb', line 409

def replace_bin_path(specs, specs_by_name)
  gem_class = (class << Gem; self; end)

  redefine_method(gem_class, :find_spec_for_exe) do |gem_name, *args|
    exec_name = args.first

    spec_with_name = specs_by_name[gem_name]
    spec = if exec_name
      if spec_with_name && spec_with_name.executables.include?(exec_name)
        spec_with_name
      else
        specs.find {|s| s.executables.include?(exec_name) }
      end
    else
      spec_with_name
    end

    unless spec
      message = "can't find executable #{exec_name} for gem #{gem_name}"
      if !exec_name || spec_with_name.nil?
        message += ". #{gem_name} is not currently included in the bundle, " \
                   "perhaps you meant to add it to your #{Bundler.default_gemfile.basename}?"
      end
      raise Gem::Exception, message
    end

    raise Gem::Exception, "no default executable for #{spec.full_name}" unless exec_name ||= spec.default_executable

    unless spec.name == name
      Bundler::SharedHelpers.major_deprecation \
        "Bundler is using a binstub that was created for a different gem.\n" \
        "You should run `bundle binstub #{gem_name}` " \
        "to work around a system/bundle conflict."
    end
    spec
  end

  redefine_method(gem_class, :activate_bin_path) do |name, *args|
    exec_name = args.first
    return ENV["BUNDLE_BIN_PATH"] if exec_name == "bundle"

    # Copy of Rubygems activate_bin_path impl
    requirement = args.last
    spec = find_spec_for_exe name, exec_name, [requirement]

    gem_bin = File.join(spec.full_gem_path, spec.bindir, exec_name)
    gem_from_path_bin = File.join(File.dirname(spec.loaded_from), spec.bindir, exec_name)
    File.exist?(gem_bin) ? gem_bin : gem_from_path_bin
  end

  redefine_method(gem_class, :bin_path) do |name, *args|
    exec_name = args.first
    return ENV["BUNDLE_BIN_PATH"] if exec_name == "bundle"

    spec = find_spec_for_exe(name, *args)
    exec_name ||= spec.default_executable

    gem_bin = File.join(spec.full_gem_path, spec.bindir, exec_name)
    gem_from_path_bin = File.join(File.dirname(spec.loaded_from), spec.bindir, exec_name)
    File.exist?(gem_bin) ? gem_bin : gem_from_path_bin
  end
end

#replace_entrypoints(specs) ⇒ Object

Replace or hook into Rubygems to provide a bundlerized view of the world.



481
482
483
484
485
486
487
488
489
490
491
492
493
# File 'lib/bundler/rubygems_integration.rb', line 481

def replace_entrypoints(specs)
  specs_by_name = specs.reduce({}) do |h, s|
    h[s.name] = s
    h
  end

  replace_gem(specs, specs_by_name)
  stub_rubygems(specs)
  replace_bin_path(specs, specs_by_name)
  replace_refresh

  Gem.clear_paths
end

#replace_gem(specs, specs_by_name) ⇒ Object



339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
# File 'lib/bundler/rubygems_integration.rb', line 339

def replace_gem(specs, specs_by_name)
  reverse_rubygems_kernel_mixin

  executables = nil

  kernel = (class << ::Kernel; self; end)
  [kernel, ::Kernel].each do |kernel_class|
    redefine_method(kernel_class, :gem) do |dep, *reqs|
      executables ||= specs.map(&:executables).flatten if ::Bundler.rubygems.binstubs_call_gem?
      if executables && executables.include?(File.basename(caller.first.split(":").first))
        break
      end

      reqs.pop if reqs.last.is_a?(Hash)

      unless dep.respond_to?(:name) && dep.respond_to?(:requirement)
        dep = Gem::Dependency.new(dep, reqs)
      end

      if spec = specs_by_name[dep.name]
        return true if dep.matches_spec?(spec)
      end

      message = if spec.nil?
        "#{dep.name} is not part of the bundle." \
        " Add it to your #{Bundler.default_gemfile.basename}."
      else
        "can't activate #{dep}, already activated #{spec.full_name}. " \
        "Make sure all dependencies are added to Gemfile."
      end

      e = Gem::LoadError.new(message)
      e.name = dep.name
      if e.respond_to?(:requirement=)
        e.requirement = dep.requirement
      elsif e.respond_to?(:version_requirement=)
        e.version_requirement = dep.requirement
      end
      raise e
    end

    # TODO: delete this in 2.0, it's a backwards compatibility shim
    # see https://github.com/bundler/bundler/issues/5102
    kernel_class.send(:public, :gem)
  end
end

#replace_refreshObject

Because Bundler has a static view of what specs are available, we don't #refresh, so stub it out.



474
475
476
477
# File 'lib/bundler/rubygems_integration.rb', line 474

def replace_refresh
  gem_class = (class << Gem; self; end)
  redefine_method(gem_class, :refresh) {}
end

#repository_subdirectoriesObject



181
182
183
# File 'lib/bundler/rubygems_integration.rb', line 181

def repository_subdirectories
  %w(cache doc gems specifications)
end

#resetObject



153
154
155
# File 'lib/bundler/rubygems_integration.rb', line 153

def reset
  Gem::Specification.reset
end

#reverse_rubygems_kernel_mixinObject



321
322
323
324
325
326
327
328
329
# File 'lib/bundler/rubygems_integration.rb', line 321

def reverse_rubygems_kernel_mixin
  # Disable rubygems' gem activation system
  kernel = (class << ::Kernel; self; end)
  [kernel, ::Kernel].each do |k|
    if k.private_method_defined?(:gem_original_require)
      redefine_method(k, :require, k.instance_method(:gem_original_require))
    end
  end
end

#ruby_engineObject



112
113
114
# File 'lib/bundler/rubygems_integration.rb', line 112

def ruby_engine
  Gem.ruby_engine
end

#security_policiesObject



312
313
314
315
316
317
318
319
# File 'lib/bundler/rubygems_integration.rb', line 312

def security_policies
  @security_policies ||= begin
    require "rubygems/security"
    Gem::Security::Policies
  rescue LoadError, NameError
    {}
  end
end

#security_policy_keysObject



308
309
310
# File 'lib/bundler/rubygems_integration.rb', line 308

def security_policy_keys
  %w(High Medium Low AlmostNo No).map {|level| "#{level}Security" }
end

#set_installed_by_version(spec, installed_by_version = Gem::VERSION) ⇒ Object



69
70
71
72
# File 'lib/bundler/rubygems_integration.rb', line 69

def set_installed_by_version(spec, installed_by_version = Gem::VERSION)
  return unless spec.respond_to?(:installed_by_version=)
  spec.installed_by_version = Gem::Version.create(installed_by_version)
end

#sourcesObject



133
134
135
# File 'lib/bundler/rubygems_integration.rb', line 133

def sources
  Gem.sources
end

#sources=(val) ⇒ Object



124
125
126
127
128
129
130
131
# File 'lib/bundler/rubygems_integration.rb', line 124

def sources=(val)
  # Gem.configuration creates a new Gem::ConfigFile, which by default will read ~/.gemrc
  # If that file exists, its settings (including sources) will overwrite the values we
  # are about to set here. In order to avoid that, we force memoizing the config file now.
  configuration

  Gem.sources = val
end

#spec_cache_dirsObject



165
166
167
168
169
170
171
# File 'lib/bundler/rubygems_integration.rb', line 165

def spec_cache_dirs
  @spec_cache_dirs ||= begin
    dirs = gem_path.map {|dir| File.join(dir, "specifications") }
    dirs << Gem.spec_cache_dir if Gem.respond_to?(:spec_cache_dir) # Not in Rubygems 2.0.3 or earlier
    dirs.uniq.select {|dir| File.directory? dir }
  end
end

#spec_default_gem?(spec) ⇒ Boolean

Returns:

  • (Boolean)


83
84
85
# File 'lib/bundler/rubygems_integration.rb', line 83

def spec_default_gem?(spec)
  spec.respond_to?(:default_gem?) && spec.default_gem?
end

#spec_from_gem(path, policy = nil) ⇒ Object



274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
# File 'lib/bundler/rubygems_integration.rb', line 274

def spec_from_gem(path, policy = nil)
  require "rubygems/security"
  gem_from_path(path, security_policies[policy]).spec
rescue Gem::Package::FormatError
  raise GemspecError, "Could not read gem at #{path}. It may be corrupted."
rescue Exception, Gem::Exception, Gem::Security::Exception => e
  if e.is_a?(Gem::Security::Exception) ||
      e.message =~ /unknown trust policy|unsigned gem/i ||
      e.message =~ /couldn't verify (meta)?data signature/i
    raise SecurityError,
      "The gem #{File.basename(path, ".gem")} can't be installed because " \
      "the security policy didn't allow it, with the message: #{e.message}"
  else
    raise e
  end
end

#spec_missing_extensions?(spec, default = true) ⇒ Boolean

Returns:

  • (Boolean)


74
75
76
77
78
79
80
81
# File 'lib/bundler/rubygems_integration.rb', line 74

def spec_missing_extensions?(spec, default = true)
  return spec.missing_extensions? if spec.respond_to?(:missing_extensions?)

  return false if spec_default_gem?(spec)
  return false if spec.extensions.empty?

  default
end

#stub_set_spec(stub, spec) ⇒ Object



87
88
89
# File 'lib/bundler/rubygems_integration.rb', line 87

def stub_set_spec(stub, spec)
  stub.instance_variable_set(:@spec, spec)
end

#stub_source_index(specs) ⇒ Object



386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
# File 'lib/bundler/rubygems_integration.rb', line 386

def stub_source_index(specs)
  Gem::SourceIndex.send(:alias_method, :old_initialize, :initialize)
  redefine_method(Gem::SourceIndex, :initialize) do |*args|
    @gems = {}
    # You're looking at this thinking: Oh! This is how I make those
    # rubygems deprecations go away!
    #
    # You'd be correct BUT using of this method in production code
    # must be approved by the rubygems team itself!
    #
    # This is your warning. If you use this and don't have approval
    # we can't protect you.
    #
    Deprecate.skip_during do
      self.spec_dirs = *args
      add_specs(*specs)
    end
  end
end

#stubs_provide_full_functionality?Boolean

Returns:

  • (Boolean)


335
336
337
# File 'lib/bundler/rubygems_integration.rb', line 335

def stubs_provide_full_functionality?
  false
end

#ui=(obj) ⇒ Object



215
216
217
# File 'lib/bundler/rubygems_integration.rb', line 215

def ui=(obj)
  Gem::DefaultUserInteraction.ui = obj
end

#undo_replacementsObject



543
544
545
546
547
548
549
550
551
# File 'lib/bundler/rubygems_integration.rb', line 543

def undo_replacements
  @replaced_methods.each do |(sym, klass), method|
    redefine_method(klass, sym, method)
  end
  post_reset_hooks.reject! do |proc|
    proc.binding.eval("__FILE__") == __FILE__
  end
  @replaced_methods.clear
end

#user_homeObject



145
146
147
# File 'lib/bundler/rubygems_integration.rb', line 145

def user_home
  Gem.user_home
end

#validate(spec) ⇒ Object



59
60
61
62
63
64
65
66
67
# File 'lib/bundler/rubygems_integration.rb', line 59

def validate(spec)
  Bundler.ui.silence { spec.validate(false) }
rescue Gem::InvalidSpecificationException => e
  error_message = "The gemspec at #{spec.loaded_from} is not valid. Please fix this gemspec.\n" \
    "The validation error was '#{e.message}'\n"
  raise Gem::InvalidSpecificationException.new(error_message)
rescue Errno::ENOENT
  nil
end

#versionObject



26
27
28
# File 'lib/bundler/rubygems_integration.rb', line 26

def version
  self.class.version
end

#with_build_args(args) ⇒ Object



253
254
255
256
257
258
259
260
261
262
263
# File 'lib/bundler/rubygems_integration.rb', line 253

def with_build_args(args)
  ext_lock.synchronize do
    old_args = build_args
    begin
      self.build_args = args
      yield
    ensure
      self.build_args = old_args
    end
  end
end