Support repeated validation and add some tests.

Author: csWen

lib/dsl.ex

@@ -4,23 +4,18 @@ defmodule ProtoValidator.DSL do
 
     quote bind_quoted: [validator: validator] do
       Enum.map(@validations, fn {field, rules} ->
-        rules = apply(validator, :translate_rules, [field, rules])
+        rules = apply(validator, :translate_rules, [rules])
 
-        def validate_field(unquote(field) = field, data) do
-          apply(unquote(validator), :validate_field, [data, field, unquote(rules)])
+        def validate_value(unquote(field) = field, value) do
+          apply(
+            unquote(validator),
+            :validate_value,
+            [field, value, unquote(Macro.escape(rules))]
+          )
         end
       end)
 
-      def validate_field(field, _data), do: true
-
-      def validate(data) do
-        @validations
-        |> Stream.map(fn {field, _options} ->
-          validate_field(field, data)
-        end)
-        |> Stream.filter(&Kernel.match?({:error, msg}, &1))
-        |> Enum.at(0, :ok)
-      end
+      def validate_value(field, _value), do: :ok
     end
   end
 

lib/proto_validator.ex

@@ -1,5 +1,6 @@
 defprotocol ProtoValidator.Verifiable do
   @doc ""
+  @fallback_to_any true
   def validate(data)
 end
 
@@ -16,24 +17,59 @@ defmodule ProtoValidator do
   """
 
   defmacro __using__(opts) do
-    entity_module = Keyword.get(opts, :entity)
+    # entity_module = Keyword.get(opts, :entity)
 
     quote location: :keep do
-      import unquote(__MODULE__), except: [validate: 2]
       import ProtoValidator.DSL, only: [validate: 2]
 
       @options unquote(opts)
       Module.register_attribute(__MODULE__, :validations, accumulate: true)
 
       validator_module = __MODULE__
 
-      defimpl ProtoValidator.Verifiable, for: unquote(entity_module) do
+      entity_module = Keyword.get(@options, :entity)
+
+      defimpl ProtoValidator.Verifiable, for: entity_module do
         @validator_module validator_module
         def validate(data) do
           apply(@validator_module, :validate, [data])
         end
       end
 
+      def validate(%{__struct__: protobuf_module} = data) do
+        props = protobuf_module.__message_props__()
+
+        props
+        |> Map.get(:field_props)
+        |> Stream.filter(fn {_, %{oneof: oneof}} -> is_nil(oneof) end)
+        |> ProtoValidator.Utils.pipe_validates(fn {_, %{name_atom: field} = field_prop} ->
+          value = Map.get(data, field)
+
+          case validate_value(field, value) do
+            :ok -> validate_field(field_prop, value)
+            {:error, msg} -> {:error, msg}
+          end
+        end)
+      end
+
+      def validate(data) when is_map(data) do
+        @options |> Keyword.get(:entity) |> struct(data) |> validate()
+      end
+
+      def validate(_), do: :ok
+
+      def validate_field(_, nil), do: :ok
+
+      def validate_field(%{type: type, repeated?: true}, values) do
+        ProtoValidator.Utils.pipe_validates(values, fn value ->
+          ProtoValidator.validate(type, value)
+        end)
+      end
+
+      def validate_field(%{type: type} = field_prop, value) do
+        ProtoValidator.validate(type, value)
+      end
+
       @before_compile ProtoValidator.DSL
     end
   end
@@ -42,9 +78,19 @@ defmodule ProtoValidator do
     ProtoValidator.Verifiable.validate(data)
   end
 
-  def validate(module, data) do
+  def validate(_), do: :ok
+
+  def validate(_module, %_{} = data) do
+    validate(data)
+  end
+
+  def validate(module, data) when is_map(data) do
     module
     |> struct(data)
     |> ProtoValidator.Verifiable.validate()
+  rescue
+    err -> {:error, inspect(err)}
   end
+
+  def validate(_, _), do: :ok
 end

lib/proto_validator/protoc/cli.ex

@@ -32,6 +32,7 @@ defmodule ProtoValidator.Protoc.CLI do
         |> Enum.map(fn file_metadata ->
           ProtoValidator.Protoc.Generator.generate(file_metadata)
         end)
+        |> Enum.reject(&is_nil/1)
 
       Google.Protobuf.Compiler.CodeGeneratorResponse.new(file: files)
     end)

lib/proto_validator/protoc/generator.ex

@@ -2,14 +2,19 @@ defmodule ProtoValidator.Protoc.Generator do
   @moduledoc false
 
   alias Protobuf.Protoc.Metadata
+  alias ProtoValidator.Protoc.Utils
+  alias Google.Protobuf.Compiler.CodeGeneratorResponse
 
   def generate(file) do
     name = new_file_name(file.fqn)
 
-    Google.Protobuf.Compiler.CodeGeneratorResponse.File.new(
-      name: name,
-      content: generate_content(file)
-    )
+    case generate_content(file) do
+      nil ->
+        nil
+
+      content ->
+        CodeGeneratorResponse.File.new(name: name, content: content)
+    end
   end
 
   defp new_file_name(name) do
@@ -20,8 +25,16 @@ defmodule ProtoValidator.Protoc.Generator do
     file
     |> Metadata.File.all_messages()
     |> Enum.map(fn msg -> generate_message(msg) end)
-    |> Enum.join("\n")
-    |> Protobuf.Protoc.Generator.format_code()
+    |> Enum.reject(&is_nil/1)
+    |> case do
+      [] ->
+        nil
+
+      validations ->
+        validations
+        |> Enum.join("\n")
+        |> Protobuf.Protoc.Generator.format_code()
+    end
   end
 
   # TODO: put get_str functions to a separate module
@@ -74,25 +87,8 @@ defmodule ProtoValidator.Protoc.Generator do
   defp gen_validation([]), do: nil
 
   defp gen_validation(validations) do
-    Enum.map(validations, fn {name, %Validate.FieldRules{message: message, type: type}} ->
-      message_rule_str_list = get_rule_str_list(message)
-      type_rule_str_list = get_rule_str_list(type)
-      rules_str = "#{message_rule_str_list}#{type_rule_str_list}"
-
-      ":#{name}, #{rules_str}"
+    Enum.map(validations, fn {name, rules} ->
+      ":#{name}, #{Utils.get_rule_str(rules)}"
     end)
   end
-
-  defp get_rule_str_list(nil), do: nil
-
-  defp get_rule_str_list({type, type_rules}) do
-    ", #{type}: [#{get_rule_str_list(type_rules)}]"
-  end
-
-  defp get_rule_str_list(rules) do
-    rules
-    |> Map.from_struct()
-    |> Enum.map(fn {k, v} -> "#{k}: #{v}" end)
-    |> Enum.join(", ")
-  end
 end

lib/proto_validator/protoc/utils.ex

@@ -0,0 +1,58 @@
+defmodule ProtoValidator.Protoc.Utils do
+  @moduledoc """
+  """
+
+  @doc """
+  convert rules map to string:
+  From:
+    %Validate.FieldRules{
+      message: %Validate.MessageRules{required: true},
+      type: {
+        :repeated,
+        %Validate.RepeatedRules{
+          items: %Validate.FieldRules{
+            message: nil,
+            type: {:uint64, %Validate.UInt64Rules{gt: 0, lt: 90}}
+          },
+          max_items: nil,
+          min_items: 0,
+          unique: true
+        }
+      }
+    }
+    
+  To:
+    "required: true, repeated: [items: [uint64: [gt: 0, lt: 90]], min_items: 0, unique: true]"
+  """
+  def get_rule_str(%{message: message, type: type}) do
+    [get_rule_str(message), get_rule_str(type)]
+    |> Enum.reject(&is_nil/1)
+    |> Enum.join(", ")
+  end
+
+  def get_rule_str(nil), do: nil
+
+  def get_rule_str(%_{} = rules) when is_map(rules) do
+    rules |> Map.from_struct() |> get_rule_str()
+  end
+
+  def get_rule_str(rules) when is_map(rules) do
+    rule_str =
+      rules
+      |> Enum.map(fn
+        {_k, nil} -> nil
+        {k, v} when is_map(v) -> "#{k}: [#{get_rule_str(v)}]"
+        {k, v} -> "#{k}: #{get_rule_str(v)}"
+      end)
+      |> Enum.reject(&is_nil/1)
+      |> Enum.join(", ")
+
+    "#{rule_str}"
+  end
+
+  def get_rule_str({type, type_rules}) do
+    "#{type}: [#{get_rule_str(type_rules)}]"
+  end
+
+  def get_rule_str(v), do: to_string(v)
+end

lib/utils.ex

@@ -0,0 +1,10 @@
+defmodule ProtoValidator.Utils do
+  @moduledoc ""
+
+  def pipe_validates(objects, validate_fun) do
+    objects
+    |> Stream.map(fn object -> validate_fun.(object) end)
+    |> Stream.filter(&Kernel.match?({:error, _msg}, &1))
+    |> Enum.at(0, :ok)
+  end
+end

lib/validate.pb.ex

@@ -12,6 +12,7 @@ defmodule Validate.FieldRules do
 
   field(:message, 17, optional: true, type: Validate.MessageRules)
   field(:uint64, 6, optional: true, type: Validate.UInt64Rules, oneof: 0)
+  field(:repeated, 18, optional: true, type: Validate.RepeatedRules, oneof: 0)
 end
 
 defmodule Validate.MessageRules do
@@ -40,6 +41,24 @@ defmodule Validate.UInt64Rules do
   field(:gt, 4, optional: true, type: :uint64)
 end
 
+defmodule Validate.RepeatedRules do
+  @moduledoc false
+  use Protobuf, syntax: :proto2
+
+  @type t :: %__MODULE__{
+          min_items: non_neg_integer,
+          max_items: non_neg_integer,
+          unique: boolean,
+          items: Validate.FieldRules.t() | nil
+        }
+  defstruct [:min_items, :max_items, :unique, :items]
+
+  field(:min_items, 1, optional: true, type: :uint64)
+  field(:max_items, 2, optional: true, type: :uint64)
+  field(:unique, 3, optional: true, type: :bool)
+  field(:items, 4, optional: true, type: Validate.FieldRules)
+end
+
 defmodule Validate.PbExtension do
   @moduledoc false
   use Protobuf, syntax: :proto2

lib/validator.ex

@@ -6,4 +6,10 @@ defmodule ProtoValidator.Validator do
   end
 
   defp get_validator(:vex), do: ProtoValidator.Validator.Vex
+
+  def validate_uniq(nil), do: :ok
+
+  def validate_uniq(value) do
+    if Enum.uniq(value) == value, do: :ok, else: {:error, "values should be uniq"}
+  end
 end