Implementing few features

lib/jake.ex

@@ -9,31 +9,91 @@ 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))
-    end)
+  def generator(jschema) do
+    IO.puts(jschema)
+    jschema |> Poison.decode!() |> gen_init()
+  end
+
+  def gen_init(%{"anyOf" => options} = map) when is_list(options) do
+    nmap = Map.drop(map, ["anyOf"])
+
+    for(n <- options, is_map(n), do: Jake.gen_init(Map.merge(nmap, n)))
     |> 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(%{"allOf" => options} = map) when is_list(options) do
+    nmap = Map.drop(map, ["allOf"])
+
+    Enum.reduce(options, %{}, fn x, acc -> Jake.MapUtil.deep_merge(acc, x) end)
+    |> Jake.MapUtil.deep_merge(nmap)
+    |> Jake.gen_init()
+  end
+
+  def gen_init(map) do
+    gen_all(map, map["enum"], map["type"])
   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 gen_all(map, enum, type) when is_list(type) do
+    list = for n <- type, do: %{"type" => n}
+    nmap = Map.drop(map, ["type"])
+    for(n <- list, is_map(n), do: Map.merge(n, nmap) |> Jake.gen_init()) |> StreamData.one_of()
   end
 
-  # type not present
-  def gen(spec) do
-    Enum.map(@types, fn type ->
-      Map.put(spec, "type", type)
-      |> gen()
-    end)
-    |> StreamData.one_of()
+  def gen_all(map, enum, type) when type in @types, do: gen_type(type, map)
+
+  def gen_all(map, enum, type) when enum != nil, do: gen_enum(enum, type)
+
+  def gen_all(map, enum, type) when type == nil do
+    Jake.Notype.gen_notype(map, type)
+  end
+
+  def gen_type(type, map) when type == "string" do
+    Jake.String.gen_string(map)
+  end
+
+  def gen_type(type, map) when type in ["integer", "number"] do
+    Jake.Number.gen_number(map, type)
+  end
+
+  def gen_type(type, map) when type == "boolean" do
+    StreamData.boolean()
+  end
+
+  def gen_type(type, map) when type == "null" do
+    StreamData.constant(nil)
+  end
+
+  def gen_type(type, map) when type == "array" do
+    Jake.Array.gen_array(map, type)
+  end
+
+  def gen_type(type, map) when type == "object" do
+    Jake.Object.gen_object(map, type)
+  end
+
+  def gen_enum(list, type) do
+    nlist =
+      case type do
+        x when x == "integer" ->
+          nlist = for n <- list, is_integer(n), do: n
+
+        x when x == "number" ->
+          for n <- list, is_number(n), do: n
+
+        x when x == "string" ->
+          for n <- list, is_binary(n), do: n
+
+        x when x == "array" ->
+          for n <- list, is_list(n), do: n
+
+        x when x == "object" ->
+          for n <- list, is_map(n), do: n
+
+        _ ->
+          list
+      end
+
+    IO.inspect(nlist)
+    StreamData.member_of(nlist)
   end
 end

lib/jake/array.ex

@@ -1,5 +1,100 @@
 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(map, type), do: arraytype(map, map["enum"], map["items"])
+
+  def arraytype(map, enum, items) when enum != nil, do: Jake.gen_enum(enum, "array")
+
+  def arraytype(map, enum, items) when is_list(items) do
+    list = for n <- items, is_map(n), do: Jake.gen_init(n)
+
+    {min, max} = get_min_max(map)
+
+    case map["additionalItems"] do
+      x when (is_boolean(x) and x) or is_nil(x) ->
+        add_additional_items(list, true, max, min)
+
+      x when is_map(x) ->
+        add_additional_items(list, x, max, min)
+
+      _ ->
+        add_additional_items(list, false, max, min)
+    end
+  end
+
+  def arraytype(map, enum, items) when is_map(items) do
+    {min, max} = get_min_max(map)
+    item = Jake.gen_init(items)
+    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 arraytype(map, enum, items) when is_nil(items) and is_nil(enum) do
+    item = get_one_of()
+    {min, max} = get_min_max(map)
+    decide_min_max(map, item, 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 get_one_of() do
+    for(n <- @type_list, is_map(n), do: Jake.gen_init(n)) |> StreamData.one_of()
+  end
+
+  def add_additional_items(list, bool, max, min) when is_boolean(bool) and bool do
+    generate_list(list, get_one_of(), max, min)
+  end
+
+  def add_additional_items(list, bool, max, min) when is_boolean(bool) and not bool do
+    if length(list) in min..max do
+      StreamData.fixed_list(list)
+    end
+  end
+
+  def add_additional_items(list, map, max, min) when is_map(map) do
+    generate_list(list, Jake.gen_init(map), max, min)
+  end
+
+  def generate_list(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)}
+
+          nlist when true ->
+            :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/notype.ex

@@ -0,0 +1,38 @@
+defmodule Jake.Notype do
+  @prop %{
+    "minLength" => "string",
+    "maxLength" => "string",
+    "pattern" => "string",
+    "multipleOf" => "number",
+    "minimum" => "number",
+    "maximum" => "number",
+    "exclusiveMinimum" => "number",
+    "exclusiveMaximum" => "number",
+    "items" => "array",
+    "additionalItems" => "array",
+    "minItems" => "array",
+    "maxItems" => "array",
+    "uniqueItems" => "array",
+    "properties" => "object",
+    "patternProperties" => "object",
+    "additionalProperties" => "object",
+    "dependencies" => "object",
+    "required" => "object",
+    "minProperties" => "object",
+    "maxProperties" => "object"
+  }
+
+  def gen_notype(map, type) do
+    nmap = for {k, v} <- map, into: %{}, do: {k, v}
+    nlist = for {k, v} <- map, into: [], do: @prop[k]
+
+    types =
+      Enum.reduce(nlist, nil, fn
+        x, acc when not is_nil(x) -> x
+        x, acc when is_nil(x) -> acc
+      end)
+
+    nmap = if not is_nil(types), do: Map.put(nmap, "type", types), else: nmap
+    if nmap["type"], do: Jake.gen_init(nmap)
+  end
+end