sinatra-my-params 0.0.6 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 004ffa9a419a6ca94f76672d37e9cd242aca9f69ca1c92ada97ac135a1329abc
-  data.tar.gz: a0dcc3771df668d6356a4443e98cd1bcb4d1ad6e877076bbc3cc5f99e904a078
+  metadata.gz: e8b53c81f8e6331c9f40d1b36cd45393132c6345478ae80132def61c44f5e6bd
+  data.tar.gz: d049d0ec154d84196d13ac5db1ffe7d07ca8926e8c9a8e84f1ae0d7707b9a79c
 SHA512:
-  metadata.gz: 04d4e285426806ac16f36f7b757eed7682d1502c272dedf7f0fd3291234e9cf3eb611c52c25a73cca3f3b29d6190ed83523cde335125599cfb92f81e2eee8c17
-  data.tar.gz: 861c6fc9858865ac856e66ed030f5bd8ac7005b268c3a3a2cb66deec648feec52b1c596808e6736b4495bf20e1fe7e4e818ccbfa8ebb24fe2727d77511bb13cf
+  metadata.gz: c424f3ff45c18ada07d4e9377177793849c665ae69b6198ab1742c533b3c1dc647ff302b69e987e1d10caa87024787fa9197c940807e8c2367e54db9a31f1661
+  data.tar.gz: 4ea6c14c51e42bc649ad6251503173a9765188f3281bd7c56e3cd7aa2bb8aa62dc2c0e24b2fb8560c0fe06ed6868ad60675b0ea34c3462bae4cb520823250309

data/lib/permit_params.rb

@@ -1,18 +1,25 @@
+# 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?
-  
+
     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)
-        coerced_params[key] = coerced if !coerced.nil?
-      end
+      next unless permitted?(permitted: permitted, key: key, value: value)
+
+      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
@@ -21,40 +28,94 @@ module PermitParams
 
   Boolean = :boolean
   Any = :any
+  Shape = :shape
 
-  def coerce(param, type, strong_validation = false, options = {})
+  def permitted?(permitted:, key:, value:)
+    permitted.keys.map(&:to_s).include?(key.to_s) && !value.nil?
+  end
+
+  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 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 coerce_array(param) if type == Array
-      return coerce_hash(param) if type == Hash
+      return coerce_array(param, options) if type == Array
+      return coerce_shape(param, options) if type == Shape
+      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_validation
     end
   end
 
-  def coerce_array(param)
-    Array(param.split(options[:delimiter] || ","))
+  def coerce_integer(param, options = {})
+    Integer(param, options[:integer_precision] || 10)
+  end
+
+  def coerce_array(param, options = {})
+    delimiter = valid_delimiter?(param, options[:delimiter])
+    return unless delimiter
+
+    Array(param.split(delimiter).map(&:strip))
   end
 
-  def coerce_hash(param)
-    Hash[param.split(options[:delimiter] || ",").map{|c| c.split(options[:separator] || ":")}]
+  def coerce_hash(param, options = {})
+    return param if param.is_a?(Hash)
+
+    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
 
   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
 
+  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
+  end
+
+  def has_shape?(hash, shape)
+    hash.all? do |k, v|
+      v.is_a?(Hash) ? has_shape?(v, shape[k]) : shape[k] === v
+    end
+  end
+end

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

@@ -1,91 +1,142 @@
-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
-  before do
-    class TestClass; end
+describe 'behaviours' do
+  it 'should raise error when at least one param is invalid' do
+    input = { param: 'a' }
+    expect  do
+      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: 'a string' }
+    expect(input).to eq permitted_params(input)
+  end
+
+  it 'should remove a string when permitted param is integer' do
+    input = { param: 'a string' }
+    output = {}
+    expect(output).to eq permitted_params(input, { param: Integer })
+  end
+
+  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 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 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 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 permitted param is date' do
+    input = { param: Date.new }
+    expect(input).to eq permitted_params(input, { param: Date })
   end
 
-  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, "'a' is not a valid Integer") 
+  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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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: { 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
-    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}  }
+  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, 
-      { 
+      input,
+      {
         number: Integer,
         string: String,
         bol: Boolean,
@@ -95,24 +146,30 @@ describe "exceptions" do
     )
   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 })
+  it 'returns the paramter without casting if Any' do
+    class TestClass
+      attr_accessor :some_attribute
 
-    input = { param_1: TestClass.new }
-    expect(input).to eq permitted_params(input, { param_1: Any })
-  end
+      def initialize(some_attribute: nil)
+        @some_attribute = some_attribute
+      end
+    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
+    input = { param: '1' }
+    output = { param: '1' }
+    expect(output).to eq permitted_params(input, { param: Any })
 
-  it "should allow all params when no restriction is given" do
-    input = { param_1: "a string" }
-    expect(input).to eq permitted_params(input)
+    input = {
+      param: TestClass.new(some_attribute: 'a string')
+    }
+    output = permitted_params(input, { param: Any })
+    expect(input[:param].some_attribute).to eq output[:param].some_attribute
+
+    input = {
+      param: TestClass.new(some_attribute: 1),
+      antoher_param: 2
+    }
+    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.6
+  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 sinatra params sanitizer
+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