Release 1.0.0: require localize 1.0, add credo and strict dialyzer

Author: kipcole9

.credo.exs

@@ -0,0 +1,25 @@
+# Credo configuration for Unity.
+#
+# Mirrors the Localize policy: strict, with `Design.AliasUsage` disabled.
+# Unit parsing and conversion code fully qualifies many calls because
+# module names such as `Localize.Unit` and `Unity.Unit` read more clearly
+# at the call site than an alias, and because trailing segments such as
+# `Unit`, `Parser` and `List` shadow other modules when aliased. Alias
+# submodules opportunistically where the trailing segment does not clash,
+# never as a bulk conversion.
+%{
+  configs: [
+    %{
+      name: "default",
+      strict: true,
+      files: %{
+        included: ["lib/", "test/"]
+      },
+      checks: %{
+        disabled: [
+          {Credo.Check.Design.AliasUsage, []}
+        ]
+      }
+    }
+  ]
+}

.github/workflows/ci.yml

@@ -43,10 +43,12 @@ jobs:
             otp: "28"
 
           # Elixir 1.20 — supports OTP 27–28
-          - elixir: "1.20.0-rc.4-otp-27"
+          - elixir: "1.20.2-otp-27"
             otp: "27"
-          - elixir: "1.20.0-rc.4-otp-28"
+          - elixir: "1.20.2-otp-28"
             otp: "28"
+          - elixir: "1.20.2-otp-29"
+            otp: "29"
             lint: true
 
     steps:
@@ -76,6 +78,10 @@ jobs:
         if: matrix.lint
         run: mix format --check-formatted
 
+      - name: Run credo
+        if: matrix.lint
+        run: mix credo --strict
+
       - name: Compile (warnings as errors)
         run: mix compile --warnings-as-errors
 
@@ -102,3 +108,9 @@ jobs:
         env:
           MIX_ENV: dev
         run: mix dialyzer
+
+      - name: Check docs
+        if: matrix.lint
+        env:
+          MIX_ENV: release
+        run: mix docs --warnings-as-errors

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v1.0.0 (2026-07-31)
+
+### Changed
+
+* Requires `localize ~> 1.0`. The previous requirement of `~> 0.9` excluded Localize 1.0.
+
 ## v0.7.0 (2026-05-10)
 
 ### Enhancements

README.md

@@ -34,7 +34,7 @@ Add `unity` to your list of dependencies in `mix.exs`:
 ```elixir
 def deps do
   [
-    {:unity, "~> 0.5"}
+    {:unity, "~> 1.0"}
   ]
 end
 ```

lib/unity/cli.ex

@@ -31,44 +31,51 @@ defmodule Unity.CLI do
   """
   @spec main([String.t()]) :: :ok
   def main(args) do
-    {options, positional, _invalid} =
-      OptionParser.parse(args,
-        aliases: [
-          v: :verbose,
-          t: :terse,
-          q: :quiet,
-          h: :help,
-          d: :digits,
-          e: :exponential,
-          o: :output_format,
-          s: :strict,
-          f: :file
-        ],
-        switches: [
-          verbose: :boolean,
-          terse: :boolean,
-          quiet: :boolean,
-          strict: :boolean,
-          exponential: :boolean,
-          one_line: :boolean,
-          no_color: :boolean,
-          locale: :string,
-          digits: :integer,
-          output_format: :string,
-          file: :keep,
-          conformable: :string,
-          list: :string,
-          version: :boolean,
-          help: :boolean
-        ]
-      )
+    {options, positional, _invalid} = parse_args(args)
 
     # Load custom unit files before any evaluation
     load_custom_unit_files(options)
 
     # Configure color output
     if options[:no_color], do: Application.put_env(:unity, :no_color, true)
 
+    dispatch(options, positional)
+  end
+
+  defp parse_args(args) do
+    OptionParser.parse(args,
+      aliases: [
+        v: :verbose,
+        t: :terse,
+        q: :quiet,
+        h: :help,
+        d: :digits,
+        e: :exponential,
+        o: :output_format,
+        s: :strict,
+        f: :file
+      ],
+      switches: [
+        verbose: :boolean,
+        terse: :boolean,
+        quiet: :boolean,
+        strict: :boolean,
+        exponential: :boolean,
+        one_line: :boolean,
+        no_color: :boolean,
+        locale: :string,
+        digits: :integer,
+        output_format: :string,
+        file: :keep,
+        conformable: :string,
+        list: :string,
+        version: :boolean,
+        help: :boolean
+      ]
+    )
+  end
+
+  defp dispatch(options, positional) do
     cond do
       options[:version] ->
         IO.puts("Unity v#{@version}")
@@ -102,24 +109,27 @@ defmodule Unity.CLI do
     format_options = build_format_options(options, nil)
 
     IO.stream(:stdio, :line)
-    |> Enum.each(fn line ->
-      expression = String.trim(line)
+    |> Enum.each(&evaluate_stdin_line(&1, format_options))
+  end
 
-      if expression != "" do
-        expr_options = Keyword.put(format_options, :input, expression)
+  defp evaluate_stdin_line(line, format_options) do
+    expression = String.trim(line)
 
-        case Unity.eval(expression) do
-          {:ok, result, _env} ->
-            case Unity.Formatter.format(result, expr_options) do
-              {:ok, formatted} -> IO.puts(formatted)
-              {:error, reason} -> IO.puts(:stderr, Unity.Error.format(reason))
-            end
+    if expression != "" do
+      expr_options = Keyword.put(format_options, :input, expression)
 
-          {:error, message} ->
-            IO.puts(:stderr, Unity.Error.format(message))
-        end
+      case Unity.eval(expression) do
+        {:ok, result, _env} -> print_result(result, expr_options)
+        {:error, message} -> IO.puts(:stderr, Unity.Error.format(message))
       end
-    end)
+    end
+  end
+
+  defp print_result(result, expr_options) do
+    case Unity.Formatter.format(result, expr_options) do
+      {:ok, formatted} -> IO.puts(formatted)
+      {:error, reason} -> IO.puts(:stderr, Unity.Error.format(reason))
+    end
   end
 
   defp io_tty? do
@@ -134,34 +144,37 @@ defmodule Unity.CLI do
       Localize.put_locale(locale)
     end
 
-    expression =
-      case positional do
-        # "units - feet" reads from stdin for the source
-        ["-", target] ->
-          source = IO.read(:stdio, :eof) |> String.trim()
-          "#{source} to #{target}"
+    expression = expression_from(positional)
+    format_options = build_format_options(options, expression)
 
-        [expr] ->
-          expr
+    case Unity.eval(expression) do
+      {:ok, result, _env} -> print_result_or_exit(result, format_options)
+      {:error, message} -> error_exit(message)
+    end
+  end
 
-        [from, to] ->
-          "#{from} to #{to}"
+  defp expression_from(positional) do
+    case positional do
+      # "units - feet" reads from stdin for the source
+      ["-", target] ->
+        source = IO.read(:stdio, :eof) |> String.trim()
+        "#{source} to #{target}"
 
-        _ ->
-          Enum.join(positional, " ")
-      end
+      [expr] ->
+        expr
 
-    format_options = build_format_options(options, expression)
+      [from, to] ->
+        "#{from} to #{to}"
 
-    case Unity.eval(expression) do
-      {:ok, result, _env} ->
-        case Unity.Formatter.format(result, format_options) do
-          {:ok, formatted} -> IO.puts(formatted)
-          {:error, reason} -> error_exit(reason)
-        end
+      _ ->
+        Enum.join(positional, " ")
+    end
+  end
 
-      {:error, message} ->
-        error_exit(message)
+  defp print_result_or_exit(result, format_options) do
+    case Unity.Formatter.format(result, format_options) do
+      {:ok, formatted} -> IO.puts(formatted)
+      {:error, reason} -> error_exit(reason)
     end
   end
 

lib/unity/conversion/gauge.ex

@@ -34,7 +34,7 @@ defmodule Unity.Conversion.Gauge do
   # Volume of sphere = 4/3 π r³, so r = (3V / 4π)^(1/3)
   # V = pound / (ga * leaddensity)
   @pound 0.45359237
-  @lead_density 11340.0
+  @lead_density 11_340.0
   @pi :math.pi()
 
   @doc "Shotgun gauge number to bore diameter in meters."

lib/unity/gnu_units_importer.ex

@@ -23,7 +23,7 @@ defmodule Unity.GnuUnitsImporter do
 
   """
 
-  alias Unity.GnuUnitsImporter.{Parser, Resolver, Registrar}
+  alias Unity.GnuUnitsImporter.{Parser, Registrar, Resolver}
 
   @bundled_path Application.app_dir(:unity, "priv/definitions.units")
 

lib/unity/gnu_units_importer/parser.ex

@@ -154,7 +154,7 @@ defmodule Unity.GnuUnitsImporter.Parser do
         %{state | primitives: Map.put(state.primitives, name, type)}
 
       # Single-word expression that doesn't contain numbers or operators → alias
-      is_alias?(expression) ->
+      alias_expression?(expression) ->
         %{state | aliases: Map.put(state.aliases, name, expression)}
 
       # Regular unit definition
@@ -163,7 +163,7 @@ defmodule Unity.GnuUnitsImporter.Parser do
     end
   end
 
-  defp is_alias?(expression) do
+  defp alias_expression?(expression) do
     # An alias is a single identifier with no numbers, operators, spaces, or hyphens.
     # Must be purely alphabetic (no digits — "1e3" or "2^10" are not aliases).
     Regex.match?(~r/^[a-zA-Z_]+$/, expression)

lib/unity/gnu_units_importer/resolver.ex

@@ -197,13 +197,7 @@ defmodule Unity.GnuUnitsImporter.Resolver do
     sorted_prefixes = Process.get(:gnu_sorted_prefixes)
     known_bases = Process.get(:gnu_known_bases)
 
-    result =
-      Enum.find_value(sorted_prefixes, fn prefix ->
-        if String.starts_with?(name, prefix) and byte_size(name) > byte_size(prefix) do
-          remainder = binary_part(name, byte_size(prefix), byte_size(name) - byte_size(prefix))
-          if MapSet.member?(known_bases, remainder), do: {prefix, remainder}
-        end
-      end)
+    result = Enum.find_value(sorted_prefixes, &split_known_prefix(name, &1, known_bases))
 
     case result do
       {prefix, remainder} ->
@@ -219,6 +213,15 @@ defmodule Unity.GnuUnitsImporter.Resolver do
     end
   end
 
+  # Returns `{prefix, remainder}` when `name` starts with `prefix` and the
+  # remainder is a known base unit, otherwise `nil` so `find_value` continues.
+  defp split_known_prefix(name, prefix, known_bases) do
+    if String.starts_with?(name, prefix) and byte_size(name) > byte_size(prefix) do
+      remainder = binary_part(name, byte_size(prefix), byte_size(name) - byte_size(prefix))
+      if MapSet.member?(known_bases, remainder), do: {prefix, remainder}
+    end
+  end
+
   # ── Helpers ──
 
   defp split_on_slash(tokens), do: do_split_slash(tokens, [], 0)