Class: BundlerFixture

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dir: File.join(Dir.tmpdir, 'fake_project_root'), gemfile: 'Gemfile') ⇒ BundlerFixture

Returns a new instance of BundlerFixture.



12
13
14
15
16
17
18
19
 
# File 'lib/bundler/fixture.rb', line 12

def initialize(dir: File.join(Dir.tmpdir, 'fake_project_root'), gemfile: 'Gemfile')
  @dir = dir
  @gemfile = gemfile
  FileUtils.makedirs @dir

  @sources = Bundler::SourceList.new
  @sources.add_rubygems_remote('https://rubygems.org')
end

Instance Attribute Details

#dir ⇒ Object (readonly)

Returns the value of attribute dir.



6
7
8
 
# File 'lib/bundler/fixture.rb', line 6

def dir
  @dir
end

Class Method Details

.bundler_version_or_higher(version) ⇒ Object 



8
9
10
 
# File 'lib/bundler/fixture.rb', line 8

def self.bundler_version_or_higher(version)
  Gem::Version.new(Bundler::VERSION) >= Gem::Version.new(version)
end

Instance Method Details

#bundler_version_or_higher(version) ⇒ Object 



21
22
23
 
# File 'lib/bundler/fixture.rb', line 21

def bundler_version_or_higher(version)
  self.class.bundler_version_or_higher(version)
end

#clean_up ⇒ Object 



25
26
27
 
# File 'lib/bundler/fixture.rb', line 25

def clean_up
  FileUtils.rmtree @dir
end

#create_config(hash) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/bundler/fixture.rb', line 93

def create_config(hash)
  config_dir = File.join(@dir, '.bundle')
  FileUtils.makedirs config_dir
  s = Bundler::Settings.new(config_dir)
  hash.each_pair do |k, v|
    # never support set_global, we don't want a test fixture jacking with an entire machine's bundler config
    s.set_local(k, v)
    if k.to_s == 'path'
      if v.nil?
        s.set_local('disable_shared_gems', nil)
      else
        s.set_local('disable_shared_gems', 'true')
      end
    end
  end
end

#create_definition(gem_dependencies:, source_specs:, ensure_sources:, update_gems:, ruby_version: nil) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/bundler/fixture.rb', line 50

def create_definition(gem_dependencies:, source_specs:, ensure_sources:, update_gems:, ruby_version: nil)
  index = Bundler::Index.new
  Array(source_specs).flatten.each { |s| index << s }
  if bundler_version_or_higher('1.14.0')
    index << Gem::Specification.new("ruby\0", Bundler::RubyVersion.system.to_gem_version_with_patchlevel)
    index << Gem::Specification.new("rubygems\0", Gem::VERSION)
  end

  Array(gem_dependencies).each do |dep|
    index << create_spec(dep.name, dep.requirement.requirements.first.last)
  end if ensure_sources

  update_hash = update_gems === true ? true : {gems: Array(update_gems)}
  ruby_version_obj = Bundler::RubyVersion.new(ruby_version, nil, nil, nil)
  dfn = Bundler::Definition.new(lockfile_filename, Array(gem_dependencies), @sources, update_hash, ruby_version_obj)
  dfn.instance_variable_set('@index', index)
  # reading an existing lockfile in will overwrite the hacked up sources with detected
  # ones from lockfile, so this needs to go here after the constructor is called.
  source.instance_variable_set('@specs', index)
  dfn
end

#create_dependency(name, *requirements) ⇒ Object 



147
148
149
 
# File 'lib/bundler/fixture.rb', line 147

def create_dependency(name, *requirements)
  Bundler::Dependency.new(name, requirements, {'source' => source})
end

#create_gemfile(gem_dependencies:, ruby_version: nil) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/bundler/fixture.rb', line 72

def create_gemfile(gem_dependencies:, ruby_version: nil)
  lines = []
  lines << "source 'https://rubygems.org'"
  Array(gem_dependencies).each do |spec|
    name, requirement = case spec
                        when Array
                          spec
                        when Gem::Dependency, Bundler::Dependency
                          [spec.name, spec.requirement]
                        end
    line = "gem '#{name}'"
    if requirement
      req_output = requirement_to_s(requirement)
      line << ", #{req_output}" unless req_output.empty?
    end
    lines << line
  end
  lines << "ruby '#{ruby_version}'" if ruby_version
  File.open(gemfile_filename, 'w') { |f| f.puts lines }
end

#create_lockfile(gem_dependencies:, source_specs: [], ensure_sources: true, update_gems: [], gemfile: nil, ruby_version: nil) ⇒ Object

Parameters:

  • gem_dependencies (Gem::Specification) —

    This simulates gem requirements in Gemfile.

  • source_specs (Gem::Specification) (defaults to: []) —

    This simulates gems in the source index.

  • ensure_sources (boolean) (defaults to: true) —

    Default is true, makes sure a source exists for each gem_dependency. Set this to false to require sending in sources in @param source_specs.

  • update_gems (Array boolean) (defaults to: []) —

    An array of gem names to update to latest, or ‘true` to update all. Default is empty Array.



35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/bundler/fixture.rb', line 35

def create_lockfile(gem_dependencies:,
                    source_specs: [],
                    ensure_sources: true,
                    update_gems: [],
                    gemfile: nil,
                    ruby_version: nil)
  @gemfile = gemfile if gemfile
  dfn = create_definition(gem_dependencies: gem_dependencies,
                          source_specs: source_specs,
                          ensure_sources: ensure_sources,
                          update_gems: update_gems,
                          ruby_version: ruby_version)
  dfn.lock(lockfile_filename)
end

#create_spec(name, version, dependencies = {}) ⇒ Object 



155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/bundler/fixture.rb', line 155

def create_spec(name, version, dependencies={})
  Gem::Specification.new do |s|
    s.name = name
    s.version = Gem::Version.new(version)
    s.platform = 'ruby'
    s.source = source
    dependencies.each do |name, requirement|
      s.add_dependency name, requirement
    end
  end
end

#create_specs(name, versions, dependencies = {}) ⇒ Object 



167
168
169
170
171
 
# File 'lib/bundler/fixture.rb', line 167

def create_specs(name, versions, dependencies={})
  versions.map do |version|
    create_spec(name, version, dependencies)
  end
end

#gemfile_filename ⇒ Object 



127
128
129
 
# File 'lib/bundler/fixture.rb', line 127

def gemfile_filename
  File.join(@dir, "#{@gemfile}")
end

#lockfile_contents ⇒ Object 



135
136
137
 
# File 'lib/bundler/fixture.rb', line 135

def lockfile_contents
  File.read(lockfile_filename)
end

#lockfile_filename ⇒ Object 



131
132
133
 
# File 'lib/bundler/fixture.rb', line 131

def lockfile_filename
  File.join(@dir, "#{@gemfile}.lock")
end

#parsed_lockfile ⇒ Object 



139
140
141
 
# File 'lib/bundler/fixture.rb', line 139

def parsed_lockfile
  Bundler::LockfileParser.new(lockfile_contents)
end

#parsed_lockfile_spec(gem_name) ⇒ Object 



143
144
145
 
# File 'lib/bundler/fixture.rb', line 143

def parsed_lockfile_spec(gem_name)
  parsed_lockfile.specs.detect { |s| s.name == gem_name }
end

#requirement_to_s(req) ⇒ Object 



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/bundler/fixture.rb', line 110

def requirement_to_s(req)
  case req
  when Gem::Requirement
    req.as_list.delete_if do |r|
      r == '>= 0'
    end.map do |r|
      "'#{r.gsub(/^= /, '')}'"
    end.join(', ')
  when String
    "'#{req}'"
  when Array
    req.map { |r| "'#{r}'" }.join(', ')
  else
    req
  end
end

#source ⇒ Object 



151
152
153
 
# File 'lib/bundler/fixture.rb', line 151

def source
  @sources.all_sources.first
end