sinatra-my-params 0.0.4 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2c387628a7d4582e28e5fe2bdc905abc284cdcf81c76fc8bd2f0c3e23f254e1
-  data.tar.gz: e86107885442e79700caf8f293b591814798296275b5588dbe2120d80df63898
+  metadata.gz: 5a1f7f7726f5d92878f2f65847f2d853d3ab3033b3dfaf4e84784d0bb56bd9b3
+  data.tar.gz: 4ebf4d253a1286535ff93503433695867faf4ab4c3b3fd08076e807ba40535f9
 SHA512:
-  metadata.gz: 8c544a84df83f1e507dced93487e175f0d3b4044141f47774f59fdd8f12592070f98134a472b524983ddde905af04444da6acf359cbf8a34c14fe5e0d1eb65b5
-  data.tar.gz: b03d81b690692988673bdf9fbf944ca533fa770ff3e4b21f358e371579b6c0ebc6c5688d5729adc243c4e1f522737b256941cee23ee71df6964917b87c6c3a3e
+  metadata.gz: b87393662b298d9acf0c127427ed77894c2c378fc05f4f737c0412c60180eae68f99ba55c7e6bafdfd42afc8428971482c19cac9bb3c0524ca289f741488364c
+  data.tar.gz: d9a899475bb3e5d6af6cd2c5d539b645a5770e9d4de99cf37797899058bd0ad18c2bec8799905aab8dd3c46cbacf8915d3ad97679684dfce15e56583d9d5c554

data/lib/permit_params.rb

@@ -1,45 +1,83 @@
+# frozen_string_literal: true
+
 module PermitParams
   class InvalidParameterError < StandardError
     attr_accessor :param, :options
   end
 
-  def permitted_params(params, permitted = {}, strong_validation = false)
+  def permitted_params(params, permitted = {}, strong_validation = false, options = {})
     return params if permitted.empty?
-  
-    params.select do |k,v| 
-      permitted.keys.map(&:to_s).include?(k.to_s) && 
-        !v.nil? && 
-        !coerce(v, permitted[k.to_sym], strong_validation).nil?
+
+    coerced_params = Hash.new({})
+
+    params.each do |key, value|
+      next unless permitted.keys.map(&:to_s).include?(key.to_s) && !value.nil?
+
+      coerced = coerce(
+        param: value,
+        type: permitted[key.to_sym],
+        strong_validation: strong_validation,
+        options: options
+      )
+      coerced_params[key] = coerced unless coerced.nil?
     end
+    coerced_params
   end
 
   private
 
   Boolean = :boolean
+  Any = :any
+
+  def coerce(param:, type:, strong_validation: false, options: {})
+    return param if type == Any
 
-  def coerce(param, type, strong = false, options = {})
     begin
       return nil if param.nil?
-      return param if (param.is_a?(type) rescue false)
-      return Integer(param, 10) if type == Integer
+      return param if begin
+        param.is_a?(type)
+      rescue StandardError
+        false
+      end
+      return coerce_integer(param, options) if type == Integer
       return Float(param) if type == Float
       return String(param) if type == String
       return Date.parse(param) if type == Date
       return Time.parse(param) if type == Time
       return DateTime.parse(param) if type == DateTime
-      return Array(param.split(options[:delimiter] || ",")) if type == Array
-      return Hash[param.split(options[:delimiter] || ",").map{|c| c.split(options[:separator] || ":")}] if type == Hash
+      return coerce_array(param, options) if type == Array
+      return coerce_hash(param, options) if type == Hash
       return coerce_boolean(param) if [TrueClass, FalseClass, Boolean].include? type
-      return nil
+
+      nil
     rescue ArgumentError
-      raise InvalidParameterError, "'#{param}' is not a valid #{type}" if strong
+      raise InvalidParameterError, "'#{param}' is not a valid #{type}" if strong_validation
     end
   end
 
+  def coerce_integer(param, options = {})
+    Integer(param, options[:integer_precision] || 10)
+  end
+
+  def coerce_array(param, options = {})
+    Array(param.split(options[:delimiter] || ',').map(&:strip))
+  end
+
+  def coerce_hash(param, options = {})
+    key_value = param.split(options[:delimiter] || ',').map(&:strip).map do |c|
+      c.split(options[:separator] || ':').map(&:strip)
+    end
+    Hash[key_value]
+  end
+
   def coerce_boolean(param)
-    coerced = /^(false|f|no|n|0)$/i === param.to_s ? false : /^(true|t|yes|y|1)$/i === param.to_s ? true : nil
+    coerced = if /^(false|f|no|n|0)$/i === param.to_s
+                false
+              else
+                /^(true|t|yes|y|1)$/i === param.to_s ? true : nil
+              end
     raise ArgumentError if coerced.nil?
+
     coerced
   end
 end
-

data/spec/permit_params_spec.rb

@@ -1,70 +1,150 @@
-require "test/unit"
-require "permit_params"
-require "rspec"
-require "rack/test"
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'permit_params'
+require 'rspec'
+require 'rack/test'
 
 include PermitParams
 
-describe "exceptions" do
-  it "should raise error when at least one param is invalid" do
-    input = { param_1: "a" }
-    expect{
+describe 'exceptions' do
+  before do
+    class TestClass; end
+  end
+
+  it 'should raise error when at least one param is invalid' do
+    input = { param_1: 'a' }
+    expect  do
       permitted_params(input, { param_1: Integer }, true)
-    }.to raise_error(InvalidParameterError, "'a' is not a valid Integer") 
+    end.to raise_error(InvalidParameterError, "'a' is not a valid Integer")
+  end
+
+  it 'should allow all params when no restriction is given' do
+    input = { param_1: 'a string' }
+    expect(input).to eq permitted_params(input)
+  end
+
+  it 'should remove a string when a pemitted is integer' do
+    input = { param_1: 'a string' }
+    output = {}
+    expect(output).to eq permitted_params(input, { param_1: Integer })
+  end
+
+  it 'should return an integer when a pemitted is integer' do
+    input = { param_1: 1 }
+    expect(input).to eq permitted_params(input, { param_1: Integer })
   end
 
-  it "should return a string when a pemitted is string" do
-    input = { param_1: "a string" }
+  it 'should return an integer when a pemitted can be cast into integer' do
+    input = { param_1: '1' }
+    output = { param_1: 1 }
+    expect(output).to eq permitted_params(input, { param_1: Integer })
+  end
+
+  it 'should return a string when a pemitted is string' do
+    input = { param_1: 'a string' }
     expect(input).to eq permitted_params(input, { param_1: String })
   end
 
-  it "should return a float when a pemitted is float" do
+  it 'should return a float when a pemitted is float' do
     input = { param_1: 10.0 }
     expect(input).to eq permitted_params(input, { param_1: Float })
   end
 
-  it "should return a date when a pemitted is date" do
+  it 'should return a date when a pemitted is date' do
     input = { param_1: Date.new }
     expect(input).to eq permitted_params(input, { param_1: Date })
   end
 
-  it "should return a time when a pemitted is time" do
+  it 'should return a time when a pemitted is time' do
     input = { param_1: Time.new }
     expect(input).to eq permitted_params(input, { param_1: Time })
   end
 
-  it "should return an integer when a pemitted is integer" do
-    input = { param_1: 1 }
-    expect(input).to eq permitted_params(input, { param_1: Integer })
+  it 'should return a false(boolean) when a pemitted is boolean' do
+    input = { param_1: 'false' }
+    output = { param_1: false }
+    expect(output).to eq permitted_params(input, { param_1: Boolean })
   end
 
-  it "should return an integer when a pemitted can be cast into integer" do
-    input = { param_1: "1" }
-    output = { param_1: 1 }
-    expect(input).to eq permitted_params(input, { param_1: Integer })
+  it 'should return a true(boolean) when a pemitted is boolean' do
+    input = { param_1: 'true' }
+    output = { param_1: true }
+    expect(output).to eq permitted_params(input, { param_1: Boolean })
   end
 
-  it "should return a false(boolean) when a pemitted is boolean" do
-    input = { param_1: "false" }
-    output = { param_1: "false" }
-    expect(output).to eq permitted_params(input, { param_1: Boolean })
+  it 'should return an array when a pemitted is array' do
+    input = { param_1: [1, 2] }
+    expect(input).to eq permitted_params(input, { param_1: Array })
   end
 
-  it "should return a true(boolean) when a pemitted is boolean" do
-    input = { param_1: "true" }
-    output = { param_1: "true" }
-    expect(output).to eq permitted_params(input, { param_1: Boolean })
+  it 'should return an array when a pemitted is array' do
+    input = { param_1: '1, 2' }
+    output = { param_1: %w[1 2] }
+    expect(output).to eq permitted_params(input, { param_1: Array })
   end
 
-  it "should remove a string when a pemitted is integer" do
-    input = { param_1: "a string" }
-    output = {}
-    expect(output).to eq permitted_params(input, { param_1: Integer })
+  it 'should return an array when a pemitted is array' do
+    input = { param_1: '1; 2' }
+    output = { param_1: %w[1 2] }
+    expect(output).to eq permitted_params(input, { param_1: Array }, false, { delimiter: ';' })
   end
 
-  it "should allow all params when no restriction is given" do
-    input = { param_1: "a string" }
-    expect(input).to eq permitted_params(input)
+  it 'should return a hash when a pemitted is hash' do
+    input = { param_1: 'a: 1, b: 2' }
+    output = { param_1: { 'a' => '1', 'b' => '2' } }
+    expect(output).to eq permitted_params(input, { param_1: Hash })
+  end
+
+  it 'should return a hash when a pemitted is hash' do
+    input = { param_1: 'a: 1; b: 2' }
+    output = { param_1: { 'a' => '1', 'b' => '2' } }
+    expect(output).to eq permitted_params(input, { param_1: Hash }, false, { delimiter: ';' })
+  end
+
+  it 'should return a hash when a pemitted is hash' do
+    input = { param_1: { a: 1 } }
+    expect(input).to eq permitted_params(input, { param_1: Hash })
+  end
+
+  it 'should return a hash when a pemitted is hash' do
+    input = { param_1: { a: { b: 1 } } }
+    expect(input).to eq permitted_params(input, { param_1: Hash })
   end
-end
 
+  it 'should return a hash when a pemitted is hash' do
+    input = { param_1: { "a": 1 } }
+    expect(input).to eq permitted_params(input, { param_1: Hash })
+  end
+
+  it 'should return a several types for several inputs' do
+    input = { number: 1, string: 'string', bol: 'true', array: [1, 2], hsh: { a: 3 } }
+    output = { number: 1, string: 'string', bol: true, array: [1, 2], hsh: { a: 3 } }
+    expect(output).to eq permitted_params(
+      input,
+      {
+        number: Integer,
+        string: String,
+        bol: Boolean,
+        array: Array,
+        hsh: Hash
+      }
+    )
+  end
+
+  it 'returns the paramter without casting if Any' do
+    input = { param_1: '1' }
+    output = { param_1: '1' }
+    expect(output).to eq permitted_params(input, { param_1: Any })
+
+    test_class = TestClass.new
+    input = { param_1: test_class }
+    output = { param_1: test_class }
+    expect(output).to eq permitted_params(input, { param_1: Any })
+
+    test_class = TestClass.new
+    input = { param_1: test_class, param_2: 2 }
+    output = { param_1: test_class }
+    expect(output).to eq permitted_params(input, { param_1: Any })
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-my-params
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.8
 platform: ruby
 authors:
 - Marco Aviles