Fully support location-independent identifiers and refs

Author: jonasschmidt

.formatter.exs

@@ -1,4 +1,4 @@
 [
-  line_length: 120,
-  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],
+  line_length: 120
 ]

config/test.exs

@@ -6,7 +6,12 @@ end
 
 config :ex_json_schema,
   decode_json: fn json -> Jason.decode(json) end,
-  remote_schema_resolver: fn url -> HTTPoison.get!(url).body |> Jason.decode!() end,
+  remote_schema_resolver: fn url ->
+    case HTTPoison.get!(url) do
+      %{status_code: 200, body: body} -> body |> Jason.decode!()
+      %{status_code: 404} -> raise "Remote schema not found at #{url}"
+    end
+  end,
   custom_format_validator: {CustomFormatValidator, :validate}
 
 config :ex_json_schema, SamplePhoenix.Endpoint,

lib/ex_json_schema/schema.ex

@@ -26,30 +26,23 @@ defmodule ExJsonSchema.Schema do
   alias ExJsonSchema.Validator
 
   @type ref_path :: [:root | String.t()]
-  @type resolved ::
-          ExJsonSchema.data()
-          | %{String.t() => (Root.t() -> {Root.t(), resolved}) | ref_path}
-          | true
-          | false
+  @type resolved :: ExJsonSchema.data() | %{String.t() => (Root.t() -> {Root.t(), resolved}) | ref_path} | true | false
   @type invalid_reference_error :: {:error, :invalid_reference}
 
   @current_draft_schema_url "http://json-schema.org/schema"
   @draft4_schema_url "http://json-schema.org/draft-04/schema"
   @draft6_schema_url "http://json-schema.org/draft-06/schema"
   @draft7_schema_url "http://json-schema.org/draft-07/schema"
 
+  @ignored_properties ["const", "default", "enum", "examples"]
+
   @spec decode_json(String.t()) :: {:ok, String.t()} | {:error, String.t()}
   def decode_json(json) do
-    decoder =
-      Application.get_env(:ex_json_schema, :decode_json) ||
-        fn _json -> raise MissingJsonDecoderError end
-
+    decoder = Application.get_env(:ex_json_schema, :decode_json) || fn _json -> raise MissingJsonDecoderError end
     decoder.(json)
   end
 
-  @spec resolve(boolean | Root.t() | ExJsonSchema.object(),
-          custom_format_validator: {module(), atom()}
-        ) ::
+  @spec resolve(boolean | Root.t() | ExJsonSchema.object(), custom_format_validator: {module(), atom()}) ::
           Root.t() | no_return
   def resolve(schema, options \\ [])
 
@@ -75,25 +68,31 @@ defmodule ExJsonSchema.Schema do
     end
   end
 
-  def get_fragment(root = %Root{}, [:root | path] = ref) do
-    do_get_fragment(root.schema, path, ref)
+  def get_fragment(%Root{schema: schema, refs: refs}, [:root | path] = ref) do
+    case Map.get(refs, ref_to_string(ref)) do
+      nil -> do_get_fragment(schema, path, ref)
+      schema -> {:ok, schema}
+    end
   end
 
-  def get_fragment(root = %Root{}, [url | path] = ref) when is_binary(url) do
-    do_get_fragment(root.refs[url], path, ref)
+  def get_fragment(%Root{refs: refs}, [url | path] = ref) when is_binary(url) do
+    case Map.get(refs, ref_to_string(ref)) do
+      nil -> do_get_fragment(refs[url], path, ref)
+      schema -> {:ok, schema}
+    end
   end
 
   @spec get_fragment!(Root.t(), ref_path | ExJsonSchema.json_path()) :: resolved | no_return
-  def get_fragment!(schema, ref) do
-    case get_fragment(schema, ref) do
+  def get_fragment!(root, ref) do
+    case get_fragment(root, ref) do
       {:ok, schema} -> schema
       {:error, :invalid_reference} -> raise_invalid_reference_error(ref)
     end
   end
 
   @spec get_ref_schema(Root.t(), [:root | String.t()]) :: ExJsonSchema.data() | no_return
-  def get_ref_schema(root = %Root{}, [:root | path] = ref) do
-    case get_ref_schema_with_schema(root.schema, path, ref) do
+  def get_ref_schema(%Root{schema: schema}, [:root | path] = ref) do
+    case get_ref_schema_with_schema(schema, path, ref) do
       {:error, error} ->
         raise InvalidSchemaError, message: error
 
@@ -102,8 +101,8 @@ defmodule ExJsonSchema.Schema do
     end
   end
 
-  def get_ref_schema(root = %Root{}, [url | path] = ref) when is_binary(url) do
-    case get_ref_schema_with_schema(root.refs[url], path, ref) do
+  def get_ref_schema(%Root{refs: refs}, [url | path] = ref) when is_binary(url) do
+    case get_ref_schema_with_schema(refs[url], path, ref) do
       {:error, error} ->
         raise InvalidSchemaError, message: error
 
@@ -128,9 +127,42 @@ defmodule ExJsonSchema.Schema do
           message: "schema did not pass validation against its meta-schema: #{inspect(errors)}"
     end
 
+    root = %Root{root | version: schema_version}
     {root, schema} = resolve_with_root(root, root_schema)
 
-    %Root{root | schema: schema, version: schema_version}
+    %Root{root | schema: schema}
+    |> resolve_refs(schema)
+  end
+
+  defp resolve_refs(%Root{} = root, schema) when is_map(schema) do
+    schema
+    |> Enum.reduce(root, fn
+      {"$ref", [:root | _]}, root ->
+        root
+
+      {"$ref", ref}, root when is_list(ref) ->
+        if local_ref?(root, ref) do
+          root
+        else
+          resolve_and_cache_remote_schema(root, ref)
+        end
+
+      {_, value}, root when is_map(value) ->
+        resolve_refs(root, value)
+
+      {_, values}, root when is_list(values) ->
+        values
+        |> Enum.reduce(root, fn value, root -> resolve_refs(root, value) end)
+
+      _, root ->
+        root
+    end)
+  end
+
+  defp resolve_refs(%Root{} = root, _), do: root
+
+  defp local_ref?(%Root{refs: refs}, [url | _] = ref) do
+    Map.has_key?(refs, url) || Map.has_key?(refs, ref_to_string(ref))
   end
 
   defp schema_version!(schema_url) do
@@ -165,25 +197,30 @@ defmodule ExJsonSchema.Schema do
 
   defp resolve_with_root(root, schema, scope \\ "")
 
+  defp resolve_with_root(root, %{"$ref" => ref}, scope) when is_binary(ref) do
+    do_resolve(root, %{"$ref" => ref}, scope)
+  end
+
   defp resolve_with_root(root, schema = %{"$id" => id}, scope) when is_binary(id) do
-    resolve_id(root, schema, scope, id)
+    resolve_with_id(root, schema, scope, id)
   end
 
   defp resolve_with_root(root, schema = %{"id" => id}, scope) when is_binary(id) do
-    resolve_id(root, schema, scope, id)
+    resolve_with_id(root, schema, scope, id)
   end
 
   defp resolve_with_root(root, schema = %{}, scope), do: do_resolve(root, schema, scope)
   defp resolve_with_root(root, non_schema, _scope), do: {root, non_schema}
 
-  defp resolve_id(root, schema, scope, id) do
+  defp resolve_with_id(root, schema, scope, id) do
     scope =
       case URI.parse(scope) do
         %URI{host: nil} -> id
         uri -> uri |> URI.merge(id) |> to_string()
       end
 
-    do_resolve(root, schema, scope)
+    {root, schema} = do_resolve(root, schema, scope)
+    {root_with_ref(root, scope, schema), schema}
   end
 
   defp do_resolve(root, schema, scope) do
@@ -196,12 +233,12 @@ defmodule ExJsonSchema.Schema do
     {root, schema |> sanitize_attributes()}
   end
 
-  defp resolve_property(root, {key, value}, scope) when is_map(value) do
+  defp resolve_property(root, {key, value}, scope) when is_map(value) and key not in @ignored_properties do
     {root, resolved} = resolve_with_root(root, value, scope)
     {root, {key, resolved}}
   end
 
-  defp resolve_property(root, {key, values}, scope) when is_list(values) do
+  defp resolve_property(root, {key, values}, scope) when is_list(values) and key not in @ignored_properties do
     {root, values} =
       Enum.reduce(values, {root, []}, fn value, {root, values} ->
         {root, resolved} = resolve_with_root(root, value, scope)
@@ -211,19 +248,13 @@ defmodule ExJsonSchema.Schema do
     {root, {key, Enum.reverse(values)}}
   end
 
-  defp resolve_property(root, {"$ref", ref}, scope) do
+  defp resolve_property(root, {"$ref", ref}, scope) when is_binary(ref) do
+    ref_uri = URI.parse(ref)
+
     scoped_ref =
-      case URI.parse(ref) do
-        # TODO: this special case is only needed until there is proper support for URL references
-        # that point to a local schema (via scope changes)
-        %URI{host: nil, path: nil} = uri ->
-          to_string(uri)
-
-        ref_uri ->
-          case URI.parse(scope) do
-            %URI{host: nil} -> ref
-            scope_uri -> URI.merge(scope_uri, ref_uri) |> to_string()
-          end
+      case URI.parse(scope) do
+        %URI{host: nil} -> ref
+        scope_uri -> URI.merge(scope_uri, ref_uri) |> to_string()
       end
 
     {root, path} = resolve_ref!(root, scoped_ref)
@@ -232,19 +263,20 @@ defmodule ExJsonSchema.Schema do
 
   defp resolve_property(root, tuple, _) when is_tuple(tuple), do: {root, tuple}
 
-  defp resolve_ref(root, "#") do
-    {:ok, {root, [root.location]}}
+  defp resolve_ref(%Root{location: location} = root, "#") do
+    {:ok, {root, [location]}}
   end
 
   defp resolve_ref(root, ref) do
     [url | anchor] = String.split(ref, "#")
     ref_path = validate_ref_path(anchor, ref)
     {root, path} = root_and_path_for_url(root, ref_path, url)
 
-    case get_fragment(root, path) do
-      {:ok, _schema} -> {:ok, {root, path}}
-      error -> error
-    end
+    {:ok, {root, path}}
+    # case get_fragment(root, path) do
+    #   {:ok, _schema} -> {:ok, {root, path}}
+    #   error -> error
+    # end
   end
 
   defp resolve_ref!(root, ref) do
@@ -256,23 +288,23 @@ defmodule ExJsonSchema.Schema do
 
   defp validate_ref_path([], _), do: nil
   defp validate_ref_path([""], _), do: nil
-  defp validate_ref_path([fragment = "/" <> _], _), do: fragment
+  defp validate_ref_path([fragment], _) when is_binary(fragment), do: fragment
   defp validate_ref_path(_, ref), do: raise_invalid_reference_error(ref)
 
-  defp root_and_path_for_url(root, fragment, "") do
-    {root, [root.location | relative_path(fragment)]}
+  defp root_and_path_for_url(%Root{location: location} = root, fragment, "") do
+    {root, [location | relative_path(fragment)]}
   end
 
   defp root_and_path_for_url(root, fragment, url) do
-    root = resolve_and_cache_remote_schema(root, url)
+    # root = resolve_and_cache_remote_schema(root, url)
     {root, [url | relative_path(fragment)]}
   end
 
   defp relative_path(nil), do: []
   defp relative_path(fragment), do: relative_ref_path(fragment)
 
   defp relative_ref_path(ref) do
-    ["" | keys] = unescaped_ref_segments(ref)
+    keys = unescaped_ref_segments(ref)
 
     Enum.map(keys, fn key ->
       case key =~ ~r/^\d+$/ do
@@ -285,13 +317,9 @@ defmodule ExJsonSchema.Schema do
     end)
   end
 
-  defp resolve_and_cache_remote_schema(root, url) do
-    if root.refs[url] do
-      root
-    else
-      remote_schema = remote_schema(url)
-      resolve_remote_schema(root, url, remote_schema)
-    end
+  defp resolve_and_cache_remote_schema(root, [url | _]) do
+    remote_schema = remote_schema(url)
+    resolve_remote_schema(root, url, remote_schema)
   end
 
   @spec remote_schema(String.t()) :: ExJsonSchema.object()
@@ -303,13 +331,14 @@ defmodule ExJsonSchema.Schema do
 
   defp resolve_remote_schema(root, url, remote_schema) do
     root = root_with_ref(root, url, remote_schema)
-    resolved_root = resolve_root(%{root | schema: remote_schema, location: url})
-    root = %{root | refs: resolved_root.refs}
-    root_with_ref(root, url, resolved_root.schema)
+    %Root{schema: schema, refs: refs} = resolve_root(%Root{root | schema: remote_schema, location: url})
+
+    %Root{root | refs: refs}
+    |> root_with_ref(url, schema)
   end
 
-  defp root_with_ref(root, url, ref) do
-    %{root | refs: Map.put(root.refs, url, ref)}
+  defp root_with_ref(%Root{refs: refs} = root, url, ref) do
+    %{root | refs: Map.put(refs, url, ref)}
   end
 
   defp fetch_remote_schema(url) do
@@ -362,6 +391,7 @@ defmodule ExJsonSchema.Schema do
   defp unescaped_ref_segments(ref) do
     ref
     |> String.split("/")
+    |> Enum.reject(&(&1 == ""))
     |> Enum.map(fn segment ->
       segment
       |> String.replace("~0", "~")
@@ -377,8 +407,9 @@ defmodule ExJsonSchema.Schema do
   defp do_get_fragment(nil, _, _ref), do: {:error, :invalid_reference}
   defp do_get_fragment(schema, [], _), do: {:ok, schema}
 
-  defp do_get_fragment(schema, [key | path], ref) when is_binary(key),
-    do: do_get_fragment(Map.get(schema, key), path, ref)
+  defp do_get_fragment(schema, [key | path], ref) when is_binary(key) do
+    do_get_fragment(Map.get(schema, key), path, ref)
+  end
 
   defp do_get_fragment(schema, [idx | path], ref) when is_integer(idx) do
     try do
@@ -408,8 +439,8 @@ defmodule ExJsonSchema.Schema do
     |> get_ref_schema_with_schema(path, ref)
   end
 
-  defp ref_to_string([:root | path]), do: ["#" | path] |> Enum.join("/")
-  defp ref_to_string([url | path]), do: [url <> "#" | path] |> Enum.join("/")
+  defp ref_to_string([:root | path]), do: "##{path}"
+  defp ref_to_string([url | path]), do: url <> "#" <> Enum.join(path, "/")
 
   @spec raise_invalid_reference_error(any) :: no_return
   def raise_invalid_reference_error(ref) when is_binary(ref),

lib/ex_json_schema/schema/root.ex

@@ -1,7 +1,6 @@
 defmodule ExJsonSchema.Schema.Root do
   defstruct schema: %{},
             refs: %{},
-            definitions: %{},
             location: :root,
             version: nil,
             custom_format_validator: nil
@@ -10,7 +9,6 @@ defmodule ExJsonSchema.Schema.Root do
           schema: ExJsonSchema.Schema.resolved(),
           refs: %{String.t() => ExJsonSchema.Schema.resolved()},
           location: :root | String.t(),
-          definitions: %{String.t() => ExJsonSchema.Schema.resolved()},
           version: non_neg_integer | nil,
           custom_format_validator: {module(), atom()} | (String.t(), any() -> boolean | {:error, any()}) | nil
         }

lib/ex_json_schema/validator/multiple_of.ex

@@ -27,9 +27,11 @@ defmodule ExJsonSchema.Validator.MultipleOf do
     cond do
       dec_multiple_of == @zero -> [%Error{error: %Error.MultipleOf{expected: 0}}]
       dec_data == @zero -> []
-      Decimal.integer?(Decimal.div(dec_data, dec_multiple_of)) -> []
+      Decimal.equal?(Decimal.rem(dec_data, dec_multiple_of), Decimal.new(0)) -> []
       true -> [%Error{error: %Error.MultipleOf{expected: multiple_of}}]
     end
+  rescue
+    Decimal.Error -> [%Error{error: %Error.MultipleOf{expected: multiple_of}}]
   end
 
   defp do_validate(_, _) do