api_validator 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e001388521bb57ebafb2c6fd2f6d0d130af547b
-  data.tar.gz: 38696b838c273fc595523cd55ac31d7aec3e4029
+  metadata.gz: 8d32ef54839f650fd8e19746d176e26e241880b2
+  data.tar.gz: 67719c03e4cb48e79bc944d10bb98fba1b868161
 SHA512:
-  metadata.gz: 59ecdf26a07d570f15006def55a5e4357406ee9e24125f3bce24bbd4979f45000a9e4bb041f304b186abca434391ed44cd53cf6f44a5894ffac29e66da7f4b6d
-  data.tar.gz: 5b604d93767fc676ab63b52055af1d48fe73b3f8aeb478de5a7535ebb1d7aae6d5b0eac81e2430c7bdb99379609d6443096e43c36a4ac2571377ee6e1d42b171
+  metadata.gz: 7a7f4e019579c940dd6607c0933d13c076c6b3a36b2aebddecc8367e2b43b1757e09cbf9fa6463de397f5b8a0c10a48e31add4345fd875a048bd4cfb90b1daef
+  data.tar.gz: 020c51cdd554f68469b3c4836feefd6a412506906e52c1c0f3803e1cf655cc76807844b21e4059212a36f1dd01324d340f0d9b27ac2dd36d1cb4684d0e895e6f

data/README.md

@@ -1,4 +1,5 @@
 # api_validator
+[![Gem Version](https://badge.fury.io/rb/api_validator.svg)](https://badge.fury.io/rb/api_validator)
 This gem helpful to validate api calls. You need to set rules and messages in yml file and rest of the things are handle by gem.
 
 ## Installation
@@ -25,7 +26,7 @@ Note : Here you can pass any name you want to set for initilizer file and valida
 
 ## Usage
 
-Before use of this gem you need to set ```ruby before_filter :request_validation ``` in controller where you want to validate request before reach to controller's method.
+Before use of this gem you need to set ``` before_action :request_validation ``` in controller where you want to validate request before reach to controller's method.
 
 Also you need to set rules in the api_validator.yml.erb file. Example are mentioned in yml file.
 
@@ -40,13 +41,15 @@ controller_name:
          integer: true
          min_length: 5
          max_length: 15
-         pattern: <%= /\A^[a-zA-Z\s'.-]*$\Z/.source %> 
+         pattern: <%= /\A^[a-zA-Z\s'.-]*$\Z/.source %>
+         inclusion: "1..10"
        messages:
          presence: "Param1 must present."
          integer: "Param1 must contain integer only."
          min_length: "Param1 must have minimum length of 5."
          max_length: "Param1 must have maximum length of 15."
          pattern: "Invalid Param1"
+         inclusion: "The param1 must be between 1 and 10"
 ```
 
 Sample validation for JSON value in request parameter -

data/lib/api_validator.rb

@@ -4,7 +4,7 @@ module ApiValidator
 	INTEGER_REGEX = /^[1-9]([0-9]*)?$/
   # request validation method
   # Input - request params
-  # Process - Validate params with there rules & definition
+  # Process - Validate params with there rules & defination
   # Output - report error on invalidity
   def request_validation
     if is_api_validator_applicable?(params[:controller], params[:action])
@@ -13,9 +13,9 @@ module ApiValidator
       
       validation_pd.keys.each do |key|
         next if params.has_key?(key) == false && validation_pd[key]["rules"].has_key?("presence") == false
-        validation_pd[key]["rules"].each do |rule, definition|
+        validation_pd[key]["rules"].each do |rule, defination|
           # when param's value is JSON string then parse it and validate parameters
-          if (rule == "json_string" and definition == true)
+          if (rule == "json_string" and defination == true)
             begin
               json_data = JSON.parse(params[key])
               json_data = [json_data] unless json_data.class == Array
@@ -23,9 +23,9 @@ module ApiValidator
                 data.keys.each do |json_data_key|
                   if validation_pd[key].has_key?("parameters")
                     next unless validation_pd[key]["parameters"].has_key?(json_data_key)
-                    validation_pd[key]["parameters"][json_data_key]["rules"].each do |json_data_rule, json_data_definition|
+                    validation_pd[key]["parameters"][json_data_key]["rules"].each do |json_data_rule, json_data_defination|
                       #CAUTION: if nested JSON, this should be recursive
-                      return error_response(validation_pd[key]["parameters"][json_data_key]["messages"][json_data_rule]) if validate?(json_data_key, data[json_data_key], json_data_rule, json_data_definition, validation_pd[key]["parameters"][json_data_key])
+                      return error_response(validation_pd[key]["parameters"][json_data_key]["messages"][json_data_rule]) if validate?(json_data_key, data[json_data_key], json_data_rule, json_data_defination, validation_pd[key]["parameters"][json_data_key])
                     end
                   end
                 end
@@ -35,7 +35,7 @@ module ApiValidator
             end
           # when param's value is NOT JSON
           else
-            return error_response(validation_pd[key]["messages"][rule]) if validate?(key, params[key], rule, definition, validation_pd[key])
+            return error_response(validation_pd[key]["messages"][rule]) if validate?(key, params[key], rule, defination, validation_pd[key])
           end
         end # param rule loop end
       end # params list loop end
@@ -59,6 +59,11 @@ module ApiValidator
     !!(value =~ pattern)
   end
 
+  def is_in_inclusion?(defination, value)
+    range = defination.split("..").map(&:to_i)
+    Range.new(range[0], range[-1]) === value.to_i
+  end 
+
   def validate_array_string?(value, separator)
     parameter_ids = value.split(separator)
     parameter_ids.each do |parameter|
@@ -67,34 +72,37 @@ module ApiValidator
     return true
   end
 
-  def validate?(key, value, rule, definition, dtd)
+  def validate?(key, value, rule, defination, dtd)
     is_error_found = false
     case
-    when (rule == "ignore_if_present" and definition.present?)
+    when (rule == "ignore_if_present" and defination.present?)
       # return error if not present & defination absence
-      is_error_found = true if value.present? == false and params[definition].present? == false
-    when (rule == "presence" and definition == true)
+      is_error_found = true if value.present? == false and params[defination].present? == false
+    when (rule == "presence" and defination == true)
       # return error if not present
       is_error_found = true unless value.present?
-    when (rule == "array_string" and definition.present?)
+    when (rule == "array_string" and defination.present?)
       # return error if array string invalid
-      is_error_found = true unless validate_array_string?(value, definition)
-    when (rule == "integer" and definition == true)
+      is_error_found = true unless validate_array_string?(value, defination)
+    when (rule == "integer" and defination == true)
       # return error if not match with integer
       is_error_found = true unless is_integer?(value)
-    when (rule == "min_length" and definition > 0)
+    when (rule == "min_length" and defination > 0)
       # return error if minimum length is not achived
-      is_error_found = true unless value.length >= definition
-    when (rule == "max_length" and definition > 0)
+      is_error_found = true unless value.length >= defination
+    when (rule == "max_length" and defination > 0)
       # return error if maximum length is not achived
-      is_error_found = true unless value.length <= definition
-    when (rule == "max_value" and definition > 0)
-      # return error if param's value is less or equal to definition
-      is_error_found = true unless value.to_f <= definition
-    when (rule == "pattern" and definition.present?)
+      is_error_found = true unless value.length <= defination
+    when (rule == "max_value" and defination > 0)
+      # return error if param's value is less or equal to defination
+      is_error_found = true unless value.to_f <= defination
+    when (rule=="inclusion" and defination.present?)
+      # return error if param's value is not in between defination
+      is_error_found = true unless is_in_inclusion?(defination, value)
+    when (rule == "pattern" and defination.present?)
       # return error if pattern doesn't match
       if dtd["rules"].has_key?("presence") == true || value.present?
-        is_error_found = true unless is_pattern_match?(value, Regexp.new(definition))
+        is_error_found = true unless is_pattern_match?(value, Regexp.new(defination))
       end
     end
     return is_error_found

data/lib/api_validator/version.rb

@@ -1,3 +1,3 @@
 module ApiValidator
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/generators/api_validator/install/templates/validate_api.yml.erb

@@ -9,12 +9,14 @@
 #         min_length: 5
 #         max_length: 15
 #         pattern: <%#= "/\A^[a-zA-Z\s'.-]*$\Z/".source %> 
+#         inclusion: "1..10"
 #       messages:
 #         presence: "Param1 must present."
 #         integer: "Param1 must contain integer only."
 #         min_length: "Param1 must have minimum length of 5."
 #         max_length: "Param1 must have maximum length of 15."
 #         pattern: "Invalid Param1"
+#         inclusion: "The param1 must be between 1 and 10"
 #
 # Also if have some paramters which accepts json as value and that json have some 
 # which need to be validate you need to follow following pattern to make it applicable

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_validator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - sandipkaranjekar
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-29 00:00:00.000000000 Z
+date: 2017-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler