Implementing few features

lib/jake.ex

@@ -9,31 +9,83 @@ defmodule Jake do
     "string"
   ]
 
-  def gen(%{"anyOf" => options} = spec) when is_list(options) do
-    Enum.map(options, fn option ->
-      gen(Map.merge(Map.drop(spec, ["anyOf"]), option))
+  def generator(jschema) do
+    IO.puts(jschema)
+    map = jschema |> Poison.decode!()
+
+    StreamData.sized(fn size ->
+      Map.put(%{}, "map", map) |> Map.put("omap", map) |> Map.put("size", 2 * size) |> gen_init()
     end)
-    |> StreamData.one_of()
   end
 
-  def gen(%{"type" => type} = spec) when is_binary(type) do
-    module = String.to_existing_atom("Elixir.Jake.#{String.capitalize(type)}")
-    apply(module, :gen, [spec])
+  def gen_init(schema) do
+    StreamData.bind(
+      get_lazy_streamkey(schema),
+      fn {nmap, nsize} ->
+        nschema = Map.put(schema, "map", nmap) |> Map.put("size", nsize)
+
+        if nmap["allOf"] || nmap["oneOf"] || nmap["anyOf"] || nmap["not"] do
+          Jake.Mixed.gen_mixed(nmap, nschema)
+        else
+          gen_all(nschema, nmap["enum"], nmap["type"])
+        end
+        |> StreamData.resize(nsize)
+      end
+    )
   end
 
-  def gen(%{"type" => types} = spec) when is_list(types) do
-    Enum.map(types, fn type ->
-      gen(%{spec | "type" => type})
-    end)
-    |> StreamData.one_of()
+  def get_lazy_streamkey(schema) do
+    {map, _} =
+      get_in(schema, ["map", "$ref"]) |> Jake.Ref.expand_ref(schema["map"], schema["omap"])
+
+    StreamData.constant({map, trunc(schema["size"] / 2)})
   end
 
-  # type not present
-  def gen(spec) do
-    Enum.map(@types, fn type ->
-      Map.put(spec, "type", type)
-      |> gen()
-    end)
+  def gen_all(schema, enum, _type) when enum != nil, do: gen_enum(schema["map"], enum)
+
+  def gen_all(schema, _enum, type) when is_list(type) do
+    list = for n <- type, do: %{"type" => n}
+    nmap = schema["map"] |> Map.drop(["type"])
+
+    for(n <- list, is_map(n), do: Map.put(schema, "map", Map.merge(n, nmap)) |> Jake.gen_init())
     |> StreamData.one_of()
   end
+
+  def gen_all(schema, _enum, type) when type in @types,
+    do: gen_type(type, schema)
+
+  def gen_all(schema, _enum, type) when type == nil do
+    Jake.Notype.gen_notype(type, schema)
+  end
+
+  def gen_type(type, schema) when type == "string" do
+    map = schema["map"]
+    Jake.String.gen_string(map, map["pattern"])
+  end
+
+  def gen_type(type, schema) when type in ["integer", "number"] do
+    Jake.Number.gen_number(schema["map"], type)
+  end
+
+  def gen_type(type, schema) when type == "boolean" do
+    StreamData.boolean()
+  end
+
+  def gen_type(type, schema) when type == "null" do
+    StreamData.constant(nil)
+  end
+
+  def gen_type(type, schema) when type == "array" do
+    Jake.Array.gen_array(schema["map"], schema)
+  end
+
+  def gen_type(type, schema) when type == "object" do
+    map = schema["map"]
+    Jake.Object.gen_object(map, map["properties"], schema)
+  end
+
+  def gen_enum(map, list) do
+    Enum.filter(list, fn x -> ExJsonSchema.Validator.valid?(map, x) end)
+    |> StreamData.member_of()
+  end
 end

lib/jake/array.ex

@@ -1,5 +1,108 @@
 defmodule Jake.Array do
-  def gen(_) do
-    StreamData.constant([])
+  @type_list [
+    %{"type" => "integer"},
+    %{"type" => "number"},
+    %{"type" => "boolean"},
+    %{"type" => "string"},
+    %{"type" => "null"},
+    nil
+  ]
+
+  @min_items 0
+
+  @max_items 1000
+
+  def gen_array(%{"items" => items} = map, schema) do
+    case items do
+      item when is_map(item) and map_size(item) == 0 ->
+        StreamData.constant([])
+
+      item when is_map(item) ->
+        gen_list(map, item, schema)
+
+      item when is_list(item) ->
+        gen_tuple(map, item, schema)
+
+      _ ->
+        raise "Invalid items in array"
+    end
+  end
+
+  def gen_array(map, schema), do: arraytype(map, map["items"], schema)
+
+  def arraytype(map, items, schema) when is_nil(items) do
+    item = get_one_of(schema)
+    {min, max} = get_min_max(map)
+    decide_min_max(map, item, min, max)
+  end
+
+  def gen_tuple(map, items, schema) do
+    list = for n <- items, is_map(n), do: Map.put(schema, "map", n) |> Jake.gen_init()
+
+    {min, max} = get_min_max(map)
+
+    case map["additionalItems"] do
+      x when is_map(x) ->
+        add_additional_items(list, Jake.gen_init(Map.put(schema, "map", x)), max, min)
+
+      x when (is_boolean(x) and x) or is_nil(x) ->
+        add_additional_items(list, get_one_of(schema), max, min)
+
+      x when is_boolean(x) and not x and length(list) in min..max ->
+        StreamData.fixed_list(list)
+
+      _ ->
+        raise "Invalid items or length of list exceeds specified bounds"
+    end
+  end
+
+  def gen_list(map, items, schema) do
+    {min, max} = get_min_max(map)
+    item = Map.put(schema, "map", items) |> Jake.gen_init()
+    decide_min_max(map, item, min, max)
+  end
+
+  def get_min_max(map) do
+    min = Map.get(map, "minItems", @min_items)
+    max = Map.get(map, "maxItems", @max_items)
+    {min, max}
+  end
+
+  def decide_min_max(map, item, min, max)
+      when is_integer(min) and is_integer(max) and min < max do
+    if map["uniqueItems"] do
+      StreamData.uniq_list_of(item, min_length: min, max_length: max)
+    else
+      StreamData.list_of(item, min_length: min, max_length: max)
+    end
+  end
+
+  def decide_min_max(map, item, min, max) do
+    raise "Bounds of items not well defined"
+  end
+
+  def get_one_of(schema) do
+    for(n <- @type_list, is_map(n), do: Map.put(schema, "map", n) |> Jake.gen_init())
+    |> StreamData.one_of()
+  end
+
+  def add_additional_items(olist, additional, max, min) do
+    StreamData.bind(StreamData.fixed_list(olist), fn list ->
+      StreamData.bind_filter(
+        StreamData.list_of(additional),
+        fn
+          nlist
+          when (length(list) + length(nlist)) in min..max ->
+            {:cont, StreamData.constant(list ++ nlist)}
+
+          nlist
+          when length(list) in min..max ->
+            {:cont, StreamData.constant(list)}
+
+          _ ->
+            :skip
+        end
+      )
+    end)
   end
 end

lib/jake/map_util.ex

@@ -0,0 +1,33 @@
+# Ref: https://stackoverflow.com/questions/38864001/elixir-how-to-deep-merge-maps
+# Ref: https://github.com/activesphere/jake/blob/master/lib/jake/map_util.ex
+
+defmodule Jake.MapUtil do
+  def deep_merge(left, right) do
+    Map.merge(left, right, &deep_resolve/3)
+  end
+
+  defp deep_resolve(_key, left, nil) do
+    left
+  end
+
+  defp deep_resolve(_key, nil, right) do
+    right
+  end
+
+  defp deep_resolve(key, left, right) when key == "type" do
+    case {is_list(left), is_list(right)} do
+      {x, y} when x and y -> left ++ right
+      {x, y} when x and not y -> left ++ [right]
+      {x, y} when not x and y -> [left] ++ right
+      {x, y} when not x and not y -> [left, right]
+    end
+  end
+
+  defp deep_resolve(_key, left, right) when is_map(left) do
+    Map.merge(left, right)
+  end
+
+  defp deep_resolve(_key, left, right) when is_list(left) do
+    left ++ right
+  end
+end

lib/jake/mixed.ex

@@ -0,0 +1,99 @@
+defmodule Jake.Mixed do
+  @types [
+    "array",
+    "boolean",
+    "integer",
+    "null",
+    "number",
+    "object",
+    "string"
+  ]
+
+  def gen_mixed(%{"anyOf" => options} = map, schema) when is_list(options) do
+    nmap = Map.drop(map, ["anyOf"])
+
+    nlist = for(n <- options, is_map(n), do: Map.merge(nmap, n))
+    for(n <- nlist, do: Map.put(schema, "map", n) |> Jake.gen_init()) |> StreamData.one_of()
+  end
+
+  def gen_mixed(%{"oneOf" => options} = map, schema) when is_list(options) do
+    nmap = Map.drop(map, ["oneOf"])
+
+    tail_schema = fn tail ->
+      Enum.reduce(tail, %{}, fn x, acc -> Jake.MapUtil.deep_merge(acc, x) end)
+    end
+
+    nlist =
+      for {n, counter} <- Enum.with_index(options) do
+        hd = Map.put(schema, "map", Map.merge(nmap, n)) |> Jake.gen_init()
+        tail = List.delete_at(options, counter) |> tail_schema.()
+        {hd, tail}
+      end
+
+    try_one_of(nlist, 0)
+  end
+
+  def gen_mixed(%{"allOf" => options} = map, schema) when is_list(options) do
+    nmap = Map.drop(map, ["allOf"])
+
+    map =
+      Enum.reduce(options, %{}, fn x, acc -> Jake.MapUtil.deep_merge(acc, x) end)
+      |> Jake.MapUtil.deep_merge(nmap)
+
+    Map.put(schema, "map", map) |> Jake.gen_init()
+  end
+
+  def gen_mixed(%{"not" => not_schema} = map, schema) when is_map(not_schema) do
+    nmap = Map.drop(map, ["not"])
+    nmap_type = nmap["type"]
+
+    type_val =
+      if not_schema["type"] do
+        not_schema["type"]
+      else
+        Jake.Notype.gen_notype("return type", schema)
+      end
+
+    type = if type_val == nil, do: "null", else: type_val
+    nlist = if is_list(type), do: @types -- type, else: @types -- [type]
+
+    data =
+      if nmap_type || (is_map(nmap) && map_size(nmap) > 0) do
+        Map.put(schema, "map", nmap) |> Jake.gen_init()
+      else
+        for(n <- nlist, do: Map.put(schema, "map", %{"type" => n}) |> Jake.gen_init())
+        |> StreamData.one_of()
+      end
+
+    StreamData.filter(
+      data,
+      fn x ->
+        if type == "null" do
+          true
+        else
+          not ExJsonSchema.Validator.valid?(not_schema, x)
+        end
+      end
+    )
+  end
+
+  def try_one_of(nlist, index) do
+    data = filter_mutually_exclusive(nlist, index)
+
+    try do
+      Enum.take(data, 25)
+      data
+    rescue
+      _ -> filter_mutually_exclusive(nlist, index + 1)
+    end
+  end
+
+  def filter_mutually_exclusive(nlist, index) do
+    if index < length(nlist) do
+      {head, tail_schema} = Enum.at(nlist, index)
+      StreamData.filter(head, fn hd -> not ExJsonSchema.Validator.valid?(tail_schema, hd) end)
+    else
+      raise "oneOf combination not possible"
+    end
+  end
+end