defmodule Rewrite do
@moduledoc """
`Rewrite` is a tool for modifying, adding and removing files in a `Mix` project.
The package is intended for use in `Mix` tasks. `Rewrite` itself uses functions
provided by `Mix`.
With `Rewrite.read!/2` you can load the whole project. Then you can modify the
project with a number of functions provided by `Rewrite` and `Rewrite.Source`
without writing any changes back to the file system. All changes are stored in
the source structs. Any version of a source is available in the project. To
write the whole project back to the file system, the `Rewrite.write_all/2` can
be used.
Elixir source files can be modified by modifying the AST. For this `Rewrite`
uses the `Sourceror` package to create the AST and to convert it back. The
`Sourceror` package also provides all the utilities needed to manipulate the
AST.
Sources can also receive a `Rewrite.Issue` to document problems or information
with the source.
`Rewrite` respects the `.formatter.exs` in the project when rewriting sources.
To do this, the formatter can be read by `Rewrite.DotFormatter` and the
resulting DotFormatter struct can be used in the function to update the
sources.
"""
alias Rewrite.DotFormatter
alias Rewrite.Error
alias Rewrite.Source
alias Rewrite.SourceError
alias Rewrite.UpdateError
defstruct sources: %{},
extensions: %{},
hooks: [],
dot_formatter: nil,
excluded: []
@type t :: %Rewrite{
sources: %{Path.t() => Source.t()},
extensions: %{String.t() => [module()]},
hooks: [module()],
dot_formatter: DotFormatter.t() | nil,
excluded: [Path.t()]
}
@type input :: Path.t() | wildcard() | GlobEx.t()
@type wildcard :: IO.chardata()
@type opts :: keyword()
@type by :: module()
@type key :: atom()
@type updater :: (term() -> term())
@doc """
Creates an empty project.
## Options
* `:filetypes` - a list of modules implementing the behavior
`Rewrite.Filetype`. This list is used to add the `filetype` to the
`sources` of the corresponding files. The list can contain modules
representing a file type or a tuple of `{module(), keyword()}`. Rewrite
uses the keyword list from the tuple as the options argument when a file
is read.
Defaults to `[Rewrite.Source, Rewrite.Source.Ex]`.
* `:dot_formatter` - a `%DotFormatter{}` that is used to format sources.
To get and update a dot formatter see `dot_formatter/2` and to create one
see `Rewrite.DotFormatter`.
## Examples
iex> project = Rewrite.new()
iex> path = "test/fixtures/source/hello.txt"
iex> project = Rewrite.read!(project, path)
iex> project |> Rewrite.source!(path) |> Source.get(:content)
"hello\\n"
iex> project |> Rewrite.source!(path) |> Source.owner()
Rewrite
iex> project = Rewrite.new(filetypes: [{Rewrite.Source, owner: MyApp}])
iex> path = "test/fixtures/source/hello.txt"
iex> project = Rewrite.read!(project, path)
iex> project |> Rewrite.source!(path) |> Source.owner()
MyApp
"""
@spec new(keyword()) :: t()
def new(opts \\ []) do
Rewrite
|> struct!(
extensions: extensions(opts),
hooks: Keyword.get(opts, :hooks, [])
)
|> dot_formatter(Keyword.get(opts, :dot_formatter))
|> handle_hooks(:new)
end
@doc """
Creates a `%Rewrite{}` from the given `inputs`.
## Options
* Accepts the same options as `new/1`.
* 'exclude' - a list of paths and/or glob expressions to exclude sources
from the project. The option also accepts a predicate function which is
called for each source path. The exclusion takes place before the file is
read.
"""
@spec new!(input() | [input()], opts) :: t()
def new!(inputs, opts \\ []) do
opts |> new() |> read!(inputs, opts)
end
@doc """
Reads the given `input`/`inputs` and adds the source/sources to the `project`
when not already readed.
## Options
* `:force`, default: `false` - forces the reading of sources. With
`force: true` updates and issues for an already existing source are
deleted.
* `:exclude` - a list of paths and/or glob expressions to exclude sources
from the project. The option also accepts a predicate function which is
called for each source path. The exclusion takes place before the file is
read.
"""
@spec read!(t(), input() | [input()], opts()) :: t()
def read!(%Rewrite{} = rewrite, inputs, opts \\ []) do
reader = rewrite.sources |> Map.keys() |> reader(rewrite.extensions, opts)
inputs = expand(inputs)
{added, excluded, sources} =
Rewrite.TaskSupervisor
|> Task.Supervisor.async_stream_nolink(inputs, reader)
|> Enum.reduce({[], [], rewrite.sources}, fn
{:ok, {path, :excluded}}, {added, excluded, sources} ->
{added, [path | excluded], sources}
{:ok, {path, source}}, {added, excluded, sources} ->
{[path | added], excluded, Map.put(sources, path, source)}
{:exit, {error, _stacktrace}}, _sources when is_exception(error) ->
raise error
end)
rewrite
|> Map.put(:sources, sources)
|> Map.update!(:excluded, fn list -> list |> Enum.concat(excluded) |> Enum.uniq() end)
|> handle_hooks({:added, added})
end
defp reader(paths, extensions, opts) do
force = Keyword.get(opts, :force, false)
exclude? = opts |> Keyword.get(:exclude) |> exclude()
fn path ->
Logger.disable(self())
if exclude?.(path) || File.dir?(path) || (!force && path in paths) do
{path, :excluded}
else
source = read_source!(path, extensions)
{path, source}
end
end
end
defp exclude(nil) do
fn _path -> false end
end
defp exclude(list) when is_list(list) do
globs =
Enum.map(list, fn
%GlobEx{} = glob -> glob
path -> GlobEx.compile!(path)
end)
fn path ->
Enum.any?(globs, fn glob -> GlobEx.match?(glob, path) end)
end
end
defp exclude(fun) when is_function(fun, 1), do: fun
defp read_source!(path, extensions) when not is_nil(path) do
{source, opts} = extension_for_file(extensions, path)
source.read!(path, opts)
end
@doc """
Returns the extension of the given `file`.
"""
@spec extension_for_file(t() | map(), Path.t() | nil) :: {module(), opts()}
def extension_for_file(%Rewrite{extensions: extensions}, path) do
extension_for_file(extensions, path)
end
def extension_for_file(extensions, path) do
ext = if path, do: Path.extname(path)
default = Map.fetch!(extensions, "default")
case Map.get(extensions, ext, default) do
{module, opts} -> {module, opts}
module -> {module, []}
end
end
@doc """
Puts the given `source` to the given `rewrite` project.
Returns `{:ok, rewrite}` if successful, `{:error, reason}` otherwise.
## Examples
iex> project = Rewrite.new()
iex> {:ok, project} = Rewrite.put(project, Source.from_string(":a", path: "a.exs"))
iex> map_size(project.sources)
1
iex> Rewrite.put(project, Source.from_string(":b"))
{:error, %Rewrite.Error{reason: :nopath}}
iex> Rewrite.put(project, Source.from_string(":a", path: "a.exs"))
{:error, %Rewrite.Error{reason: :overwrites, path: "a.exs"}}
"""
@spec put(t(), Source.t()) :: {:ok, t()} | {:error, Error.t()}
def put(%Rewrite{}, %Source{path: nil}), do: {:error, Error.exception(reason: :nopath)}
def put(%Rewrite{sources: sources} = rewrite, %Source{path: path} = source) do
case Map.has_key?(sources, path) do
true ->
{:error, Error.exception(reason: :overwrites, path: path)}
false ->
rewrite = %{rewrite | sources: Map.put(sources, path, source)}
rewrite = handle_hooks(rewrite, {:added, [path]})
{:ok, rewrite}
end
end
@doc """
Same as `put/2`, but raises a `Rewrite.Error` exception in case of failure.
"""
@spec put!(t(), Source.t()) :: t()
def put!(%Rewrite{} = rewrite, %Source{} = source) do
case put(rewrite, source) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Deletes the source for the given `path` from the `rewrite`.
The file system files are not removed, even if the project is written. Use
`rm/2` or `rm!/2` to delete a file and source.
If the source is not part of the `rewrite` project the unchanged `rewrite` is
returned.
## Examples
iex> {:ok, project} = Rewrite.from_sources([
...> Source.from_string(":a", path: "a.exs"),
...> Source.from_string(":b", path: "b.exs"),
...> Source.from_string(":a", path: "c.exs")
...> ])
iex> Rewrite.paths(project)
["a.exs", "b.exs", "c.exs"]
iex> project = Rewrite.delete(project, "a.exs")
iex> Rewrite.paths(project)
["b.exs", "c.exs"]
iex> project = Rewrite.delete(project, "b.exs")
iex> Rewrite.paths(project)
["c.exs"]
iex> project = Rewrite.delete(project, "b.exs")
iex> Rewrite.paths(project)
["c.exs"]
"""
@spec delete(t(), Path.t()) :: t()
def delete(%Rewrite{sources: sources} = rewrite, path) when is_binary(path) do
%{rewrite | sources: Map.delete(sources, path)}
end
@doc """
Drops the sources with the given `paths` from the `rewrite` project.
The file system files are not removed, even if the project is written. Use
`rm/2` or `rm!/2` to delete a file and source.
If `paths` contains paths that are not in `rewrite`, they're simply ignored.
## Examples
iex> {:ok, project} = Rewrite.from_sources([
...> Source.from_string(":a", path: "a.exs"),
...> Source.from_string(":b", path: "b.exs"),
...> Source.from_string(":a", path: "c.exs")
...> ])
iex> project = Rewrite.drop(project, ["a.exs", "b.exs", "z.exs"])
iex> Rewrite.paths(project)
["c.exs"]
"""
@spec drop(t(), [Path.t()]) :: t()
def drop(%Rewrite{} = rewrite, paths) when is_list(paths) do
Enum.reduce(paths, rewrite, fn source, rewrite -> delete(rewrite, source) end)
end
@doc """
Tries to delete the `source` file in the file system and removes the `source`
from the `rewrite` project.
Returns `{:ok, rewrite}` if successful, or `{:error, error}` if an error
occurs.
Note the file is deleted even if in read-only mode.
"""
@spec rm(t(), Source.t() | Path.t()) ::
{:ok, t()} | {:error, Error.t() | SourceError.t()}
def rm(%Rewrite{} = rewrite, %Source{} = source) do
with :ok <- Source.rm(source) do
{:ok, delete(rewrite, source.path)}
end
end
def rm(%Rewrite{} = rewrite, source) when is_binary(source) do
with {:ok, source} <- source(rewrite, source) do
rm(rewrite, source)
end
end
@doc """
Same as `source/2`, but raises a `Rewrite.Error` exception in case of failure.
"""
@spec rm!(t(), Source.t() | Path.t()) :: t()
def rm!(%Rewrite{} = rewrite, source) when is_binary(source) or is_struct(source, Source) do
case rm(rewrite, source) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Moves a source from one path to another.
"""
@spec move(t(), Source.t() | Path.t(), Path.t(), module()) :: {:ok, t()} | {:error, term()}
def move(rewrite, from, to, by \\ Rewrite)
def move(%Rewrite{} = rewrite, from, to, by)
when is_struct(from, Source) and is_binary(to) and is_atom(by) do
case Map.has_key?(rewrite.sources, to) do
true ->
{:error, UpdateError.exception(reason: :overwrites, path: to, source: from)}
false ->
update(rewrite, from.path, fn source ->
Source.update(source, :path, to, by: by)
end)
end
end
def move(%Rewrite{} = rewrite, from, to, by)
when is_binary(from) and is_binary(to) and is_atom(by) do
with {:ok, source} <- source(rewrite, from) do
move(rewrite, source, to, by)
end
end
@doc """
Same as `move/4`, but raises an exception in case of failure.
"""
@spec move!(t(), Source.t() | Path.t(), Path.t(), module()) :: t()
def move!(%Rewrite{} = rewrite, from, to, by \\ Rewrite) do
case move(rewrite, from, to, by) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Returns a sorted list of all paths in the `rewrite` project.
"""
@spec paths(t()) :: [Path.t()]
def paths(%Rewrite{sources: sources}) do
sources |> Map.keys() |> Enum.sort()
end
@doc """
Returns `true` if any source in the `rewrite` project returns `true` for
`Source.updated?/1`.
## Examples
iex> {:ok, project} = Rewrite.from_sources([
...> Source.Ex.from_string(":a", path: "a.exs"),
...> Source.Ex.from_string(":b", path: "b.exs"),
...> Source.Ex.from_string("c", path: "c.txt")
...> ])
iex> Rewrite.updated?(project)
false
iex> project = Rewrite.update!(project, "a.exs", fn source ->
...> Source.update(source, :quoted, ":z")
...> end)
iex> Rewrite.updated?(project)
true
"""
@spec updated?(t()) :: boolean()
def updated?(%Rewrite{} = rewrite) do
rewrite.sources |> Map.values() |> Enum.any?(fn source -> Source.updated?(source) end)
end
@doc ~S"""
Creates a `%Rewrite{}` from the given sources.
Returns `{:ok, rewrite}` for a list of regular sources.
Returns `{:error, error}` for sources with a missing path and/or duplicated
paths.
"""
@spec from_sources([Source.t()], opts()) :: {:ok, t()} | {:error, term()}
def from_sources(sources, opts \\ []) when is_list(sources) do
{sources, missing, duplicated} =
Enum.reduce(sources, {%{}, [], []}, fn %Source{} = source, {sources, missing, duplicated} ->
cond do
is_nil(source.path) ->
{sources, [source | missing], duplicated}
Map.has_key?(sources, source.path) ->
{sources, missing, [source | duplicated]}
true ->
{Map.put(sources, source.path, source), missing, duplicated}
end
end)
if Enum.empty?(missing) && Enum.empty?(duplicated) do
rewrite = new(opts)
rewrite = %{rewrite | sources: sources}
rewrite =
rewrite
|> Map.put(:sources, sources)
|> handle_hooks({:added_sources, sources})
{:ok, rewrite}
else
{:error,
Error.exception(
reason: :invalid_sources,
missing_paths: missing,
duplicated_paths: duplicated
)}
end
end
@doc """
Same as `from_sources/2`, but raises a `Rewrite.Error` exception in case of
failure.
"""
@spec from_sources!([Source.t()], opts()) :: t()
def from_sources!(sources, opts \\ []) when is_list(sources) do
case from_sources(sources, opts) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Returns all sources sorted by path.
"""
@spec sources(t()) :: [Source.t()]
def sources(%Rewrite{sources: sources}) do
sources
|> Map.values()
|> Enum.sort_by(fn source -> source.path end)
end
@doc """
Returns the `%Rewrite.Source{}` for the given `path`.
Returns an `:ok` tuple with the found source, if not exactly one source is
available an `:error` is returned.
See also `sources/2` to get a list of sources for a given `path`.
"""
@spec source(t(), Path.t()) :: {:ok, Source.t()} | {:error, Error.t()}
def source(%Rewrite{sources: sources}, path) when is_binary(path) do
with :error <- Map.fetch(sources, path) do
{:error, Error.exception(reason: :nosource, path: path)}
end
end
@doc """
Same as `source/2`, but raises a `Rewrite.Error` exception in case of
failure.
"""
@spec source!(t(), Path.t()) :: Source.t()
def source!(%Rewrite{} = rewrite, path) do
case source(rewrite, path) do
{:ok, source} -> source
{:error, error} -> raise error
end
end
@doc """
Updates the given `source` in the `rewrite` project.
This function will be usually used if the `path` for the `source` has not
changed.
Returns `{:ok, rewrite}` if successful, `{:error, error}` otherwise.
"""
@spec update(t(), Source.t()) ::
{:ok, t()} | {:error, Error.t()}
def update(%Rewrite{}, %Source{path: nil}),
do: {:error, Error.exception(reason: :nopath)}
def update(%Rewrite{} = rewrite, %Source{} = source) do
update(rewrite, source.path, source)
end
@doc """
The same as `update/2` but raises a `Rewrite.Error` exception in case
of an error.
"""
@spec update!(t(), Source.t()) :: t()
def update!(%Rewrite{} = rewrite, %Source{} = source) do
case update(rewrite, source) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Updates a source for the given `path` in the `rewrite` project.
If `source` a `Rewrite.Source` struct the struct is used to update the
`rewrite` project.
If `source` is a function the source for the given `path` is passed to the
function and the result is used to update the `rewrite` project.
Returns `{:ok, rewrite}` if the update was successful, `{:error, error}`
otherwise.
## Examples
iex> a = Source.Ex.from_string(":a", path: "a.exs")
iex> b = Source.Ex.from_string(":b", path: "b.exs")
iex> {:ok, project} = Rewrite.from_sources([a, b])
iex> {:ok, project} = Rewrite.update(project, "a.exs", Source.Ex.from_string(":foo", path: "a.exs"))
iex> project |> Rewrite.source!("a.exs") |> Source.get(:content)
":foo"
iex> {:ok, project} = Rewrite.update(project, "a.exs", fn s -> Source.update(s, :content, ":baz") end)
iex> project |> Rewrite.source!("a.exs") |> Source.get(:content)
":baz"
iex> {:ok, project} = Rewrite.update(project, "a.exs", fn s -> Source.update(s, :path, "c.exs") end)
iex> Rewrite.paths(project)
["b.exs", "c.exs"]
iex> Rewrite.update(project, "no.exs", Source.from_string(":foo", path: "x.exs"))
{:error, %Rewrite.Error{reason: :nosource, path: "no.exs"}}
iex> Rewrite.update(project, "c.exs", Source.from_string(":foo"))
{:error, %Rewrite.UpdateError{reason: :nopath, source: "c.exs"}}
iex> Rewrite.update(project, "c.exs", fn _ -> b end)
{:error, %Rewrite.UpdateError{reason: :overwrites, path: "b.exs", source: "c.exs"}}
"""
@spec update(t(), Path.t(), Source.t() | function()) ::
{:ok, t()} | {:error, Error.t() | UpdateError.t()}
def update(%Rewrite{}, path, %Source{path: nil}) when is_binary(path) do
{:error, UpdateError.exception(reason: :nopath, source: path)}
end
def update(%Rewrite{} = rewrite, path, %Source{} = source)
when is_binary(path) do
with {:ok, _stored} <- source(rewrite, path) do
do_update(rewrite, path, source)
end
end
def update(%Rewrite{} = rewrite, path, fun) when is_binary(path) and is_function(fun, 1) do
with {:ok, stored} <- source(rewrite, path),
{:ok, source} <- apply_update!(stored, fun) do
do_update(rewrite, path, source)
end
end
defp do_update(rewrite, path, source) do
case path == source.path do
true ->
rewrite = %{rewrite | sources: Map.put(rewrite.sources, path, source)}
rewrite = handle_hooks(rewrite, {:updated, path})
{:ok, rewrite}
false ->
case Map.has_key?(rewrite.sources, source.path) do
true ->
{:error, UpdateError.exception(reason: :overwrites, path: source.path, source: path)}
false ->
sources = rewrite.sources |> Map.delete(path) |> Map.put(source.path, source)
{:ok, %{rewrite | sources: sources}}
end
end
end
defp apply_update!(source, fun) do
case fun.(source) do
%Source{path: nil} ->
{:error, UpdateError.exception(reason: :nopath, source: source.path)}
%Source{} = source ->
{:ok, source}
got ->
raise RuntimeError, """
expected %Source{} from anonymous function given to Rewrite.update/3, got: #{inspect(got)}\
"""
end
end
@doc """
The same as `update/3` but raises a `Rewrite.Error` exception in case
of an error.
"""
@spec update!(t(), Path.t(), Source.t() | function()) :: t()
def update!(%Rewrite{} = rewrite, path, new) when is_binary(path) do
case update(rewrite, path, new) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Updates the source for the given `path` and `key` with the given `fun`.
The function combines `update/3` and `Source.update/4` in one call.
## Examples
iex> project =
...> Rewrite.new()
...> |> Rewrite.new_source!("test.md", "foo")
...> |> Rewrite.update_source!("test.md", :content, fn content ->
...> content <> "bar"
...> end)
...> |> Rewrite.update_source!("test.md", :content, &String.upcase/1, by: MyApp)
iex> source = Rewrite.source!(project, "test.md")
iex> source.content
"FOOBAR"
iex> source.history
[{:content, MyApp, "foobar"}, {:content, Rewrite, "foo"}]
"""
@spec update_source(t(), Path.t(), key(), updater(), opts()) ::
{:ok, t()} | {:error, term()}
def update_source(%Rewrite{} = rewrite, path, key, fun, opts \\ []) do
update(rewrite, path, fn source ->
Source.update(source, key, fun, opts)
end)
end
@doc """
The same as `update_source/5` but raises a `Rewrite.Error` exception in case
of an error.
"""
@spec update_source!(t(), Path.t(), key(), updater(), opts()) :: t()
def update_source!(%Rewrite{} = rewrite, path, key, fun, opts \\ []) do
case update_source(rewrite, path, key, fun, opts) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Returns `true` when the `%Rewrite{}` contains a `%Source{}` with the given
`path`.
## Examples
iex> {:ok, project} = Rewrite.from_sources([
...> Source.from_string(":a", path: "a.exs")
...> ])
iex> Rewrite.has_source?(project, "a.exs")
true
iex> Rewrite.has_source?(project, "b.exs")
false
"""
@spec has_source?(t(), Path.t()) :: boolean()
def has_source?(%Rewrite{sources: sources}, path) when is_binary(path) do
Map.has_key?(sources, path)
end
@doc """
Returns `true` if any source has one or more issues.
"""
@spec issues?(t) :: boolean
def issues?(%Rewrite{sources: sources}) do
sources
|> Map.values()
|> Enum.any?(fn %Source{issues: issues} -> not Enum.empty?(issues) end)
end
@doc """
Counts the sources with the given `extname` in the `rewrite` project.
"""
@spec count(t, String.t()) :: non_neg_integer
def count(%Rewrite{sources: sources}, extname) when is_binary(extname) do
sources
|> Map.keys()
|> Enum.count(fn path -> Path.extname(path) == extname end)
end
@doc """
Invokes `fun` for each `source` in the `rewrite` project and updates the
`rewirte` project with the result of `fun`.
Returns a `{:ok, rewrite}` if any update is successful.
Returns `{:error, errors, rewrite}` where `rewrite` is updated for all sources
that are updated successful. The `errors` are the `errors` of `update/3`.
"""
@spec map(t(), (Source.t() -> Source.t())) ::
{:ok, t()} | {:error, [{:nosource | :overwrites | :nopath, Source.t()}]}
def map(%Rewrite{} = rewrite, fun) when is_function(fun, 1) do
{rewrite, errors} =
Enum.reduce(rewrite, {rewrite, []}, fn source, {rewrite, errors} ->
with {:ok, updated} <- apply_update!(source, fun),
{:ok, rewrite} <- do_update(rewrite, source.path, updated) do
{rewrite, errors}
else
{:error, error} -> {rewrite, [error | errors]}
end
end)
if Enum.empty?(errors) do
{:ok, rewrite}
else
{:error, errors, rewrite}
end
end
@doc """
Return a `rewrite` project where each `source` is the result of invoking
`fun` on each `source` of the given `rewrite` project.
"""
@spec map!(t(), (Source.t() -> Source.t())) :: t()
def map!(%Rewrite{} = rewrite, fun) when is_function(fun, 1) do
Enum.reduce(rewrite, rewrite, fn source, rewrite ->
with {:ok, updated} <- apply_update!(source, fun),
{:ok, rewrite} <- do_update(rewrite, source.path, updated) do
rewrite
else
{:error, error} -> raise error
end
end)
end
@doc """
Writes a source to disk.
The function expects a path or a `%Source{}` as first argument.
Returns `{:ok, rewrite}` if the file was written successful. See also
`Source.write/2`.
If the given `source` is not part of the `rewrite` project then it is added.
"""
@spec write(t(), Path.t() | Source.t(), nil | :force) ::
{:ok, t()} | {:error, Error.t() | SourceError.t()}
def write(rewrite, path, force \\ nil)
def write(%Rewrite{} = rewrite, path, force) when is_binary(path) and force in [nil, :force] do
with {:ok, source} <- source(rewrite, path) do
write(rewrite, source, force)
end
end
def write(%Rewrite{} = rewrite, %Source{} = source, force) when force in [nil, :force] do
with {:ok, source} <- Source.write(source) do
{:ok, Rewrite.update!(rewrite, source)}
end
end
@doc """
The same as `write/3` but raises an exception in case of an error.
"""
@spec write!(t(), Path.t() | Source.t(), nil | :force) :: t()
def write!(%Rewrite{} = rewrite, source, force \\ nil) do
case write(rewrite, source, force) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Writes all sources in the `rewrite` project to disk.
This function calls `Rewrite.Source.write/1` on all sources in the `rewrite`
project.
Returns `{:ok, rewrite}` if all sources are written successfully.
Returns `{:error, reasons, rewrite}` where `rewrite` is updated for all
sources that are written successfully.
## Options
+ `exclude` - a list paths to exclude form writting.
+ `force`, default: `false` - forces the writting of unchanged files.
"""
@spec write_all(t(), opts()) ::
{:ok, t()} | {:error, [SourceError.t()], t()}
def write_all(%Rewrite{} = rewrite, opts \\ []) do
exclude = Keyword.get(opts, :exclude, [])
force = if Keyword.get(opts, :force, false), do: :force, else: nil
write_all(rewrite, exclude, force)
end
defp write_all(%Rewrite{sources: sources} = rewrite, exclude, force)
when force in [nil, :force] do
sources = for {path, source} <- sources, path not in exclude, do: source
writer = fn source -> Source.write(source, force: force) end
{rewrite, errors} =
Rewrite.TaskSupervisor
|> Task.Supervisor.async_stream_nolink(sources, writer)
|> Enum.reduce({rewrite, []}, fn {:ok, result}, {rewrite, errors} ->
case result do
{:ok, source} -> {Rewrite.update!(rewrite, source), errors}
{:error, error} -> {rewrite, [error | errors]}
end
end)
if Enum.empty?(errors) do
{:ok, rewrite}
else
{:error, errors, rewrite}
end
end
@doc """
Formats the given `rewrite` project with the given `dot_formatter`.
Uses the formatter from `dot_formatter/2` if no formatter ist set by
`:dot_formatter` in the options. The other options are the same as for
`DotFormatter.read!/2`.
"""
@spec format(t(), opts()) :: {:ok, t()} | {:error, term()}
def format(%Rewrite{} = rewrite, opts \\ []) do
dot_formatter = Keyword.get(opts, :dot_formatter, dot_formatter(rewrite))
DotFormatter.format_rewrite(dot_formatter, rewrite, opts)
end
@doc """
The same as `format/2` but raises an exception in case of an error.
"""
@spec format!(t(), opts()) :: t()
def format!(rewrite, opts \\ []) do
case format(rewrite, opts) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Formats a source in a `rewrite` project.
Uses the formatter from `dot_formatter/2` if no formatter ist set by
`:dot_formatter` in the options. The other options are the same as for
`Code.format_string!/2`.
"""
@spec format_source(t(), Path.t() | Source.t(), keyword()) :: {:ok, t()} | {:error, term()}
def format_source(rewrite, file, opts \\ [])
def format_source(%Rewrite{} = rewrite, %Source{path: path}, opts) when is_binary(path) do
format_source(rewrite, path, opts)
end
def format_source(%Rewrite{} = rewrite, file, opts) do
dot_formatter = Keyword.get_lazy(opts, :dot_formatter, fn -> dot_formatter(rewrite) end)
DotFormatter.format_source(dot_formatter, rewrite, file, opts)
end
@doc """
The same as `format_source/3` but raises an exception in case of an error.
"""
@spec format_source!(t(), Path.t() | Source.t(), keyword()) :: t()
def format_source!(rewrite, file, opts \\ []) do
case format_source(rewrite, file, opts) do
{:ok, source} -> source
{:error, error} -> raise error
end
end
@doc """
Returns the `DotFormatter` for the given `rewrite` project.
When no formatter is set, the default formatter from
`Rewrite.DotFormatter.default/0` is returned. A dot formatter can be set with
`dot_formatter/2`.
"""
@spec dot_formatter(t()) :: DotFormatter.t()
def dot_formatter(%Rewrite{dot_formatter: nil}), do: DotFormatter.default()
def dot_formatter(%Rewrite{dot_formatter: dot_formatter}), do: dot_formatter
@doc """
Sets a `dot_formatter` for the given `rewrite` project.
"""
@spec dot_formatter(t(), DotFormatter.t() | nil) :: t()
def dot_formatter(%Rewrite{} = rewrite, dot_formatter)
when is_struct(dot_formatter, DotFormatter) or is_nil(dot_formatter) do
%{rewrite | dot_formatter: dot_formatter}
end
@doc """
Creates a new `%Source{}` and puts the source to the `%Rewrite{}` project.
The `:filetypes` option of the project is used to create the source. If
options have been specified for the file type, the given options will be
merged into those options.
Use `create_source/4` if the source is not to be inserted directly into the
project.
"""
@spec new_source(t(), Path.t(), String.t(), opts()) :: {:ok, t()} | {:error, Error.t()}
def new_source(%Rewrite{sources: sources} = rewrite, path, content, opts \\ [])
when is_binary(path) do
case Map.has_key?(sources, path) do
true ->
{:error, Error.exception(reason: :overwrites, path: path)}
false ->
source = create_source(rewrite, path, content, opts)
put(rewrite, source)
end
end
@doc """
Same as `new_source/4`, but raises a `Rewrite.Error` exception in case of failure.
"""
@spec new_source!(t(), Path.t(), String.t(), opts()) :: t()
def new_source!(%Rewrite{} = rewrite, path, content, opts \\ []) do
case new_source(rewrite, path, content, opts) do
{:ok, rewrite} -> rewrite
{:error, error} -> raise error
end
end
@doc """
Creates a new `%Source{}` without putting it to the `%Rewrite{}` project.
The `:filetypes` option of the project is used to create the source. If
options have been specified for the file type, the given options will be
merged into those options. If no `path` is given, the default file type is
created.
The function does not check whether the `%Rewrite{}` project already has a
`%Source{}` with the specified path.
Use `new_source/4` if the source is to be inserted directly into the project.
"""
@spec create_source(t(), Path.t() | nil, String.t(), opts()) :: Source.t()
def create_source(%Rewrite{} = rewrite, path, content, opts \\ []) do
{source, source_opts} = extension_for_file(rewrite, path)
opts = source_opts |> Keyword.merge(opts) |> Keyword.put(:path, path)
source.from_string(content, opts)
end
defp extensions(opts) do
opts
|> Keyword.get(:filetypes, [Source, Source.Ex])
|> Enum.flat_map(fn
Source ->
[{"default", Source}]
{Source, opts} ->
[{"default", {Source, opts}}]
{module, opts} ->
Enum.map(module.extensions(), fn extension -> {extension, {module, opts}} end)
module ->
Enum.map(module.extensions(), fn extension -> {extension, module} end)
end)
|> Map.new()
|> Map.put_new("default", Source)
end
defp expand(inputs) do
inputs
|> List.wrap()
|> Stream.map(&compile_globs!/1)
|> Stream.flat_map(&GlobEx.ls/1)
|> Stream.uniq()
end
defp compile_globs!(str) when is_binary(str), do: GlobEx.compile!(str, match_dot: true)
defp compile_globs!(glob) when is_struct(glob, GlobEx), do: glob
defimpl Enumerable do
def count(rewrite) do
{:ok, map_size(rewrite.sources)}
end
def member?(rewrite, %Source{} = source) do
member? = Map.get(rewrite.sources, source.path) == source
{:ok, member?}
end
def member?(_rewrite, _other) do
{:ok, false}
end
def slice(rewrite) do
sources = rewrite.sources |> Map.values() |> Enum.sort_by(fn source -> source.path end)
length = length(sources)
{:ok, length,
fn
start, count when start + count == length -> Enum.drop(sources, start)
start, count -> sources |> Enum.drop(start) |> Enum.take(count)
end}
end
def reduce(rewrite, acc, fun) do
sources = Map.values(rewrite.sources)
Enumerable.List.reduce(sources, acc, fun)
end
end
defp handle_hooks(%{hooks: []} = rewrite, _action), do: rewrite
defp handle_hooks(rewrite, {:added_sources, sources}) do
paths = Enum.map(sources, fn {path, _source} -> path end)
handle_hooks(rewrite, {:added, paths})
end
defp handle_hooks(%{hooks: hooks} = rewrite, action) do
Enum.reduce(hooks, rewrite, fn hook, rewrite ->
case hook.handle(action, rewrite) do
:ok ->
rewrite
{:ok, rewrite} ->
rewrite
unexpected ->
raise Error.exception(
reason: :unexpected_hook_response,
message: """
unexpected response from hook, got: #{inspect(unexpected)}\
"""
)
end
end)
end
defimpl Inspect do
def inspect(rewrite, _opts) do
"#Rewrite<#{Enum.count(rewrite.sources)} source(s)>"
end
end
end
