Add @external_resource attribute, closes #2455

Author: José Valim

lib/eex/lib/eex.ex

@@ -82,7 +82,7 @@ defmodule EEx do
       iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
       "1"
 
-  In other words, <%= @foo %> is simply translated to:
+  In other words, `<%= @foo %>` is simply translated to:
 
       <%= Dict.get assigns, :foo %>
 
@@ -92,6 +92,7 @@ defmodule EEx do
 
   @doc """
   Generates a function definition from the string.
+
   The kind (`:def` or `:defp`) must be given, the
   function name, its arguments and the compilation options.
 
@@ -120,6 +121,7 @@ defmodule EEx do
 
   @doc """
   Generates a function definition from the file contents.
+
   The kind (`:def` or `:defp`) must be given, the
   function name, its arguments and the compilation options.
 
@@ -147,6 +149,7 @@ defmodule EEx do
       args = Enum.map args, fn arg -> {arg, [line: 1], nil} end
       compiled = EEx.compile_file(file, info)
 
+      @external_resource file
       @file file
       case kind do
         :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))

lib/eex/test/eex_test.exs

@@ -2,7 +2,7 @@ Code.require_file "test_helper.exs", __DIR__
 
 require EEx
 
-defmodule EExText.Compiled do
+defmodule EExTest.Compiled do
   def before_compile do
     fill_in_stacktrace
     {__ENV__.line, hd(tl(System.stacktrace))}
@@ -12,6 +12,10 @@ defmodule EExText.Compiled do
 
   filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
   EEx.function_from_file :defp, :private_file_sample, filename, [:bar]
+
+  filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
+  EEx.function_from_file :def, :public_file_sample, filename, [:bar]
+
   def file_sample(arg), do: private_file_sample(arg)
 
   def after_compile do
@@ -319,39 +323,45 @@ foo
     end
   end
 
+  test "sets external resource attribute" do
+    assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
+           [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
+  end
+
   test "defined from string" do
-    assert EExText.Compiled.string_sample(1, 2) == "3"
+    assert EExTest.Compiled.string_sample(1, 2) == "3"
   end
 
   test "defined from file" do
-    assert EExText.Compiled.file_sample(1) == "foo 1\n"
+    assert EExTest.Compiled.file_sample(1) == "foo 1\n"
+    assert EExTest.Compiled.public_file_sample(1) == "foo 1\n"
   end
 
   test "defined from file do not affect backtrace" do
-    assert EExText.Compiled.before_compile ==
+    assert EExTest.Compiled.before_compile ==
       {8,
-        {EExText.Compiled,
+        {EExTest.Compiled,
           :before_compile,
           0,
           [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 7]
        }
      }
 
-    assert EExText.Compiled.after_compile ==
-      {19,
-        {EExText.Compiled,
+    assert EExTest.Compiled.after_compile ==
+      {23,
+        {EExTest.Compiled,
           :after_compile,
           0,
-          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 18]
+          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 22]
        }
      }
 
-    assert EExText.Compiled.unknown ==
-      {25,
-        {EExText.Compiled,
+    assert EExTest.Compiled.unknown ==
+      {29,
+        {EExTest.Compiled,
           :unknown,
           0,
-          [file: 'unknown', line: 24]
+          [file: 'unknown', line: 28]
        }
      }
   end

lib/elixir/lib/module.ex

@@ -247,6 +247,17 @@ defmodule Module do
               @vsn "1.0"
             end
 
+    * `@external_resource`
+
+      Specify an external resource to the current module.
+
+      Many times a module embeds information from an external file. This
+      attribute allows the module to annotate which external resources
+      have been used.
+
+      Tools like Mix may use this information to ensure the module is
+      recompiled in case any of the external resources change.
+
   The following attributes are part of typespecs and are also reserved by
   Elixir (see `Kernel.Typespec` for more information about typespecs):
 

lib/elixir/src/elixir_module.erl

@@ -111,7 +111,7 @@ build(Line, File, Module, Lexical) ->
     _    -> ets:insert(DataTable, {on_definition, []})
   end,
 
-  Attributes = [behaviour, on_load, spec, type, typep, opaque, callback, compile],
+  Attributes = [behaviour, on_load, spec, type, typep, opaque, callback, compile, external_resource],
   ets:insert(DataTable, {?acc_attr, [before_compile, after_compile, on_definition, derive|Attributes]}),
   ets:insert(DataTable, {?persisted_attr, [vsn|Attributes]}),
   ets:insert(DataTable, {?docs_attr, ets:new(DataTable, [ordered_set, public])}),
@@ -156,7 +156,7 @@ functions_form(Line, File, Module, BaseAll, BaseExport, Def, Defmacro, BaseFunct
 
 %% Add attributes handling to the form
 
-attributes_form(Line, _File, Module, Current) ->
+attributes_form(Line, File, Module, Current) ->
   Table = data_table(Module),
 
   AccAttrs = ets:lookup_element(Table, '__acc_attributes', 2),
@@ -166,16 +166,31 @@ attributes_form(Line, _File, Module, Current) ->
     case lists:member(Key, PersistedAttrs) of
       false -> Acc;
       true  ->
-        Attrs = case lists:member(Key, AccAttrs) of
-          true  -> Value;
-          false -> [Value]
-        end,
-        lists:foldl(fun(X, Final) -> [{attribute, Line, Key, X}|Final] end, Acc, Attrs)
+        Values =
+          case lists:member(Key, AccAttrs) of
+            true  -> Value;
+            false -> [Value]
+          end,
+
+        lists:foldl(fun(X, Final) ->
+          [{attribute, Line, Key, X}|Final]
+        end, Acc, process_attribute(Line, File, Key, Values))
     end
   end,
 
   ets:foldl(Transform, Current, Table).
 
+process_attribute(Line, File, external_resource, Values) ->
+  lists:usort([process_external_resource(Line, File, Value) || Value <- Values]);
+process_attribute(_Line, _File, _Key, Values) ->
+  Values.
+
+process_external_resource(_Line, _File, Value) when is_binary(Value) ->
+  Value;
+process_external_resource(Line, File, Value) ->
+  elixir_errors:handle_file_error(File,
+    {Line, ?MODULE, {invalid_external_resource, Value}}).
+
 %% Types
 
 types_form(Module, Forms0) ->
@@ -463,14 +478,17 @@ prune_stacktrace(Info, []) ->
 
 format_error({invalid_clause, {Name, Arity}}) ->
   io_lib:format("empty clause provided for nonexistent function or macro ~ts/~B", [Name, Arity]);
+format_error({invalid_external_resource, Value}) ->
+  io_lib:format("expected a string value for @external_resource, got: ~p",
+    ['Elixir.Kernel':inspect(Value)]);
 format_error({unused_doc, typedoc}) ->
   "@typedoc provided but no type follows it";
 format_error({unused_doc, doc}) ->
   "@doc provided but no definition follows it";
 format_error({internal_function_overridden, {Name, Arity}}) ->
   io_lib:format("function ~ts/~B is internal and should not be overridden", [Name, Arity]);
 format_error({invalid_module, Module}) ->
-  io_lib:format("invalid module name: ~p", [Module]);
+  io_lib:format("invalid module name: ~ts", ['Elixir.Kernel':inspect(Module)]);
 format_error({module_defined, Module}) ->
   io_lib:format("redefining module ~ts", [elixir_aliases:inspect(Module)]);
 format_error({module_reserved, Module}) ->

lib/mix/lib/mix/compilers/elixir.ex

@@ -107,23 +107,17 @@ defmodule Mix.Compilers.Elixir do
            |> Enum.map(&Atom.to_string(&1))
            |> Enum.reject(&match?("elixir_" <> _, &1))
 
-    files = get_beam_files(binary, cwd)
-            |> List.delete(source)
-            |> Enum.filter(&(Path.type(&1) == :relative))
+    files = for file <- get_external_resources(module, cwd),
+                File.regular?(file),
+                relative = Path.relative_to(file, cwd),
+                Path.type(relative) == :relative,
+                do: relative
 
     Agent.cast pid, &:lists.keystore(beam, 1, &1, {beam, bin, source, deps, files, binary})
   end
 
-  defp get_beam_files(binary, cwd) do
-    case :beam_lib.chunks(binary, [:abstract_code]) do
-      {:ok, {_, [abstract_code: {:raw_abstract_v1, code}]}} ->
-        for {:attribute, _, :file, {file, _}} <- code,
-            File.exists?(file) do
-          Path.relative_to(file, cwd)
-        end
-      _ ->
-        []
-    end
+  defp get_external_resources(module, cwd) do
+    module.__info__(:attributes)[:external_resource] || []
   end
 
   defp each_file(file) do

lib/mix/test/mix/tasks/compile.elixir_test.exs

@@ -132,7 +132,7 @@ defmodule Mix.Tasks.Compile.ElixirTest do
       File.touch!("lib/a.eex")
       File.write!("lib/a.ex", """
       defmodule A do
-        @file "lib/a.eex"
+        @external_resource "lib/a.eex"
         def a, do: :ok
       end
       """)