Class/Module Index [+]

Quicksearch

ActiveSupport::CoreExtensions::Hash::Conversions

Public Class Methods

included(klass) click to toggle source
# File lib/active_support/core_ext/hash/conversions.rb, line 80
def self.included(klass)
  klass.extend(ClassMethods)
end

Public Instance Methods

rename_key(key, options = {}) click to toggle source
# File lib/active_support/core_ext/hash/conversions.rb, line 154
def rename_key(key, options = {})
  camelize  = options.has_key?(:camelize) ? options[:camelize]   : ActiveSupport.camelize_xml
  dasherize = options.has_key?(:dasherize) ? options[:dasherize] : ActiveSupport.dasherize_xml
  key = key.camelize if camelize
  key = key.dasherize if dasherize
  key
end
to_param(namespace = nil) click to toggle source
Alias for: to_query
to_query(namespace = nil) click to toggle source

Converts a hash into a string suitable for use as a URL query string. An optional namespace can be passed to enclose the param names (see example below).

Examples

{ :name => 'David', :nationality => 'Danish' }.to_query # => "name=David&nationality=Danish"

{ :name => 'David', :nationality => 'Danish' }.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
# File lib/active_support/core_ext/hash/conversions.rb, line 91
def to_query(namespace = nil)
  collect do |key, value|
    value.to_query(namespace ? "#{namespace}[#{key}]" : key)
  end.sort * '&'
end
Also aliased as: to_param
to_xml(options = {}) click to toggle source
# File lib/active_support/core_ext/hash/conversions.rb, line 99
def to_xml(options = {})
  require 'builder' unless defined?(Builder)

  options = options.dup
  options[:indent] ||= 2
  options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
                           :root => "hash" })
  options[:builder].instruct! unless options.delete(:skip_instruct)
  root = rename_key(options[:root].to_s, options)

  options[:builder].__send__(:method_missing, root) do
    each do |key, value|
      case value
        when ::Hash
          value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
        when ::Array
          value.to_xml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
        when ::Method, ::Proc
          # If the Method or Proc takes two arguments, then
          # pass the suggested child element name.  This is
          # used if the Method or Proc will be operating over
          # multiple records and needs to create an containing
          # element that will contain the objects being
          # serialized.
          if 1 == value.arity
            value.call(options.merge({ :root => key, :skip_instruct => true }))
          else
            value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
          end
        else
          if value.respond_to?(:to_xml)
            value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
          else
            type_name = XML_TYPE_NAMES[value.class.name]

            key = rename_key(key.to_s, options)

            attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
            if value.nil?
              attributes[:nil] = true
            end

            options[:builder].tag!(key,
              XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
              attributes
            )
          end
      end
    end
    
    yield options[:builder] if block_given?
  end

end

[Validate]

Generated with the Darkfish Rdoc Generator 2.