Class: Bundler::LazySpecification

Inherits:
Object
  • Object
show all
Includes:
ForcePlatform, MatchMetadata, MatchPlatform
Defined in:
lib/bundler/lazy_specification.rb

Constant Summary

Constants included from GemHelpers

GemHelpers::GENERICS, GemHelpers::GENERIC_CACHE

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ForcePlatform

#default_force_ruby_platform

Methods included from MatchPlatform

#match_platform, platforms_match?

Methods included from GemHelpers

generic, generic_local_platform, generic_local_platform_is_ruby?, local_platform, platform_specificity_match, same_deps, same_specificity, select_all_platform_match, select_best_local_platform_match, select_best_platform_match, sort_and_filter_best_platform_match, sort_best_platform_match

Methods included from MatchMetadata

#matches_current_metadata?, #matches_current_ruby?, #matches_current_rubygems?

Constructor Details

#initialize(name, version, platform, source = nil) ⇒ LazySpecification

Returns a new instance of LazySpecification.



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

def initialize(name, version, platform, source = nil)
  @name          = name
  @version       = version
  @dependencies  = []
  @required_ruby_version = Gem::Requirement.default
  @required_rubygems_version = Gem::Requirement.default
  @platform = platform || Gem::Platform::RUBY

  @original_source = source
  @source = source

  @force_ruby_platform = default_force_ruby_platform
  @most_specific_locked_platform = nil
  @materialization = nil
end

Instance Attribute Details

#dependencies ⇒ Object Also known as: runtime_dependencies

Returns the value of attribute dependencies.



12
13
14
 
# File 'lib/bundler/lazy_specification.rb', line 12

def dependencies
  @dependencies
end

#force_ruby_platform ⇒ Object

Returns the value of attribute force_ruby_platform.



12
13
14
 
# File 'lib/bundler/lazy_specification.rb', line 12

def force_ruby_platform
  @force_ruby_platform
end

#materialization ⇒ Object (readonly)

Returns the value of attribute materialization.



11
12
13
 
# File 'lib/bundler/lazy_specification.rb', line 11

def materialization
  @materialization
end

#most_specific_locked_platform ⇒ Object

For backwards compatibility with existing lockfiles, if the most specific locked platform is not a specific platform like x86_64-linux or universal-java-11, then we keep the previous behaviour of resolving the best platform variant at materiliazation time. For previous bundler versions (before 2.2.0) this was always the case (except when the lockfile only included non-ruby platforms), but we’re also keeping this behaviour on newer bundlers unless users generate the lockfile from scratch or explicitly add a more specific platform.



24
25
26
 
# File 'lib/bundler/lazy_specification.rb', line 24

def most_specific_locked_platform
  @most_specific_locked_platform
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



11
12
13
 
# File 'lib/bundler/lazy_specification.rb', line 11

def name
  @name
end

#platform ⇒ Object (readonly)

Returns the value of attribute platform.



11
12
13
 
# File 'lib/bundler/lazy_specification.rb', line 11

def platform
  @platform
end

#remote ⇒ Object

Returns the value of attribute remote.



12
13
14
 
# File 'lib/bundler/lazy_specification.rb', line 12

def remote
  @remote
end

#required_ruby_version ⇒ Object

Returns the value of attribute required_ruby_version.



12
13
14
 
# File 'lib/bundler/lazy_specification.rb', line 12

def required_ruby_version
  @required_ruby_version
end

#required_rubygems_version ⇒ Object

Returns the value of attribute required_rubygems_version.



12
13
14
 
# File 'lib/bundler/lazy_specification.rb', line 12

def required_rubygems_version
  @required_rubygems_version
end

#source ⇒ Object

Returns the value of attribute source.



12
13
14
 
# File 'lib/bundler/lazy_specification.rb', line 12

def source
  @source
end

#version ⇒ Object (readonly)

Returns the value of attribute version.



11
12
13
 
# File 'lib/bundler/lazy_specification.rb', line 11

def version
  @version
end

Class Method Details

.from_spec(s) ⇒ Object 



28
29
30
31
32
33
34
 
# File 'lib/bundler/lazy_specification.rb', line 28

def self.from_spec(s)
  lazy_spec = new(s.name, s.version, s.platform, s.source)
  lazy_spec.dependencies = s.runtime_dependencies
  lazy_spec.required_ruby_version = s.required_ruby_version
  lazy_spec.required_rubygems_version = s.required_rubygems_version
  lazy_spec
end

Instance Method Details

#==(other) ⇒ Object 



80
81
82
 
# File 'lib/bundler/lazy_specification.rb', line 80

def ==(other)
  full_name == other.full_name
end

#__materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?) ⇒ Object

If in frozen mode, we fallback to a non-installable candidate because by doing this we avoid re-resolving and potentially end up changing the lock file, which is not allowed. In that case, we will give a proper error about the mismatch higher up the stack, right before trying to install the bad gem.



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/bundler/lazy_specification.rb', line 168

def __materialize__(candidates, fallback_to_non_installable: Bundler.frozen_bundle?)
  search = candidates.reverse.find do |spec|
    spec.is_a?(StubSpecification) || spec.matches_current_metadata?
  end
  if search.nil? && fallback_to_non_installable
    search = candidates.last
  elsif search && search.full_name == full_name
    # We don't validate locally installed dependencies but accept what's in
    # the lockfile instead for performance, since loading locally installed
    # dependencies would mean evaluating all gemspecs, which would affect
    # `bundler/setup` performance
    if search.is_a?(StubSpecification)
      search.dependencies = dependencies
    else
      if !source.is_a?(Source::Path) && search.runtime_dependencies.sort != dependencies.sort
        raise IncorrectLockfileDependencies.new(self)
      end

      search.locked_platform = platform if search.instance_of?(RemoteSpecification) || search.instance_of?(EndpointSpecification)
    end
  end
  search
end

#eql?(other) ⇒ Boolean

Returns:

  • (Boolean) 


84
85
86
 
# File 'lib/bundler/lazy_specification.rb', line 84

def eql?(other)
  full_name.eql?(other.full_name)
end

#force_ruby_platform! ⇒ Object 



205
206
207
 
# File 'lib/bundler/lazy_specification.rb', line 205

def force_ruby_platform!
  @force_ruby_platform = true
end

#full_name ⇒ Object 



64
65
66
67
68
69
70
 
# File 'lib/bundler/lazy_specification.rb', line 64

def full_name
  @full_name ||= if platform == Gem::Platform::RUBY
    "#{@name}-#{@version}"
  else
    "#{@name}-#{@version}-#{platform}"
  end
end

#git_version ⇒ Object 



200
201
202
203
 
# File 'lib/bundler/lazy_specification.rb', line 200

def git_version
  return unless source.is_a?(Bundler::Source::Git)
  " #{source.revision[0..6]}"
end

#hash ⇒ Object 



88
89
90
 
# File 'lib/bundler/lazy_specification.rb', line 88

def hash
  full_name.hash
end

#incomplete? ⇒ Boolean

Returns:

  • (Boolean) 


56
57
58
 
# File 'lib/bundler/lazy_specification.rb', line 56

def incomplete?
  @materialization.nil?
end

#inspect ⇒ Object 



192
193
194
 
# File 'lib/bundler/lazy_specification.rb', line 192

def inspect
  "#<#{self.class} @name=\"#{name}\" (#{full_name.delete_prefix("#{name}-")})>"
end

#lock_name ⇒ Object 



72
73
74
 
# File 'lib/bundler/lazy_specification.rb', line 72

def lock_name
  @lock_name ||= name_tuple.lock_name
end

#materialize_for_installation ⇒ Object 



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/bundler/lazy_specification.rb', line 139

def materialize_for_installation
  source.local!

  if use_exact_resolved_specifications?
    materialize_strictly
  else
    matching_specs = source.specs.search([name, version])
    return self if matching_specs.empty?

    target_platform = source.is_a?(Source::Path) ? platform : local_platform

    installable_candidates = GemHelpers.select_best_platform_match(matching_specs, target_platform)

    specification = __materialize__(installable_candidates, fallback_to_non_installable: false)
    return specification unless specification.nil?

    if target_platform != platform
      installable_candidates = GemHelpers.select_best_platform_match(matching_specs, platform)
    end

    __materialize__(installable_candidates)
  end
end

#materialize_strictly ⇒ Object 



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

def materialize_strictly
  source.local!

  matching_specs = source.specs.search(self)
  return self if matching_specs.empty?

  __materialize__(matching_specs)
end

#materialized_for_installation ⇒ Object 



133
134
135
136
137
 
# File 'lib/bundler/lazy_specification.rb', line 133

def materialized_for_installation
  @materialization = materialize_for_installation

  self unless incomplete?
end

#missing? ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
 
# File 'lib/bundler/lazy_specification.rb', line 52

def missing?
  @materialization == self
end

#name_tuple ⇒ Object 



76
77
78
 
# File 'lib/bundler/lazy_specification.rb', line 76

def name_tuple
  Gem::NameTuple.new(@name, @version, @platform)
end

#satisfies?(dependency) ⇒ Boolean

Does this locked specification satisfy dependency?

NOTE: Rubygems default requirement is “>= 0”, which doesn’t match prereleases of 0 versions, like “0.0.0.dev” or “0.0.0.SNAPSHOT”. However, bundler users expect those to work. We need to make sure that Gemfile dependencies without explicit requirements (which use “>= 0” under the hood by default) are still valid for locked specs using this kind of versions. The method implements an ad-hoc fix for that. A better solution might be to change default rubygems requirement of dependencies to be “>= 0.A” but that’s a major refactoring likely to break things. Hopefully we can attempt it in the future.

Returns:

  • (Boolean) 


106
107
108
109
110
 
# File 'lib/bundler/lazy_specification.rb', line 106

def satisfies?(dependency)
  effective_requirement = dependency.requirement == Gem::Requirement.default ? Gem::Requirement.new(">= 0.A") : dependency.requirement

  @name == dependency.name && effective_requirement.satisfied_by?(Gem::Version.new(@version))
end

#source_changed? ⇒ Boolean

Returns:

  • (Boolean) 


60
61
62
 
# File 'lib/bundler/lazy_specification.rb', line 60

def source_changed?
  @original_source != source
end

#to_lock ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/bundler/lazy_specification.rb', line 112

def to_lock
  out = String.new
  out << "    #{lock_name}\n"

  dependencies.sort_by(&:to_s).uniq.each do |dep|
    next if dep.type == :development
    out << "    #{dep.to_lock}\n"
  end

  out
end

#to_s ⇒ Object 



196
197
198
 
# File 'lib/bundler/lazy_specification.rb', line 196

def to_s
  lock_name
end