Class: Kettle::Dev::LockfileReset

Inherits:
Object
  • Object
show all
Defined in:
lib/kettle/dev/lockfile_reset.rb

Constant Summary collapse

DEFAULT_DISABLED_ENV = 
{
  "KETTLE_DEV_DEV" => "false",
  "K_JEM_TEMPLATING" => "false",
  "STRUCTUREDMERGE_DEV" => "false",
  "TREE_SITTER_LANGUAGE_PACK_DEV" => "false",
  "RUBOCOP_LTS_LOCAL" => "false",
  "GALTZO_FLOSS_DEV" => "false",
  "UR_BRAIN_DEV" => "false"
}.freeze
ALLOWED_LOCAL_PATH_ROOTS_ENV = 
"KETTLE_RELEASE_ALLOWED_LOCAL_PATH_ROOTS"
ALLOWED_LOCAL_PATH_ENVS_ENV = 
"KETTLE_RELEASE_ALLOWED_LOCAL_PATH_ENVS"
RELEASE_LOCKFILES_TARGET = 
"release-lockfiles"
SUPPORTED_TARGETS = 
["Gemfile.lock", "Appraisal.root.gemfile.lock", RELEASE_LOCKFILES_TARGET].freeze
UNBUNDLED_ENV_KEYS = 
(BundlerEnvGuard::RESET_ENV_KEYS + %w[
  RUBYLIB
  RUBYOPT
]).freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(root:, command_runner:) ⇒ LockfileReset

Returns a new instance of LockfileReset.



112
113
114
115
116
117
118
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 112

def initialize(root:, command_runner:)
  @root = root
  @command_runner = command_runner
  @release_platforms = {}
  @allowed_local_path_roots = configured_allowed_local_path_roots
  @allowed_local_path_env_names = configured_allowed_local_path_env_names
end

Instance Attribute Details

#allowed_local_path_env_names ⇒ Object (readonly)

Returns the value of attribute allowed_local_path_env_names.



371
372
373
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 371

def allowed_local_path_env_names
  @allowed_local_path_env_names
end

#allowed_local_path_roots ⇒ Object (readonly)

Returns the value of attribute allowed_local_path_roots.



371
372
373
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 371

def allowed_local_path_roots
  @allowed_local_path_roots
end

Class Method Details

.checksum_entries_from_source(lockfile_source) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 52

def checksum_entries_from_source(lockfile_source)
  in_checksums = false
  entries = {}
  lockfile_source.each_line do |line|
    stripped = line.chomp
    if stripped == "CHECKSUMS"
      in_checksums = true
      next
    end
    next unless in_checksums
    break if !stripped.empty? && stripped == stripped.upcase && !stripped.start_with?(" ")
    next unless stripped.start_with?("  ")

    parsed = parse_lockfile_spec_line(stripped)
    entries[[parsed.fetch(:name), parsed.fetch(:version)]] = parsed.fetch(:suffix) if parsed
  end
  in_checksums ? entries : nil
end

.gem_specs_from_source(lockfile_source) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 71

def gem_specs_from_source(lockfile_source)
  in_gem = false
  in_specs = false
  specs = []
  lockfile_source.each_line do |line|
    stripped = line.chomp
    if stripped == "GEM"
      in_gem = true
      in_specs = false
      next
    end
    next unless in_gem
    break if !stripped.empty? && stripped == stripped.upcase && !stripped.start_with?(" ")

    if stripped == "  specs:"
      in_specs = true
      next
    end
    next unless in_specs
    next unless line.start_with?("    ") && !line.start_with?("      ")

    parsed = parse_lockfile_spec_line(stripped)
    specs << [parsed.fetch(:name), parsed.fetch(:version)] if parsed
  end
  specs.uniq
end

.local_path_remote_lines_from_source(lockfile_source) ⇒ Object 



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

def local_path_remote_lines_from_source(lockfile_source)
  in_path = false
  lockfile_source.each_line.with_index(1).filter_map do |line, index|
    stripped = line.strip
    if stripped.match?(/\A[A-Z][A-Z ]*\z/)
      in_path = stripped == "PATH"
      next
    end
    next unless in_path
    next unless stripped.start_with?("remote:")
    next if stripped == "remote: ."
    next unless stripped.start_with?("remote: /", "remote: ./", "remote: ../")

    index
  end
end

Instance Method Details

#active_local_path_env?(name) ⇒ Boolean

Returns:

  • (Boolean) 


359
360
361
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 359

def active_local_path_env?(name)
  local_path_env_value?(ENV[name])
end

#allowed_local_path?(path) ⇒ Boolean

Returns:

  • (Boolean) 


395
396
397
398
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 395

def allowed_local_path?(path)
  remote = canonical_path(path)
  allowed_local_path_roots.any? { |root| remote == root || remote.start_with?("#{root}/") }
end

#appraisal_normalization_env ⇒ Object

Appraisal generation normally uses the release-normalized environment. During family templating it instead needs the caller's deliberately selected local graph so generated Appraisal Gemfiles can resolve unpublished sibling dependencies.



328
329
330
331
332
333
334
335
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 328

def appraisal_normalization_env
  env = normalization_env
  return env unless template_local_environment?

  env.reject do |name, _value|
    name == "K_JEM_TEMPLATING" || active_local_path_env?(name)
  end
end

#canonical_path(path) ⇒ Object 



400
401
402
403
404
405
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 400

def canonical_path(path)
  expanded = File.expand_path(path, root)
  File.realpath(expanded)
rescue Errno::ENOENT
  expanded
end

#configured_allowed_local_path_env_names ⇒ Object 



387
388
389
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 387

def configured_allowed_local_path_env_names
  ENV.fetch(ALLOWED_LOCAL_PATH_ENVS_ENV, "").split(",").map(&:strip).reject(&:empty?).uniq
end

#configured_allowed_local_path_roots ⇒ Object 



379
380
381
382
383
384
385
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 379

def configured_allowed_local_path_roots
  ENV.fetch(ALLOWED_LOCAL_PATH_ROOTS_ENV, "").split(File::PATH_SEPARATOR).filter_map do |value|
    next if value.strip.empty?

    canonical_path(value)
  end.uniq
end

#diagnostics(path) ⇒ Object 



260
261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 260

def diagnostics(path)
  diagnostics = []
  disallowed_local_path_remote_lines(path).each do |line_number|
    diagnostics << "#{display_path(path)} has local path remote at line #{line_number}"
  end
  empty_registry_checksums(path).each do |name, version, line_number|
    diagnostics << "#{display_path(path)} CHECKSUMS has no sha256 for #{name} #{version} at line #{line_number}"
  end
  unreleased_workspace_registry_specs(path).each do |name, version, line_number|
    diagnostics << "#{display_path(path)} locks local workspace gem #{name} #{version} as a registry gem, but that version is not resolvable from the configured gem source at line #{line_number}"
  end
  diagnostics
end

#disallowed_local_path_remote_lines(path) ⇒ Object 



373
374
375
376
377
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 373

def disallowed_local_path_remote_lines(path)
  local_path_remote_lines(path).reject do |line_number|
    allowed_local_path?(local_path_remote_at(path, line_number))
  end
end

#display_path(path) ⇒ Object 



482
483
484
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 482

def display_path(path)
  Kettle::Dev.display_path(path)
end

#dynamic_local_path_env ⇒ Object 



337
338
339
340
341
342
343
344
345
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 337

def dynamic_local_path_env
  ENV.each_with_object({}) do |(key, value), env|
    next unless key.end_with?("_DEV", "_LOCAL")
    next unless local_path_env_value?(value)
    next if allowed_local_path_env_names.include?(key)

    env[key] = "false"
  end
end

#empty_registry_checksums(path) ⇒ Object 



407
408
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
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 407

def empty_registry_checksums(path)
  non_registry_gems = non_registry_source_gems(path) | path_dependency_gems(path)
  in_checksums = false
  entries = File.readlines(path).filter_map.with_index(1) do |line, index|
    stripped = line.strip
    if stripped == "CHECKSUMS"
      in_checksums = true
      next
    end
    next unless in_checksums
    next if stripped.empty?
    next if stripped == "BUNDLED WITH"

    match = stripped.match(/\A([A-Za-z0-9_.-]+) \(([^)]+)\)(?:\s+(sha256=.*))?\z/)
    next unless match

    name = match[1]
    checksum = match[3].to_s
    next unless checksum.empty?
    next if non_registry_gems.include?(name)

    [name, match[2], index]
  end
  return [] unless has_any_sha_checksum?(path)

  entries
end

#gemfile_for_lockfile(path) ⇒ Object 



311
312
313
314
315
316
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 311

def gemfile_for_lockfile(path)
  basename = File.basename(path)
  return File.join(root, "Gemfile") if basename == "Gemfile.lock"

  path.delete_suffix(".lock")
end

#has_any_sha_checksum?(path) ⇒ Boolean

Returns:

  • (Boolean) 


448
449
450
451
452
453
454
455
456
457
458
459
460
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 448

def has_any_sha_checksum?(path)
  in_checksums = false
  File.readlines(path).any? do |line|
    stripped = line.strip
    if stripped == "CHECKSUMS"
      in_checksums = true
      next false
    end
    next false unless in_checksums

    stripped.include?("sha256=")
  end
end

#has_local_path_remote?(path) ⇒ Boolean

Returns:

  • (Boolean) 


363
364
365
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 363

def has_local_path_remote?(path)
  !disallowed_local_path_remote_lines(path).empty?
end

#local_path_env_value?(value) ⇒ Boolean

Returns:

  • (Boolean) 


347
348
349
350
351
352
353
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 347

def local_path_env_value?(value)
  text = value.to_s.strip
  return false if text.empty? || text.casecmp("false").zero?
  return true if text.start_with?("/", "./", "../", "~")

  text.include?(File::SEPARATOR)
end

#local_path_remote_at(path, line_number) ⇒ Object 



391
392
393
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 391

def local_path_remote_at(path, line_number)
  File.readlines(path)[line_number - 1].to_s.split("remote:", 2).last.to_s.strip
end

#local_path_remote_lines(path) ⇒ Object 



367
368
369
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 367

def local_path_remote_lines(path)
  self.class.local_path_remote_lines_from_source(File.read(path))
end

#lockfile_path_for(target) ⇒ Object

Raises:



282
283
284
285
286
287
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 282

def lockfile_path_for(target)
  paths = lockfile_paths_for(target)
  raise Error, "reset target #{target.inspect} resolves to multiple lockfiles; use lockfile_paths_for" if paths.length != 1

  paths.first
end

#lockfile_paths ⇒ Object 



274
275
276
277
278
279
280
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 274

def lockfile_paths
  candidates = [
    File.join(root, "Gemfile.lock"),
    File.join(root, "Appraisal.root.gemfile.lock")
  ]
  candidates.select { |path| File.file?(path) }.sort
end

#lockfile_paths_for(target) ⇒ Object

Raises:



289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 289

def lockfile_paths_for(target)
  normalized = target.to_s.strip
  raise Error, "reset requires TARGET" if normalized.empty?
  if release_lockfiles_target?(normalized)
    paths = lockfile_paths
    raise Error, "no release lockfiles found" if paths.empty?

    return paths
  end
  supported = SUPPORTED_TARGETS.reject { |candidate| candidate == RELEASE_LOCKFILES_TARGET }
  match = supported.find { |candidate| candidate.casecmp(normalized).zero? }
  unless match
    raise Error, "reset target #{normalized.inspect} is not supported; supported targets: #{SUPPORTED_TARGETS.join(", ")}"
  end

  [File.join(root, match)]
end

#lockfile_platforms(path) ⇒ Object 



232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 232

def lockfile_platforms(path)
  in_platforms = false
  File.readlines(path).filter_map do |line|
    stripped = line.strip
    if stripped.match?(/\A[A-Z][A-Z ]*\z/)
      in_platforms = stripped == "PLATFORMS"
      next
    end
    next unless in_platforms
    next if stripped.empty?

    stripped
  end
end

#non_registry_source_gems(path) ⇒ Object 



469
470
471
472
473
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 469

def non_registry_source_gems(path)
  lockfile_parser(path).specs.each_with_object(Set.new) do |spec, gems|
    gems << spec.name unless registry_source?(spec.source)
  end
end

#normalization_env ⇒ Object 



318
319
320
321
322
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 318

def normalization_env
  DEFAULT_DISABLED_ENV
    .reject { |name, _| allowed_local_path_env_names.include?(name) }
    .merge(dynamic_local_path_env)
end

#normalization_needed?(path) ⇒ Boolean

Returns:

  • (Boolean) 


256
257
258
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 256

def normalization_needed?(path)
  has_local_path_remote?(path) || !empty_registry_checksums(path).empty? || !unreleased_workspace_registry_specs(path).empty?
end

#path_dependency_gems(path) ⇒ Object 



475
476
477
478
479
480
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 475

def path_dependency_gems(path)
  lockfile_parser(path).dependencies.each_value.each_with_object(Set.new) do |dependency, gems|
    source = dependency.source
    gems << dependency.name if path_source?(source) && !self_path_source?(source)
  end
end

#path_source_gems(path) ⇒ Object 



462
463
464
465
466
467
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 462

def path_source_gems(path)
  lockfile_parser(path).specs.each_with_object(Set.new) do |spec, gems|
    source = spec.source
    gems << spec.name if path_source?(source) && !self_path_source?(source)
  end
end

#release_lockfiles_target?(target) ⇒ Boolean

Returns:

  • (Boolean) 


307
308
309
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 307

def release_lockfiles_target?(target)
  target.to_s.strip.casecmp(RELEASE_LOCKFILES_TARGET).zero?
end

#release_platforms_for(paths) ⇒ Object 



226
227
228
229
230
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 226

def release_platforms_for(paths)
  paths.each_with_object({}) do |path, platforms|
    platforms[path] = (@release_platforms[path] ||= reset_platforms(path))
  end
end

#reset(target, skip_changelog_dependency: false) ⇒ Object

Raises:



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 120

def reset(target, skip_changelog_dependency: false)
  BundlerEnvGuard.warn_unexpected_env!
  paths = lockfile_paths_for(target)
  # A monorepo lockfile may deliberately use paths rooted in the
  # repository's members directory. Keep that valid development graph;
  # only rebuild when an unapproved path or other diagnostic remains.
  force_full_update = release_lockfiles_target?(target) &&
    (allowed_local_path_roots.empty? || paths.any? { |path| normalization_needed?(path) })
  platforms = release_platforms_for(paths) if force_full_update
  uninstall_unreleased_local_gems(paths) if force_full_update
  paths.each do |path|
    if force_full_update || normalization_needed?(path)
      reset_lockfile!(
        path,
        full_update: force_full_update,
        platforms: platforms&.fetch(path),
        skip_changelog_dependency: skip_changelog_dependency,
        update_bundler: force_full_update
      )
    end
  end
  if force_full_update && uninstall_unreleased_local_gems(paths)
    paths.each do |path|
      reset_lockfile!(
        path,
        full_update: true,
        platforms: platforms.fetch(path),
        skip_changelog_dependency: skip_changelog_dependency,
        update_bundler: true
      )
    end
  end
  diagnostics = paths.flat_map { |path| diagnostics(path) }
  raise Error, validation_message(target, diagnostics) unless diagnostics.empty?

  paths
end

#reset_command(path:, gemfile:, full_update: false, platforms: nil, skip_changelog_dependency: false, update_bundler: false, isolated_gem_home: nil, isolated_gem_path: nil) ⇒ Object 



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 184

def reset_command(path:, gemfile:, full_update: false, platforms: nil, skip_changelog_dependency: false, update_bundler: false, isolated_gem_home: nil, isolated_gem_path: nil)
  update_gems = (full_update || has_local_path_remote?(path)) ? [] : reset_update_gems(path)
  platforms ||= reset_platforms(path)
  removed_platforms = full_update ? [] : lockfile_platforms(path) - platforms
  env = normalization_env.merge(
    "BUNDLE_GEMFILE" => gemfile,
    "BUNDLE_LOCKFILE" => path
  )
  env["KETTLE_DEV_SKIP_CHANGELOG_DEPENDENCY"] = "true" if skip_changelog_dependency
  if isolated_gem_home
    env["GEM_HOME"] = isolated_gem_home
    env["GEM_PATH"] = isolated_gem_path || isolated_gem_home
  end
  command = +"env"
  UNBUNDLED_ENV_KEYS.each do |key|
    command << " -u #{key}"
  end
  env.each do |key, value|
    command << " #{key}=#{Shellwords.escape(value)}"
  end
  command << " bundle lock"
  # Bundler accepts each platform option once followed by a list. Repeating
  # either option silently keeps only the final occurrence with Bundler 4.
  command << " --remove-platform #{removed_platforms.sort.map { |platform| Shellwords.escape(platform) }.join(" ")}" unless removed_platforms.empty?
  command << " --add-platform #{platforms.map { |platform| Shellwords.escape(platform) }.join(" ")}" unless platforms.empty?
  command << " --update"
  command << " #{update_gems.map { |gem_name| Shellwords.escape(gem_name) }.join(" ")}" unless update_gems.empty?
  # Bundler preserves BUNDLED WITH during a normal lockfile update.
  # Release lockfiles must record the Bundler that performed the final
  # reset, or the next release command can dirty them after the prep
  # commit by reconciling to a newer installed Bundler.
  command << " --bundler" if update_bundler
  command << " --add-checksums"
  command
end

#reset_lockfile!(path, full_update: false, platforms: nil, skip_changelog_dependency: false, update_bundler: false) ⇒ Object 



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 158

def reset_lockfile!(path, full_update: false, platforms: nil, skip_changelog_dependency: false, update_bundler: false)
  gemfile = gemfile_for_lockfile(path)
  unless gemfile && File.file?(gemfile)
    warn("Cannot reset #{display_path(path)} because its Gemfile was not found.")
    return
  end

  with_isolated_gem_paths do |gem_home|
    install_gemfile_bootstrap_gems!(gemfile: gemfile, lockfile: path, gem_home: gem_home)
    command = reset_command(
      path: path,
      gemfile: gemfile,
      full_update: full_update,
      platforms: platforms,
      skip_changelog_dependency: skip_changelog_dependency,
      update_bundler: update_bundler,
      isolated_gem_home: gem_home
    )
    if full_update || has_local_path_remote?(path)
      rebuild_lockfile(path) { command_runner.call(command) }
    else
      command_runner.call(command)
    end
  end
end

#reset_platforms(path) ⇒ Object 



220
221
222
223
224
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 220

def reset_platforms(path)
  platforms = lockfile_platforms(path)
  platforms = [Gem::Platform.local.to_s] if platforms.empty?
  platforms.reject(&:empty?).sort
end

#reset_update_gems(path) ⇒ Object 



247
248
249
250
251
252
253
254
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 247

def reset_update_gems(path)
  (
    path_source_gems(path).to_a |
    path_dependency_gems(path).to_a |
    empty_registry_checksums(path).map(&:first) |
    unreleased_workspace_registry_specs(path).map(&:first)
  ).uniq.sort
end

#template_local_environment? ⇒ Boolean

Returns:

  • (Boolean) 


355
356
357
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 355

def template_local_environment?
  %w[1 true yes on].include?(ENV.fetch("K_JEM_TEMPLATING", "").to_s.strip.downcase)
end

#unreleased_workspace_registry_specs(path) ⇒ Object 



435
436
437
438
439
440
441
442
443
444
445
446
 
# File 'lib/kettle/dev/lockfile_reset.rb', line 435

def unreleased_workspace_registry_specs(path)
  local_names = local_workspace_gem_names
  return [] if local_names.empty?

  source_urls = registry_source_urls(path)
  registry_specs_with_lines(path).filter_map do |name, version, line_number|
    next unless local_names.include?(name)
    next if gem_source_version_available?(name, version, source_urls)

    [name, version, line_number]
  end
end