rename info to identifiers

Signed-off-by: Connor Rigby <[email protected]>

Author: ConnorRigby

lib/gpio.ex

@@ -118,7 +118,7 @@ defmodule Circuits.GPIO do
     or be more helpful that the `:location`. It may be passed to `GPIO.open/3`.
   * `:controller` - the name or an alias for the GPIO controller. Empty string if unused
   """
-  @type info() :: %{
+  @type identifiers() :: %{
           location: {controller(), non_neg_integer()},
           controller: controller(),
           label: label()
@@ -186,11 +186,11 @@ defmodule Circuits.GPIO do
   See `t:gpio_spec/0` for the ways of referring to GPIOs. If the GPIO is found,
   this function returns information about the GPIO.
   """
-  @spec info(gpio_spec()) :: {:ok, info()} | {:error, atom()}
-  def info(gpio_spec) do
+  @spec identifiers(gpio_spec()) :: {:ok, identifiers()} | {:error, atom()}
+  def identifiers(gpio_spec) do
     {backend, backend_defaults} = default_backend()
 
-    backend.gpio_info(gpio_spec, backend_defaults)
+    backend.gpio_identifiers(gpio_spec, backend_defaults)
   end
 
   @doc """
@@ -225,7 +225,7 @@ defmodule Circuits.GPIO do
 
   Returns `{:ok, handle}` on success.
   """
-  @spec open(gpio_spec() | info(), direction(), open_options()) ::
+  @spec open(gpio_spec() | identifiers(), direction(), open_options()) ::
           {:ok, Handle.t()} | {:error, atom()}
   def open(gpio_spec_or_line_info, direction, options \\ [])
 
@@ -401,7 +401,7 @@ defmodule Circuits.GPIO do
   itself can also be passed to `open/3` and the function will figure out how to
   access the GPIO.
   """
-  @spec enumerate(backend() | nil) :: [info()]
+  @spec enumerate(backend() | nil) :: [identifiers()]
   def enumerate(backend \\ nil)
   def enumerate(nil), do: enumerate(default_backend())
   def enumerate({backend, options}), do: backend.enumerate(options)

lib/gpio/backend.ex

@@ -12,30 +12,30 @@ defmodule Circuits.GPIO.Backend do
   @doc """
   Return a list of GPIOs
 
-  See `t:GPIO.gpio_info/0` for the information that is returned. The `options` contain
+  See `t:GPIO.identifiers/0` for the information that is returned. The `options` contain
   backend-specific options to help with enumeration.
   """
-  @callback enumerate(options :: GPIO.open_options()) :: [GPIO.info()]
+  @callback enumerate(options :: GPIO.open_options()) :: [GPIO.identifiers()]
 
   @doc """
-  Return information about a GPIO
+  Return identifying information about a GPIO
 
   See `t:gpio_spec/0` for the ways of referring to GPIOs. The `options` contain
   backend-specific options to help enumerating GPIOs.
 
   If the GPIO is found, this function returns information about the GPIO.
   """
-  @callback gpio_info(
+  @callback gpio_identifiers(
               gpio_spec :: GPIO.gpio_spec(),
               options :: GPIO.open_options()
-            ) :: {:ok, GPIO.info()} | {:error, atom()}
+            ) :: {:ok, GPIO.identifiers()} | {:error, atom()}
 
   @doc """
   Return a GPIO's current status
 
   This function returns how a GPIO is configured. The GPIO doesn't need to be
-  opened. It's different from `gpio_info/2` since it returns dynamic information
-  whereas `gpio_info/2` only returns information about how to refer to a GPIO
+  opened. It's different from `gpio_identifiers/2` since it returns dynamic information
+  whereas `gpio_identifiers/2` only returns information about how to refer to a GPIO
   and where it exists in the system.
 
   See `t:gpio_spec/0` for the ways of referring to GPIOs. The `options` contain

lib/gpio/cdev.ex

@@ -70,20 +70,20 @@ defmodule Circuits.GPIO.CDev do
   end
 
   @impl Backend
-  def gpio_info(number, options) when is_integer(number) and number >= 0 do
+  def gpio_identifiers(number, options) when is_integer(number) and number >= 0 do
     retry_find(options, &find_by_index(&1, number))
   end
 
-  def gpio_info(line_label, options) when is_binary(line_label) do
+  def gpio_identifiers(line_label, options) when is_binary(line_label) do
     retry_find(options, &find_by_label(&1, line_label))
   end
 
-  def gpio_info(tuple_spec, options)
+  def gpio_identifiers(tuple_spec, options)
       when is_tuple(tuple_spec) and tuple_size(tuple_spec) == 2 do
     retry_find(options, &find_by_tuple(&1, tuple_spec))
   end
 
-  def gpio_info(_gpio_spec, _options) do
+  def gpio_identifiers(_gpio_spec, _options) do
     {:error, :not_found}
   end
 
@@ -101,8 +101,8 @@ defmodule Circuits.GPIO.CDev do
   end
 
   defp find_location(gpio_spec, options) do
-    with {:ok, gpio_info} <- gpio_info(gpio_spec, options) do
-      {:ok, gpio_info.location}
+    with {:ok, identifiers} <- gpio_identifiers(gpio_spec, options) do
+      {:ok, identifiers.location}
     end
   end
 

lib/gpio/diagnostics.ex

@@ -37,8 +37,8 @@ defmodule Circuits.GPIO.Diagnostics do
   """
   @spec report(GPIO.gpio_spec(), GPIO.gpio_spec()) :: boolean
   def report(out_gpio_spec, in_gpio_spec) do
-    {:ok, out_gpio_info} = GPIO.info(out_gpio_spec)
-    {:ok, in_gpio_info} = GPIO.info(in_gpio_spec)
+    {:ok, out_gpio_identifiers} = GPIO.identifiers(out_gpio_spec)
+    {:ok, in_gpio_identifiers} = GPIO.identifiers(in_gpio_spec)
     results = run(out_gpio_spec, in_gpio_spec)
     passed = Enum.all?(results, fn {_, result} -> result == :ok end)
     check_connections? = hd(results) != {"Simple writes and reads work", :ok}
@@ -51,8 +51,8 @@ defmodule Circuits.GPIO.Diagnostics do
       Output GPIO: #{inspect(out_gpio_spec)}
       Input GPIO:  #{inspect(in_gpio_spec)}
 
-      Output info: #{inspect(out_gpio_info)}
-      Input info:  #{inspect(in_gpio_info)}
+      Output info: #{inspect(out_gpio_identifiers)}
+      Input info:  #{inspect(in_gpio_identifiers)}
       Backend: #{inspect(Circuits.GPIO.backend_info()[:name])}
 
       """,

lib/gpio/nil_backend.ex

@@ -16,7 +16,7 @@ defmodule Circuits.GPIO.NilBackend do
   end
 
   @impl Backend
-  def gpio_info(_gpio_spec, _options) do
+  def gpio_identifiers(_gpio_spec, _options) do
     {:error, :not_found}
   end
 

test/circuits_gpio_test.exs

@@ -37,33 +37,33 @@ defmodule Circuits.GPIO2Test do
     assert info.pins_open == 0
   end
 
-  describe "info/2" do
+  describe "identifiers/2" do
     test "all gpio_spec examples" do
       expected = %{
         location: {"gpiochip0", 5},
         label: "pair_2_1",
         controller: "stub0"
       }
 
-      assert GPIO.info(5) == {:ok, expected}
-      assert GPIO.info("pair_2_1") == {:ok, expected}
-      assert GPIO.info({"gpiochip0", 5}) == {:ok, expected}
-      assert GPIO.info({"stub0", 5}) == {:ok, expected}
-      assert GPIO.info({"gpiochip0", "pair_2_1"}) == {:ok, expected}
-      assert GPIO.info({"stub0", "pair_2_1"}) == {:ok, expected}
-
-      assert GPIO.info(-1) == {:error, :not_found}
-      assert GPIO.info(64) == {:error, :not_found}
-      assert GPIO.info("something") == {:error, :not_found}
-      assert GPIO.info({"gpiochip0", 64}) == {:error, :not_found}
-      assert GPIO.info({"stub0", 64}) == {:error, :not_found}
-      assert GPIO.info({"gpiochip0", "something"}) == {:error, :not_found}
-      assert GPIO.info({"stub0", "something"}) == {:error, :not_found}
+      assert GPIO.identifiers(5) == {:ok, expected}
+      assert GPIO.identifiers("pair_2_1") == {:ok, expected}
+      assert GPIO.identifiers({"gpiochip0", 5}) == {:ok, expected}
+      assert GPIO.identifiers({"stub0", 5}) == {:ok, expected}
+      assert GPIO.identifiers({"gpiochip0", "pair_2_1"}) == {:ok, expected}
+      assert GPIO.identifiers({"stub0", "pair_2_1"}) == {:ok, expected}
+
+      assert GPIO.identifiers(-1) == {:error, :not_found}
+      assert GPIO.identifiers(64) == {:error, :not_found}
+      assert GPIO.identifiers("something") == {:error, :not_found}
+      assert GPIO.identifiers({"gpiochip0", 64}) == {:error, :not_found}
+      assert GPIO.identifiers({"stub0", 64}) == {:error, :not_found}
+      assert GPIO.identifiers({"gpiochip0", "something"}) == {:error, :not_found}
+      assert GPIO.identifiers({"stub0", "something"}) == {:error, :not_found}
     end
 
     test "lines in stub1" do
       for spec <- [33, "pair_16_1", {"stub1", "pair_16_1"}] do
-        info = GPIO.info(spec)
+        info = GPIO.identifiers(spec)
 
         expected_line_info = %{
           location: {"gpiochip1", 1},
@@ -78,7 +78,7 @@ defmodule Circuits.GPIO2Test do
 
     test "nonexistent lines" do
       for spec <- [-1, 65, "pair_100_0", {"stub10", "pair_2_0"}] do
-        info = GPIO.info(spec)
+        info = GPIO.identifiers(spec)
 
         assert info == {:error, :not_found},
                "Unexpected info for #{inspect(spec)} -> #{inspect(info)}"
@@ -468,13 +468,13 @@ defmodule Circuits.GPIO2Test do
 
     # Set the cache to something bogus and check that it's comes back
     :persistent_term.put(Circuits.GPIO.CDev, [bogus_gpio])
-    assert GPIO.info("not_a_gpio") == {:ok, bogus_gpio}
+    assert GPIO.identifiers("not_a_gpio") == {:ok, bogus_gpio}
 
     # Now check that the cache gets refreshed when a gpio isn't found
-    assert GPIO.info("pair_18_1") == {:ok, good_gpio}
+    assert GPIO.identifiers("pair_18_1") == {:ok, good_gpio}
 
     # The bogus GPIO doesn't come back
-    assert GPIO.info("not_a_gpio") == {:error, :not_found}
+    assert GPIO.identifiers("not_a_gpio") == {:error, :not_found}
   end
 
   test "write_one/2 + read_one/1" do