param_checker 0.1.0 → 0.2.0

data/README.rdoc

@@ -22,41 +22,45 @@ Include the ParamChecker module where ever you like. I usually put it into my Ra
     include ParamChecker
   end
 
-You can then simply call for example <tt>check_string(param_to_check, "my default", ["foo", "bar"])</tt> in every controller.
+You can then simply call for example <tt>check_string(params[:name], "Mia", :allowed => ["foo", "bar"])</tt> in every controller.
 
 Instead of including the module you could also call all functions of the module directly, like
 
-  ParamChecker.check_string(param_to_check, "my default", ["foo", "bar"])
+  ParamChecker.check_string(params[:name], "Mia", ["foo", "bar"])
 
 There are currently 5 supported functions:
 
-  check_integer(param, default, min, max)
-  check_float(param, default, min, max)
-  check_string(param, default, allowed)
-  check_symbol(param, default, allowed)
-  check_boolean(param, default)
+  check_integer(param, default, options)
+  check_float(param, default, options)
+  check_string(param, default, options)
+  check_symbol(param, default, options)
+  check_boolean(param, default, options)
 
-* +param+ (_required_) is the string parameter to check.
-* +default+ (_required_) is the value that is returned when +param+ does not pass the check.
-* +min+ (_optional_), +max+ (_optional_) in +check_integer+ and +check_float+ are the minimum and maximum allowed values of param. (If not provided then no range is checked at all.)
-* +allowed+ (_optional_) in +check_string+ and +check_symbol+ represent the allowed values of +param+. They can be either a string (resp. a symbol for +check_symbol+), a regular expression, or an array of strings (resp. symbols for +check_symbol+).
-* +check_boolean+ evaluates "1" or "true" string as true and "0" or "false" string to false.
+* +param+ is the string parameter to check.
+* +default+ is the value that will be returned when +param+ does not pass the check.
+* +options+ are function specific options to check +param+ against:
+  * +min+, +max+ in +check_integer+ and +check_float+ are the minimum and maximum allowed values of param. (If not provided then no range is checked at all.)
+  * +allowed+ in +check_string+ and +check_symbol+ represent the allowed values of +param+. It can be either a regular expression, a string (resp. a symbol for +check_symbol+),  or an array of strings (resp. an array of symbols for +check_symbol+).
+  * +true+ and +false+ represent the allowed string values for the true and false booleans. By default is :true => ["1", "true"] and :false => ["0", "false"]
 
-All functions return the the casted value (check_integer returns an integer, check_symbol returns a symbol, and so on).
+All functions return the casted value (check_integer returns an integer, check_symbol returns a symbol, and so on).
 
 == Examples
 
-Below are some simple examples how I use those function in my controllers.
+Below are some simple examples how to use those functions.
 
-  # +max+ is not provided in this case. I just want to ensure that page is bigger than 1 and otherwise return 1.
-  page = check_integer(params[:page], 1, 1)
+  # Check if per_page parameter is a valid integer representation, ensure that it is bigger than 1 and smaller than 100 and return its integer value. Otherwise return 10.
+  page = check_integer(params[:per_page], 10, :min => 1, :max => 100)
 
-  # Returns "name" if params[:field] is not "name" or "address"
-  field = check_string(params[:field], "name", ["name", "address"])
+  # If field parameter is equal to "name" or "address" then return it, otherwise return "name".
+  field = check_string(params[:field], "name", :allowed => ["name", "address"])
 
-  # Return the boolean if params[:accepted] is a valid boolean representation, and the default false otherwise.
+  # Return the boolean if params[:accepted] is a valid boolean representation and the default false otherwise.
   accepted = check_boolean(params[:accepted], false)
 
+  # Have custom boolean string representation values.
+  accepted = check_boolean(params[:accepted], false, :true => ["yep", "yes"], :false => ["nope", "no"])
+
 == Testing
 
 ParamChecker uses RSpec for testing and has a rake task for executing the provided specs

data/lib/param_checker.rb

@@ -3,15 +3,16 @@ module ParamChecker
   module_function
 
   # Check a parameter string if it is a valid integer and return its integer value.
-  # +param+: the string parameter to check
-  # +default+: the default integer to return if the check fails
-  # +min+: the minimum value allowed (optional)
-  # +max+: the maximum value allowed (optional)
-  def check_integer(param, default, min = nil, max = nil)
-    min_lambda = (min.nil? ? lambda { true } : lambda { param.to_i >= min })
-    max_lambda = (max.nil? ? lambda { true } : lambda { param.to_i <= max })
+  # * +param+: the string parameter to check
+  # * +default+: the default integer to return if the check fails
+  # * +options+: a hash of options:
+  #   * +min+: the minimum integer value allowed
+  #   * +max+: the maximum integer value allowed
+  def check_integer(param, default, options = {})
+    min = (options[:min] ? param.to_i >= options[:min] : true)
+    max = (options[:max] ? param.to_i <= options[:max] : true)
 
-    if (param && param.strip =~ /^-?[0-9]+$/ && min_lambda.call && max_lambda.call)
+    if (param && param.strip =~ /^-?[0-9]+$/ && min && max)
       param.to_i
     else
       default
@@ -19,15 +20,16 @@ module ParamChecker
   end
 
   # Check a parameter string if it is a valid float and return its float value.
-  # +param+: the string parameter to check
-  # +default+: the default float to return if the check fails
-  # +min+: the minimum value allowed (optional)
-  # +max+: the maximum value allowed (optional)
-  def check_float(param, default, min = nil, max = nil)
-    min_lambda = (min.nil? ? lambda { true } : lambda { param.to_i >= min })
-    max_lambda = (max.nil? ? lambda { true } : lambda { param.to_i <= max })
+  # * +param+: the string parameter to check
+  # * +default+: the default float to return if the check fails
+  # * +options+: a hash of options:
+  #   * +min+: the minimum float value allowed (optional)
+  #   * +max+: the maximum float value allowed (optional)
+  def check_float(param, default, options = {})
+    min = (options[:min] ? param.to_f >= options[:min] : true)
+    max = (options[:max] ? param.to_f <= options[:max] : true)
 
-    if (param && param.strip =~ /^-?[0-9]+(\.[0-9]+)?$/ && min_lambda.call && max_lambda.call)
+    if (param && param.strip =~ /^-?[0-9]+(\.[0-9]+)?$/ && min && max)
       param.to_f
     else
       default
@@ -35,11 +37,12 @@ module ParamChecker
   end
 
   # Check a parameter string if it is a valid sting and return its string value.
-  # +param+: the string parameter to check
-  # +default+: the default string to return if the check fails
-  # +allowed+: the allowed string value to check +param+ against; could be
-  #   a regular expression, a string or an array of strings
-  def check_string(param, default, allowed)
+  # * +param+: the string parameter to check
+  # * +default+: the default string to return if the check fails
+  # * +options+: a hash of options:
+  #   * +allowed+: the allowed string values to check +param+ against; could be a regular expression, a string or an array of strings
+  def check_string(param, default, options = {})
+    allowed = options[:allowed]
     if (param && allowed.class == Regexp && param =~ allowed)
       param
     elsif (param && allowed.class == Array && allowed.include?(param))
@@ -51,12 +54,13 @@ module ParamChecker
     end
   end
 
-  # Check a parameter string if it is a valid :symbol and return its symbol value.
-  # +param+: the string parameter to check
-  # +default+: the default symbol to return if the check fails
-  # +allowed+: the allowed symbol value to check +param+ against; could be
-  #   a regular expression, a string, a symbol, an array of strings or an array of symbols.
-  def check_symbol(param, default, allowed)
+  # Check a parameter string if it is a valid symbol and return its symbol value.
+  # * +param+: the string parameter to check
+  # * +default+: the default symbol to return if the check fails
+  # * +options+: a hash of options:
+  #   * +allowed+: the allowed symbol values to check +param+ against; could be a regular expression, a symbol or an array of symbols.
+  def check_symbol(param, default, options = {})
+    allowed = options[:allowed]
     if (param && !param.empty? && allowed.class == Regexp && param =~ allowed)
       param.to_sym
     elsif (param && !param.empty? && allowed.class == Array && allowed.map { |a| a.to_sym }.include?(param.to_sym))
@@ -69,13 +73,17 @@ module ParamChecker
   end
 
   # Check a parameter string if it represents a valid boolean and return its boolean value.
-  # Allowed string parameters are "1" or "true" for +true+, and "0" or "false" for +false+.
-  # +param+: the string parameter to check
-  # +default+: the default boolean to return if the check fails
-  def check_boolean(param, default)
-    if (param && param == "1" || param == "true")
+  # * +param+: the string parameter to check
+  # * +default+: the default boolean to return if the check fails
+  # * +options+: a hash of options:
+  #   * +true+: an array of string representations of true (by default "1" and "true")
+  #   * +false+: an array of string representations of false (by default "0" and "false")
+  def check_boolean(param, default, options = {})
+    true_values = (options[:true] ? options[:true] : ["1", "true"])
+    false_values = (options[:false] ? options[:false] : ["0", "false"])
+    if (true_values.include?(param))
       true
-    elsif (param && param == "0" || param == "false")
+    elsif (false_values.include?(param))
       false
     else
       default

data/lib/param_checker/version.rb

@@ -1,3 +1,3 @@
 module ParamChecker
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/lib/param_checker_spec.rb

@@ -8,9 +8,9 @@ describe "ParamChecker" do
   describe "check integer" do
     it "should pass" do
       @model.check_integer("5", 99).should == 5
-      @model.check_integer("5", 99, 4).should == 5
-      @model.check_integer("5", 99, nil, 6).should == 5
-      @model.check_integer("5", 99, 4, 6).should == 5
+      @model.check_integer("5", 99, :min => 4).should == 5
+      @model.check_integer("5", 99, :max => 6).should == 5
+      @model.check_integer("5", 99, :min => 4, :max => 6).should == 5
       @model.check_integer("-5", 99).should == -5
       @model.check_integer(" 5 ", 99).should == 5
     end
@@ -19,10 +19,10 @@ describe "ParamChecker" do
       @model.check_integer(nil, 99).should == 99
       @model.check_integer("", 99).should == 99
       @model.check_integer("5abc", 99).should == 99
-      @model.check_integer("5", 99, 6).should == 99
-      @model.check_integer("5", 99, nil, 4).should == 99
-      @model.check_integer("5", 99, 1, 4).should == 99
-      @model.check_integer("5", 99, 10, 1).should == 99
+      @model.check_integer("5", 99, :min => 6).should == 99
+      @model.check_integer("5", 99, :max => 4).should == 99
+      @model.check_integer("5", 99, :min => 1, :max => 4).should == 99
+      @model.check_integer("5", 99, :min => 10, :max => 1).should == 99
       @model.check_integer("", nil).should == nil
     end
   end
@@ -30,59 +30,63 @@ describe "ParamChecker" do
   describe "check float" do
     it "should pass" do
       @model.check_float("5.1", 99.2).should == 5.1
-      @model.check_float("5.1", 99.2, 4.3).should == 5.1
-      @model.check_float("5.1", 99.2, nil, 6.4).should == 5.1
-      @model.check_float("5.1", 99.2, 4.3, 6.4).should == 5.1
+      @model.check_float("5.1", 99.2, :min => 4.3).should == 5.1
+      @model.check_float("5.1", 99.2, :max => 6.4).should == 5.1
+      @model.check_float("5.1", 99.2, :min => 4.3, :max => 6.4).should == 5.1
       @model.check_float("-5.1", 99.2).should == -5.1
       @model.check_float(" 5.1 ", 99.2).should == 5.1
+      @model.check_float("5.1", 99.2, :min => 5.1, :max => 5.1).should == 5.1
     end
 
     it "should fail" do
       @model.check_float(nil, 99.2).should == 99.2
       @model.check_float("", 99.2).should == 99.2
       @model.check_float("5abc", 99.2).should == 99.2
-      @model.check_float("5", 99.2, 6.4).should == 99.2
-      @model.check_float("5", 99.2, nil, 4.3).should == 99.2
-      @model.check_float("5", 99.2, 1, 4.3).should == 99.2
-      @model.check_float("5", 99.2, 10.5, 1.6).should == 99.2
+      @model.check_float("5", 99.2, :min => 6.4).should == 99.2
+      @model.check_float("5", 99.2, :max => 4.3).should == 99.2
+      @model.check_float("5", 99.2, :min => 1, :max => 4.3).should == 99.2
+      @model.check_float("5", 99.2, :min => 10.5, :max => 1.6).should == 99.2
       @model.check_float("", nil).should == nil
     end
   end
 
   describe "check string" do
     it "should pass" do
-      @model.check_string("lorem", "dolor", /.*ore.*/).should == "lorem"
-      @model.check_string("lorem", "dolor", ["lorem", "ipsum"]).should == "lorem"
-      @model.check_string("lorem", "dolor", "lorem").should == "lorem"
-      @model.check_string("", "dolor", /.*/).should == ""
-      @model.check_string("", "dolor", "").should == ""
+      @model.check_string("lorem", "dolor", :allowed => /.*ore.*/).should == "lorem"
+      @model.check_string("lorem", "dolor", :allowed => ["lorem", "ipsum"]).should == "lorem"
+      @model.check_string("lorem", "dolor", :allowed => "lorem").should == "lorem"
+      @model.check_string("", "dolor", :allowed => /.*/).should == ""
+      @model.check_string("", "dolor", :allowed => "").should == ""
     end
 
     it "should fail" do
-      @model.check_string(nil, "dolor", /.*ore.*/).should == "dolor"
-      @model.check_string("lorem", "dolor", /.*ips.*/).should == "dolor"
-      @model.check_string("lorem", "dolor", ["patre", "ipsum"]).should == "dolor"
-      @model.check_string("lorem", "dolor", "ipsum").should == "dolor"
-      @model.check_string("lorem", nil, /.*ips.*/).should == nil
+      @model.check_string("lorem", "dolor").should == "dolor"
+      @model.check_string(nil, "dolor", :allowed => /.*ore.*/).should == "dolor"
+      @model.check_string("lorem", "dolor", :allowed => /.*ips.*/).should == "dolor"
+      @model.check_string("lorem", "dolor", :allowed => ["patre", "ipsum"]).should == "dolor"
+      @model.check_string("lorem", "dolor", :allowed => "ipsum").should == "dolor"
+      @model.check_string("lorem", nil, :allowed => /.*ips.*/).should == nil
     end
   end
 
   describe "check symbol" do
     it "should pass" do
-      @model.check_symbol("lorem", :dolor, /.*ore.*/).should == :lorem
-      @model.check_symbol("lorem", :dolor, ["lorem", :ipsum]).should == :lorem
-      @model.check_symbol("lorem", :dolor, :lorem).should == :lorem
+      @model.check_symbol("lorem", :dolor,:allowed =>  /.*ore.*/).should == :lorem
+      @model.check_symbol("lorem", :dolor, :allowed => ["lorem", :ipsum]).should == :lorem
+      @model.check_symbol("lorem", :dolor, :allowed => :lorem).should == :lorem
     end
 
     it "should fail" do
-      @model.check_symbol(nil, :dolor, /.*ore.*/).should == :dolor
-      @model.check_symbol("lorem", :dolor, /.*ips.*/).should == :dolor
-      @model.check_symbol("lorem", :dolor, ["patre", "ipsum"]).should == :dolor
-      @model.check_symbol("lorem", :dolor, "ipsum").should == :dolor
-      @model.check_symbol("lorem", :dolor, "ipsum").should == :dolor
-      @model.check_symbol("", :dolor, /.*/).should == :dolor
-      @model.check_symbol("", :dolor, "").should == :dolor
-      @model.check_symbol("lorem", nil, /.*ips.*/).should == nil
+      @model.check_string("lorem", :dolor).should == :dolor
+      @model.check_symbol(nil, :dolor, :allowed => /.*ore.*/).should == :dolor
+      @model.check_symbol("lorem", :dolor, :allowed => /.*ips.*/).should == :dolor
+      @model.check_symbol("lorem", :dolor, :allowed => ["patre", "ipsum"]).should == :dolor
+      @model.check_symbol("lorem", :dolor, :allowed => "ipsum").should == :dolor
+      @model.check_symbol("lorem", :dolor, :allowed => "ipsum").should == :dolor
+      @model.check_symbol("", :dolor, :allowed => /.*/).should == :dolor
+      @model.check_symbol("", :dolor, :allowed => "").should == :dolor
+      @model.check_symbol("lorem", nil, :allowed => /.*ips.*/).should == nil
+      @model.check_symbol("", :dolor, :allowed => "").should == :dolor
     end
   end
 
@@ -101,13 +105,27 @@ describe "ParamChecker" do
       @model.check_boolean("abc", true).should == true
       @model.check_boolean("abc", nil).should == nil
     end
+
+    it "should pass with custom true and false values" do
+      @model.check_boolean("yes", false, :true => "yes").should == true
+      @model.check_boolean("no", true, :false => "no").should == false
+      @model.check_boolean("ja", false, :true => ["yes", "ja"]).should == true
+      @model.check_boolean("nein", true, :false => ["no", "nein"]).should == false
+    end
+
+    it "should fail with custom true and false values" do
+      @model.check_boolean("yep", false, :true => "yes").should == false
+      @model.check_boolean("nope", true, :false => "no").should == true
+      @model.check_boolean("yep", false, :true => ["yes", "ja"]).should == false
+      @model.check_boolean("nope", true, :false => ["no", "nein"]).should == true
+    end
   end
 
   it "can be called as module functions" do
     ParamChecker.check_integer("5", 99).should == 5
     ParamChecker.check_float("5.1", 99.2).should == 5.1
-    ParamChecker.check_string("lorem", "dolor", /.*ore.*/).should == "lorem"
-    ParamChecker.check_symbol("lorem", :dolor, /.*ore.*/).should == :lorem
+    ParamChecker.check_string("lorem", "dolor", :allowed => /.*ore.*/).should == "lorem"
+    ParamChecker.check_symbol("lorem", :dolor, :allowed => /.*ore.*/).should == :lorem
     ParamChecker.check_boolean("1", false).should == true
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: param_checker
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Kai Schlamp