Changes: replaces auto-generated names with :anonymous

- Changes: replaces auto-generated schema names like `zero` and `one` with
  `:anonymous` making it easier for a consuming project to decide what to do when
  a subschema does not have an explicit name.
- Changes: replaces stringly-typed `type` properties for several schema types to
  instead use specific atoms corresponding to the set of valid JSON value type.
- Adds: better error description for invalid union types.

Author: dragonwasrobot

README.md

@@ -39,7 +39,7 @@ resolving a JSON schema type given an identifier via `resolve_type`.
 
 Presuming we have the following two JSON schema files:
 
-```elixir
+```json
 {
     "$schema": "http://json-schema.org/draft-07/schema#",
     "$id": "http://example.com/circle.json",
@@ -63,7 +63,7 @@ Presuming we have the following two JSON schema files:
 
 and
 
-```elixir
+```json
 {
     "$schema": "http://json-schema.org/draft-07/schema#",
     "title": "Definitions",
@@ -242,7 +242,7 @@ the schema dictionary. The `resolve_type` function expects:
 
 In the example below, we resolve the reference to `color`:
 
-```elixir
+```json
 "color": {
   "$ref": "http://example.com/definitions.json#color"
 }

lib/parser/const_parser.ex

@@ -21,29 +21,30 @@ defmodule JsonSchema.Parser.ConstParser do
 
   ## Examples
 
-  iex> type?(%{})
-  false
+      iex> type?(%{})
+      false
 
-  iex> type?(%{"const" => nil})
-  true
+      iex> type?(%{"const" => nil})
+      true
 
-  iex> type?(%{"const" => false})
-  true
+      iex> type?(%{"const" => false})
+      true
 
-  iex> type?(%{"const" => "23.4"})
-  true
+      iex> type?(%{"const" => "23.4"})
+      true
 
-  iex> type?(%{"const" => "This is a constant"})
-  true
+      iex> type?(%{"const" => "This is a constant"})
+      true
 
-  iex> type?(%{"const" => %{"foo" => 42}})
-  true
+      iex> type?(%{"const" => %{"foo" => 42}})
+      true
   """
   @impl JsonSchema.Parser.ParserBehaviour
   @spec type?(Types.schemaNode()) :: boolean
   def type?(%{"const" => const})
-      when is_nil(const) or is_boolean(const) or is_number(const) or
-             is_binary(const) or is_list(const) or is_map(const),
+      when is_nil(const) or is_boolean(const) or is_integer(const) or
+             is_number(const) or is_binary(const) or is_list(const) or
+             is_map(const),
       do: true
 
   def type?(_schema_node), do: false
@@ -67,12 +68,25 @@ defmodule JsonSchema.Parser.ConstParser do
       name: name,
       description: description,
       path: path,
-      type: type,
+      type: value_type_from_string(type),
       const: const
     }
 
     const_type
     |> Util.create_type_dict(path, id)
     |> ParserResult.new()
   end
+
+  @spec value_type_from_string(String.t()) :: ConstType.value_type()
+  defp value_type_from_string(type) do
+    case type do
+      "null" -> :null
+      "boolean" -> :boolean
+      "integer" -> :integer
+      "number" -> :number
+      "string" -> :string
+      "object" -> :object
+      "array" -> :array
+    end
+  end
 end

lib/parser/enum_parser.ex

@@ -49,7 +49,7 @@ defmodule JsonSchema.Parser.EnumParser do
         ) :: ParserResult.t()
   def parse(%{"enum" => values} = schema_node, _parent_id, id, path, name) do
     description = Map.get(schema_node, "description")
-    type = Map.get(schema_node, "type")
+    type = schema_node |> Map.get("type") |> parse_enum_type()
 
     enum_type = %EnumType{
       name: name,
@@ -63,4 +63,13 @@ defmodule JsonSchema.Parser.EnumParser do
     |> Util.create_type_dict(path, id)
     |> ParserResult.new()
   end
+
+  @spec parse_enum_type(String.t()) :: EnumType.value_type()
+  defp parse_enum_type(raw_type) do
+    case raw_type do
+      "string" -> :string
+      "integer" -> :integer
+      "number" -> :number
+    end
+  end
 end

lib/parser/error_util.ex

@@ -204,6 +204,25 @@ defmodule JsonSchema.Parser.ErrorUtil do
     ParserError.new(identifier, :unexpected_type, error_msg)
   end
 
+  @spec unknown_union_type(Types.typeIdentifier(), String.t()) ::
+          ParserError.t()
+  def unknown_union_type(identifier, type_name) do
+    printed_path = to_string(identifier)
+
+    error_msg = """
+
+    Encountered unknown union type at `#{printed_path}`
+
+    "type": [#{type_name}]
+    #{error_markings(type_name)}
+
+    Hint: See the specification section 6. "Validation Keywords"
+    <https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.1.1>
+    """
+
+    ParserError.new(identifier, :unknown_union_type, error_msg)
+  end
+
   @spec unknown_enum_type(String.t()) :: ParserError.t()
   def unknown_enum_type(type_name) do
     error_msg = "Unknown or unsupported enum type: '#{type_name}'"
@@ -218,14 +237,18 @@ defmodule JsonSchema.Parser.ErrorUtil do
 
   @spec unknown_node_type(
           Types.typeIdentifier(),
-          String.t(),
+          String.t() | :anonymous,
           Types.schemaNode()
         ) :: ParserError.t()
   def unknown_node_type(identifier, name, schema_node) do
     full_identifier =
-      identifier
-      |> Util.add_fragment_child(name)
-      |> to_string()
+      if name == :anonymous do
+        identifier |> to_string()
+      else
+        identifier
+        |> Util.add_fragment_child(name)
+        |> to_string()
+      end
 
     stringified_value = sanitize_value(schema_node["type"])
 

lib/parser/parser_result_types.ex

@@ -13,6 +13,7 @@ defmodule JsonSchema.Parser.ParserError do
           | :unknown_type
           | :unexpected_type
           | :unknown_enum_type
+          | :unknown_union_type
           | :unknown_primitive_type
           | :unknown_node_type
 

lib/parser/primitive_parser.ex

@@ -38,7 +38,7 @@ defmodule JsonSchema.Parser.PrimitiveParser do
   @spec type?(map) :: boolean
   def type?(schema_node) do
     type = schema_node["type"]
-    type in ["null", "boolean", "string", "number", "integer"]
+    type in ["null", "boolean", "integer", "number", "string"]
   end
 
   @doc """
@@ -54,11 +54,22 @@ defmodule JsonSchema.Parser.PrimitiveParser do
       name: name,
       description: description,
       path: path,
-      type: type
+      type: value_type_from_string(type)
     }
 
     primitive_type
     |> Util.create_type_dict(path, id)
     |> ParserResult.new()
   end
+
+  @spec value_type_from_string(String.t()) :: PrimitiveType.value_type()
+  defp value_type_from_string(type) do
+    case type do
+      "null" -> :null
+      "boolean" -> :boolean
+      "integer" -> :integer
+      "number" -> :number
+      "string" -> :string
+    end
+  end
 end

lib/parser/union_parser.ex

@@ -12,7 +12,7 @@ defmodule JsonSchema.Parser.UnionParser do
 
   require Logger
   alias JsonSchema.{Parser, Types}
-  alias Parser.{ParserResult, Util}
+  alias Parser.{ErrorUtil, ParserResult, Util}
   alias Types.UnionType
 
   @doc """
@@ -41,15 +41,47 @@ defmodule JsonSchema.Parser.UnionParser do
   def parse(%{"type" => types} = schema_node, _parent_id, id, path, name) do
     description = Map.get(schema_node, "description")
 
+    unknown_type =
+      types
+      |> Enum.find(fn type ->
+        type not in [
+          "null",
+          "boolean",
+          "number",
+          "integer",
+          "string",
+          "array",
+          "object"
+        ]
+      end)
+
+    errors =
+      if unknown_type do
+        [ErrorUtil.unknown_union_type(path, unknown_type)]
+      else
+        []
+      end
+
     union_type = %UnionType{
       name: name,
       description: description,
       path: path,
-      types: types
+      types: types |> Enum.map(&value_type_from_string/1)
     }
 
     union_type
     |> Util.create_type_dict(path, id)
-    |> ParserResult.new()
+    |> ParserResult.new([], errors)
+  end
+
+  @spec value_type_from_string(String.t()) :: UnionType.value_type()
+  defp value_type_from_string(type) do
+    case type do
+      "null" -> :null
+      "boolean" -> :boolean
+      "integer" -> :integer
+      "number" -> :number
+      "string" -> :string
+    end
   end
 end

lib/parser/util.ex

@@ -64,17 +64,43 @@ defmodule JsonSchema.Parser.Util do
         ]
   def create_types_list(type_dict, path) do
     type_dict
-    |> Enum.reduce(%{}, fn {child_abs_path, child_type}, reference_dict ->
+    |> Enum.reduce(MapSet.new(), fn {child_abs_path, child_type}, acc_set ->
       normalized_child_name = child_type.name
-      child_type_path = add_fragment_child(path, normalized_child_name)
 
-      if child_type_path == URI.parse(child_abs_path) do
-        Map.merge(reference_dict, %{normalized_child_name => child_type_path})
+      if normalized_child_name == :anonymous do
+        child_abs_path_parts =
+          child_abs_path
+          |> String.split("/")
+
+        child_prefix_path =
+          child_abs_path_parts
+          |> Enum.drop(-1)
+          |> Enum.join("/")
+          |> URI.parse()
+
+        shares_prefix = child_prefix_path == path
+
+        last_path_part_is_number =
+          child_abs_path_parts
+          |> List.last()
+          |> Integer.parse() != :error
+
+        if shares_prefix and last_path_part_is_number do
+          MapSet.put(acc_set, URI.parse(child_abs_path))
+        else
+          acc_set
+        end
       else
-        reference_dict
+        child_type_path = add_fragment_child(path, normalized_child_name)
+
+        if child_type_path == URI.parse(child_abs_path) do
+          MapSet.put(acc_set, child_type_path)
+        else
+          acc_set
+        end
       end
     end)
-    |> Map.values()
+    |> MapSet.to_list()
   end
 
   @doc """
@@ -87,8 +113,14 @@ defmodule JsonSchema.Parser.Util do
       when is_list(child_nodes) do
     child_nodes
     |> Enum.reduce({ParserResult.new(), 0}, fn child_node, {result, idx} ->
-      child_name = to_string(idx)
-      child_result = parse_type(child_node, parent_id, path, child_name)
+      child_result =
+        parse_type(
+          child_node,
+          parent_id,
+          add_fragment_child(path, to_string(idx)),
+          :anonymous
+        )
+
       {ParserResult.merge(result, child_result), idx + 1}
     end)
     |> elem(0)
@@ -97,7 +129,13 @@ defmodule JsonSchema.Parser.Util do
   @doc """
   Parses a node type.
   """
-  @spec parse_type(Types.schemaNode(), URI.t(), URI.t(), String.t(), boolean) ::
+  @spec parse_type(
+          Types.schemaNode(),
+          URI.t(),
+          URI.t(),
+          String.t() | :anonymous,
+          boolean
+        ) ::
           ParserResult.t()
   def parse_type(schema_node, parent_id, path, name, name_is_regex \\ false) do
     definitions_result =
@@ -234,7 +272,11 @@ defmodule JsonSchema.Parser.Util do
       }
 
   """
-  @spec add_fragment_child(URI.t(), String.t()) :: URI.t()
+  @spec add_fragment_child(URI.t(), String.t() | :anonymous) :: URI.t()
+  def add_fragment_child(uri, :anonymous) do
+    uri
+  end
+
   def add_fragment_child(uri, child) do
     old_fragment = uri.fragment
 

lib/types/all_of_type.ex

@@ -1,5 +1,5 @@
 defmodule JsonSchema.Types.AllOfType do
-  @moduledoc """
+  @moduledoc ~S"""
   Represents a custom `allOf` type definition in a JSON schema.
 
   JSON Schema:
@@ -58,7 +58,7 @@ defmodule JsonSchema.Types.AllOfType do
   use TypedStruct
 
   typedstruct do
-    field :name, String.t(), enforce: true
+    field :name, String.t() | :anonymous, enforce: true
     field :description, String.t() | nil, default: nil
     field :path, URI.t(), enforce: true
     field :types, [URI.t()], enforce: true

lib/types/any_of_type.ex

@@ -1,5 +1,5 @@
 defmodule JsonSchema.Types.AnyOfType do
-  @moduledoc """
+  @moduledoc ~S"""
   Represents a custom `anyOf` type definition in a JSON schema.
 
   JSON Schema:
@@ -58,7 +58,7 @@ defmodule JsonSchema.Types.AnyOfType do
   use TypedStruct
 
   typedstruct do
-    field :name, String.t(), enforce: true
+    field :name, String.t() | :anonymous, enforce: true
     field :description, String.t() | nil, default: nil
     field :path, URI.t(), enforce: true
     field :types, [URI.t()], enforce: true