fix(lexicon): correct a bunch of mistakes in `deflexicon`

lib/atex/handle.ex

···
 defmodule Atex.Handle do
-  @re ~r/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/
+  @re ~r/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/
 
   @spec re() :: Regex.t()
   def re, do: @re

lib/atex/lexicon.ex

···
          def_name,
          %{
            type: "object",
-           properties: properties,
-           required: required
+           properties: properties
          } = def
        ) do
+    required = Map.get(def, :required, [])
     nullable = Map.get(def, :nullable, [])
 
     properties
···
         [schema] =
           def_to_schema(nsid, "params", %{
             type: "object",
-            required: def.parameters.required,
-            nullable: [],
+            required: Map.get(def.parameters, :required, []),
             properties: def.parameters.properties
           })
 
···
       end
 
     output =
-      if def.output && def.output.schema do
+      if def[:output] && def.output[:schema] do
         [schema] = def_to_schema(nsid, "output", def.output.schema)
         schema
       end
···
         [schema] =
           def_to_schema(nsid, "params", %{
             type: "object",
-            required: def.parameters.required,
+            required: Map.get(def.parameters, :required, []),
             properties: def.parameters.properties
           })
 
···
       end
 
     output =
-      if def[:output] && def.output.schema do
+      if def[:output] && def.output[:schema] do
         [schema] = def_to_schema(nsid, "output", def.output.schema)
         schema
       end
 
     input =
-      if def[:input] && def.input.schema do
-        [schema] = def_to_schema(nsid, "output", def.input.schema)
+      if def[:input] && def.input[:schema] do
+        [schema] = def_to_schema(nsid, "input", def.input.schema)
         schema
       end
 
···
         [schema] =
           def_to_schema(nsid, "params", %{
             type: "object",
-            required: def.parameters.required,
+            required: Map.get(def.parameters, :required, []),
             properties: def.parameters.properties
           })
 
···
       |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)
       |> then(&{:custom, {Validators.String, :validate, [&1]}})
       |> maybe_default(field)
-      |> then(
-        &{Macro.escape(&1),
-         quote do
-           String.t()
-         end}
-      )
     end
+    |> then(
+      &{Macro.escape(&1),
+       quote do
+         String.t()
+       end}
+    )
   end
 
   defp field_to_schema(%{type: "boolean"} = field, _nsid) do
···
   end
 
   defp field_to_schema(%{type: "union", refs: refs}, nsid) do
-    refs
-    |> Enum.map(fn ref ->
-      {nsid, fragment} =
-        nsid
-        |> Atex.NSID.expand_possible_fragment_shorthand(ref)
-        |> Atex.NSID.to_atom_with_fragment()
+    if refs == [] do
+      {quote do
+         {:oneof, []}
+       end, nil}
+    else
+      refs
+      |> Enum.map(fn ref ->
+        {nsid, fragment} =
+          nsid
+          |> Atex.NSID.expand_possible_fragment_shorthand(ref)
+          |> Atex.NSID.to_atom_with_fragment()
 
-      {quote do
-         unquote(nsid).get_schema(unquote(fragment))
-       end,
-       quote do
-         unquote(nsid).unquote(fragment)()
-       end}
-    end)
-    |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->
-      {[quoted_schema | schemas], [quoted_type | types]}
-    end)
-    |> then(fn {schemaa, types} ->
-      {quote do
-         {:oneof, unquote(schemaa)}
-       end,
-       quote do
-         unquote(join_with_pipe(types))
-       end}
-    end)
+        {quote do
+           unquote(nsid).get_schema(unquote(fragment))
+         end,
+         quote do
+           unquote(nsid).unquote(fragment)()
+         end}
+      end)
+      |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->
+        {[quoted_schema | schemas], [quoted_type | types]}
+      end)
+      |> then(fn {schemas, types} ->
+        {quote do
+           {:oneof, unquote(schemas)}
+         end,
+         quote do
+           unquote(join_with_pipe(types))
+         end}
+      end)
+    end
   end
 
   # TODO: apparently should be a data object, not a primitive?

lib/atex/lexicon/schema.ex

···
 
   defschema :lexicon, %{
     lexicon: {:required, {:literal, 1}},
-    id:
-      {:required,
-       {:string,
-        {:regex,
-         ~r/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z]{0,61}[a-zA-Z])?)$/}}},
+    id: {:required, {:string, {:regex, Atex.NSID.re()}}},
     revision: {:integer, {:gte, 0}},
     description: :string,
     defs: {
···
   defschema :parameters, %{
     type: {:required, {:literal, "params"}},
     description: :string,
-    required: {{:list, :string}, {:default, []}},
+    # required: {{:list, :string}, {:default, []}},
+    required: {:list, :string},
     properties:
       {:required, {:map, {:either, {get_schema(:primitive), get_schema(:primitive_array)}}}}
   }
···
   defschema :object, %{
     type: {:required, {:literal, "object"}},
     description: :string,
-    required: {{:list, :string}, {:default, []}},
-    nullable: {{:list, :string}, {:default, []}},
+    # required: {{:list, :string}, {:default, []}},
+    # nullable: {{:list, :string}, {:default, []}},
+    required: {:list, :string},
+    nullable: {:list, :string},
     properties:
       {:required,
        {:map,

lib/atex/nsid.ex

···
 defmodule Atex.NSID do
-  @re ~r/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/
+  @re ~r/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/
+  # TODO: regex with support for fragment
 
   @spec re() :: Regex.t()
   def re, do: @re