A bit different approach to external validators plus validation against definition in a schema

.gitignore

@@ -12,3 +12,4 @@
 /rebar3.crashdump
 /rebar.lock
 /test/*.beam
+/deps/

AUTHORS

@@ -15,6 +15,7 @@ Andrei Neculau <[email protected]>
 Stefan Strigler <[email protected]>
 Sergey Prokhorov <[email protected]>
 Yakov <[email protected]>
+Anton Belyaev <[email protected]>
 Luis Azedo <[email protected]>
 Carl-Johan Kjellander <[email protected]>
 Alastair Hole <[email protected]>

README.md

@@ -128,6 +128,38 @@ ok
                       [<<"foo">>]}]}
 ```
 
+* Validate an instanse against a particular definition from schema definitions
+
+```erlang
+1> Schema = <<"{\"definitions\": {\"Foo\": {\"properties\": {\"foo\": {\"type\": \"integer\"}}}, \"Bar\": {\"properties\": {\"bar\": {\"type\": \"boolean\"}}}}}">>.
+<<"{\"definitions\": {\"Foo\": {\"properties\": {\"foo\": {\"type\": \"integer\"}}}, \"Bar\": {\"properties\": {\"bar\": {\"type\": \"boolea"...>>
+2> jesse:validate_definition("Foo",
+2>                            Schema,
+2>                            <<"{\"foo\": 1}">>,
+2>                            [{parser_fun, fun jiffy:decode/1}]).
+{ok,[{<<"foo">>,1}]}
+3> jesse:validate_definition("Bar",
+3>                            Schema,
+3>                            <<"{\"bar\": 2}">>,
+3>                            [{parser_fun, fun jiffy:decode/1}]).
+{error,[{data_invalid,[{<<"type">>,<<"boolean">>}],
+                      wrong_type,2,
+                      [<<"bar">>]}]}
+4> jesse:validate_definition("FooBar",
+4>                            Schema,
+4>                            <<"{\"bar\": 2}">>,
+4>                            [{parser_fun, fun jiffy:decode/1}]).
+{error,[{schema_invalid,[{<<"definitions">>,
+                          [{<<"Foo">>,
+                            [{<<"properties">>,
+                              [{<<"foo">>,[{<<"type">>,<<"integer">>}]}]}]},
+                           {<<"Bar">>,
+                            [{<<"properties">>,
+                              [{<<"bar">>,[{<<"type">>,<<"boolean">>}]}]}]}]}],
+                        {schema_not_found,"#/definitions/FooBar"}}]}
+```
+
+
 * Since 0.4.0 it's possible to instruct jesse to collect errors, and not stop
   immediately when it finds an error in the given JSON instance:
 
@@ -245,6 +277,11 @@ the given schema), one should use 'default_schema_ver' option when call
 a binary consisting a schema path,
  i.e. <<"http://json-schema.org/draft-03/schema#">>.
 
+It is also possible to specify a validator module to use via `validator` option.
+This option supersedes the mechanism with the $schema property described above.
+Custom validator module can be specified as well. Such module should implement
+`jesse_schema_validator` behaviour.
+
 ## Validation errors
 
 The validation functions `jesse:validate/2` and `jesse:validate_with_schema/2,3`

rebar.config

@@ -11,6 +11,7 @@
            , warnings_as_errors
            , warn_unused_record
            , warn_unused_vars
+           , nowarn_export_all
            ]}.
 {edoc_opts, [{preprocess, true}]}.
 {cover_enabled, true}.
@@ -20,7 +21,6 @@
               ]}.
 { deps
 , [ {jsx, "3.1.0"}
-  , {rfc3339, "0.2.2"}
   ]}.
 
 { project_plugins

src/jesse.app.src

@@ -12,7 +12,6 @@
                    , ssl
                    , inets
                    , jsx
-                   , rfc3339
                    ]}
   , {licenses, [ "Apache 2.0"
                ]}

src/jesse.erl

@@ -33,6 +33,10 @@
         , load_schemas/3
         , validate/2
         , validate/3
+        , validate_definition/3
+        , validate_definition/4
+        , validate_local_ref/3
+        , validate_local_ref/4
         , validate_with_schema/2
         , validate_with_schema/3
         ]).
@@ -215,6 +219,82 @@ validate(Schema, Data, Options) ->
       {error, Error}
   end.
 
+%% @doc Equivalent to {@link validate_definition/4} where `Options' is an empty list.
+-spec validate_definition( Definition :: string()
+                         , Schema     :: json_term() | binary()
+                         , Data       :: json_term() | binary()
+                         ) -> {ok, json_term()}
+                            | jesse_error:error().
+validate_definition(Definition, Schema, Data) ->
+  validate_definition(Definition, Schema, Data, []).
+
+%% @doc Validates json `Data' agains the given `Definition' in the given
+%% schema `Schema', using `Options'.
+%% If the given json is valid, then it is returned to the caller, otherwise
+%% an error with an appropriate error reason is returned. If the `parser_fun'
+%% option is provided, then both `Schema' and `Data' are considered to be a
+%% binary string, so `parser_fun' is used to convert both binary strings to a
+%% supported internal representation of json.
+%% If `parser_fun' is not provided, then both `Schema' and `Data' are considered
+%% to already be a supported internal representation of json.
+-spec validate_definition( Definition :: string()
+                         , Schema     :: json_term() | binary()
+                         , Data       :: json_term() | binary()
+                         , Options    :: [{Key :: atom(), Data :: any()}]
+                         ) -> {ok, json_term()}
+                            | jesse_error:error().
+validate_definition(Defintion, Schema, Data, Options) ->
+  try
+    ParserFun    = proplists:get_value(parser_fun, Options, fun(X) -> X end),
+    ParsedSchema = try_parse(schema, ParserFun, Schema),
+    ParsedData   = try_parse(data, ParserFun, Data),
+    jesse_schema_validator:validate_definition( Defintion
+                                              , ParsedSchema
+                                              , ParsedData
+                                              , Options
+                                              )
+  catch
+    throw:Error -> {error, Error}
+  end.
+
+%% @doc Equivalent to {@link validate_local_ref/4} where `Options' is an empty list.
+-spec validate_local_ref( RefPath :: string()
+                         , Schema     :: json_term() | binary()
+                         , Data       :: json_term() | binary()
+                         ) -> {ok, json_term()}
+                            | jesse_error:error().
+validate_local_ref(RefPath, Schema, Data) ->
+  validate_local_ref(RefPath, Schema, Data, []).
+
+%% @doc Validates json `Data' agains the given definition path 'RefPath' in the given
+%% schema `Schema', using `Options'.
+%% If the given json is valid, then it is returned to the caller, otherwise
+%% an error with an appropriate error reason is returned. If the `parser_fun'
+%% option is provided, then both `Schema' and `Data' are considered to be a
+%% binary string, so `parser_fun' is used to convert both binary strings to a
+%% supported internal representation of json.
+%% If `parser_fun' is not provided, then both `Schema' and `Data' are considered
+%% to already be a supported internal representation of json.
+-spec validate_local_ref( RefPath :: string()
+                         , Schema     :: json_term() | binary()
+                         , Data       :: json_term() | binary()
+                         , Options    :: [{Key :: atom(), Data :: any()}]
+                         ) -> {ok, json_term()}
+                            | jesse_error:error().
+validate_local_ref(RefPath, Schema, Data, Options) ->
+  try
+    ParserFun    = proplists:get_value(parser_fun, Options, fun(X) -> X end),
+    ParsedSchema = try_parse(schema, ParserFun, Schema),
+    ParsedData   = try_parse(data, ParserFun, Data),
+    jesse_schema_validator:validate_local_ref( RefPath
+                                              , ParsedSchema
+                                              , ParsedData
+                                              , Options
+                                              )
+  catch
+    throw:Error -> {error, Error}
+  end.
+
 %% @doc Equivalent to {@link validate_with_schema/3} where `Options'
 %% is an empty list.
 -spec validate_with_schema( Schema :: schema() | binary()

src/jesse_database.erl

@@ -303,13 +303,13 @@ get_schema_info(File, {Acc, ParseFun}) ->
 %% @doc Returns value of "id" field from json object `Schema', assuming that
 %% the given json object has such a field, otherwise returns undefined.
 %% @private
--spec get_schema_id(Schema :: jesse:json_term()) -> string() | undefined.
+-spec get_schema_id(Schema :: jesse:json_term()) -> binary() | undefined.
 get_schema_id(Schema) ->
   case jesse_json_path:value(?ID, Schema, undefined) of
     undefined ->
       undefined;
     Id ->
-      erlang:binary_to_list(Id)
+      Id
   end.
 
 %% @private

src/jesse_schema_validator.erl

@@ -25,12 +25,30 @@
 
 %% API
 -export([ validate/3
+        , validate_definition/4
+        , validate_local_ref/4
         , validate_with_state/3
         ]).
 
 %% Includes
 -include("jesse_schema_validator.hrl").
 
+%% Behaviour definition
+-callback check_value(Value, Attr, State) ->
+  State | no_return()
+    when
+    Value :: any(),
+    Attr  :: {binary(), jesse:json_term()},
+    State :: jesse_state:state().
+
+-callback init_state(Opts :: jesse_state:validator_opts()) ->
+    validator_state().
+
+-type validator_state() :: any().
+
+-export_type([ validator_state/0
+             ]).
+
 %%% API
 %% @doc Validates json `Data' against `JsonSchema' with `Options'.
 %% If the given json is valid, then it is returned to the caller as is,
@@ -45,6 +63,34 @@ validate(JsonSchema, Value, Options) ->
   NewState = validate_with_state(JsonSchema, Value, State),
   {result(NewState), Value}.
 
+%% @doc Validates json `Data' against a given $ref path in `JsonSchema' with `Options'.
+%% If the given json is valid, then it is returned to the caller as is,
+%% otherwise an exception will be thrown.
+-spec validate_definition( Definition :: string()
+                         , JsonSchema :: jesse:json_term()
+                         , Data       :: jesse:json_term()
+                         , Options    :: [{Key :: atom(), Data :: any()}]
+                         ) -> {ok, jesse:json_term()}
+                            | no_return().
+validate_definition(Definition, JsonSchema, Value, Options) ->
+  RefPath = "#/definitions/" ++ Definition,
+  validate_local_ref(RefPath, JsonSchema, Value, Options).
+
+%% @doc Validates json `Data' against `Definition' in `JsonSchema' with `Options'.
+%% If the given json is valid, then it is returned to the caller as is,
+%% otherwise an exception will be thrown.
+-spec validate_local_ref( RefPath :: string()
+                         , JsonSchema :: jesse:json_term()
+                         , Data       :: jesse:json_term()
+                         , Options    :: [{Key :: atom(), Data :: any()}]
+                         ) -> {ok, jesse:json_term()}
+                            | no_return().
+validate_local_ref(RefPath, JsonSchema, Value, Options) ->
+  State = jesse_state:new(JsonSchema, Options),
+  Ref   = make_ref(RefPath),
+  NewState = validate_with_state(Ref, Value, State),
+  {result(NewState), Value}.
+
 %% @doc Validates json `Data' against `JsonSchema' with `State'.
 %% If the given json is valid, then the latest state is returned to the caller,
 %% otherwise an exception will be thrown.
@@ -53,11 +99,31 @@ validate(JsonSchema, Value, Options) ->
                          , State      :: jesse_state:state()
                          ) -> jesse_state:state()
                             | no_return().
-validate_with_state(JsonSchema, Value, State) ->
-  SchemaVer = get_schema_ver(JsonSchema, State),
-  select_and_run_validator(SchemaVer, JsonSchema, Value, State).
+validate_with_state(JsonSchema0, Value, State) ->
+  Validator = select_validator(JsonSchema0, State),
+  JsonSchema = jesse_json_path:unwrap_value(JsonSchema0),
+  run_validator(Validator, Value, JsonSchema, State).
+
 
 %%% Internal functions
+%% @doc Gets validator from the state or else
+%% selects an appropriate one by schema version.
+%% @private
+select_validator(JsonSchema, State) ->
+  case jesse_state:get_validator(State) of
+    undefined ->
+      select_validator_by_schema(get_schema_ver(JsonSchema, State), State);
+    Validator ->
+      Validator
+  end.
+
+select_validator_by_schema(?json_schema_draft3, _) ->
+  jesse_validator_draft3;
+select_validator_by_schema(?json_schema_draft4, _) ->
+  jesse_validator_draft4;
+select_validator_by_schema(SchemaURI, State) ->
+  jesse_error:handle_schema_invalid({?schema_unsupported, SchemaURI}, State).
+
 %% @doc Returns "$schema" property from `JsonSchema' if it is present,
 %% otherwise the default schema version from `State' is returned.
 %% @private
@@ -76,18 +142,21 @@ result(State) ->
     _  -> throw(ErrorList)
   end.
 
-%% @doc Runs appropriate validator depending on schema version
-%% it is called with.
+%% @doc Goes through attributes of the given `JsonSchema' and
+%% validates the `Value' against them calling `Validator'.
 %% @private
-select_and_run_validator(?json_schema_draft3, JsonSchema, Value, State) ->
-  jesse_validator_draft3:check_value( Value
-                                    , jesse_json_path:unwrap_value(JsonSchema)
-                                    , State
-                                    );
-select_and_run_validator(?json_schema_draft4, JsonSchema, Value, State) ->
-    jesse_validator_draft4:check_value( Value
-                                      , jesse_json_path:unwrap_value(JsonSchema)
-                                      , State
-                                      );
-select_and_run_validator(SchemaURI, _JsonSchema, _Value, State) ->
-  jesse_error:handle_schema_invalid({?schema_unsupported, SchemaURI}, State).
+run_validator(_Validator, _Value, [], State) ->
+  State;
+run_validator(Validator, Value, [Attr | Attrs], State0) ->
+  State = Validator:check_value( Value
+                               , Attr
+                               , State0
+                               ),
+  run_validator(Validator, Value, Attrs, State).
+
+%% @doc Makes a $ref schema object pointing to the given path
+%% in schema defintions.
+%% @private
+make_ref(RefPath) ->
+  RefPath1 = list_to_binary(RefPath),
+  [{<<"$ref">>, RefPath1}].