Class: RBS::Collection::Config::LockfileGenerator

# File 'lib/rbs/collection/config/lockfile_generator.rb', line 31

def initialize(config:, definition:, with_lockfile:)
  @config = config

  @gem_entries = config.gems.each.with_object({}) do |entry, hash| #$ Hash[String, gem_entry?]
    name = entry["name"]
    hash[name] = entry
  end

  lockfile_path = Config.to_lockfile_path(config.config_path)
  lockfile_dir = lockfile_path.parent

  @lockfile = Lockfile.new(
    lockfile_path: lockfile_path,
    path: config.repo_path_data,
    gemfile_lock_path: definition.lockfile.relative_path_from(lockfile_dir)
  )

  if with_lockfile && lockfile_path.file?
    @existing_lockfile = Lockfile.from_lockfile(lockfile_path: lockfile_path, data: YAML.load_file(lockfile_path.to_s))
    validate_gemfile_lock_path!(lock: @existing_lockfile, gemfile_lock_path: definition.lockfile)
  end

  @definition = definition
  @gem_hash = definition.locked_gems.specs.each.with_object({}) do |spec, hash|  #$ Hash[String, Bundler::LazySpecification]
    hash[spec.name] = spec
  end
end

# File 'lib/rbs/collection/config/lockfile_generator.rb', line 25

def self.generate(config:, definition:, with_lockfile: true)
  generator = new(config: config, definition: definition, with_lockfile: with_lockfile)
  generator.generate
  generator.lockfile
end

# File 'lib/rbs/collection/config/lockfile_generator.rb', line 23

attr_reader :config, :lockfile, :definition, :existing_lockfile, :gem_hash, :gem_entries

# File 'lib/rbs/collection/config/lockfile_generator.rb', line 91

private def assign_gem(name:, version:, skip: false)
  entry = gem_entries[name]
  src_data = entry&.fetch("source", nil)
  ignored = entry&.fetch("ignore", false)

  return if ignored
  return if lockfile.gems.key?(name)

  unless skip
    # @type var locked: Lockfile::library?

    if existing_lockfile
      locked = existing_lockfile.gems[name]
    end

    # If rbs_collection.lock.yaml contain the gem, use it.
    # Else find the gem from gem_collection.
    unless locked
      source =
        if src_data
          Sources.from_config_entry(src_data, base_directory: config.config_path.dirname)
        else
          find_source(name: name)
        end

      if source
        installed_version = version
        best_version = find_best_version(version: installed_version, versions: source.versions(name))

        locked = {
          name: name,
          version: best_version.to_s,
          source: source,
        }
      end
    end

    if locked
      lockfile.gems[name] = locked

      begin
        locked[:source].dependencies_of(locked[:name], locked[:version])&.each do |dep|
          assign_stdlib(name: dep["name"], from_gem: name)
        end
      rescue
        RBS.logger.warn "Cannot find `#{locked[:name]}-#{locked[:version]}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
      end
    end
  end

  if spec = gem_hash.fetch(name, nil)
    spec.dependencies.each do |dep|
      if dep_spec = gem_hash[dep.name]
        assign_gem(name: dep.name, version: dep_spec.version)
      end
    end
  else
    RBS.logger.warn "Cannot find `#{name}` gem. Using incorrect Bundler context? (#{definition.lockfile})"
  end
end