Rename StringIO API to be more IO like (start -> open, stop -> close)

Author: José Valim

lib/elixir/lib/string_io.ex

@@ -4,7 +4,7 @@ defmodule StringIO do
 
   ## Examples
 
-      iex> { :ok, pid } = StringIO.start("foo")
+      iex> { :ok, pid } = StringIO.open("foo")
       iex> IO.read(pid, 2)
       "fo"
   """
@@ -22,31 +22,21 @@ defmodule StringIO do
 
   ## Examples
 
-      iex> { :ok, pid } = StringIO.start("foo")
+      iex> { :ok, pid } = StringIO.open("foo")
       iex> IO.gets(pid, ">")
       "foo"
-      iex> StringIO.peek(pid)
+      iex> StringIO.contents(pid)
       { "", "" }
 
-      iex> { :ok, pid } = StringIO.start("foo", capture_prompt: true)
+      iex> { :ok, pid } = StringIO.open("foo", capture_prompt: true)
       iex> IO.gets(pid, ">")
       "foo"
-      iex> StringIO.peek(pid)
+      iex> StringIO.contents(pid)
       { "", ">" }
 
   """
-  @spec start(binary, Keyword.t) :: { :ok, pid }
-  def start(string, options \\ []) when is_binary(string) do
-    :gen_server.start(__MODULE__, { string, options }, [])
-  end
-
-  @doc """
-  Creates an IO device.
-
-  See also `start/2`
-  """
-  @spec start_link(binary, Keyword.t) :: { :ok, pid }
-  def start_link(string, options \\ []) when is_binary(string) do
+  @spec open(binary, Keyword.t) :: { :ok, pid }
+  def open(string, options \\ []) when is_binary(string) do
     :gen_server.start_link(__MODULE__, { string, options }, [])
   end
 
@@ -55,29 +45,29 @@ defmodule StringIO do
 
   ## Examples
 
-      iex> { :ok, pid } = StringIO.start("in")
+      iex> { :ok, pid } = StringIO.open("in")
       ...> IO.write(pid, "out")
-      ...> StringIO.peek(pid)
+      ...> StringIO.contents(pid)
       { "in", "out" }
   """
-  @spec peek(pid) :: { binary, binary }
-  def peek(pid) when is_pid(pid) do
-    :gen_server.call(pid, :peek)
+  @spec contents(pid) :: { binary, binary }
+  def contents(pid) when is_pid(pid) do
+    :gen_server.call(pid, :contents)
   end
 
   @doc """
   Stops the IO device and returns remaining buffers.
 
   ## Examples
 
-      iex> { :ok, pid } = StringIO.start("in")
+      iex> { :ok, pid } = StringIO.open("in")
       ...> IO.write(pid, "out")
-      ...> StringIO.stop(pid)
+      ...> StringIO.close(pid)
       { :ok, { "in", "out" } }
   """
-  @spec stop(pid) :: { :ok, { binary, binary } }
-  def stop(pid) when is_pid(pid) do
-    :gen_server.call(pid, :stop)
+  @spec close(pid) :: { :ok, { binary, binary } }
+  def close(pid) when is_pid(pid) do
+    :gen_server.call(pid, :close)
   end
 
   ## callbacks
@@ -96,11 +86,11 @@ defmodule StringIO do
     super(msg, s)
   end
 
-  def handle_call(:peek, _from, state(input: input, output: output) = s) do
+  def handle_call(:contents, _from, state(input: input, output: output) = s) do
     { :reply, { input, output }, s }
   end
 
-  def handle_call(:stop, _from, state(input: input, output: output) = s) do
+  def handle_call(:close, _from, state(input: input, output: output) = s) do
     { :stop, :normal, { :ok, { input, output } }, s }
   end
 
@@ -164,7 +154,7 @@ defmodule StringIO do
   end
 
   defp io_request(:getopts, s) do
-    { [ binary: true, encoding: :unicode ], s }
+    { { :ok, [binary: true, encoding: :unicode] }, s }
   end
 
   defp io_request({ :get_geometry, :columns }, s) do

lib/elixir/test/elixir/string_io_test.exs

@@ -4,29 +4,29 @@ defmodule StringIOTest do
   use ExUnit.Case, async: true
 
   test "start and stop" do
-    { :ok, pid } = StringIO.start("")
-    assert StringIO.stop(pid) == { :ok, { "", "" } }
+    { :ok, pid } = StringIO.open("")
+    assert StringIO.close(pid) == { :ok, { "", "" } }
   end
 
   test "start_link and stop" do
-    { :ok, pid } = StringIO.start_link("")
-    assert StringIO.stop(pid) == { :ok, { "", "" } }
+    { :ok, pid } = StringIO.open("")
+    assert StringIO.close(pid) == { :ok, { "", "" } }
   end
 
   test "peek" do
-    { :ok, pid } = StringIO.start("abc")
+    { :ok, pid } = StringIO.open("abc")
     IO.write(pid, "edf")
-    assert StringIO.peek(pid) == { "abc", "edf" }
+    assert StringIO.contents(pid) == { "abc", "edf" }
   end
 
   ## IO module
 
   def start(string, opts \\ []) do
-    StringIO.start(string, opts) |> elem(1)
+    StringIO.open(string, opts) |> elem(1)
   end
 
   def contents(pid) do
-    StringIO.peek(pid)
+    StringIO.contents(pid)
   end
 
   test "IO.read :line with \\n" do

lib/ex_unit/lib/ex_unit/capture_io.ex

@@ -89,12 +89,12 @@ defmodule ExUnit.CaptureIO do
     input = Keyword.get(options, :input, "")
 
     original_gl = :erlang.group_leader
-    { :ok, capture_gl } = StringIO.start_link(input, capture_prompt: prompt_config)
+    { :ok, capture_gl } = StringIO.open(input, capture_prompt: prompt_config)
     :erlang.group_leader(capture_gl, self)
 
     try do
       fun.()
-      StringIO.stop(capture_gl) |> elem(1) |> elem(1)
+      StringIO.close(capture_gl) |> elem(1) |> elem(1)
     after
       :erlang.group_leader(original_gl, self)
     end
@@ -112,12 +112,12 @@ defmodule ExUnit.CaptureIO do
     input = Keyword.get(options, :input, "")
 
     Process.unregister(device)
-    { :ok, capture_io } = StringIO.start_link(input)
+    { :ok, capture_io } = StringIO.open(input)
     Process.register(capture_io, device)
 
     try do
       fun.()
-      StringIO.stop(capture_io) |> elem(1) |> elem(1)
+      StringIO.close(capture_io) |> elem(1) |> elem(1)
     after
       try do
         Process.unregister(device)

lib/ex_unit/test/ex_unit/capture_io_test.exs

@@ -250,22 +250,14 @@ defmodule ExUnit.CaptureIOTest do
 
   test "with setopts" do
     assert capture_io(fn ->
-      :io.setopts({ :encoding, :latin1 })
+      assert :io.setopts({ :encoding, :latin1 }) == {:error, :enotsup}
     end) == ""
-
-    capture_io(fn ->
-      assert :io.setopts({ :encoding, :latin1 }) == :ok
-    end)
   end
 
   test "with getopts" do
     assert capture_io(fn ->
-      :io.getopts
+      assert :io.getopts == { :ok, [binary: true, encoding: :unicode] }
     end) == ""
-
-    capture_io(fn ->
-      assert :io.getopts == { :error, :enotsup }
-    end)
   end
 
   test "with columns" do