class Upfluence::Mixin::StrongParameters::Parameters

Constants

NEVER_UNPERMITTED_PARAMS

Never raise an UnpermittedParameters exception because of these params are present. They are added by Rails and it's of no concern.

PERMITTED_SCALAR_TYPES

This is a white list of permitted scalar types that includes the ones supported in XML and JSON requests.

This list is in particular used to filter ordinary requests, String goes as first element to quickly short-circuit the common case.

If you modify this collection please update the README.

Attributes

permitted[RW]
permitted?[RW]

Public Class Methods

new(attributes = nil) click to toggle source
Calls superclass method
# File lib/upfluence/mixin/strong_parameters.rb, line 32
def initialize(attributes = nil)
  super(attributes)
  @permitted = false
end

Public Instance Methods

[](key) click to toggle source
Calls superclass method
# File lib/upfluence/mixin/strong_parameters.rb, line 78
def [](key)
  convert_hashes_to_parameters(key, super)
end
dup() click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 94
def dup
  self.class.new(self).tap do |duplicate|
    duplicate.default = default
    duplicate.instance_variable_set :@permitted, @permitted
  end
end
fetch(key, *args) click to toggle source
Calls superclass method
# File lib/upfluence/mixin/strong_parameters.rb, line 82
def fetch(key, *args)
  convert_hashes_to_parameters(key, super, false)
rescue KeyError, IndexError
  raise ParameterMissing.new(key)
end
permit(*filters) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 61
def permit(*filters)
  params = self.class.new

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

  unpermitted_parameters!(params) if self.class.action_on_unpermitted_parameters

  params.permit!
end
permit!() click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 37
def permit!
  each_pair do |key, value|
    value = convert_hashes_to_parameters(key, value)
    Array.wrap(value).each do |_|
      _.permit! if _.respond_to? :permit!
    end
  end

  @permitted = true
  self
end
require(key) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 49
def require(key)
  return key.map { |k| require(k) } if key.is_a?(Array)
  value = self[key]
  if value.present? || value == false
    value
  else
    raise ParameterMissing.new(key)
  end
end
Also aliased as: required
required(key)
Alias for: require
slice(*keys) click to toggle source
Calls superclass method
# File lib/upfluence/mixin/strong_parameters.rb, line 88
def slice(*keys)
  self.class.new(super).tap do |new_instance|
    new_instance.instance_variable_set :@permitted, @permitted
  end
end

Protected Instance Methods

convert_value(value, options = {}) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 103
def convert_value(value, options = {})
  if value.class == Hash
    self.class.new(value)
  elsif value.is_a?(Array)
    value.dup.replace(value.map { |e| convert_value(e) })
  else
    value
  end
end

Private Instance Methods

array_of_permitted_scalars?(value) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 162
def array_of_permitted_scalars?(value)
  if value.is_a?(Array)
    value.all? {|element| permitted_scalar?(element)}
  end
end
array_of_permitted_scalars_filter(params, key, hash = self) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 180
def array_of_permitted_scalars_filter(params, key, hash = self)
  if hash.has_key?(key) && array_of_permitted_scalars?(hash[key])
    params[key] = hash[key]
  end
end
convert_hashes_to_parameters(key, value, assign_if_converted=true) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 115
def convert_hashes_to_parameters(key, value, assign_if_converted=true)
  converted = convert_value_to_parameters(value)
  self[key] = converted if assign_if_converted && !converted.equal?(value)
  converted
end
convert_value_to_parameters(value) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 121
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/upfluence/mixin/strong_parameters.rb, line 210
def each_element(value)
  if value.is_a?(Array)
    value.map { |el| yield el }.compact
    # fields_for on an array of records uses numeric hash keys.
  elsif fields_for_style?(value)
    hash = value.class.new
    value.each { |k,v| hash[k] = yield(v, k) }
    hash
  else
    yield value
  end
end
fields_for_style?(object) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 223
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/upfluence/mixin/strong_parameters.rb, line 186
def hash_filter(params, filter)
  filter = filter.with_indifferent_access

  # Slicing filters out non-declared keys.
  slice(*filter.keys).each do |key, value|
    next unless value

    if filter[key] == []
      # Declaration {:comment_ids => []}.
      array_of_permitted_scalars_filter(params, key)
    else
      # Declaration {:user => :name} or {:user => [:name, :age, {:adress => ...}]}.
      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(*Array.wrap(filter[key]))
        elsif filter[key].is_a?(Hash) && filter[key][index] == []
          array_of_permitted_scalars_filter(params, index, value)
        end
      end
    end
  end
end
permitted_scalar?(value) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 158
def permitted_scalar?(value)
  PERMITTED_SCALAR_TYPES.any? {|type| value.is_a?(type)}
end
permitted_scalar_filter(params, key) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 168
def permitted_scalar_filter(params, key)
  if has_key?(key) && permitted_scalar?(self[key])
    params[key] = self[key]
  end

  keys.grep(/\A#{Regexp.escape(key.to_s)}\(\d+[if]?\)\z/).each do |key|
    if permitted_scalar?(self[key])
      params[key] = self[key]
    end
  end
end
unpermitted_keys(params) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 243
def unpermitted_keys(params)
  self.keys - params.keys - NEVER_UNPERMITTED_PARAMS
end
unpermitted_parameters!(params) click to toggle source
# File lib/upfluence/mixin/strong_parameters.rb, line 227
def unpermitted_parameters!(params)
  return unless self.class.action_on_unpermitted_parameters

  unpermitted_keys = unpermitted_keys(params)

  if unpermitted_keys.any?
    case self.class.action_on_unpermitted_parameters
    when :log
      name = "unpermitted_parameters.action_controller"
      ActiveSupport::Notifications.instrument(name, :keys => unpermitted_keys)
    when :raise
      raise UnpermittedParameters.new(unpermitted_keys)
    end
  end
end