elixir: remove include_vm (#541)

Author: jgonet

popcorn/elixir/lib/mix/tasks/popcorn.cook.ex

@@ -1,31 +1,35 @@
 defmodule Mix.Tasks.Popcorn.Cook do
-  @shortdoc "Generates static artifacts to run the project in the browser."
+  @shortdoc "Builds the `.avm` bundle for a Popcorn project."
   @moduledoc """
   #{@shortdoc}
 
   Accepts the following options:
   - `out_dir` - the directory to write artifacts to
-  - `target` - `wasm` (default) or `unix`. If `unix` is chosed, you need to build the runtime
-  first with `mix popcorn.build_runtime --target unix`
-  - `--include-vm` - include the VM and supporting files in the output directory.
-  Without this flag, only the `.avm` bundle is generated.
+  - `start_module` - optional module with `start/0` used as the bundle entrypoint
 
   `out_dir` is mandatory, unless provided via `config.exs`,
   for example `config :popcorn, out_dir: "dist/wasm"`
   """
   use Mix.Task
 
   @requirements "compile"
+  @parser_config [
+    strict: [out_dir: :string, start_module: :string],
+    aliases: [d: :out_dir]
+  ]
 
   @impl true
   def run(args) do
-    parser_config = [
-      strict: [out_dir: :string, target: :string, include_vm: :boolean],
-      aliases: [d: :out_dir]
-    ]
+    {options, _rest} = OptionParser.parse!(args, @parser_config)
 
-    {options, _rest} = OptionParser.parse!(args, parser_config)
+    options
+    |> Keyword.update(:start_module, nil, &as_module/1)
+    |> Popcorn.cook()
+  end
 
-    Popcorn.cook(options)
+  defp as_module(module_name) when is_binary(module_name) do
+    module_name
+    |> String.split(".")
+    |> Module.safe_concat()
   end
 end

popcorn/elixir/lib/popcorn.ex

@@ -4,11 +4,9 @@ defmodule Popcorn do
   """
 
   alias Popcorn.Build
-  alias Popcorn.Utils.FetchArtifacts
 
   @popcorn_path Mix.Project.app_path()
   @popcorn_generated_path Path.join(@popcorn_path, "popcorn_generated_ebin")
-  @priv_dir :code.priv_dir(:popcorn)
   @api_dir Path.join(["popcorn", "api"])
 
   defmodule CookingError do
@@ -17,27 +15,19 @@ defmodule Popcorn do
   end
 
   @doc """
-  Generates static artifacts to run the project in the browser.
+  Builds a Popcorn `.avm` bundle.
 
   Options:
   - `out_dir` - The directory to write artifacts to. Required, unless provided via `config.exs`.
   - `start_module` - Optional; a module with `start/0` function that will be called after applications start.
-  - `target` - `wasm` (default) or `unix`. If `unix` is chosed, you need to build the runtime
-  first with `mix popcorn.build_runtime --target unix`
   - `extra_beams` - Compiled BEAMs that should be included in the generated bundle.
-  - `include_vm` - If `true`, includes the VM and supporting files in the output directory (e.g. AtomVM.wasm, AtomVM.mjs and JS glue for wasm; AtomVM binary for unix).
-
-  Instead of calling `cook/1`, you can call `ingredients/1` and then `bundle/1`.
   """
   @spec cook([
           {:out_dir, String.t()}
           | {:start_module, module}
-          | {:target, :wasm | :unix}
           | {:extra_beams, [String.t()]}
-          | {:include_vm, boolean()}
         ]) :: :ok
   def cook(options \\ []) do
-    ingredients(Keyword.take(options, [:out_dir, :target, :include_vm]))
     bundle(Keyword.take(options, [:out_dir, :start_module, :extra_beams]))
   end
 
@@ -72,29 +62,6 @@ defmodule Popcorn do
     end
   end
 
-  @doc """
-  Generates artifacts needed to run any Popcorn-based project.
-
-  Options have the same semantics as in `cook/1`.
-  """
-  @spec ingredients([{:out_dir, String.t()} | {:target, :wasm | :unix} | {:include_vm, boolean()}]) ::
-          :ok
-  def ingredients(options \\ []) do
-    default_options = [
-      out_dir: Popcorn.Config.get(:out_dir),
-      target: :wasm,
-      include_vm: false
-    ]
-
-    options = options |> Keyword.validate!(default_options) |> Map.new()
-    ensure_option_present(options, :out_dir, "Output directory")
-
-    File.mkdir_p!(options.out_dir)
-    maybe_copy_runtime_artifacts(options)
-
-    :ok
-  end
-
   defp bundled_artifacts(applications) do
     builtin_apps = Build.builtin_app_names() |> MapSet.new()
 
@@ -173,25 +140,6 @@ defmodule Popcorn do
     String.contains?(src_path, @api_dir)
   end
 
-  defp maybe_copy_runtime_artifacts(%{include_vm: false}), do: :ok
-
-  defp maybe_copy_runtime_artifacts(options) do
-    if options.target == :wasm do
-      wasm_template_files = Path.wildcard(Path.join(@priv_dir, "static-template/wasm/**"))
-      cp_gzip(wasm_template_files, options.out_dir)
-    end
-
-    paths = FetchArtifacts.fetch_artifacts(options.target)
-
-    cp_gzip(paths, options.out_dir, fn path ->
-      raise CookingError, """
-      Couldn't find runtime artifact #{Path.basename(path)} at #{path} for target `#{options.target}`. \
-      To build artifacts from source, run \
-      `mix popcorn.build_runtime --target #{options.target}`.
-      """
-    end)
-  end
-
   defp ensure_option_present(options, key, name) do
     if options[key] == nil do
       raise CookingError, """
@@ -320,17 +268,6 @@ defmodule Popcorn do
     gather_app_specs(deps, Map.merge(specs, new_specs))
   end
 
-  defp cp_gzip(paths, out_dir, handle_missing_file \\ fn _path -> :ok end) do
-    for path <- List.wrap(paths) do
-      dest = Path.join(out_dir, Path.basename(path))
-      if not File.exists?(path), do: handle_missing_file.(path)
-      File.cp!(path, dest)
-      gzip(dest)
-    end
-
-    :ok
-  end
-
   defp gzip(path) do
     File.read!(path) |> :zlib.gzip() |> then(&File.write!("#{path}.gz", &1))
   end

popcorn/elixir/mix.exs

@@ -22,7 +22,7 @@ defmodule Popcorn.MixProject do
       elixirc_paths: elixirc_paths(Mix.env()),
       aliases: [
         docs: ["docs", &generate_js_docs/1],
-        compile: ["compile", &download_artifacts/1, &patch/1],
+        compile: ["compile", &patch/1],
         lint: [
           "format --check-formatted",
           "deps.unlock --check-unused",
@@ -128,13 +128,18 @@ defmodule Popcorn.MixProject do
   end
 
   defp generate_js_docs(_) do
-    Mix.shell().cmd(
-      "npx documentation build priv/static-template/wasm/popcorn.js -f html -o doc/js-api"
-    )
+    js_dir = Path.expand("../js", __DIR__)
+    js_entry = Path.join(js_dir, "dist/popcorn.mjs")
+
+    run_cmd!("pnpm run build", cd: js_dir)
+    run_cmd!("npx documentation build #{js_entry} -f html -o doc/js-api", [])
   end
 
-  defp download_artifacts(_args) do
-    Popcorn.Utils.FetchArtifacts.download_artifacts(force: "--force" in System.argv())
+  defp run_cmd!(command, opts) do
+    case Mix.shell().cmd(command, opts) do
+      0 -> :ok
+      status -> Mix.raise("command failed with status #{status}: #{command}")
+    end
   end
 
   defp patch(_args) do

popcorn/elixir/pages/getting_started/first_steps.md

@@ -74,7 +74,7 @@ import Config
 config :popcorn, out_dir: "dist/wasm"
 ```
 
-Next, fetch dependencies and compile your Elixir code to WebAssembly:
+Next, fetch dependencies and compile your Elixir code into a Popcorn `.avm` bundle:
 
 ```console
 $ mix deps.get
@@ -114,7 +114,7 @@ $ npm install --prefix assets
 $ npm run build --prefix assets
 ```
 
-The build step bundles your JavaScript, copies the WebAssembly runtime assets, and outputs everything to the `dist/` directory.
+The JavaScript build step bundles your JavaScript, copies the WebAssembly runtime assets, and outputs everything to the `dist/` directory. `mix popcorn.cook` only produces the `.avm` bundle.
 
 > #### Other bundlers {: .info}
 >