pkl

var MaybePreconfiguredOptions = func(opts *EvaluatorOptions) {
	if len(opts.AllowedResources) == 0 {
		WithDefaultAllowedResources(opts)
	}
	if len(opts.Env) == 0 {
		WithOsEnv(opts)
	}
	if len(opts.AllowedModules) == 0 {
		WithDefaultAllowedModules(opts)
	}
	if opts.CacheDir == "" {
		WithDefaultCacheDir(opts)
	}
	if opts.Logger == nil {
		opts.Logger = NoopLogger
	}
}

var NoopLogger = NewLogger(io.Discard)

var PreconfiguredOptions = func(opts *EvaluatorOptions) {
	WithDefaultAllowedResources(opts)
	WithOsEnv(opts)
	WithDefaultAllowedModules(opts)
	WithDefaultCacheDir(opts)
	opts.Logger = NoopLogger
}

var StderrLogger = NewLogger(os.Stdout)

var WithDefaultAllowedModules = func(opts *EvaluatorOptions) {
	opts.AllowedModules = append(opts.AllowedModules, "pkl:", "repl:", "file:", "http:", "https:", "modulepath:", "package:", "projectpackage:")
}

var WithDefaultAllowedResources = func(opts *EvaluatorOptions) {
	opts.AllowedResources = append(opts.AllowedResources, "http:", "https:", "file:", "env:", "prop:", "modulepath:", "package:", "projectpackage:")
}

var WithDefaultCacheDir = func(opts *EvaluatorOptions) {
	dirname, err := os.UserHomeDir()
	if err != nil {
		panic(err)
	}
	opts.CacheDir = filepath.Join(dirname, ".pkl/cache")
}

var WithExternalClientFs = func(fs fs.FS, scheme string) func(opts *ExternalReaderClientOptions) {
	return func(opts *ExternalReaderClientOptions) {
		reader := &fsReader{fs: fs, scheme: scheme}
		WithExternalClientModuleReader(&fsModuleReader{reader})(opts)
		WithExternalClientResourceReader(&fsResourceReader{reader})(opts)
	}
}

var WithExternalClientModuleReader = func(reader ModuleReader) func(*ExternalReaderClientOptions) {
	return func(options *ExternalReaderClientOptions) {
		options.ModuleReaders = append(options.ModuleReaders, reader)
	}
}

var WithExternalClientResourceReader = func(reader ResourceReader) func(*ExternalReaderClientOptions) {
	return func(options *ExternalReaderClientOptions) {
		options.ResourceReaders = append(options.ResourceReaders, reader)
	}
}

var WithExternalClientStreams = func(requestReader io.Reader, responseWriter io.Writer) func(*ExternalReaderClientOptions) {
	return func(options *ExternalReaderClientOptions) {
		options.RequestReader = requestReader
		options.ResponseWriter = responseWriter
	}
}

var WithExternalModuleReader = func(scheme string, spec ExternalReader) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		if opts.ExternalModuleReaders == nil {
			opts.ExternalModuleReaders = map[string]ExternalReader{}
		}
		opts.ExternalModuleReaders[scheme] = spec
		opts.AllowedModules = append(opts.AllowedModules, regexp.QuoteMeta(scheme+":"))
	}
}

var WithExternalResourceReader = func(scheme string, spec ExternalReader) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		if opts.ExternalResourceReaders == nil {
			opts.ExternalResourceReaders = map[string]ExternalReader{}
		}
		opts.ExternalResourceReaders[scheme] = spec
		opts.AllowedResources = append(opts.AllowedResources, regexp.QuoteMeta(scheme+":"))
	}
}

var WithFs = func(fs fs.FS, scheme string) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		reader := &fsReader{fs: fs, scheme: scheme}
		WithModuleReader(&fsModuleReader{reader})(opts)
		WithResourceReader(&fsResourceReader{reader})(opts)
	}
}

var WithModuleReader = func(reader ModuleReader) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		opts.ModuleReaders = append(opts.ModuleReaders, reader)
		opts.AllowedModules = append(opts.AllowedModules, regexp.QuoteMeta(reader.Scheme()+":"))
	}
}

var WithOsEnv = func(opts *EvaluatorOptions) {
	if opts.Env == nil {
		opts.Env = make(map[string]string)
	}
	for _, e := range os.Environ() {
		if i := strings.Index(e, "="); i >= 0 {
			opts.Env[e[:i]] = e[i+1:]
		}
	}
}

var WithProject = func(project *Project) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		WithProjectEvaluatorSettings(project)(opts)
		WithProjectDependencies(project)(opts)
	}
}

var WithProjectDependencies = func(project *Project) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		opts.ProjectBaseURI = strings.TrimSuffix(project.ProjectFileUri, "/PklProject")
		opts.DeclaredProjectDependencies = project.Dependencies()
	}
}

var WithProjectEvaluatorSettings = func(project *Project) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		evaluatorSettings := project.EvaluatorSettings
		opts.Properties = evaluatorSettings.ExternalProperties
		opts.Env = evaluatorSettings.Env
		if evaluatorSettings.AllowedModules != nil {
			opts.AllowedModules = *evaluatorSettings.AllowedModules
		}
		if evaluatorSettings.AllowedResources != nil {
			opts.AllowedResources = *evaluatorSettings.AllowedResources
		}
		if evaluatorSettings.NoCache != nil && *evaluatorSettings.NoCache {
			opts.CacheDir = ""
		} else {
			opts.CacheDir = evaluatorSettings.ModuleCacheDir
		}
		opts.RootDir = evaluatorSettings.RootDir
		if evaluatorSettings.Http != nil {
			opts.Http = &Http{}
			if evaluatorSettings.Http.Proxy != nil {
				opts.Http.Proxy = &Proxy{NoProxy: opts.Http.Proxy.NoProxy}
				if evaluatorSettings.Http.Proxy.Address != nil {
					opts.Http.Proxy.Address = *evaluatorSettings.Http.Proxy.Address
				}
			}
			if evaluatorSettings.Http.Rewrites != nil {
				opts.Http.Rewrites = *evaluatorSettings.Http.Rewrites
			}
		}
		if evaluatorSettings.ExternalModuleReaders != nil {
			opts.ExternalModuleReaders = make(map[string]ExternalReader, len(evaluatorSettings.ExternalModuleReaders))
			for scheme, reader := range evaluatorSettings.ExternalModuleReaders {
				opts.ExternalModuleReaders[scheme] = ExternalReader(reader)
				if evaluatorSettings.AllowedModules == nil {
					WithDefaultAllowedModules(opts)
					opts.AllowedModules = append(opts.AllowedModules, regexp.QuoteMeta(scheme+":"))
				}
			}
		}
		if evaluatorSettings.ExternalResourceReaders != nil {
			opts.ExternalResourceReaders = make(map[string]ExternalReader, len(evaluatorSettings.ExternalResourceReaders))
			for scheme, reader := range evaluatorSettings.ExternalResourceReaders {
				opts.ExternalResourceReaders[scheme] = ExternalReader(reader)
				if evaluatorSettings.AllowedResources == nil {
					WithDefaultAllowedResources(opts)
					opts.AllowedResources = append(opts.AllowedResources, regexp.QuoteMeta(scheme+":"))
				}
			}
		}
		if evaluatorSettings.TraceMode != nil {
			opts.TraceMode = *evaluatorSettings.TraceMode
		}
	}
}

var WithResourceReader = func(reader ResourceReader) func(opts *EvaluatorOptions) {
	return func(opts *EvaluatorOptions) {
		opts.ResourceReaders = append(opts.ResourceReaders, reader)
		opts.AllowedResources = append(opts.AllowedResources,