Dagger.ModuleSource (dagger v0.18.3)

A content-hash of the module source. Module sources with the same digest will output the same generated context and convert into the same module instance.

directory(module_source, path)

The directory containing the module configuration and source code (source code may be in a subdir).

engine_version(module_source)

The engine version of the module.

generated_context_directory(module_source)

The generated files and directories made on top of the module source's context directory.

html_repo_url(module_source)

The URL to access the web view of the repository (e.g., GitHub, GitLab, Bitbucket).

html_url(module_source)

The URL to the source's git repo in a web browser. Only valid for git sources.

id(module_source)

A unique identifier for this ModuleSource.

kind(module_source)

The kind of module source (currently local, git or dir).

local_context_directory_path(module_source)

The full absolute path to the context directory on the caller's host filesystem that this module source is loaded from. Only valid for local module sources.

module_name(module_source)

The name of the module, including any setting via the withName API.

module_original_name(module_source)

The original name of the module as read from the module's dagger.json (or set for the first time with the withName API).

original_subpath(module_source)

The original subpath used when instantiating this module source, relative to the context directory.

pin(module_source)

The pinned version of this module source.

repo_root_path(module_source)

The import path corresponding to the root of the git repo this source points to. Only valid for git sources.

sdk(module_source)

The SDK configuration of the module.

source_root_subpath(module_source)

The path, relative to the context directory, that contains the module's dagger.json.

source_subpath(module_source)

The path to the directory containing the module's source code, relative to the context directory.

sync(module_source)

Forces evaluation of the module source, including any loading into the engine and associated validation.

version(module_source)

The specified version of the git repo this source points to.

with_client(module_source, generator, output_dir, optional_args \\ [])

Update the module source with a new client to generate.

with_dependencies(module_source, dependencies)

Append the provided dependencies to the module source's dependency list.

with_engine_version(module_source, version)

Upgrade the engine version of the module to the given value.

with_includes(module_source, patterns)

Update the module source with additional include patterns for files+directories from its context that are required for building it

with_name(module_source, name)

Update the module source with a new name.

with_sdk(module_source, source)

Update the module source with a new SDK.

with_source_subpath(module_source, path)

Update the module source with a new source subpath.

with_update_dependencies(module_source, dependencies)

Update one or more module dependencies.

without_dependencies(module_source, dependencies)

Remove the provided dependencies from the module source's dependency list.

Types

t()

@type t() :: %Dagger.ModuleSource{client: term(), query_builder: term()}

Functions

as_module(module_source)

@spec as_module(t()) :: Dagger.Module.t()

Load the source as a module. If this is a local source, the parent directory must have been provided during module source creation

as_string(module_source)

@spec as_string(t()) :: {:ok, String.t()} | {:error, term()}

A human readable ref string representation of this module source.

clone_ref(module_source)

@spec clone_ref(t()) :: {:ok, String.t()} | {:error, term()}

The ref to clone the root of the git repo from. Only valid for git sources.

commit(module_source)

@spec commit(t()) :: {:ok, String.t()} | {:error, term()}

The resolved commit of the git repo this source points to.

config_clients(module_source)

@spec config_clients(t()) :: {:ok, [Dagger.ModuleConfigClient.t()]} | {:error, term()}

The clients generated for the module.

config_exists(module_source)

@spec config_exists(t()) :: {:ok, boolean()} | {:error, term()}

Whether an existing dagger.json for the module was found.

context_directory(module_source)

@spec context_directory(t()) :: Dagger.Directory.t()

The full directory loaded for the module source, including the source code as a subdirectory.

dependencies(module_source)

@spec dependencies(t()) :: {:ok, [t()]} | {:error, term()}

The dependencies of the module source.

digest(module_source)

@spec digest(t()) :: {:ok, String.t()} | {:error, term()}