Issue #69: Change `range` to require only one arg

Currently range is hard-coded to take both max and min. This is
unhelpful in cases where we may only want to check one of the bounds.

Update so that it behaves more like the `length` validator and can take
either max or min, as well as both. Also ensure that at least one of
them is supplied.

3 files changed, 42 insertions, 29 deletions

diff --git a/validator_derive/src/lit.rs b/validator_derive/src/lit.rs
index 14e3f56..de0e21e 100644
--- a/validator_derive/src/lit.rs
+++ b/validator_derive/src/lit.rs
@@ -46,3 +46,10 @@ pub fn option_u64_to_tokens(opt: Option<u64>) -> proc_macro2::TokenStream {
         None => quote!(::std::option::Option::None),
     }
 }
+
+pub fn option_f64_to_tokens(opt: Option<f64>) -> proc_macro2::TokenStream {
+    match opt {
+        Some(ref t) => quote!(::std::option::Option::Some(#t)),
+        None => quote!(::std::option::Option::None),
+    }
+}
diff --git a/validator_derive/src/quoting.rs b/validator_derive/src/quoting.rs
index f94d8fc..fa97623 100644
--- a/validator_derive/src/quoting.rs
+++ b/validator_derive/src/quoting.rs
@@ -3,7 +3,7 @@ use syn;
 use validator::Validator;
 
 use asserts::{COW_TYPE, NUMBER_TYPES};
-use lit::option_u64_to_tokens;
+use lit::{option_f64_to_tokens, option_u64_to_tokens};
 use validation::{FieldValidation, SchemaValidation};
 
 /// Pass around all the information needed for creating a validation
@@ -183,12 +183,25 @@ pub fn quote_range_validation(
     let quoted_ident = field_quoter.quote_validator_param();
 
     if let Validator::Range { min, max } = validation.validator {
+        // Can't interpolate None
+        let min_tokens = option_f64_to_tokens(min);
+        let max_tokens = option_f64_to_tokens(max);
+
+        let min_err_param_quoted = if let Some(v) = min {
+            quote!(err.add_param(::std::borrow::Cow::from("min"), &#v);)
+        } else {
+            quote!()
+        };
+        let max_err_param_quoted = if let Some(v) = max {
+            quote!(err.add_param(::std::borrow::Cow::from("max"), &#v);)
+        } else {
+            quote!()
+        };
+
         let quoted_error = quote_error(&validation);
-        let min_err_param_quoted = quote!(err.add_param(::std::borrow::Cow::from("min"), &#min););
-        let max_err_param_quoted = quote!(err.add_param(::std::borrow::Cow::from("max"), &#max););
         let quoted = quote!(
             if !::validator::validate_range(
-                ::validator::Validator::Range {min: #min, max: #max},
+                ::validator::Validator::Range {min: #min_tokens, max: #max_tokens},
                 #quoted_ident as f64
             ) {
                 #quoted_error
diff --git a/validator_derive/src/validation.rs b/validator_derive/src/validation.rs
index a9762db..d9ad5a5 100644
--- a/validator_derive/src/validation.rs
+++ b/validator_derive/src/validation.rs
@@ -95,8 +95,8 @@ pub fn extract_range_validation(
     field: String,
     meta_items: &Vec<syn::NestedMeta>,
 ) -> FieldValidation {
-    let mut min = 0.0;
-    let mut max = 0.0;
+    let mut min = None;
+    let mut max = None;
 
     let (message, code) = extract_message_and_code("range", &field, meta_items);
 
@@ -104,45 +104,38 @@ pub fn extract_range_validation(
         panic!("Invalid attribute #[validate] on field `{}`: {}", field, msg);
     };
 
-    // whether it has both `min` and `max`
-    let mut has_min = false;
-    let mut has_max = false;
-
     for meta_item in meta_items {
         match *meta_item {
             syn::NestedMeta::Meta(ref item) => match *item {
-                syn::Meta::NameValue(syn::MetaNameValue { ref ident, ref lit, .. }) => match ident
-                    .to_string()
-                    .as_ref()
-                {
-                    "message" | "code" => continue,
-                    "min" => {
-                        min = match lit_to_float(lit) {
-                                Some(s) => s,
+                syn::Meta::NameValue(syn::MetaNameValue { ref ident, ref lit, .. }) => {
+                    match ident.to_string().as_ref() {
+                        "message" | "code" => continue,
+                        "min" => {
+                            min = match lit_to_float(lit) {
+                                Some(s) => Some(s),
                                 None => error("invalid argument type for `min` of `range` validator: only integers are allowed")
                             };
-                        has_min = true;
-                    }
-                    "max" => {
-                        max = match lit_to_float(lit) {
-                                Some(s) => s,
+                        }
+                        "max" => {
+                            max = match lit_to_float(lit) {
+                                Some(s) => Some(s),
                                 None => error("invalid argument type for `max` of `range` validator: only integers are allowed")
                             };
-                        has_max = true;
-                    }
-                    v => error(&format!(
+                        }
+                        v => error(&format!(
                         "unknown argument `{}` for validator `range` (it only has `min`, `max`)",
                         v
                     )),
-                },
+                    }
+                }
                 _ => panic!("unexpected item {:?} while parsing `range` validator", item),
             },
             _ => unreachable!(),
         }
     }
 
-    if !has_min || !has_max {
-        error("Validator `range` requires 2 arguments: `min` and `max`");
+    if !min.is_some() && !max.is_some() {
+        error("Validator `range` requires at least 1 argument out of `min` and `max`");
     }
 
     let validator = Validator::Range { min, max };