mirror of
https://github.com/bonfire-networks/bonfire-app.git
synced 2024-05-14 07:02:38 +00:00
562 lines
16 KiB
Elixir
Executable file
562 lines
16 KiB
Elixir
Executable file
Code.eval_file("mess.exs")
|
|
|
|
defmodule Bonfire.MixProject do
|
|
use Mix.Project
|
|
|
|
# TODO: put these in ENV or an external writeable config file similar to deps.*
|
|
@config [
|
|
# note that the flavour will automatically be added where the dash appears
|
|
version: "0.3.5-beta.0",
|
|
elixir: "~> 1.13",
|
|
default_flavour: "classic",
|
|
logo: "assets/static/images/bonfire-icon.png",
|
|
docs: [
|
|
"README.md",
|
|
"docs/HACKING.md",
|
|
"docs/DEPLOY.md",
|
|
"docs/ARCHITECTURE.md",
|
|
"docs/BONFIRE-FLAVOURED-ELIXIR.md",
|
|
"docs/DATABASE.md",
|
|
"docs/BOUNDARIES.md",
|
|
"docs/GRAPHQL.md",
|
|
"docs/MRF.md",
|
|
"docs/CHANGELOG.md",
|
|
"docs/CHANGELOG-autogenerated.md"
|
|
],
|
|
deps_prefixes: [
|
|
docs: [
|
|
"bonfire",
|
|
"pointers",
|
|
"paginator",
|
|
"ecto_shorts",
|
|
"ecto_sparkles",
|
|
"absinthe_client",
|
|
"activity_pub",
|
|
"arrows",
|
|
"ecto_materialized_path",
|
|
"flexto",
|
|
"grumble",
|
|
"linkify",
|
|
"verbs",
|
|
"voodoo",
|
|
"waffle",
|
|
"zest"
|
|
],
|
|
test: [
|
|
"bonfire",
|
|
"pointers",
|
|
"paginator",
|
|
"ecto_shorts",
|
|
"ecto_sparkles",
|
|
"activity_pub",
|
|
"arrows",
|
|
"linkify",
|
|
"fetch_favicon"
|
|
],
|
|
data: [
|
|
"bonfire_data_",
|
|
"bonfire_data_edges",
|
|
"pointers",
|
|
"bonfire_boundaries",
|
|
"bonfire_tag",
|
|
"bonfire_classify",
|
|
"bonfire_geolocate",
|
|
"bonfire_quantify",
|
|
"bonfire_valueflows"
|
|
],
|
|
api: [
|
|
"bonfire_me",
|
|
"bonfire_social",
|
|
"bonfire_tag",
|
|
"bonfire_classify",
|
|
"bonfire_geolocate",
|
|
"bonfire_valueflows"
|
|
],
|
|
required: [
|
|
"bonfire_boundaries",
|
|
"bonfire_social",
|
|
"bonfire_me",
|
|
"bonfire_ecto",
|
|
"bonfire_epics",
|
|
"bonfire_common"
|
|
],
|
|
localise: ["bonfire"],
|
|
localise_self: []
|
|
]
|
|
]
|
|
|
|
def project do
|
|
[
|
|
app: :bonfire,
|
|
version: version(),
|
|
elixir: @config[:elixir],
|
|
elixirc_options: [debug_info: true, docs: true],
|
|
elixirc_paths: elixirc_paths(Mix.env()),
|
|
test_paths: test_paths(),
|
|
test_deps: deps(:test),
|
|
required_deps: @config[:deps_prefixes][:required],
|
|
compilers: compilers(Mix.env()),
|
|
start_permanent: Mix.env() == :prod,
|
|
aliases: aliases(),
|
|
deps: deps(),
|
|
multirepo_deps: deps(:bonfire),
|
|
in_multirepo_fn: &in_multirepo?/1,
|
|
multirepo_recompile_fn: &deps_recompile/0,
|
|
config_path: config_path("config.exs"),
|
|
releases: [
|
|
bonfire: [
|
|
runtime_config_path: config_path("runtime.exs"),
|
|
# to enable debugging
|
|
strip_beams: false
|
|
]
|
|
],
|
|
source_url: "https://github.com/bonfire-networks/bonfire-app",
|
|
homepage_url: "https://bonfirenetworks.org",
|
|
docs: [
|
|
# The first page to display from the docs
|
|
main: "readme",
|
|
logo: @config[:logo],
|
|
output: "docs/exdoc",
|
|
source_url_pattern: &source_url_pattern/2,
|
|
# extra pages to include
|
|
extras: readme_paths(),
|
|
# extra apps to include in module docs
|
|
source_beam: beam_paths(:docs),
|
|
deps: doc_deps(),
|
|
# Note: first match wins
|
|
groups_for_extras: [
|
|
Guides: Path.wildcard("docs/*"),
|
|
"Flavours of Bonfire": Path.wildcard("flavours/*/*"),
|
|
"Data schemas": Path.wildcard("{deps,forks}/bonfire_data_*/*"),
|
|
"UI extensions": Path.wildcard("{deps,forks}/bonfire_ui_*/*"),
|
|
"Bonfire utilities":
|
|
[
|
|
"bonfire_api_graphql",
|
|
"bonfire_boundaries",
|
|
"bonfire_common",
|
|
"bonfire_ecto",
|
|
"bonfire_epics",
|
|
"bonfire_fail",
|
|
"bonfire_files",
|
|
"bonfire_mailer"
|
|
]
|
|
|> Enum.flat_map(&Path.wildcard("{deps,forks}/#{&1}/*")),
|
|
"Feature extensions": Path.wildcard("{deps,forks}/bonfire_*/*"),
|
|
"Other utilities": Path.wildcard("{deps,forks}/*/*"),
|
|
Dependencies: Path.wildcard("docs/DEPENDENCIES/*")
|
|
],
|
|
groups_for_modules: [
|
|
"Data schemas": ~r/^Bonfire.Data.?/,
|
|
"UI extensions": ~r/^Bonfire.UI.?/,
|
|
"Bonfire utilities": [
|
|
~r/^Bonfire.API?/,
|
|
~r/^Bonfire.GraphQL?/,
|
|
~r/^Bonfire.Web?/,
|
|
~r/^Bonfire.Boundaries?/,
|
|
~r/^Bonfire.Common?/,
|
|
~r/^Bonfire.Ecto?/,
|
|
~r/^Bonfire.Epics?/,
|
|
~r/^Bonfire.Fail?/,
|
|
~r/^Bonfire.Files?/,
|
|
~r/^Bonfire.Mailer?/
|
|
],
|
|
"Feature extensions": [~r/^Bonfire.?/, ~r/^ValueFlows.?/],
|
|
Utilities: ~r/.?/
|
|
],
|
|
nest_modules_by_prefix: [
|
|
Bonfire.Data,
|
|
# Bonfire.UI,
|
|
Bonfire,
|
|
ValueFlows
|
|
]
|
|
]
|
|
]
|
|
end
|
|
|
|
def application do
|
|
[
|
|
mod: {Bonfire.Application, []},
|
|
extra_applications: [
|
|
:logger,
|
|
:runtime_tools,
|
|
:os_mon,
|
|
:ssl,
|
|
:bamboo,
|
|
:bamboo_smtp
|
|
]
|
|
]
|
|
end
|
|
|
|
defp aliases do
|
|
[
|
|
"hex.setup": ["local.hex --force"],
|
|
"rebar.setup": ["local.rebar --force"],
|
|
"assets.build": [
|
|
"cmd cd ./assets && yarn build"
|
|
],
|
|
"bonfire.seeds": [
|
|
# "phil_columns.seed",
|
|
],
|
|
"bonfire.deps.update": ["deps.update " <> deps_to_update()],
|
|
"bonfire.deps.clean": [
|
|
"deps.clean " <> deps_to_clean(:localise) <> " --build"
|
|
],
|
|
"bonfire.deps.clean.data": [
|
|
"deps.clean " <> deps_to_clean(:data) <> " --build"
|
|
],
|
|
"bonfire.deps.clean.api": [
|
|
"deps.clean " <> deps_to_clean(:api) <> " --build"
|
|
],
|
|
"bonfire.deps.recompile": [
|
|
"deps.compile " <> deps_to_update() <> " --force"
|
|
],
|
|
"bonfire.deps": ["bonfire.deps.update", "bonfire.deps.clean.data"],
|
|
"ecto.seeds": [
|
|
"run #{flavour_path()}/repo/seeds.exs"
|
|
],
|
|
"js.deps.get": ["cmd make js.deps.get"],
|
|
"js.deps.update": ["cmd cd assets && yarn update"],
|
|
setup: [
|
|
"hex.setup",
|
|
"rebar.setup",
|
|
"deps.get",
|
|
"bonfire.deps.clean.data",
|
|
"ecto.setup"
|
|
],
|
|
updates: ["deps.get", "bonfire.deps"],
|
|
upgrade: ["updates", "ecto.migrate"],
|
|
"ecto.setup": ["ecto.create", "ecto.migrate"],
|
|
"ecto.migrate": ["ecto.migrate", "bonfire.seeds"],
|
|
"ecto.reset": ["ecto.drop --force", "ecto.setup"],
|
|
test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"]
|
|
]
|
|
end
|
|
|
|
def deps() do
|
|
Mess.deps(mess_sources(), [
|
|
## password hashing - builtin vs nif
|
|
{:pbkdf2_elixir, "~> 2.0", only: [:dev, :test]},
|
|
{:argon2_elixir, "~> 3.0", only: [:prod]},
|
|
|
|
# error reporting
|
|
{:sentry, "~> 8.0", only: [:dev, :prod]},
|
|
|
|
## dev conveniences
|
|
# {:dbg, "~> 1.0", only: [:dev, :test]},
|
|
{:phoenix_live_reload, "~> 1.3", only: :dev},
|
|
{:exsync, git: "https://github.com/falood/exsync", only: :dev},
|
|
# {:mix_unused, "~> 0.4", only: :dev},
|
|
{:ex_doc, "~> 0.28.3", only: [:dev, :test], runtime: false},
|
|
{:ecto_erd, "~> 0.4", only: :dev},
|
|
# {:ecto_dev_logger, "~> 0.4", only: :dev},
|
|
# flame graphs in live_dashboard
|
|
{:flame_on, "~> 0.5", only: :dev},
|
|
{:pseudo_gettext, git: "https://github.com/tmbb/pseudo_gettext", only: :dev},
|
|
{:periscope, "~> 0.4", only: :dev},
|
|
# {:changelog, "~> 0.1", only: [:dev, :test], runtime: false}, # retrieve changelogs of latest dependency versions
|
|
# changelog generation
|
|
{:versioce, "~> 1.1.2", only: :dev},
|
|
# needed for changelog generation
|
|
{:git_cli, "~> 0.3.0", only: :dev},
|
|
# {:archeometer, git: "https://gitlab.com/mayel/archeometer", only: [:dev, :test]}, # "~> 0.1.0" # disabled because exqlite not working in CI
|
|
{:recode, "~> 0.4", only: :dev},
|
|
# API client needed for changelog generation
|
|
{:neuron, "~> 5.0", only: :dev, override: true},
|
|
|
|
# tests
|
|
{:floki, ">= 0.0.0", only: [:dev, :test]},
|
|
{:ex_machina, "~> 2.4", only: :test},
|
|
{:mock, "~> 0.3", only: :test},
|
|
{:mox, "~> 1.0", only: :test},
|
|
{:zest, "~> 0.1.0"},
|
|
{:grumble, "~> 0.1.3", only: [:test], override: true},
|
|
{:mix_test_watch, "~> 1.0", only: :test, runtime: false},
|
|
{:mix_test_interactive, "~> 1.2", only: :test, runtime: false},
|
|
{:ex_unit_notifier, "~> 1.0", only: :test},
|
|
{:wallaby, "~> 0.30", runtime: false, only: :test},
|
|
# {:bypass, "~> 2.1", only: :test}, # used in furlex
|
|
|
|
# Benchmarking utilities
|
|
{:benchee, "~> 1.1", only: :dev},
|
|
{:benchee_html, "~> 1.0", only: :dev},
|
|
|
|
# list dependencies & licenses
|
|
{
|
|
:licensir,
|
|
only: :dev,
|
|
runtime: false,
|
|
git: "https://github.com/bonfire-networks/licensir",
|
|
branch: "main"
|
|
# path: "./forks/licensir"
|
|
},
|
|
|
|
# security auditing
|
|
# {:mix_audit, "~> 0.1", only: [:dev], runtime: false}
|
|
{:sobelow, "~> 0.8", only: :dev}
|
|
])
|
|
end
|
|
|
|
# defp compilers(:dev) do
|
|
# [:unused] ++ compilers(nil)
|
|
# end
|
|
|
|
defp compilers(_) do
|
|
[:phoenix] ++ Mix.compilers()
|
|
end
|
|
|
|
def catalogues(_env) do
|
|
[
|
|
"deps/surface/priv/catalogue",
|
|
dep_path("bonfire_ui_social") <> "/priv/catalogue"
|
|
]
|
|
end
|
|
|
|
def deps(deps \\ deps(), deps_subtype)
|
|
|
|
def deps(deps, :bonfire) do
|
|
deps_prefixes = multirepo_prefixes()
|
|
Enum.filter(deps, &in_multirepo?(&1, deps_prefixes))
|
|
end
|
|
|
|
def deps(deps, deps_subtype) when is_atom(deps_subtype),
|
|
do:
|
|
Enum.filter(
|
|
deps,
|
|
&include_dep?(deps_subtype, &1, @config[:deps_prefixes][deps_subtype])
|
|
)
|
|
|
|
def multirepo_prefixes(),
|
|
do:
|
|
Enum.flat_map(@config[:deps_prefixes], fn {_, list} -> list end)
|
|
|> Enum.uniq()
|
|
|
|
def in_multirepo?(dep, deps_prefixes \\ multirepo_prefixes()),
|
|
do: include_dep?(:bonfire, dep, deps_prefixes)
|
|
|
|
def deps_recompile(deps \\ deps_for(:bonfire)),
|
|
do: Mix.Task.run("bonfire.dep.compile", ["--force"] ++ List.wrap(deps))
|
|
|
|
def flavour_path(),
|
|
do: System.get_env("FLAVOUR_PATH", "flavours/" <> flavour())
|
|
|
|
def flavour(), do: System.get_env("FLAVOUR", @config[:default_flavour])
|
|
|
|
def config_path(flavour_path \\ flavour_path(), filename),
|
|
do: Path.expand(Path.join([flavour_path, "config", filename]))
|
|
|
|
def forks_path(), do: System.get_env("FORKS_PATH", "forks/")
|
|
|
|
defp mess_sources() do
|
|
mess_sources(System.get_env("WITH_FORKS", "1"))
|
|
|> Enum.map(fn {k, v} -> {k, config_path(v)} end)
|
|
end
|
|
|
|
defp mess_sources("0"), do: [git: "deps.git", hex: "deps.hex"]
|
|
|
|
defp mess_sources(_),
|
|
do: [path: "deps.path", git: "deps.git", hex: "deps.hex"]
|
|
|
|
def deps_to_clean(type) do
|
|
deps(type)
|
|
|> deps_names()
|
|
end
|
|
|
|
def deps_to_update() do
|
|
deps(:update)
|
|
|> deps_names()
|
|
|> IO.inspect(
|
|
label:
|
|
"Running Bonfire #{version()} with configuration from #{flavour_path()} in #{Mix.env()} environment. You can run `mix bonfire.deps.update` to update these extensions and dependencies"
|
|
)
|
|
end
|
|
|
|
# Specifies which paths to include in docs
|
|
|
|
def beam_paths(type \\ :all) do
|
|
build = Mix.Project.build_path()
|
|
|
|
([:bonfire] ++ deps(type))
|
|
|> Enum.map(&beam_path(&1, build))
|
|
end
|
|
|
|
defp beam_path(app, build),
|
|
do: Path.join([build, "lib", dep_name(app), "ebin"])
|
|
|
|
def readme_paths(),
|
|
do:
|
|
@config[:docs] ++
|
|
Enum.map(Path.wildcard("flavours/*/README.md"), &flavour_readme/1) ++
|
|
Enum.map(Path.wildcard("docs/DEPENDENCIES/*.md"), &flavour_deps_doc/1) ++
|
|
Enum.flat_map(deps(:docs), &readme_path/1)
|
|
|
|
defp readme_path(dep) when not is_nil(dep),
|
|
do: dep_paths(dep, "README.md") |> List.first() |> readme_path(dep)
|
|
|
|
defp readme_path(path, dep) when not is_nil(path),
|
|
do: [{path |> String.to_atom(), [filename: "extension-" <> dep_name(dep)]}]
|
|
|
|
defp readme_path(_, _), do: []
|
|
|
|
def flavour_readme(path),
|
|
do: {path |> String.to_atom(), [filename: path |> String.split("/") |> Enum.at(1)]}
|
|
|
|
def flavour_deps_doc(path),
|
|
do:
|
|
{path |> String.to_atom(),
|
|
[
|
|
title:
|
|
path
|
|
|> String.split("/")
|
|
|> Enum.at(2)
|
|
|> String.slice(0..-4)
|
|
|> String.capitalize(),
|
|
filename:
|
|
path
|
|
|> String.split("/")
|
|
|> Enum.at(2)
|
|
|> String.slice(0..-4)
|
|
|> then(&"deps-#{&1}")
|
|
]}
|
|
|
|
# [plug: "https://myserver/plug/"]
|
|
defp doc_deps(), do: deps(:docs) |> Enum.map(&doc_dep/1)
|
|
defp doc_dep(dep), do: {elem(dep, 0), "./"}
|
|
|
|
def source_url_pattern("deps/" <> _ = path, line),
|
|
do: bonfire_ext_pattern(path, line)
|
|
|
|
def source_url_pattern("forks/" <> _ = path, line),
|
|
do: bonfire_ext_pattern(path, line)
|
|
|
|
def source_url_pattern(path, line), do: bonfire_app_pattern(path, line)
|
|
|
|
defp bonfire_ext_pattern(path, line),
|
|
do:
|
|
bonfire_ext_pattern(
|
|
path |> String.split("/") |> Enum.at(1),
|
|
path |> String.split("/") |> Enum.slice(2..1000) |> Enum.join("/"),
|
|
line
|
|
)
|
|
|
|
defp bonfire_ext_pattern(dep, path, line),
|
|
do:
|
|
bonfire_app_pattern(
|
|
"https://github.com/bonfire-networks/#{dep}/blob/main/%{path}#L%{line}",
|
|
path,
|
|
line
|
|
)
|
|
|
|
defp bonfire_app_pattern(path, line),
|
|
do:
|
|
bonfire_app_pattern(
|
|
"https://github.com/bonfire-networks/bonfire-app/blob/main/%{path}#L%{line}",
|
|
path,
|
|
line
|
|
)
|
|
|
|
defp bonfire_app_pattern(pattern, path, line),
|
|
do:
|
|
pattern
|
|
|> String.replace("%{path}", "#{path}")
|
|
|> String.replace("%{line}", "#{line}")
|
|
|
|
# Specifies which paths to include when running tests
|
|
defp test_paths(),
|
|
do: ["test" | Enum.flat_map(deps(:test), &dep_paths(&1, "test"))]
|
|
|
|
# Specifies which paths to compile per environment
|
|
defp elixirc_paths(:test),
|
|
do: [
|
|
"lib",
|
|
"test/support"
|
|
| Enum.flat_map(deps(:test), &dep_paths(&1, "test/support"))
|
|
]
|
|
|
|
# |> IO.inspect()
|
|
|
|
defp elixirc_paths(env), do: ["lib"] ++ catalogues(env)
|
|
|
|
defp include_dep?(type, dep, deps_prefixes)
|
|
|
|
defp include_dep?(:update, dep, _deps_prefixes) when is_tuple(dep),
|
|
do: unpinned_git_dep?(dep)
|
|
|
|
# defp include_dep?(:docs = type, dep, deps_prefixes), do: String.starts_with?(dep_name(dep), deps_prefixes || @config[:deps_prefixes][type]) || git_dep?(dep)
|
|
defp include_dep?(type, dep, deps_prefixes),
|
|
do:
|
|
String.starts_with?(
|
|
dep_name(dep),
|
|
deps_prefixes || @config[:deps_prefixes][type]
|
|
)
|
|
|
|
# defp git_dep?(dep) do
|
|
# spec = elem(dep, 1)
|
|
# is_list(spec) && spec[:git]
|
|
# end
|
|
|
|
defp unpinned_git_dep?(dep) do
|
|
spec = elem(dep, 1)
|
|
is_list(spec) && spec[:git] && !spec[:commit]
|
|
end
|
|
|
|
defp dep_name(dep) when is_tuple(dep), do: elem(dep, 0) |> dep_name()
|
|
defp dep_name(dep) when is_atom(dep), do: Atom.to_string(dep)
|
|
defp dep_name(dep) when is_binary(dep), do: dep
|
|
|
|
def deps_names(deps) do
|
|
deps
|
|
|> Enum.map(&dep_name/1)
|
|
|> Enum.join(" ")
|
|
end
|
|
|
|
def deps_for(type) do
|
|
deps(type)
|
|
|> Enum.map(&dep_name/1)
|
|
end
|
|
|
|
defp dep_path(dep) when is_binary(dep) do
|
|
path_if_exists(forks_path() <> dep) ||
|
|
path_if_exists(
|
|
(Mix.Project.deps_path() <> "/" <> dep)
|
|
|> Path.expand(File.cwd!())
|
|
) ||
|
|
"."
|
|
end
|
|
|
|
defp dep_path(dep) do
|
|
spec = elem(dep, 1)
|
|
|
|
path =
|
|
if is_list(spec) && spec[:path],
|
|
do: spec[:path],
|
|
else:
|
|
(Mix.Project.deps_path() <> "/" <> dep_name(dep))
|
|
|> Path.relative_to_cwd()
|
|
|
|
path_if_exists(path)
|
|
end
|
|
|
|
defp path_if_exists(path), do: if(File.exists?(path), do: path)
|
|
|
|
defp dep_paths(dep, extra) when is_list(extra),
|
|
do: Enum.flat_map(extra, &dep_paths(dep, &1))
|
|
|
|
defp dep_paths(dep, extra) when is_binary(extra) do
|
|
dep_path = dep_path(dep)
|
|
|
|
if dep_path do
|
|
path = Path.join(dep_path, extra) |> path_if_exists()
|
|
if path, do: [path], else: []
|
|
else
|
|
[]
|
|
end
|
|
end
|
|
|
|
def version do
|
|
@config[:version]
|
|
|> String.split("-", parts: 2)
|
|
|> List.insert_at(1, flavour())
|
|
|> Enum.join("-")
|
|
end
|
|
end
|