class RuboCop::Lockfile

def dependencies
  return [] unless parser
  parser.dependencies.values
end

def gem_versions(include_transitive_dependencies: true)
  return {} unless parser
  all_gem_versions = parser.specs.to_h { |spec| [spec.name, spec.version] }
  if include_transitive_dependencies
    all_gem_versions
  else
    direct_dep_names = parser.dependencies.keys
    all_gem_versions.slice(*direct_dep_names)
  end
end

def gems
  return [] unless parser
  # `Bundler::LockfileParser` returns `Bundler::LazySpecification` objects
  # which are not resolved, so extract the dependencies from them
  parser.dependencies.values.concat(parser.specs.flat_map(&:dependencies))
end

def includes_gem?(name)
  gems.any? { |gem| gem.name == name }
end

def initialize(lockfile_path = nil)
  lockfile_path ||= begin
    ::Bundler.default_lockfile if use_bundler_lock_parser?
  rescue ::Bundler::GemfileNotFound
    nil # We might not be a folder with a Gemfile, but that's okay.
  end
  @lockfile_path = lockfile_path
end

def parser
  return @parser if defined?(@parser)
  @parser = if @lockfile_path && File.exist?(@lockfile_path) && use_bundler_lock_parser?
              begin
                lockfile = ::Bundler.read_file(@lockfile_path)
                ::Bundler::LockfileParser.new(lockfile) if lockfile
              rescue ::Bundler::BundlerError
                nil
              end
            end
end

def use_bundler_lock_parser?
  return false unless Object.const_defined?(:Bundler)
  Bundler.const_defined?(:LockfileParser) && Bundler::VERSION >= '2.0'
end