Class: ActionController::Parameters
- Inherits:
-
Object
- Object
- ActionController::Parameters
- Defined in:
- lib/action_controller/metal/strong_parameters.rb
Overview
Action Controller Parameters
Allows you to choose which attributes should be whitelisted for mass updating and thus prevent accidentally exposing that which shouldn’t be exposed. Provides two methods for this purpose: #require and #permit. The former is used to mark parameters as required. The latter is used to set the parameter as permitted and limit which attributes should be allowed for mass updating.
params = ActionController::Parameters.new({
person: {
name: 'Francesco',
age: 22,
role: 'admin'
}
})
permitted = params.require(:person).permit(:name, :age)
permitted # => <ActionController::Parameters {"name"=>"Francesco", "age"=>22} permitted: true>
permitted.permitted? # => true
Person.first.update!(permitted)
# => #<Person id: 1, name: "Francesco", age: 22, role: "user">
It provides two options that controls the top-level behavior of new instances:
-
permit_all_parameters
- If it’strue
, all the parameters will be permitted by default. The default isfalse
. -
action_on_unpermitted_parameters
- Allow to control the behavior when parameters that are not explicitly permitted are found. The values can be:log
to write a message on the logger or:raise
to raise ActionController::UnpermittedParameters exception. The default value is:log
in test and development environments,false
otherwise.
Examples:
params = ActionController::Parameters.new
params.permitted? # => false
ActionController::Parameters.permit_all_parameters = true
params = ActionController::Parameters.new
params.permitted? # => true
params = ActionController::Parameters.new(a: "123", b: "456")
params.permit(:c)
# => <ActionController::Parameters {} permitted: true>
ActionController::Parameters.action_on_unpermitted_parameters = :raise
params = ActionController::Parameters.new(a: "123", b: "456")
params.permit(:c)
# => ActionController::UnpermittedParameters: found unpermitted keys: a, b
Please note that these options *are not thread-safe*. In a multi-threaded environment they should only be set once at boot-time and never mutated at runtime.
You can fetch values of ActionController::Parameters
using either :key
or "key"
.
params = ActionController::Parameters.new(key: 'value')
params[:key] # => "value"
params["key"] # => "value"
Class Method Summary collapse
-
.hook_into_yaml_loading ⇒ Object
:nodoc:.
Instance Method Summary collapse
-
#==(other) ⇒ Object
Returns true if another
Parameters
object contains the same content and permitted flag. -
#[](key) ⇒ Object
Returns a parameter for the given
key
. -
#[]=(key, value) ⇒ Object
Assigns a value to a given
key
. -
#converted_arrays ⇒ Object
Attribute that keeps track of converted arrays, if any, to avoid double looping in the common use case permit + mass-assignment.
-
#deep_dup ⇒ Object
Returns duplicate of object including all parameters.
-
#delete(key) ⇒ Object
Deletes and returns a key-value pair from
Parameters
whose key is equal to key. -
#dig(*keys) ⇒ Object
Extracts the nested parameter from the given
keys
by callingdig
at each step. -
#each_pair(&block) ⇒ Object
(also: #each)
Convert all hashes in values into parameters, then yield each pair in the same way as
Hash#each_pair
. -
#except(*keys) ⇒ Object
Returns a new
ActionController::Parameters
instance that filters out the givenkeys
. -
#extract!(*keys) ⇒ Object
Removes and returns the key/value pairs matching the given keys.
-
#fetch(key, *args) ⇒ Object
Returns a parameter for the given
key
. -
#init_with(coder) ⇒ Object
:nodoc:.
-
#initialize(parameters = {}) ⇒ Parameters
constructor
Returns a new instance of
ActionController::Parameters
. - #inspect ⇒ Object
-
#merge(other_hash) ⇒ Object
Returns a new
ActionController::Parameters
with all keys fromother_hash
merges into current hash. -
#merge!(other_hash) ⇒ Object
Returns current
ActionController::Parameters
instance whichother_hash
merges into current hash. - #method_missing(method_sym, *args, &block) ⇒ Object
-
#permit(*filters) ⇒ Object
Returns a new
ActionController::Parameters
instance that includes only the givenfilters
and sets thepermitted
attribute for the object totrue
. -
#permit! ⇒ Object
Sets the
permitted
attribute totrue
. -
#permitted? ⇒ Boolean
Returns
true
if the parameter is permitted,false
otherwise. -
#reject(&block) ⇒ Object
Returns a new instance of
ActionController::Parameters
with items that the block evaluates to true removed. -
#reject!(&block) ⇒ Object
(also: #delete_if)
Removes items that the block evaluates to true and returns self.
-
#require(key) ⇒ Object
(also: #required)
This method accepts both a single key and an array of keys.
-
#select(&block) ⇒ Object
Returns a new instance of
ActionController::Parameters
with only items that the block evaluates to true. -
#select!(&block) ⇒ Object
(also: #keep_if)
Equivalent to Hash#keep_if, but returns nil if no changes were made.
-
#slice(*keys) ⇒ Object
Returns a new
ActionController::Parameters
instance that includes only the givenkeys
. -
#slice!(*keys) ⇒ Object
Returns current
ActionController::Parameters
instance which contains only the givenkeys
. -
#stringify_keys ⇒ Object
This is required by ActiveModel attribute assignment, so that user can pass
Parameters
to a mass assignment methods in a model. -
#to_h ⇒ Object
Returns a safe
ActiveSupport::HashWithIndifferentAccess
representation of this parameter with all unpermitted keys removed. -
#to_unsafe_h ⇒ Object
(also: #to_unsafe_hash)
Returns an unsafe, unfiltered
ActiveSupport::HashWithIndifferentAccess
representation of this parameter. -
#transform_keys(&block) ⇒ Object
Returns a new
ActionController::Parameters
instance with the results of runningblock
once for every key. -
#transform_keys!(&block) ⇒ Object
Performs keys transformation and returns the altered
ActionController::Parameters
instance. -
#transform_values(&block) ⇒ Object
Returns a new
ActionController::Parameters
with the results of runningblock
once for every value. -
#transform_values!(&block) ⇒ Object
Performs values transformation and returns the altered
ActionController::Parameters
instance. -
#values_at(*keys) ⇒ Object
Returns values that were assigned to the given
keys
.
Constructor Details
#initialize(parameters = {}) ⇒ Parameters
Returns a new instance of ActionController::Parameters
. Also, sets the permitted
attribute to the default value of ActionController::Parameters.permit_all_parameters
.
class Person < ActiveRecord::Base
end
params = ActionController::Parameters.new(name: 'Francesco')
params.permitted? # => false
Person.new(params) # => ActiveModel::ForbiddenAttributesError
ActionController::Parameters.permit_all_parameters = true
params = ActionController::Parameters.new(name: 'Francesco')
params.permitted? # => true
Person.new(params) # => #<Person id: nil, name: "Francesco">
142 143 144 145 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 142 def initialize(parameters = {}) @parameters = parameters.with_indifferent_access @permitted = self.class.permit_all_parameters end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method_sym, *args, &block) ⇒ Object
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 632 def method_missing(method_sym, *args, &block) if @parameters.respond_to?(method_sym) = <<-DEPRECATE.squish Method #{method_sym} is deprecated and will be removed in Rails 5.1, as `ActionController::Parameters` no longer inherits from hash. Using this deprecated behavior exposes potential security problems. If you continue to use this method you may be creating a security vulnerability in your app that can be exploited. Instead, consider using one of these documented methods which are not deprecated: http://api.rubyonrails.org/v#{ActionPack.version}/classes/ActionController/Parameters.html DEPRECATE ActiveSupport::Deprecation.warn() @parameters.public_send(method_sym, *args, &block) else super end end |
Class Method Details
.hook_into_yaml_loading ⇒ Object
:nodoc:
601 602 603 604 605 606 607 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 601 def self.hook_into_yaml_loading # :nodoc: # Wire up YAML format compatibility with Rails 4.2 and Psych 2.0.8 and 2.0.9+. # Makes the YAML parser call `init_with` when it encounters the keys below # instead of trying its own parsing routines. YAML.['!ruby/hash-with-ivars:ActionController::Parameters'] = name YAML.['!ruby/hash:ActionController::Parameters'] = name end |
Instance Method Details
#==(other) ⇒ Object
Returns true if another Parameters
object contains the same content and permitted flag.
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 149 def ==(other) if other.respond_to?(:permitted?) self.permitted? == other.permitted? && self.parameters == other.parameters elsif other.is_a?(Hash) ActiveSupport::Deprecation.warn <<-WARNING.squish Comparing equality between `ActionController::Parameters` and a `Hash` is deprecated and will be removed in Rails 5.1. Please only do comparisons between instances of `ActionController::Parameters`. If you need to compare to a hash, first convert it using `ActionController::Parameters#new`. WARNING @parameters == other.with_indifferent_access else @parameters == other end end |
#[](key) ⇒ Object
Returns a parameter for the given key
. If not found, returns nil
.
params = ActionController::Parameters.new(person: { name: 'Francesco' })
params[:person] # => <ActionController::Parameters {"name"=>"Francesco"} permitted: false>
params[:none] # => nil
408 409 410 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 408 def [](key) convert_hashes_to_parameters(key, @parameters[key]) end |
#[]=(key, value) ⇒ Object
Assigns a value to a given key
. The given key may still get filtered out when permit
is called.
414 415 416 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 414 def []=(key, value) @parameters[key] = value end |
#converted_arrays ⇒ Object
Attribute that keeps track of converted arrays, if any, to avoid double looping in the common use case permit + mass-assignment. Defined in a method to instantiate it only if needed.
Testing membership still loops, but it’s going to be faster than our own loop that converts values. Also, we are not going to build a new array object per fetch.
216 217 218 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 216 def converted_arrays @converted_arrays ||= Set.new end |
#deep_dup ⇒ Object
Returns duplicate of object including all parameters
651 652 653 654 655 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 651 def deep_dup self.class.new(@parameters.deep_dup).tap do |duplicate| duplicate.permitted = @permitted end end |
#delete(key) ⇒ Object
Deletes and returns a key-value pair from Parameters
whose key is equal to key. If the key is not found, returns the default value. If the optional code block is given and the key is not found, pass in the key and return the result of block.
539 540 541 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 539 def delete(key) convert_value_to_parameters(@parameters.delete(key)) end |
#dig(*keys) ⇒ Object
Extracts the nested parameter from the given keys
by calling dig
at each step. Returns nil
if any intermediate step is nil
.
params = ActionController::Parameters.new(foo: { bar: { baz: 1 } }) params.dig(:foo, :bar, :baz) # => 1 params.dig(:foo, :zot, :xyz) # => nil
params2 = ActionController::Parameters.new(foo: [10, 11, 12]) params2.dig(:foo, 1) # => 11
451 452 453 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 451 def dig(*keys) convert_value_to_parameters(@parameters.dig(*keys)) end |
#each_pair(&block) ⇒ Object Also known as: each
Convert all hashes in values into parameters, then yield each pair in the same way as Hash#each_pair
202 203 204 205 206 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 202 def each_pair(&block) @parameters.each_pair do |key, value| yield key, convert_hashes_to_parameters(key, value) end end |
#except(*keys) ⇒ Object
Returns a new ActionController::Parameters
instance that filters out the given keys
.
params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.except(:a, :b) # => <ActionController::Parameters {"c"=>3} permitted: false>
params.except(:d) # => <ActionController::Parameters {"a"=>1, "b"=>2, "c"=>3} permitted: false>
480 481 482 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 480 def except(*keys) new_instance_with_inherited_permitted_status(@parameters.except(*keys)) end |
#extract!(*keys) ⇒ Object
Removes and returns the key/value pairs matching the given keys.
params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.extract!(:a, :b) # => <ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
params # => <ActionController::Parameters {"c"=>3} permitted: false>
489 490 491 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 489 def extract!(*keys) new_instance_with_inherited_permitted_status(@parameters.extract!(*keys)) end |
#fetch(key, *args) ⇒ Object
Returns a parameter for the given key
. If the key
can’t be found, there are several options: With no other arguments, it will raise an ActionController::ParameterMissing
error; if more arguments are given, then that will be returned; if a block is given, then that will be run and its result returned.
params = ActionController::Parameters.new(person: { name: 'Francesco' })
params.fetch(:person) # => <ActionController::Parameters {"name"=>"Francesco"} permitted: false>
params.fetch(:none) # => ActionController::ParameterMissing: param is missing or the value is empty: none
params.fetch(:none, 'Francesco') # => "Francesco"
params.fetch(:none) { 'Francesco' } # => "Francesco"
429 430 431 432 433 434 435 436 437 438 439 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 429 def fetch(key, *args) convert_value_to_parameters( @parameters.fetch(key) { if block_given? yield else args.fetch(0) { raise ActionController::ParameterMissing.new(key) } end } ) end |
#init_with(coder) ⇒ Object
:nodoc:
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 610 def init_with(coder) # :nodoc: case coder.tag when '!ruby/hash:ActionController::Parameters' # YAML 2.0.8's format where hash instance variables weren't stored. @parameters = coder.map.with_indifferent_access @permitted = false when '!ruby/hash-with-ivars:ActionController::Parameters' # YAML 2.0.9's Hash subclass format where keys and values # were stored under an elements hash and `permitted` within an ivars hash. @parameters = coder.map['elements'].with_indifferent_access @permitted = coder.map['ivars'][:@permitted] when '!ruby/object:ActionController::Parameters' # YAML's Object format. Only needed because of the format # backwardscompability above, otherwise equivalent to YAML's initialization. @parameters, @permitted = coder.map['parameters'], coder.map['permitted'] end end |
#inspect ⇒ Object
597 598 599 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 597 def inspect "<#{self.class} #{@parameters} permitted: #{@permitted}>" end |
#merge(other_hash) ⇒ Object
Returns a new ActionController::Parameters
with all keys from other_hash
merges into current hash.
577 578 579 580 581 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 577 def merge(other_hash) new_instance_with_inherited_permitted_status( @parameters.merge(other_hash.to_h) ) end |
#merge!(other_hash) ⇒ Object
Returns current ActionController::Parameters
instance which other_hash
merges into current hash.
585 586 587 588 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 585 def merge!(other_hash) @parameters.merge!(other_hash.to_h) self end |
#permit(*filters) ⇒ Object
Returns a new ActionController::Parameters
instance that includes only the given filters
and sets the permitted
attribute for the object to true
. This is useful for limiting which attributes should be allowed for mass updating.
params = ActionController::Parameters.new(user: { name: 'Francesco', age: 22, role: 'admin' })
permitted = params.require(:user).permit(:name, :age)
permitted.permitted? # => true
permitted.has_key?(:name) # => true
permitted.has_key?(:age) # => true
permitted.has_key?(:role) # => false
Only permitted scalars pass the filter. For example, given
params.permit(:name)
:name
passes if it is a key of params
whose associated value is of type String
, Symbol
, NilClass
, Numeric
, TrueClass
, FalseClass
, Date
, Time
, DateTime
, StringIO
, IO
, ActionDispatch::Http::UploadedFile
or Rack::Test::UploadedFile
. Otherwise, the key :name
is filtered out.
You may declare that the parameter should be an array of permitted scalars by mapping it to an empty array:
params = ActionController::Parameters.new(tags: ['rails', 'parameters'])
params.permit(tags: [])
You can also use permit
on nested parameters, like:
params = ActionController::Parameters.new({
person: {
name: 'Francesco',
age: 22,
pets: [{
name: 'Purplish',
category: 'dogs'
}]
}
})
permitted = params.permit(person: [ :name, { pets: :name } ])
permitted.permitted? # => true
permitted[:person][:name] # => "Francesco"
permitted[:person][:age] # => nil
permitted[:person][:pets][0][:name] # => "Purplish"
permitted[:person][:pets][0][:category] # => nil
Note that if you use permit
in a key that points to a hash, it won’t allow all the hash. You also need to specify which attributes inside the hash should be whitelisted.
params = ActionController::Parameters.new({
person: {
contact: {
email: '[email protected]',
phone: '555-1234'
}
}
})
params.require(:person).permit(:contact)
# => <ActionController::Parameters {} permitted: true>
params.require(:person).permit(contact: :phone)
# => <ActionController::Parameters {"contact"=><ActionController::Parameters {"phone"=>"555-1234"} permitted: true>} permitted: true>
params.require(:person).permit(contact: [ :email, :phone ])
# => <ActionController::Parameters {"contact"=><ActionController::Parameters {"email"=>"[email protected]", "phone"=>"555-1234"} permitted: true>} permitted: true>
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 385 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! ⇒ Object
Sets the permitted
attribute to true
. This can be used to pass mass assignment. Returns self
.
class Person < ActiveRecord::Base
end
params = ActionController::Parameters.new(name: 'Francesco')
params.permitted? # => false
Person.new(params) # => ActiveModel::ForbiddenAttributesError
params.permit!
params.permitted? # => true
Person.new(params) # => #<Person id: nil, name: "Francesco">
242 243 244 245 246 247 248 249 250 251 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 242 def permit! each_pair do |key, value| Array.wrap(value).each do |v| v.permit! if v.respond_to? :permit! end end @permitted = true self end |
#permitted? ⇒ Boolean
Returns true
if the parameter is permitted, false
otherwise.
params = ActionController::Parameters.new
params.permitted? # => false
params.permit!
params.permitted? # => true
226 227 228 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 226 def permitted? @permitted end |
#reject(&block) ⇒ Object
Returns a new instance of ActionController::Parameters
with items that the block evaluates to true removed.
558 559 560 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 558 def reject(&block) new_instance_with_inherited_permitted_status(@parameters.reject(&block)) end |
#reject!(&block) ⇒ Object Also known as: delete_if
Removes items that the block evaluates to true and returns self.
563 564 565 566 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 563 def reject!(&block) @parameters.reject!(&block) self end |
#require(key) ⇒ Object Also known as: required
This method accepts both a single key and an array of keys.
When passed a single key, if it exists and its associated value is either present or the singleton false
, returns said value:
ActionController::Parameters.new(person: { name: 'Francesco' }).require(:person)
# => <ActionController::Parameters {"name"=>"Francesco"} permitted: false>
Otherwise raises ActionController::ParameterMissing
:
ActionController::Parameters.new.require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty: person
ActionController::Parameters.new(person: nil).require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty: person
ActionController::Parameters.new(person: "\t").require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty: person
ActionController::Parameters.new(person: {}).require(:person)
# ActionController::ParameterMissing: param is missing or the value is empty: person
When given an array of keys, the method tries to require each one of them in order. If it succeeds, an array with the respective return values is returned:
params = ActionController::Parameters.new(user: { ... }, profile: { ... })
user_params, profile_params = params.require([:user, :profile])
Otherwise, the method re-raises the first exception found:
params = ActionController::Parameters.new(user: {}, profile: {})
user_params, profile_params = params.require([:user, :profile])
# ActionController::ParameterMissing: param is missing or the value is empty: user
Technically this method can be used to fetch terminal values:
# CAREFUL
params = ActionController::Parameters.new(person: { name: 'Finn' })
name = params.require(:person).require(:name) # CAREFUL
but take into account that at some point those ones have to be permitted:
def person_params
params.require(:person).permit(:name).tap do |person_params|
person_params.require(:name) # SAFER
end
end
for example.
303 304 305 306 307 308 309 310 311 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 303 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 |
#select(&block) ⇒ Object
Returns a new instance of ActionController::Parameters
with only items that the block evaluates to true.
545 546 547 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 545 def select(&block) new_instance_with_inherited_permitted_status(@parameters.select(&block)) end |
#select!(&block) ⇒ Object Also known as: keep_if
Equivalent to Hash#keep_if, but returns nil if no changes were made.
550 551 552 553 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 550 def select!(&block) @parameters.select!(&block) self end |
#slice(*keys) ⇒ Object
Returns a new ActionController::Parameters
instance that includes only the given keys
. If the given keys
don’t exist, returns an empty hash.
params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.slice(:a, :b) # => <ActionController::Parameters {"a"=>1, "b"=>2} permitted: false>
params.slice(:d) # => <ActionController::Parameters {} permitted: false>
463 464 465 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 463 def slice(*keys) new_instance_with_inherited_permitted_status(@parameters.slice(*keys)) end |
#slice!(*keys) ⇒ Object
Returns current ActionController::Parameters
instance which contains only the given keys
.
469 470 471 472 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 469 def slice!(*keys) @parameters.slice!(*keys) self end |
#stringify_keys ⇒ Object
This is required by ActiveModel attribute assignment, so that user can pass Parameters
to a mass assignment methods in a model. It should not matter as we are using HashWithIndifferentAccess
internally.
593 594 595 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 593 def stringify_keys # :nodoc: dup end |
#to_h ⇒ Object
Returns a safe ActiveSupport::HashWithIndifferentAccess
representation of this parameter with all unpermitted keys removed.
params = ActionController::Parameters.new({
name: 'Senjougahara Hitagi',
oddity: 'Heavy stone crab'
})
params.to_h # => {}
safe_params = params.permit(:name)
safe_params.to_h # => {"name"=>"Senjougahara Hitagi"}
177 178 179 180 181 182 183 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 177 def to_h if permitted? convert_parameters_to_hashes(@parameters, :to_h) else slice(*self.class.always_permitted_parameters).permit!.to_h end end |
#to_unsafe_h ⇒ Object Also known as: to_unsafe_hash
Returns an unsafe, unfiltered ActiveSupport::HashWithIndifferentAccess
representation of this parameter.
params = ActionController::Parameters.new({
name: 'Senjougahara Hitagi',
oddity: 'Heavy stone crab'
})
params.to_unsafe_h
# => {"name"=>"Senjougahara Hitagi", "oddity" => "Heavy stone crab"}
195 196 197 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 195 def to_unsafe_h convert_parameters_to_hashes(@parameters, :to_unsafe_h) end |
#transform_keys(&block) ⇒ Object
Returns a new ActionController::Parameters
instance with the results of running block
once for every key. The values are unchanged.
518 519 520 521 522 523 524 525 526 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 518 def transform_keys(&block) if block new_instance_with_inherited_permitted_status( @parameters.transform_keys(&block) ) else @parameters.transform_keys end end |
#transform_keys!(&block) ⇒ Object
Performs keys transformation and returns the altered ActionController::Parameters
instance.
530 531 532 533 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 530 def transform_keys!(&block) @parameters.transform_keys!(&block) self end |
#transform_values(&block) ⇒ Object
Returns a new ActionController::Parameters
with the results of running block
once for every value. The keys are unchanged.
params = ActionController::Parameters.new(a: 1, b: 2, c: 3)
params.transform_values { |x| x * 2 }
# => <ActionController::Parameters {"a"=>2, "b"=>4, "c"=>6} permitted: false>
499 500 501 502 503 504 505 506 507 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 499 def transform_values(&block) if block new_instance_with_inherited_permitted_status( @parameters.transform_values(&block) ) else @parameters.transform_values end end |
#transform_values!(&block) ⇒ Object
Performs values transformation and returns the altered ActionController::Parameters
instance.
511 512 513 514 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 511 def transform_values!(&block) @parameters.transform_values!(&block) self end |
#values_at(*keys) ⇒ Object
Returns values that were assigned to the given keys
. Note that all the Hash
objects will be converted to ActionController::Parameters
.
571 572 573 |
# File 'lib/action_controller/metal/strong_parameters.rb', line 571 def values_at(*keys) convert_value_to_parameters(@parameters.values_at(*keys)) end |