class Sinatra::StrongParameters::Parameters

Attributes

permitted[RW]
permitted?[RW]
raise_unpermitted[RW]

Public Class Methods

new(attributes = nil, raise_flag = false) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 47
def initialize(attributes = nil, raise_flag = false)
  @raise_unpermitted = raise_flag
  super(attributes)
  update(attributes) unless attributes.nil?

  # For nested values that need to be turned into parameters
  # in order to chain method calls.
  each_pair do |key, value|
    convert_hashes_to_parameters(key, value) if value.is_a? Hash
  end

  @permitted = false
end

Public Instance Methods

[](key) click to toggle source
Calls superclass method
# File lib/sinatra/strong_parameters.rb, line 78
def [](key)
  convert_hashes_to_parameters(key, super)
end
permit(*filters) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 82
def permit(*filters)
  params = self.class.new

  filters.flatten.each do |filter|
    case filter
    when Symbol, String 
      permitted_filter(params, filter)
    when Hash
      hash_filter(params, filter) 
    end
  end

  unpermitted_parameters!(params) if @raise_unpermitted

  params.permit!
end
permit!() click to toggle source
# File lib/sinatra/strong_parameters.rb, line 61
def permit!
  each_pair do |key, value|
    wrap(value).each do |val|
      # if this value is an instance of parameters, call permit!
      # recursively.
      val.permit! if val.respond_to? :permit!
    end 
  end

  @permitted = true
  self
end
require(key) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 74
def require(key)
  presence(self[key]) || raise(ParameterMissing.new(key))
end

Private Instance Methods

array_permitted_filter(params, key, hash = self) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 142
def array_permitted_filter(params, key, hash = self)
  params[key] = hash[key] if hash.has_key? key
end
convert_hashes_to_parameters(key, value) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 121
def convert_hashes_to_parameters(key, value)
  converted = convert_value_to_parameters(value)
  self[key] = converted if !converted.equal?(value)
  converted
end
convert_value_to_parameters(value) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 127
def convert_value_to_parameters(value)
  if value.is_a? Array
    value.map { |_| convert_value_to_parameters(_) }
  elsif value.is_a?(Parameters) || !value.is_a?(Hash)
    value
  else
    self.class.new(value)
  end
end
each_element(value) { |el| ... } click to toggle source
# File lib/sinatra/strong_parameters.rb, line 171
def each_element(value)
  if value.is_a?(Array)
    value.map { |el| yield el }.compact
  elsif fields_for_style?(value)
    hash = value.class.new
    value.each { |key, val| key=~ /\A-?\d+/ && val.is_a?(Hash) }
    hash
  else
    yield value
  end
end
fields_for_style?(object) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 183
def fields_for_style?(object)
  object.is_a?(Hash) && object.all? { |k, v| k =~ /\A-?\d+\z/ && v.is_a?(Hash) }
end
hash_filter(params, filter) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 146
def hash_filter(params, filter)
  filter = IndifferentHash.new(filter)
 
  # slice removes non-declared keys.
  slice(*filter.keys).each do |key, value|
    # filtered out
    next unless value

    if filter[key] == []
      # { comment_ids: [].
      array_permitted_filter(params, key)
    else
      # { user: name } or { user: [ :name, :age, { address: ... }]}.
      params[key] = each_element(value) do |element, index|
        if element.is_a? Hash
          element = self.class.new(element) unless element.respond_to?(:permit)
          element.permit(wrap(filter[key]))
        elsif filter[key].is_a?(Hash) && filter[key][index] == []
          array_permitted_filter(params, index, value)
        end
      end
    end
  end
end
permitted_filter(params, key) click to toggle source

TODO: See if the type is in the permitted scalar values

# File lib/sinatra/strong_parameters.rb, line 138
def permitted_filter(params, key)
  params[key] = self[key] if has_key? key
end
presence(val) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 101
def presence(val)
  val unless !val.respond_to?(:empty) ? !!val.empty? : !val
end
slice(*keys) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 105
def slice(*keys)
  self.class.new(super).tap do |new_instance|
    new_instance.instance_variable_set :@permitted, @permitted
  end
end
unpermitted_keys(params) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 194
def unpermitted_keys(params)
  self.keys - params.keys
end
unpermitted_parameters!(params) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 187
def unpermitted_parameters!(params)
  unpermitted_keys = unpermitted_keys(params)
  if unpermitted_keys.any? && @raise_unpermitted
    raise UnpermittedParameters.new(unpermitted_keys)
  end
end
wrap(obj) click to toggle source
# File lib/sinatra/strong_parameters.rb, line 111
def wrap(obj)
  if obj.nil?
    []
  elsif obj.respond_to?(:to_ary)
    obj.to_ary || [obj]
  else
    [obj]
  end
end