sinatra-my-params 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8391c458014310cc388fc93e899320baa879567e50ca8cb875e3a19e20ae5984
-  data.tar.gz: a928880e81d7f1cfb6d91d2da10347398f8eca11b85bf808eca3c12af8f7a675
+  metadata.gz: e8b53c81f8e6331c9f40d1b36cd45393132c6345478ae80132def61c44f5e6bd
+  data.tar.gz: d049d0ec154d84196d13ac5db1ffe7d07ca8926e8c9a8e84f1ae0d7707b9a79c
 SHA512:
-  metadata.gz: c18faa501799088dcf64962e616789b38a78176f4b0fdfc3b0c123e157b3f799ee7638243d6fb522ab55de945d296206d0c71e46436c4ff30444e5ee95ba8300
-  data.tar.gz: 257127aa4473a46ee13031cef5251f9b94cbb7195444130e0cb6011fc25376bab83a09e52a5c5b03c1e2e02e7a923d3fe942702c88370b65824b3ecf87fb3a11
+  metadata.gz: c424f3ff45c18ada07d4e9377177793849c665ae69b6198ab1742c533b3c1dc647ff302b69e987e1d10caa87024787fa9197c940807e8c2367e54db9a31f1661
+  data.tar.gz: 4ea6c14c51e42bc649ad6251503173a9765188f3281bd7c56e3cd7aa2bb8aa62dc2c0e24b2fb8560c0fe06ed6868ad60675b0ea34c3462bae4cb520823250309

data/lib/permit_params.rb

@@ -66,14 +66,23 @@ module PermitParams
   end
 
   def coerce_array(param, options = {})
-    Array(param.split(options[:delimiter] || ',').map(&:strip))
+    delimiter = valid_delimiter?(param, options[:delimiter])
+    return unless delimiter
+
+    Array(param.split(delimiter).map(&:strip))
   end
 
   def coerce_hash(param, options = {})
     return param if param.is_a?(Hash)
 
-    key_value = param.split(options[:delimiter] || ',').map(&:strip).map do |c|
-      c.split(options[:separator] || ':').map(&:strip)
+    delimiter =  valid_delimiter?(param, options[:delimiter])
+    return unless delimiter
+
+    separator = valid_separator?(param, options[:separator])
+    return unless separator
+
+    key_value = param.split(delimiter).map(&:strip).map do |c|
+      c.split(separator).map(&:strip)
     end
     Hash[key_value]
   end
@@ -89,6 +98,16 @@ module PermitParams
     coerced
   end
 
+  def valid_delimiter?(param, delimiter)
+    delimiter ||= ','
+    delimiter if delimiter && param.include?(delimiter)
+  end
+
+  def valid_separator?(param, separator)
+    separator ||= ':'
+    separator if separator && param.include?(separator)
+  end
+
   def coerce_shape(param, options = {})
     hash = coerce_hash(param)
     has_shape?(hash, options[:shape]) ? hash : nil

data/spec/permit_params_shape_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'permit_params'
+require 'rspec'
+require 'rack/test'
+
+include PermitParams
+
+describe 'shape behaviours' do
+  it 'should return a hash when a pemitted is of shape' do
+    input = { param: { a: 1, b: 2 } }
+    expect(input).to eq permitted_params(
+      input,
+      { param: Shape },
+      false,
+      { shape: { a: Integer, b: Integer } }
+    )
+  end
+
+  it 'should return a hash when a pemitted is of Integer shape(deep)' do
+    input = { param: { a: { b: 2 } } }
+    expect(input).to eq permitted_params(
+      input,
+      { param: Shape },
+      false,
+      { shape: { a: { b: Integer } } }
+    )
+  end
+
+  it 'should return a hash when a pemitted is of Array shape(deep)' do
+    input = { param: { a: { b: [1, 2] } } }
+    expect(input).to eq permitted_params(
+      input,
+      { param: Shape },
+      false,
+      { shape: { a: { b: Array } } }
+    )
+  end
+
+  it 'should return a empty object when a pemitted is shape not defined' do
+    input = { param: { a: 1, b: 2 } }
+    expect({}).to eq permitted_params(
+      input,
+      { param: Shape },
+      false,
+      { shape: { a: Integer } }
+    )
+  end
+end

data/spec/permit_params_spec.rb

@@ -7,140 +7,128 @@ require 'rack/test'
 
 include PermitParams
 
-describe 'exceptions' do
+describe 'behaviours' do
   it 'should raise error when at least one param is invalid' do
-    input = { param_1: 'a' }
+    input = { param: 'a' }
     expect  do
-      permitted_params(input, { param_1: Integer }, true)
+      permitted_params(input, { param: Integer }, true)
     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' }
+    input = { param: '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' }
+  it 'should remove a string when permitted param is integer' do
+    input = { param: 'a string' }
     output = {}
-    expect(output).to eq permitted_params(input, { param_1: Integer })
+    expect(output).to eq permitted_params(input, { param: 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 })
+  it 'should return an integer when permitted param is integer' do
+    input = { param: 1 }
+    expect(input).to eq permitted_params(input, { param: 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 })
+  it 'should return an integer when permitted param can be cast into integer' do
+    input = { param: '1' }
+    output = { param: 1 }
+    expect(output).to eq permitted_params(input, { param: 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 })
+  it 'should return a string when permitted param is string' do
+    input = { param: 'a string' }
+    expect(input).to eq permitted_params(input, { param: 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 })
+  it 'should return a float when permitted param is float' do
+    input = { param: 10.0 }
+    expect(input).to eq permitted_params(input, { param: 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 })
+  it 'should return a date when permitted param is date' do
+    input = { param: Date.new }
+    expect(input).to eq permitted_params(input, { param: 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 })
+  it 'should return a time when permitted param is time' do
+    input = { param: Time.new }
+    expect(input).to eq permitted_params(input, { param: Time })
   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 a false(boolean) when permitted param is boolean' do
+    input = { param: 'false' }
+    output = { param: false }
+    expect(output).to eq permitted_params(input, { param: 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 })
+  it 'should return a true(boolean) when permitted param is boolean' do
+    input = { param: 'true' }
+    output = { param: true }
+    expect(output).to eq permitted_params(input, { param: 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 })
+  it 'should return an array when permitted param is array' do
+    input = { param: [1, 2] }
+    expect(input).to eq permitted_params(input, { param: 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 })
+  it 'should return an array when permitted param is array' do
+    input = { param: '1, 2' }
+    output = { param: %w[1 2] }
+    expect(output).to eq permitted_params(input, { param: 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 }, false, { delimiter: ';' })
+  it 'should return an array when permitted param is array' do
+    input = { param: '1; 2' }
+    output = { param: %w[1 2] }
+    expect(output).to eq permitted_params(input, { param: Array }, false, { delimiter: ';' })
   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 })
+  it 'should return an empty hash when permitted param is array with wrong delimiter' do
+    input = { param: '1; 2' }
+    output = {}
+    expect(output).to eq permitted_params(input, { param: Array }, false, { delimiter: ',' })
   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: ';' })
+  it 'should return a hash when permitted param is hash' do
+    input = { param: 'a: 1, b: 2' }
+    output = { param: { 'a' => '1', 'b' => '2' } }
+    expect(output).to eq permitted_params(input, { param: 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 })
+  it 'should return a hash when permitted param is hash' do
+    input = { param: 'a: 1; b: 2' }
+    output = { param: { 'a' => '1', 'b' => '2' } }
+    expect(output).to eq permitted_params(input, { param: Hash }, false, { delimiter: ';' })
   end
 
-  it 'should return a hash when a pemitted is shape' do
-    input = { param_1: { a: 1, b: 2 } }
-    expect(input).to eq permitted_params(
-      input,
-      { param_1: Shape },
-      false,
-      { shape: { a: Integer, b: Integer } }
-    )
+  it 'should return an empty hash when permitted param is hash with wrong separator' do
+    input = { param: 'a: 1; b: 2' }
+    output = {}
+    expect(output).to eq permitted_params(input, { param: Hash }, false, { separator: '.' })
   end
 
-  it 'should return a hash when a pemitted is shape(deep)' do
-    input = { param_1: { a: { b: 2 } } }
-    expect(input).to eq permitted_params(
-      input,
-      { param_1: Shape },
-      false,
-      { shape: { a: { b: Integer } } }
-    )
+  it 'should return an empty hash when permitted param is hash with wrong delimiter' do
+    input = { param: 'a: 1; b: 2' }
+    output = {}
+    expect(output).to eq permitted_params(input, { param: Hash }, false, { delimiter: ',' })
   end
 
-  it 'should return a empty when a pemitted is shape not defined' do
-    input = { param_1: { a: 1, b: 2 } }
-    expect({}).to eq permitted_params(
-      input,
-      { param_1: Shape },
-      false,
-      { shape: { a: Integer } }
-    )
+  it 'should return a hash when permitted param is hash' do
+    input = { param: { a: 1 } }
+    expect(input).to eq permitted_params(input, { param: 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 })
+  it 'should return a hash when permitted param is hash' do
+    input = { param: { a: { b: 1 } } }
+    expect(input).to eq permitted_params(input, { param: 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 })
+  it 'should return a hash when permitted param is hash' do
+    input = { param: { "a": 1 } }
+    expect(input).to eq permitted_params(input, { param: Hash })
   end
 
   it 'should return a several types for several inputs' do
@@ -167,21 +155,21 @@ describe 'exceptions' do
       end
     end
 
-    input = { param_1: '1' }
-    output = { param_1: '1' }
-    expect(output).to eq permitted_params(input, { param_1: Any })
+    input = { param: '1' }
+    output = { param: '1' }
+    expect(output).to eq permitted_params(input, { param: Any })
 
     input = {
-      param_1: TestClass.new(some_attribute: 'a string')
+      param: TestClass.new(some_attribute: 'a string')
     }
-    output = permitted_params(input, { param_1: Any })
-    expect(input[:param_1].some_attribute).to eq output[:param_1].some_attribute
+    output = permitted_params(input, { param: Any })
+    expect(input[:param].some_attribute).to eq output[:param].some_attribute
 
     input = {
-      param_1: TestClass.new(some_attribute: 1),
-      param_2: 2
+      param: TestClass.new(some_attribute: 1),
+      antoher_param: 2
     }
-    output = permitted_params(input, { param_1: Any })
-    expect(input[:param_1].some_attribute).to eq output[:param_1].some_attribute
+    output = permitted_params(input, { param: Any })
+    expect(input[:param].some_attribute).to eq output[:param].some_attribute
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-my-params
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Marco Aviles
@@ -10,7 +10,7 @@ bindir: bin
 cert_chain: []
 date: 2021-09-19 00:00:00.000000000 Z
 dependencies: []
-description: A simple params sanitizer(originally created for sinatra)
+description: A simple params sanitizer (originally created for sinatra)
 email: gdmarav374@gmail.com
 executables: []
 extensions: []
@@ -19,6 +19,7 @@ files:
 - Rakefile
 - bin/permit_params
 - lib/permit_params.rb
+- spec/permit_params_shape_spec.rb
 - spec/permit_params_spec.rb
 homepage: https://github.com/mhero/sinatra-my-params
 licenses: []
@@ -44,3 +45,4 @@ specification_version: 3
 summary: permit_params!
 test_files:
 - spec/permit_params_spec.rb
+- spec/permit_params_shape_spec.rb