Class: Gem::RequestSet::GemDependencyAPI

Inherits:
Object
  • Object
show all
Defined in:
lib/rubygems/request_set/gem_dependency_api.rb

Overview

A semi-compatible DSL for the Bundler Gemfile and Isolate gem dependencies files.

To work with both the Bundler Gemfile and Isolate formats this implementation takes some liberties to allow compatibility with each, most notably in #source.

A basic gem dependencies file will look like the following:

source 'https://rubygems.org'

gem 'rails', '3.2.14a
gem 'devise', '~> 2.1', '>= 2.1.3'
gem 'cancan'
gem 'airbrake'
gem 'pg'

RubyGems recommends saving this as gem.deps.rb over Gemfile or Isolate.

To install the gems in this Gemfile use `gem install -g` to install it and create a lockfile. The lockfile will ensure that when you make changes to your gem dependencies file a minimum amount of change is made to the dependencies of your gems.

RubyGems can activate all the gems in your dependencies file at startup using the RUBYGEMS_GEMDEPS environment variable or through Gem.use_gemdeps. See Gem.use_gemdeps for details and warnings.

See `gem help install` and `gem help gem_dependencies` for further details.

Constant Summary collapse

ENGINE_MAP =

:nodoc:

{ # :nodoc:
  :jruby        => %w[jruby],
  :jruby_18     => %w[jruby],
  :jruby_19     => %w[jruby],
  :maglev       => %w[maglev],
  :mri          => %w[ruby],
  :mri_18       => %w[ruby],
  :mri_19       => %w[ruby],
  :mri_20       => %w[ruby],
  :mri_21       => %w[ruby],
  :rbx          => %w[rbx],
  :truffleruby  => %w[truffleruby],
  :ruby         => %w[ruby rbx maglev truffleruby],
  :ruby_18      => %w[ruby rbx maglev truffleruby],
  :ruby_19      => %w[ruby rbx maglev truffleruby],
  :ruby_20      => %w[ruby rbx maglev truffleruby],
  :ruby_21      => %w[ruby rbx maglev truffleruby],
}.freeze
PLATFORM_MAP =

:nodoc:

{ # :nodoc:
  :jruby        => Gem::Platform::RUBY,
  :jruby_18     => Gem::Platform::RUBY,
  :jruby_19     => Gem::Platform::RUBY,
  :maglev       => Gem::Platform::RUBY,
  :mingw        => x86_mingw,
  :mingw_18     => x86_mingw,
  :mingw_19     => x86_mingw,
  :mingw_20     => x86_mingw,
  :mingw_21     => x86_mingw,
  :mri          => Gem::Platform::RUBY,
  :mri_18       => Gem::Platform::RUBY,
  :mri_19       => Gem::Platform::RUBY,
  :mri_20       => Gem::Platform::RUBY,
  :mri_21       => Gem::Platform::RUBY,
  :mswin        => mswin,
  :mswin_18     => mswin,
  :mswin_19     => mswin,
  :mswin_20     => mswin,
  :mswin_21     => mswin,
  :mswin64      => mswin64,
  :mswin64_19   => mswin64,
  :mswin64_20   => mswin64,
  :mswin64_21   => mswin64,
  :rbx          => Gem::Platform::RUBY,
  :ruby         => Gem::Platform::RUBY,
  :ruby_18      => Gem::Platform::RUBY,
  :ruby_19      => Gem::Platform::RUBY,
  :ruby_20      => Gem::Platform::RUBY,
  :ruby_21      => Gem::Platform::RUBY,
  :truffleruby  => Gem::Platform::RUBY,
  :x64_mingw    => x64_mingw,
  :x64_mingw_20 => x64_mingw,
  :x64_mingw_21 => x64_mingw
}.freeze
VERSION_MAP =

:nodoc:

{ # :nodoc:
  :jruby        => gt_eq_0,
  :jruby_18     => tilde_gt_1_8_0,
  :jruby_19     => tilde_gt_1_9_0,
  :maglev       => gt_eq_0,
  :mingw        => gt_eq_0,
  :mingw_18     => tilde_gt_1_8_0,
  :mingw_19     => tilde_gt_1_9_0,
  :mingw_20     => tilde_gt_2_0_0,
  :mingw_21     => tilde_gt_2_1_0,
  :mri          => gt_eq_0,
  :mri_18       => tilde_gt_1_8_0,
  :mri_19       => tilde_gt_1_9_0,
  :mri_20       => tilde_gt_2_0_0,
  :mri_21       => tilde_gt_2_1_0,
  :mswin        => gt_eq_0,
  :mswin_18     => tilde_gt_1_8_0,
  :mswin_19     => tilde_gt_1_9_0,
  :mswin_20     => tilde_gt_2_0_0,
  :mswin_21     => tilde_gt_2_1_0,
  :mswin64      => gt_eq_0,
  :mswin64_19   => tilde_gt_1_9_0,
  :mswin64_20   => tilde_gt_2_0_0,
  :mswin64_21   => tilde_gt_2_1_0,
  :rbx          => gt_eq_0,
  :ruby         => gt_eq_0,
  :ruby_18      => tilde_gt_1_8_0,
  :ruby_19      => tilde_gt_1_9_0,
  :ruby_20      => tilde_gt_2_0_0,
  :ruby_21      => tilde_gt_2_1_0,
  :truffleruby  => gt_eq_0,
  :x64_mingw    => gt_eq_0,
  :x64_mingw_20 => tilde_gt_2_0_0,
  :x64_mingw_21 => tilde_gt_2_1_0,
}.freeze
WINDOWS =

:nodoc:

{ # :nodoc:
  :mingw        => :only,
  :mingw_18     => :only,
  :mingw_19     => :only,
  :mingw_20     => :only,
  :mingw_21     => :only,
  :mri          => :never,
  :mri_18       => :never,
  :mri_19       => :never,
  :mri_20       => :never,
  :mri_21       => :never,
  :mswin        => :only,
  :mswin_18     => :only,
  :mswin_19     => :only,
  :mswin_20     => :only,
  :mswin_21     => :only,
  :mswin64      => :only,
  :mswin64_19   => :only,
  :mswin64_20   => :only,
  :mswin64_21   => :only,
  :rbx          => :never,
  :ruby         => :never,
  :ruby_18      => :never,
  :ruby_19      => :never,
  :ruby_20      => :never,
  :ruby_21      => :never,
  :x64_mingw    => :only,
  :x64_mingw_20 => :only,
  :x64_mingw_21 => :only,
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(set, path) ⇒ GemDependencyAPI

Creates a new GemDependencyAPI that will add dependencies to the Gem::RequestSet set based on the dependency API description in path.


197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 197

def initialize(set, path)
  @set = set
  @path = path

  @current_groups     = nil
  @current_platforms  = nil
  @current_repository = nil
  @dependencies       = {}
  @default_sources    = true
  @git_set            = @set.git_set
  @git_sources        = {}
  @installing         = false
  @requires           = Hash.new { |h, name| h[name] = [] }
  @vendor_set         = @set.vendor_set
  @source_set         = @set.source_set
  @gem_sources        = {}
  @without_groups     = []

  git_source :github do |repo_name|
    repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include? "/"

    "git://github.com/#{repo_name}.git"
  end

  git_source :bitbucket do |repo_name|
    repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include? "/"

    user, = repo_name.split "/", 2

    "https://#{user}@bitbucket.org/#{repo_name}.git"
  end
end

Instance Attribute Details

#dependenciesObject (readonly)

The gems required by #gem statements in the gem.deps.rb file


171
172
173
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 171

def dependencies
  @dependencies
end

#git_setObject (readonly)

A set of gems that are loaded via the :git option to #gem


176
177
178
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 176

def git_set
  @git_set
end

#requiresObject (readonly)

A Hash containing gem names and files to require from those gems.


181
182
183
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 181

def requires
  @requires
end

#vendor_setObject (readonly)

A set of gems that are loaded via the :path option to #gem


186
187
188
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 186

def vendor_set
  @vendor_set
end

#without_groupsObject

The groups of gems to exclude from installation


191
192
193
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 191

def without_groups
  @without_groups
end

Instance Method Details

#find_gemspec(name, path) ⇒ Object

Finds a gemspec with the given name that lives at path.


247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 247

def find_gemspec(name, path) # :nodoc:
  glob = File.join path, "#{name}.gemspec"

  spec_files = Dir[glob]

  case spec_files.length
  when 1 then
    spec_file = spec_files.first

    spec = Gem::Specification.load spec_file

    return spec if spec

    raise ArgumentError, "invalid gemspec #{spec_file}"
  when 0 then
    raise ArgumentError, "no gemspecs found at #{Dir.pwd}"
  else
    raise ArgumentError,
      "found multiple gemspecs at #{Dir.pwd}, " +
      "use the name: option to specify the one you want"
  end
end

#gem(name, *requirements) ⇒ Object

:category: Gem Dependencies DSL

:call-seq:

gem(name)
gem(name, *requirements)
gem(name, *requirements, options)

Specifies a gem dependency with the given name and requirements. You may also supply options following the requirements

options include:

require:

RubyGems does not provide any autorequire features so requires in a gem dependencies file are recorded but ignored.

In bundler the require: option overrides the file to require during Bundler.require. By default the name of the dependency is required in Bundler. A single file or an Array of files may be given.

To disable requiring any file give false:

gem 'rake', require: false
group:

Place the dependencies in the given dependency group. A single group or an Array of groups may be given.

See also #group

platform:

Only install the dependency on the given platform. A single platform or an Array of platforms may be given.

See #platform for a list of platforms available.

path:

Install this dependency from an unpacked gem in the given directory.

gem 'modified_gem', path: 'vendor/modified_gem'
git:

Install this dependency from a git repository:

gem 'private_gem', git: [email protected]:private_gem.git'
gist:

Install this dependency from the gist ID:

gem 'bang', gist: '1232884'
github:

Install this dependency from a github git repository:

gem 'private_gem', github: 'my_company/private_gem'
submodules:

Set to true to include submodules when fetching the git repository for git:, gist: and github: dependencies.

ref:

Use the given commit name or SHA for git:, gist: and github: dependencies.

branch:

Use the given branch for git:, gist: and github: dependencies.

tag:

Use the given tag for git:, gist: and github: dependencies.


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
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 359

def gem(name, *requirements)
  options = requirements.pop if requirements.last.kind_of?(Hash)
  options ||= {}

  options[:git] = @current_repository if @current_repository

  source_set = false

  source_set ||= gem_path       name, options
  source_set ||= gem_git        name, options
  source_set ||= gem_git_source name, options
  source_set ||= gem_source     name, options

  duplicate = @dependencies.include? name

  @dependencies[name] =
    if requirements.empty? and not source_set
      Gem::Requirement.default
    elsif source_set
      Gem::Requirement.source_set
    else
      Gem::Requirement.create requirements
    end

  return unless gem_platforms options

  groups = gem_group name, options

  return unless (groups & @without_groups).empty?

  pin_gem_source name, :default unless source_set

  gem_requires name, options

  if duplicate
    warn <<-WARNING
Gem dependencies file #{@path} requires #{name} more than once.
    WARNING
  end

  @set.gem name, *requirements
end

#gem_deps_fileObject

Returns the basename of the file the dependencies were loaded from


614
615
616
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 614

def gem_deps_file # :nodoc:
  File.basename @path
end

#gem_git_reference(options) ⇒ Object

Handles the git options from options for git gem.

Returns reference for the git gem.


430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 430

def gem_git_reference(options) # :nodoc:
  ref    = options.delete :ref
  branch = options.delete :branch
  tag    = options.delete :tag

  reference = nil
  reference ||= ref
  reference ||= branch
  reference ||= tag
  reference ||= 'master'

  if ref && branch
    warn <<-WARNING
Gem dependencies file #{@path} includes git reference for both ref and branch but only ref is used.
    WARNING
  end
  if (ref || branch) && tag
    warn <<-WARNING
Gem dependencies file #{@path} includes git reference for both ref/branch and tag but only ref/branch is used.
    WARNING
  end

  reference
end

#gemspec(options = {}) ⇒ Object

:category: Gem Dependencies DSL

Loads dependencies from a gemspec file.

options include:

name:

The name portion of the gemspec file. Defaults to searching for any gemspec file in the current directory.

gemspec name: 'my_gem'
path:

The path the gemspec lives in. Defaults to the current directory:

gemspec 'my_gem', path: 'gemspecs', name: 'my_gem'
development_group:

The group to add development dependencies to. By default this is :development. Only one group may be specified.


640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 640

def gemspec(options = {})
  name              = options.delete(:name) || '{,*}'
  path              = options.delete(:path) || '.'
  development_group = options.delete(:development_group) || :development

  spec = find_gemspec name, path

  groups = gem_group spec.name, {}

  self_dep = Gem::Dependency.new spec.name, spec.version

  add_dependencies groups, [self_dep]
  add_dependencies groups, spec.runtime_dependencies

  @dependencies[spec.name] = Gem::Requirement.source_set

  spec.dependencies.each do |dep|
    @dependencies[dep.name] = dep.requirement
  end

  groups << development_group

  add_dependencies groups, spec.development_dependencies

  @vendor_set.add_vendor_gem spec.name, path
  gem_requires spec.name, options
end

#git(repository) ⇒ Object

:category: Gem Dependencies DSL

Block form for specifying gems from a git repository.

git 'https://github.com/rails/rails.git' do
  gem 'activesupport'
  gem 'activerecord'
end

593
594
595
596
597
598
599
600
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 593

def git(repository)
  @current_repository = repository

  yield

ensure
  @current_repository = nil
end

#git_source(name, &callback) ⇒ Object

Defines a custom git source that uses name to expand git repositories for use in gems built from git repositories. You must provide a block that accepts a git repository name for expansion.


607
608
609
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 607

def git_source(name, &callback)
  @git_sources[name] = callback
end

#group(*groups) ⇒ Object

:category: Gem Dependencies DSL

Block form for placing a dependency in the given groups.

group :development do
  gem 'debugger'
end

group :development, :test do
  gem 'minitest'
end

Groups can be excluded at install time using `gem install -g –without development`. See `gem help install` and `gem help gem_dependencies` for further details.


685
686
687
688
689
690
691
692
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 685

def group(*groups)
  @current_groups = groups

  yield

ensure
  @current_groups = nil
end

#installing=(installing) ⇒ Object

Changes the behavior of gem dependency file loading to installing mode. In installing mode certain restrictions are ignored such as ruby version mismatch checks.


275
276
277
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 275

def installing=(installing) # :nodoc:
  @installing = installing
end

#loadObject

Loads the gem dependency file and returns self.


282
283
284
285
286
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 282

def load
  instance_eval File.read(@path).tap(&Gem::UNTAINT), @path, 1

  self
end

#platform(*platforms) ⇒ Object Also known as: platforms

:category: Gem Dependencies DSL

Block form for restricting gems to a set of platforms.

The gem dependencies platform is different from Gem::Platform. A platform gem.deps.rb platform matches on the ruby engine, the ruby version and whether or not windows is allowed.

:ruby, :ruby_XY

Matches non-windows, non-jruby implementations where X and Y can be used to match releases in the 1.8, 1.9, 2.0 or 2.1 series.

:mri, :mri_XY

Matches non-windows C Ruby (Matz Ruby) or only the 1.8, 1.9, 2.0 or 2.1 series.

:mingw, :mingw_XY

Matches 32 bit C Ruby on MinGW or only the 1.8, 1.9, 2.0 or 2.1 series.

:x64_mingw, :x64_mingw_XY

Matches 64 bit C Ruby on MinGW or only the 1.8, 1.9, 2.0 or 2.1 series.

:mswin, :mswin_XY

Matches 32 bit C Ruby on Microsoft Windows or only the 1.8, 1.9, 2.0 or 2.1 series.

:mswin64, :mswin64_XY

Matches 64 bit C Ruby on Microsoft Windows or only the 1.8, 1.9, 2.0 or 2.1 series.

:jruby, :jruby_XY

Matches JRuby or JRuby in 1.8 or 1.9 mode.

:maglev

Matches Maglev

:rbx

Matches non-windows Rubinius

NOTE: There is inconsistency in what environment a platform matches. You may need to read the source to know the exact details.


760
761
762
763
764
765
766
767
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 760

def platform(*platforms)
  @current_platforms = platforms

  yield

ensure
  @current_platforms = nil
end

#ruby(version, options = {}) ⇒ Object

:category: Gem Dependencies DSL

Restricts this gem dependencies file to the given ruby version.

You may also provide engine: and engine_version: options to restrict this gem dependencies file to a particular ruby engine and its engine version. This matching is performed by using the RUBY_ENGINE and RUBY_ENGINE_VERSION constants.

Raises:

  • (ArgumentError)

787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 787

def ruby(version, options = {})
  engine         = options[:engine]
  engine_version = options[:engine_version]

  raise ArgumentError,
        'You must specify engine_version along with the Ruby engine' if
          engine and not engine_version

  return true if @installing

  unless RUBY_VERSION == version
    message = "Your Ruby version is #{RUBY_VERSION}, " +
              "but your #{gem_deps_file} requires #{version}"

    raise Gem::RubyVersionMismatch, message
  end

  if engine and engine != Gem.ruby_engine
    message = "Your Ruby engine is #{Gem.ruby_engine}, " +
              "but your #{gem_deps_file} requires #{engine}"

    raise Gem::RubyVersionMismatch, message
  end

  if engine_version
    if engine_version != RUBY_ENGINE_VERSION
      message =
        "Your Ruby engine version is #{Gem.ruby_engine} #{RUBY_ENGINE_VERSION}, " +
        "but your #{gem_deps_file} requires #{engine} #{engine_version}"

      raise Gem::RubyVersionMismatch, message
    end
  end

  return true
end

#source(url) ⇒ Object

:category: Gem Dependencies DSL

Sets url as a source for gems for this dependency API. RubyGems uses the default configured sources if no source was given. If a source is set only that source is used.

This method differs in behavior from Bundler:

  • The :gemcutter, # :rubygems and :rubyforge sources are not supported as they are deprecated in bundler.

  • The prepend: option is not supported. If you wish to order sources then list them in your preferred order.


838
839
840
841
842
843
844
# File 'lib/rubygems/request_set/gem_dependency_api.rb', line 838

def source(url)
  Gem.sources.clear if @default_sources

  @default_sources = false

  Gem.sources << url
end