Note that the hook injects a method __tagged(), and then list_tagged_modules() checks for the presence of the method in module. So it should always work, unless there is a clash with an existing method. That’s why the name of the method must be unique.
lguminski
RomanKotov
Elxir Protocols have an interesting reflection feature. It looks like SomeProtocol.__protocol__(:impls) and can return a {:consolidated, modules}. It shows all modules, that implement the protocol. You can use this to tag modules, like:
defprotocol TagExample.Tagged do
@spec tags(t()) :: [atom()]
def tags(data)
end
defmodule TagExample.Tag do
alias TagExample.Tagged
defmacro __using__(_opts) do
quote do
Module.register_attribute(
__MODULE__,
:tag,
persist: true,
accumulate: true
)
defimpl TagExample.Tagged do
def tags(_) do
:attributes
|> @for.__info__()
|> Keyword.get(:tag, [])
end
end
end
end
defimpl Tagged, for: Atom do
def tags(module) do
:attributes
|> module.__info__()
|> Keyword.get(:tag, [])
end
end
@spec tagged_modules() :: [module()]
def tagged_modules do
modules =
case Tagged.__protocol__(:impls) do
{:consolidated, modules} ->
modules
_ ->
Protocol.extract_impls(
Tagged,
:code.lib_dir()
)
end
for module <- modules,
module.__info__(:attributes)
|> Keyword.has_key?(:tag),
do: module
end
@spec modules_with_tag(tag :: atom()) :: [module()]
def modules_with_tag(tag) do
for module <- tagged_modules(),
module
|> Tagged.tags()
|> Enum.member?(tag),
do: module
end
end
defmodule TagExample.TaggedModule1 do
use TagExample.Tag
@tag :tag1
@tag :tag2
end
defmodule TagExample.TaggedModule2 do
use TagExample.Tag
@tag :tag2
@tag :tag3
end
# iex> TagExample.Tag.tagged_modules()
# [TagExample.TaggedModule2, TagExample.TaggedModule1]
# iex> TagExample.Tag.modules_with_tag(:tag2)
# [TagExample.TaggedModule2]
# iex> TagExample.Tag.modules_with_tag(:nonexisting_tag)
# []
This example uses module attributes, but you can store tags somewhere else (possibly in methods).
I have also created a blog post with edge cases for this implementation.
2