sinatra-my-params 0.0.3 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 517d1c8ee0d4be39d56aa775659ccb5a158c3f27f2f2e0f27abb6b80b890dbb8
-  data.tar.gz: aa9aca42a85144fbd460016ba3abddc9fbc2d4862fe42da3f8ffda02b65d8a85
+  metadata.gz: cab1fb0c3d28a4c3d088ed4221774c92bf3a298a4b02384bd19007b5cdea4879
+  data.tar.gz: 175b6ad103a99ee688106ef98d8cee5ce6fde7ba2f12684577235db597227e7d
 SHA512:
-  metadata.gz: d34af72735130ba06e1754e03f64b2179b1561ee8325deb1e22516843674fccafcb289f6f9fe902f5979b86cc5823083de996b6a063d904df5301f100f3eda1d
-  data.tar.gz: '09fdd6bdec6704c5edd45d60c24dcca194e6ed7751cd82b1b463a29efdffe3fa8a455b8b3fc2737386477bf50308987198eeac5db7de5eae244d3aded7477762'
+  metadata.gz: 46c2485d12ddfbac286cf2793cebef3a1fc1273dbca5b62acc6358c4fdf44250acc0772af8b1ee4a19696a2773b2c92f57bf12c911c915a7059989c618d701f8
+  data.tar.gz: f49ce81b039ab4d02af84220c74f72fc68b6f1f8dec0c4df6f57686acee7db6a30eabb8d261fc27e521d7644642524fa4e3502c1761190a02cb0975c8db8ec0f

data/Rakefile

@@ -1,8 +1,13 @@
 require "rake/testtask"
+require "rspec/core/rake_task"
 
 Rake::TestTask.new do |t|
   t.libs << "test"
 end
 
-desc "Run tests"
-task :default => :test
+begin
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+end

data/lib/permit_params.rb

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'permit_params'
+require 'rspec'
+require 'rack/test'
+
+include PermitParams
+
+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)
+    end.to raise_error(InvalidParameterError, "'a' is not a valid 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
+    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
+    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
+    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 })
+  end
+
+  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 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 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 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 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 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 } }
+    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: 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": 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 })
+
+    input = { param_1: TestClass.new }
+    expect(input).to eq permitted_params(input, { param_1: Any })
+  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 allow all params when no restriction is given' do
+    input = { param_1: 'a string' }
+    expect(input).to eq permitted_params(input)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-my-params
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.7
 platform: ruby
 authors:
 - Marco Aviles
@@ -11,7 +11,7 @@ cert_chain: []
 date: 2021-09-19 00:00:00.000000000 Z
 dependencies: []
 description: A simple sinatra params sanitizer
-email: nick@quaran.to
+email: gdmarav374@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -19,7 +19,7 @@ files:
 - Rakefile
 - bin/permit_params
 - lib/permit_params.rb
-- test/test_permit_params.rb
+- spec/permit_params_spec.rb
 homepage: https://github.com/mhero/sinatra-my-params
 licenses: []
 metadata: {}
@@ -43,4 +43,4 @@ signing_key:
 specification_version: 3
 summary: permit_params!
 test_files:
-- test/test_permit_params.rb
+- spec/permit_params_spec.rb

data/test/test_permit_params.rb

@@ -1,35 +0,0 @@
-require "test/unit"
-require "permit_params"
-require "rspec"
-require "rack/test"
-
-class PermitParamsTest < Test::Unit::TestCase
-  include PermitParams
-
-  def test_pemit_string
-    input = { param_1: "a string" }
-    output = { param_1: "a string" }
-    assert_equal output, permitted_params( input, { param_1: String } )
-  end
-
-  def test_permit_integer
-    input = { param_1: 1 }
-    output = { param_1: 1 }
-    assert_equal output, permitted_params( input, { param_1: Integer } )
-  end
-
-  def test_remove_integer
-    input = { param_1: "a string" }
-    output = {}
-    assert_equal output, permitted_params( input, { param_1: Integer } )
-  end
-
-  describe "exceptions" do
-    describe "raise" do
-      it "should raise error when at least one param is invalid" do
-        input = { param_1: "a" }
-        expect(permitted_params( input, { param_1: Integer }, true )).to raise_error InvalidParameterError
-      end
-    end
-  end
-end