黒魔術で Elixir に Ruby を召喚する

まず始めに。

ネタ記事です。

ひさびさのネタ記事です。

ネタプログラミングです。

とはいえ。

黒魔術を使うことはなくても、このようなしくみを知っていると、その知識が役に立つときが来るかもしれません（来ないかもしれません）。

Level 1, Medium: Port.open/2 で Ruby を起動する

まずは定石の範囲で。

Port.open/2 を使って Ruby のプロセスを起動します。

外部プロセスの起動には System.cmd/3 という関数もありますが、 Port.open/2 の方が制御を細かくできるのでこちらを利用しすることにします。 ちなみに System.cmd/3 も内部では Port.open/2 を利用していました。

path = System.find_executable("ruby")
port = Port.open({:spawn_executable, path},
         [:binary, args: ["-e", "puts('Hello')"]])

receive do
  {^port, {:data, data}} -> data
end
# => "Hello\n"

Port.open/2 でプロセスを起動すると、そのプロセスの出力をメッセージで送信します。 メッセージはポートの値とデータのタプル、データは :data とデータ本体の値のタプル、という形式になっています。

メッセージの形式の詳細はドキュメントを参照してください。

• Message and function APIs

Port.open/2 の戻り値を送り先に指定すると、起動したプロセスにメッセージを送ることができます。

path = System.find_executable("ruby")

# 1 行読み込んで 1 行出力する
port = Port.open({:spawn_executable, path}, [:binary, args: ["-e", ~S|puts("Hello #{gets.strip}!")|]])

# 1 行分の文字列を送る
send(port, {self(), {:command, "world\n"}})

receive do
  {^port, {:data, data}} -> data
end
# => "Hello world!\n"

Level 2, Seer: irb を起動して対話的に式を評価する

ruby コマンドでは、ループ処理を自分で描かない限り、ワンショットの実行になってしまいます。 そこで代わりに irb を起動して一つのプロセスで何度でも式を評価できるようにしてみます。

path = System.find_executable("irb")
port = Port.open({:spawn_executable, path}, [:binary])

ここで。irb を起動しするとどのような挙動になるか IEx で flush/0 を使って確認してみます。

iex> path = System.find_executable("irb")
iex> port = Port.open({:spawn_executable, path}, [:binary])
#Port<0.5>

iex> flush
{#Port<0.5>, {:data, "Switch to inspect mode.\n"}}

起動しただけでなにやらメッセージを受信しています。

メッセージとして Ruby の式を送ってみます。 評価は行単位で行われるので末尾の改行（ "\n" ）を忘れないようにしてください。

# 式展開で書くと Elixir の文脈で展開してしまうので文字列連結 ++ で書いています
iex> send(port, {self(), {:command, "puts('Hello ' ++ (gets.strip) ++ '!')\n"}})

# gets が読み込む文字列を送る
iex> send(port, {self(), {:command, "world\n"}})
{#PID<0.108.0>, {:command, "world\n"}}

iex> flush
{#Port<0.5>, {:data, "puts('Hello ' ++ (gets.strip) ++ '!')\n"}}
{#Port<0.5>, {:data, "Hello world!\n"}}
{#Port<0.5>, {:data, "nil\n"}}

入力した評価対象の文字列（ "puts('Hello ' ++ (gets.strip) ++ '!')\n" ）と、puts の出力結果、そして puts の戻り値の値である nil が送り返されました。

出力した内容（ "Hello irb!\n" ）だけが得られればよいのですが、入力した評価対象の内容も送られてきてしまっています。

明示的に出力した内容以外の出力を抑制するオプションをつけて irb を起動するようにします。

iex> path = System.find_executable("irb")
# 評価する式の出力を抑える --noverbose と 評価した値の出力を抑える --noecho を指定する
iex> port = Port.open({:spawn_executable, path}, [:binary, args: ["--noverbose", "--noecho"]])

iex> send(port, {self(), {:command, "puts('Hello ' ++ (gets.strip) ++ '!')\n"}})
iex> send(port, {self(), {:command, "world\n"}})

iex> flush
{#Port<0.5>, {:data, "Hello world!\n"}}

これで評価する式と評価した値、加えて起動時のメッセージの出力を抑制することができました。

Level 3, Conjuror: サーバにする

これらを踏まえて。 Ruby の式を評価して結果を返すサーバを書いてみます。

defmodule ExIRB do
  use GenServer

  @name __MODULE__

  def start_link(opts) do
    name = Keyword.get(opts, :name, @name)
    GenServer.start_link(__MODULE__, opts, name: name)
  end

  def eva_ruby(server \\ @name, expression) do
    GenServer.call(server, {:eva_ruby, expression})
  end

  def init(_opts) do
    path = System.find_executable("irb")
    port = Port.open({:spawn_executable, path}, [:binary, args: ["--noverbose", "--noecho"]])

    {:ok, %{port: port, froms: []}}
  end

  def handle_call({:eva_ruby, expression}, from, %{port: port, froms: froms} = state) do
    send(port, {self(), {:command, expression}})

    {:noreply, %{state | froms: [from | froms]}}
  end

  def handle_info({port, {:data, data}}, %{port: port, froms: [from | froms]} = state) do
    GenServer.reply(from, data)

    {:noreply, %{state | froms: froms}}
  end
end

実行。

iex> ExIRB.start_link([])
iex> ExIRB.eva_ruby("puts('Hello ExIRB!')\n")
"Hello ExIRB!\n"

ここで注意点として。この実装では式を評価したら必ずメッセージが返されることを期待しています。 値を出力しない式を与えるとタイムアウトが発生します。

値が返ることを期待しない式を評価したい場合は、次のような関数とハンドラを追加することで実現できます。

  def cast_ruby(server \\ @name, expression) do
    GenServer.cast(server, {:cast_ruby, expression})
  end

  def handle_cast({:cast_ruby, expression}, %{port: port} = state) do
    send(port, {self(), {:command, expression}})

    {:noreply, state}
  end

# irb は gets の入力待ちになる
iex> ExIRB.cast_ruby("puts('Hello ' ++ (gets.strip) ++ '!')\n")

# 文字列を送ると gets が値を返し、結果として上の式が評価された値が返される
iex> ExIRB.eva_ruby("world\n")
"Hello world!\n"

ここで puts を使っていると末尾に改行コードが付いてしまいます。 これは print に変更することでこれを回避できます。

iex> ExIRB.eva_ruby("print('Hello ExIRB!')\n")                
"Hello ExIRB!"

Level 4, Magician: マーシャリングした値を利用する

irb のプロセスを起動し評価したい Ruby の式を渡すことで値を得ることができるようになりました。 しかし文字列という形式でしかやりとりができません。 その文字列を Elixir 上でパースすることもできますが面倒です。

シリアライズした Ruby の値を Elixir でデシリアライズできれば文字列をパースするよりもミスなく値を受け渡すことができるはずです。

と、いうわけで。

Ruby の値を Marshal で出力し、それを Elixir で読み込むことにします。

Format of marshaling

フォーマットの仕様はドキュメントにまとめられています。

• Marshal フォーマット

フォーマットのバージョンは Ruby 1.8.0 以降は 4.8 なので、先頭の 2 バイトは 0x04 と 0x08 です。

nil、true、false はそれぞれ "0"、"T", "F" という形式になるので、マーシャリングされると

Ruby の値	マーシャリングされた値
nil	"\x04\x080"
true	"\x04\x08T"
false	"\x04\x08F"

irb で確認してみます。

irb> Marshal.load("\x04\x080")
=> nil
irb> Marshal.load("\x04\x08T")
=> true
irb> Marshal.load("\x04\x08F")
=> false

Level 3 で作成した ExIRB で同じように評価してみます。

iex> ExIRB.eva_ruby("print(Marshal.dump(nil))\n")
<<4, 8, 48>>
iex> ExIRB.eva_ruby("print(Marshal.dump(true))\n")
<<4, 8, 84>>
iex> ExIRB.eva_ruby("print(Marshal.dump(false))\n")
<<4, 8, 70>>

文字として表示できない値が含まれるためバイト列として表示されます。 フォーマットが規定されているバイト列のパースは文字列のパースよりも容易ですし、なにより Elixir はバイト列のパースが得意です。

そんなわけで。

マーシャリングされた Ruby の値を Elixir の値に変換するパッケージを がっ！ と書いてみました。

• mattsan/ex_marshal: Deserialize Ruby Objects

mix.exs の deps に ex_marshal を追加します。

# mix.exs

  defp deps do
    [
      {:ex_marshal, github: "mattsan/ex_marshal"}
    ]
  end

iex を起動しなおし、マーシャリングした値を ExMarshal.load/1 で読み込んでみます。

iex> ExIRB.start_link([])
iex> ExIRB.eva_ruby("print(Marshal.dump(nil))\n") |> ExMarshal.load()
nil
iex> ExIRB.eva_ruby("print(Marshal.dump(false))\n") |> ExMarshal.load()
false
iex> ExIRB.eva_ruby("print(Marshal.dump(true))\n") |> ExMarshal.load()
true
iex> ExIRB.eva_ruby("print(Marshal.dump(123))\n") |> ExMarshal.load()
123
iex> ExIRB.eva_ruby("print(Marshal.dump([1,2,3]))\n") |> ExMarshal.load()
[1, 2, 3]
iex> ExIRB.eva_ruby("print(Marshal.dump({a: 1, b: '2', c: :three}))\n") |> ExMarshal.load()
%{a: 1, b: "2", c: :three}

扱える値はドキュメント（ lib/ex_marshal.ex の moduledoc ）を参照してください。

Ruby のコードを外部の関数として扱うと割り切ればマーシャリングの処理をハンドラの中に隠すことができます。 思い切って書き換えてみます。

  def handle_call({:eva_ruby, expression}, from, %{port: port, froms: froms} = state) do
    send(port, {self(), {:command, "print(Marshal.dump(#{expression}))\n"}})

    {:noreply, %{state | froms: [from | froms]}}
  end

  def handle_info({port, {:data, data}}, %{port: port, froms: [from | froms]} = state) do
    GenServer.reply(from, ExMarshal.load(data))

    {:noreply, %{state | froms: froms}}
  end

修正したコードの内容を反映して Ruby の式を評価してみます。

iex> ExIRB.eva_ruby("nil")
nil
iex> ExIRB.eva_ruby("true")
true
iex> ExIRB.eva_ruby("true")
true
iex> ExIRB.eva_ruby("false")
false
iex> ExIRB.eva_ruby("123")
123
iex> ExIRB.eva_ruby("[1,2,3]")
[1, 2, 3]
iex> ExIRB.eva_ruby("{a: 1, b: '2', c: :three}")
%{a: 1, b: "2", c: :three}

文字列の中は Ruby の式として評価されるのでメソッドも記述できます。 結果は ExMarshal.load/1 で変換しているので Elixir の値として返されます。

iex> ExIRB.eva_ruby("(1..10).map {|i| i * i }")
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Level 5, Enchanter: ライブラリを読み込む

irb のコマンドラインオプション -r で起動時にライブラリを読み込むことができます。

ここでは ExIRB.start_link/1 の引数で指定できるようにしてみます。

ExIRB.init/1 を次のように書き換えます。

  def init(opts) do
    path = System.find_executable("irb")
    requires =
      opts
      |> Keyword.get(:require, [])
      |> Enum.map(&"-r#{&1}")
    port = Port.open({:spawn_executable, path}, [:binary, args: ["--noverbose", "--noecho" | requires]])

    {:ok, %{port: port, froms: []}}
  end

オプションで :require で指定された値をライブラリ名のリストとして -r をつけて irb のオプションの形式にします。 Port.open/2 の起動時の引数にそれらを渡します。

ExIRB.start_link/1 でライブラリを指定します。

iex> ExIRB.start_link(require: ["yaml"])

ここでは yaml を指定しています。 これで YAML のメソッドを利用することができるようになりました。

iex> ExIRB.eva_ruby("YAML.load('---\n- 1\n- 2\n')")
[1, 2]

混乱しそうですが、こんなこともできます。

iex> yaml = """
...> ---
...> - 1
...> - 2
...> - a:
...>   - 3
...>   - 4
...> """
"---\n- 1\n- 2\n- a:\n  - 3\n  - 4\n"
iex> ExIRB.eva_ruby("YAML.load('#{yaml}')")
[1, 2, %{"a" => [3, 4]}]

Level 6, Warlock: apply(module, function, arguments)

Ruby の式を文字列で記述する代わりにモジュール名とメソッド名と引数列を評価できれば Elixir の値を渡すことができます。 ちょうど Kernel.apply/3 のような記述です。

このためにはまず引数列を文字列に変換する必要がありますが、これは個々の値を Kernel.inspect/2 で評価してコンマで連結すれば良さそうです。

iex> args = [1, "2", :three] |> Enum.map(&inspect/1) |> Enum.join(",")
"1,\"2\",:three"

iex> "Foo.bar(#{args})"
"Foo.bar(1,\"2\",:three)"

よさそうなのですが、いくつか落とし穴があるので注意しなければなりません。

長い値は省略される

要素の数が多く表現が長くなるばあい、途中から省略されてしまいます。

iex> (1..55) |> Enum.to_list() |> inspect()
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, ...]"

すべての要素を表示させるためには :limit オプションに :infinity を指定します。

iex> (1..55) |> Enum.to_list() |> inspect(limit: :infinity)
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55]"

表示できる文字コードのリストは charlist として表示される

Erlang や Elixir の「クセ」の部分。 整数値のリストなのに、その整数値が文字コードとして表示できるばあい、文字のリスト (charlist) として表現されてしまいます。

iex> (65..90) |> Enum.to_list() |> inspect(limit: :infinity)
"'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"

整数値のリストとして表示させるためには :charlists オプションに false を指定します。

iex> (65..90) |> Enum.to_list() |> inspect(limit: :infinity, charlists: false)
"[65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90]"

マップはには % が付く

マップを inspect すると、%{ と } で囲まれた文字列になります。 これは Elixir の仕様ですから、もうどうしようもありません。

iex> %{a: 1} |> inspect(limit: :infinity, charlits: false)
"%{a: 1}"

…と、あきらめかけていたのですが。 バージョン 1.9.0 から :inspect_fun オプションに適切な変換を行う関数を渡すことで任意の表示をさせることができるようになりました。

• Inspect.Opts

たとえば次のような関数 MapToHash.inspect_fun/2 を用意します。

defmodule MapToHash do
  import Inspect.Algebra

  def inspect_fun(term, opts) when is_map(term) do
    arrow = string("=>")
    comma = string(",")

    docs =
      term
      |> Enum.reduce([string("}")], fn {k, v}, acc ->
        key = inspect_fun(k, opts)
        value = inspect_fun(v, opts)
        [comma, key, arrow, value | acc]
      end)

    docs =
      case docs do
        [^comma | docs] -> docs
        docs -> docs
      end

    concat([string("{") | docs])
  end

  def inspect_fun(term, opts) do
    Inspect.inspect(term, opts)
  end
end

この関数を :inspect_fun オプションに指定します。

iex> inspect(%{a: 1}, limit: :infinity, charlists: false, inspect_fun: &MapToHash.inspect_fun/2)
"{:a=>1}"

入れ子になったマップでも空のマップでも Ruby のハッシュの形式の文字列で出力できます。

iex> inspect(%{a: 1, b: %{c: %{d: :e}}}, limit: :infinity, charlists: false, inspect_fun: &MapToHash.inspect_fun/2)
"{:b=>{:c=>{:d=>:e}},:a=>1}"
iex> inspect(%{}, limit: :infinity, charlists: false, inspect_fun: &MapToHash.inspect_fun/2)
"{}"

Elixir のモジュール名には Elixir が付いている

あとはモジュール名と関数名とを連結して先に書いた関数で Ruby にメッセージを送ればよさそうです。

まず期待する文字列を組み立てられるか、次のような関数を書いて確かめてみます。

  def apply(module, function, args) do
    args_str =
      args
      |> Enum.map(fn arg ->
        arg
        |> inspect(limit: :infinity, charlists: false, inspect_fun: &MapToHash.inspect_fun/2)
      end)
      |> Enum.join(",")

    "#{module}.#{function}(#{args_str})"
  end

モジュール名と関数名を文字列で指定してみます。

iex> ExIRB.apply("YAML", "load", ["---\n- 1\n - 2\n"])
"YAML.load(\"---\\n- 1\\n - 2\\n\")"

よさそうです。

次に関数名をアトムで指定してみます。

iex> ExIRB.apply("YAML", :load, ["---\n- 1\n - 2\n"])
"YAML.load(\"---\\n- 1\\n - 2\\n\")"

これもよさそうです。

最後に kernel.apply/3 と同じようにモジュール名で指定してみます。

iex> ExIRB.apply(YAML, :load, ["---\n- 1\n - 2\n"])
"Elixir.YAML.load(\"---\\n- 1\\n - 2\\n\")"

Elixir の文字列がつきました。

Elixir のモジュール名の実態はアトムです。

iex> is_atom(YAML)
true

ですのでモジュールが定義されていなくてもモジュール名は自由に使うことができます。 ただし注意する点がああります。たとえば YAML と書いたばあい内部的には :"Elixir.YAML" という値になっているという点です。 これは IEx でも簡単に確認することができます。

iex> :"Elixir.YAML"
YAML

iex> :"Elixir.YAML" == YAML
true

モジュールは Module.split/1 を使うと安全に文字列として分割できるので今回はこれを使うことにします。

iex> [module_name] = Module.split(YAML)
["YAML"]
iex> module_name
"YAML"

上に書いた apply 関数を修正して、組み立てた文字列を Ruby で評価する関数にします。

  def apply(server \\ @name, module, function, args) do
    [module_name] = Module.split(module)
    args_str =
      args
      |> Enum.map(fn arg ->
        arg
        |> inspect(limit: :infinity, charlists: false, inspect_fun: &MapToHash.inspect_fun/2)
      end)
      |> Enum.join(",")

    GenServer.call(server, {:eval_ruby, "#{module_name}.#{function}(#{args_str})"})
  end

iex> ExIRB.start_link(require: ["yaml"])
iex> ExIRB.apply(YAML, :load, ["---\n- 1\n- 2\n"])
[1, 2]
iex> ExIRB.apply(YAML, :dump, [%{a: 1}])
"---\n:a: 1\n"

これで Kernel.apply/3 と同じ書式で Ruby のメソッドを呼び出せるようになりました。

Level 7, Sorcerer: 関数を定義する

apply できるようになりましたが、やはり本来の関数名で呼び出したいものです。

関数を定義してみましょう。

defmodule ExYAML do
  def load(str), do: ExIRB.apply(YAML, :load, [str])
  def dump(term), do: ExIRB.apply(YAML, :dump, [term])
end

iex> ExIRB.start_link(require: ["yaml"])
iex> ExYAML.dump(%{a: 1})
"---\n:a: 1\n"
iex(3)> ExYAML.load("---\n- 1\n- 2\n")
[1, 2]

呼び出しは便利になりましたが関数を定義するのが面倒です。

そんなときは。 そう、マクロです。

関数を定義するマクロを定義します。

defmodule Importer do
  defmacro import_ruby(module, function) do
    quote do
      def unquote(function)(args) do
        ExIRB.apply(unquote(module), unquote(function), args)
      end
    end
  end
end

関数を定義したいモジュールでマクロを展開します。

defmodule ExYAML do
  require Importer
  import Importer

  import_ruby YAML, :load
  import_ruby YAML, :dump
end

これだけで関数が使えるようになります。

iex> ExIRB.start_link(require: ["yaml"])
iex> ExYAML.dump([%{a: 1}])
"---\n:a: 1\n"
iex(3)> ExYAML.load(["---\n- 1\n- 2\n"])
[1, 2]

しかし。このままでは一つの引数しか受け取れないので複数の引数を渡したいときにはリストにまとめて渡す必要があります。

引数の数も定義できる方法を考えます。

まず、quote された関数の構造を調べます。

iex> quote do
...>   def dump(term, opts) do
...>     ExIRB.apply(YAML, :dump, [term, opts])
...>   end
...> end
{:def, [context: Elixir, import: Kernel],
 [
   {:dump, [context: Elixir], [{:term, [], Elixir}, {:opts, [], Elixir}]},
   [
     do: {{:., [], [{:__aliases__, [alias: false], [:ExIRB]}, :apply]}, [],
      [
        {:__aliases__, [alias: false], [:YAML]},
        :dump,
        [{:term, [], Elixir}, {:opts, [], Elixir}]
      ]}
   ]
 ]}

二つの引数 (term, opts) は、[{:term, [], Elixir}, {:opts, [], Elixir}] という構造に展開されていることがわかります。 また ExIRB.apply/3 の三つ目の引数 [term, opts] も同じ構造になっています。

つまり必要な引数の数だけこの構造を並べたものをマクロの値として返すようにすれば、欲しい引数の数の関数を得ることができるはずです。

引数の構造を組み立てます。 26 個より多い引数を持つ関数はないだろうという大雑把な考えのもと、Stream で個々の引数のタプルを組み立て Enum.take/2 で切り出します。

args =
  (?a..?z)
  |> Stream.map(&{String.to_atom(<<&1>>), [], __MODULE__})
  |> Enum.take(arity)

これを関数の定義に組み込みます。 全体では、このようになります。

defmodule Importer do
  defmacro import_ruby(module, function, arity) do
    args =
      (?a..?z)
      |> Stream.map(&{String.to_atom(<<&1>>), [], __MODULE__})
      |> Enum.take(arity)

    {
      :def, [context: __MODULE__, import: Kernel],
      [
        {
          function,
          [context: __MODULE__],
          args
        },
        [do: {
          {:., [], [ExIRB, :apply]},
          [],
          [
            module,
            function,
            args
          ]
        }]
      ]
    }
  end
end

マクロを展開します。 追加した第三引数に引数の個数を指定する必要がありますが、これを利用することで引数の個数違いの関数を定義することができるようになりました。

defmodule ExYAML do
  require Importer
  import Importer

  import_ruby YAML, :load, 1
  import_ruby YAML, :dump, 1
  import_ruby YAML, :dump, 2
end

iex> ExIRB.start_link(require: ["yaml"])
iex> ExYAML.dump([1, [2, [3, 4]]])
"---\n- 1\n- - 2\n  - - 3\n    - 4\n"
iex> ExYAML.dump([1, [2, [3, 4]]], %{indentation: 4})
"---\n- 1\n-   - 2\n    -   - 3\n        - 4\n"

これで扱いやすくなりました。

しかしまだ何度も import_ruby YAML と書かなければならない手間があります。

Kernel.SpecialForms.import/2 のように、関数名と引数の個数をペアにしたキーワードリストでまとめて定義できるようにしてみます。

マクロを修正します。

defmodule Importer do
  defmacro import_ruby(module, functions) do
    functions
    |> Enum.map(fn {function, arity} ->
      args =
        (?a..?z)
        |> Stream.map(&{String.to_atom(<<&1>>), [], __MODULE__})
        |> Enum.take(arity)

      {
        :def, [context: __MODULE__, import: Kernel],
        [
          {
            function,
            [context: __MODULE__],
            args
          },
          [do: {
            {:., [], [ExIRB, :apply]},
            [],
            [
              module,
              function,
              args
            ]
          }]
        ]
      }
    end)
  end
end

利用する側も修正します。

defmodule ExYAML do
  require Importer
  import Importer

  import_ruby YAML, load: 1, dump: 1, dump: 2
end

利用しやすくなりました。

Level 8, Necromancer: モジュールを定義する

しかしまだ問題があります。

defmodule ExYAMLandJSON do
  require Importer
  import Importer

  import_ruby YAML, load: 1, dump: 1
  import_ruby JSON, load: 1, dump: 1
end

同じ名前、同じ引数の数の関数を定義すると、先に定義した関数にすべてのパタンがマッチしてしまい後から定義した関数は呼ばれません。

iex> ExYAMLandJSON.dump(%{a: 1})
"---\n:a: 1\n"

名前空間をわけたいところです。 Ruby のモジュール名を渡しているので、これを名前空間にできないか考えます。

こんどは quote されたモジュールの構造を調べます。

iex> quote do
...>   defmodule Yaml do
...>     def dump(term) do
...>       ExIRB.apply(YAML, :dump, [term])
...>     end
...>
...>     def load(str) do
...>       ExIRB.apply(YAML, :dump, [str])
...>     end
...>   end
...> end
{:defmodule, [context: Elixir, import: Kernel],
 [
   {:__aliases__, [alias: false], [:Yaml]},
   [
     do: {:__block__, [],
      [
        {:def, [context: Elixir, import: Kernel],
         [
           {:dump, [context: Elixir], [{:term, [], Elixir}]},
           [
             do: {{:., [], [{:__aliases__, [alias: false], [:ExIRB]}, :apply]},
              [],
              [
                {:__aliases__, [alias: false], [:YAML]},
                :dump,
                [{:term, [], Elixir}]
              ]}
           ]
         ]},
        {:def, [context: Elixir, import: Kernel],
         [
           {:load, [context: Elixir], [{:str, [], Elixir}]},
           [
             do: {{:., [], [{:__aliases__, [alias: false], [:ExIRB]}, :apply]},
              [],
              [
                {:__aliases__, [alias: false], [:YAML]},
                :dump,
                [{:str, [], Elixir}]
              ]}
           ]
         ]}
      ]}
   ]
 ]}

関数を定義するタプル {:def, ...} の部分を除くと思いの外シンプルです。

また、マクロを利用するモジュールの名前空間の中でモジュールを定義したいわけですが、そのモジュール名は Kernel.SpecialForms.__CALLER__/0 で取得することができます。

これらをすべて適用します。

defmodule Requirer do
  defmacro require_ruby(module, functions) do
    ruby_module =
      case module do
        {:__aliases__, _, [ruby_module]} -> ruby_module
        module -> module
      end

    quoted_functions =
      functions
      |> Enum.map(fn {function, arity} ->
        args =
          (?a..?z)
          |> Stream.map(&{String.to_atom(<<&1>>), [], __MODULE__})
          |> Enum.take(arity)

        {
          :def, [import: Kernel],
          [
            {function, [], args},
            [do: {
              {:., [], [ExIRB, :apply]},
              [],
              [module, function, args]
            }]
          ]
        }
      end)

    {
      :defmodule,
      [import: Kernel],
      [
        Module.concat(__CALLER__.module, ruby_module),
        [do: {:__block__, [], quoted_functions}]
      ]
    }
  end
end

マクロを利用するモジュールを書きます。

defmodule ExYAMLandJSON do
  require Requirer
  import Requirer

  require_ruby YAML, load: 1, dump: 1
  require_ruby JSON, load: 1, dump: 1
end

使ってみます。

iex> ExIRB.start_link(require: ["yaml", "json"])
iex> ExYAMLandJSON.JSON.dump(%{a: 1, b: [1, 2, 3]})
"{\"b\":[1,2,3],\"a\":1}"
iex> ExYAMLandJSON.YAML.dump(%{a: 1, b: [1, 2, 3]})
"---\n:b:\n- 1\n- 2\n- 3\n:a: 1\n"

マクロを利用するモジュールの名前に require_ruby したモジュールの名前を連結した新しいモジュールが定義され、その各々に関数が定義されました。

Level 9, Wizard: ぜんぶまとめると

これらのコードを整理して GitHub に push しました

• mattsan/ex_irb
• mattsan/ex_marshal

使ってみましょう。

プロジェクトを作成する

新しいプロジェクトを作成します。プロセスを supervisor で管理したいので --sup オプションを指定します。

$ mix new sample --sup
$ cd sample

依存パッケージを設定する

mix.exs を編集して依存パッケージに ex_irb を指定します。

defmodule Sample.MixProject do
  use Mix.Project

  def project do
    [
      app: :sample,
      version: "0.1.0",
      elixir: "~> 1.9",
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end

  def application do
    [
      extra_applications: [:logger],
      mod: {Sample.Application, []}
    ]
  end

  defp deps do
    [
      {:ex_irb, github: "mattsan/ex_irb"}
    ]
  end
end

パッケージを取得します。

$ mix deps.get

ExIRB プロセスの起動を設定する

lib/sample/application.ex を編集して ExIRB のプロセスを起動する設定を記述します。

defmodule Sample.Application do
  @moduledoc false

  use Application

  def start(_type, _args) do
    children = [
      {ExIRB, require: ["yaml", "json"]}
    ]

    opts = [strategy: :one_for_one, name: Sample.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

召喚するモジュールを記述する

ExIRB.Requirer を使って Ruby のモジュールを Elixir のモジュールに召喚します。

defmodule Sample do
  @moduledoc """
  Documentation for Sample.
  """

  require ExIRB.Requirer
  import ExIRB.Requirer

  require_ruby YAML, load: 1, dump: 1, dump: 2
  require_ruby JSON, load: 1, dump: 1
end

使う

iex を起動します。

$ iex -S mix

iex のプロンプトから召喚した Ruby のメソッドを呼びます。 アプリケーションが起動するときに ExIRB を起動しているのですぐに利用することができます。

iex> Sample.JSON.dump(%{a: 1})
"{\"a\":1}"
iex> Sample.YAML.dump(%{a: 1})
"---\n:a: 1\n"
iex> Sample.JSON.load(~S[{"a":1}])
%{"a" => 1}
iex> Sample.YAML.load("---\na: 1\n")
%{"a" => 1}

ちなみに。

終了処理をきちんと書いていないので、 iex を終了すると irb と接続しているポートが閉じて irb が例外を投げスタックトレイスを吐き出して停止します。

まぁ、黒魔術だから…。

結論

わかりやすく書こう。

----うますぎるプログラムはいけない

プログラム書法 第2版

いつか読むはずっと読まない：霊媒師、占い師、奇術師、…

ダンジョンズ&ドラゴンズ スターター・セット第5版