# `Igniter.Project.Module`
[🔗](https://github.com/ash-project/igniter/blob/v0.8.3/lib/igniter/project/module.ex#L5)

Codemods and utilities for interacting with modules

# `location_type`

```elixir
@type location_type() ::
  :source_folder | {:source_folder, String.t()} | :test | :test_support
```

Placement instruction for a module.

- `:source_folder` - The first source folder of the project
- `{:source_folder, path}` - The selected source folder, i.e `"lib"`
- `:test` - Creating a test file
- `:test_support` - Creating a test support file

# `create_module`

Creates a new file & module in its appropriate location.

## Options

- `:location` - A location type. See `t:location_type/0` for more.

# `find_all_matching_modules`

```elixir
@spec find_all_matching_modules(igniter :: Igniter.t(), (module(),
                                                   Sourceror.Zipper.t() ->
                                                     boolean())) ::
  {Igniter.t(), [module()]}
```

# `find_and_update_module`

```elixir
@spec find_and_update_module(Igniter.t(), module(), (Sourceror.Zipper.t() ->
                                                 {:ok, Sourceror.Zipper.t()}
                                                 | :error)) ::
  {:ok, Igniter.t()} | {:error, Igniter.t()}
```

Finds a module and updates its contents. Returns `{:error, igniter}` if the module could not be found. Do not discard this igniter.

# `find_and_update_module!`

```elixir
@spec find_and_update_module!(Igniter.t(), module(), (Sourceror.Zipper.t() ->
                                                  {:ok, Sourceror.Zipper.t()}
                                                  | :error)) ::
  Igniter.t()
```

Finds a module and updates its contents. Raises an error if it doesn't exist

# `find_and_update_or_create_module`

Finds a module and updates its contents wherever it is.

If the module does not yet exist, it is created with the provided contents. In that case,
the path is determined with `Igniter.Code.Module.proper_location/2`, but may optionally be overwritten with options below.

# Options

- `:path` - Path where to create the module, relative to the project root. Default: `nil` (uses `:kind` to determine the path).

# `find_module`

```elixir
@spec find_module(Igniter.t(), module()) ::
  {:ok, {Igniter.t(), Rewrite.Source.t(), Sourceror.Zipper.t()}}
  | {:error, Igniter.t()}
```

Finds a module, returning a new igniter, and the source and zipper location. This new igniter should not be discarded.

In general, you should not use the returned source and zipper to update the module, instead, use this to interrogate
the contents or source in some way, and then call `find_and_update_module/3` with a function to perform an update.

# `find_module!`

```elixir
@spec find_module!(Igniter.t(), module()) ::
  {Igniter.t(), Rewrite.Source.t(), Sourceror.Zipper.t()} | no_return()
```

Finds a module, raising an error if its not found.

See `find_module/2` for more information.

# `module_exists`

```elixir
@spec module_exists(Igniter.t(), module()) :: {boolean(), Igniter.t()}
```

Checks if a module is defined somewhere in the project. The returned igniter should not be discarded.

# `module_exists?`

> This function is deprecated. Use `module_exists/2` instead..

Checks if a module is defined somewhere in the project. The returned igniter should not be discarded.

# `module_name`

```elixir
@spec module_name(Igniter.t(), String.t()) :: module()
```

Given a suffix, returns a module name with the prefix of the current project.

# `module_name_prefix`

```elixir
@spec module_name_prefix(Igniter.t()) :: module()
```

The module name prefix based on the mix project's module name

# `parse`

```elixir
@spec parse(String.t()) :: module()
```

Parses a string into a module name

# `proper_location`

```elixir
@spec proper_location(Igniter.t(), module(), location_type()) :: String.t()
```

Determines where a module should be placed in a project.

---

*Consult [api-reference.md](api-reference.md) for complete listing*