Namespace
Methods
I
R
T
Constants
DISALLOWED_XML_TYPES = %w(symbol yaml)
 
XML_TYPE_NAMES = { "Symbol" => "symbol", "Fixnum" => "integer", "Bignum" => "integer", "BigDecimal" => "decimal", "Float" => "float", "TrueClass" => "boolean", "FalseClass" => "boolean", "Date" => "date", "DateTime" => "datetime", "Time" => "datetime", "ActiveSupport::TimeWithZone" => "datetime" } unless defined?(XML_TYPE_NAMES)
 
XML_FORMATTING = { "symbol" => Proc.new { |symbol| symbol.to_s }, "date" => Proc.new { |date| date.to_s(:db) }, "datetime" => Proc.new { |time| time.xmlschema }, "binary" => Proc.new { |binary| ActiveSupport::Base64.encode64(binary) }, "yaml" => Proc.new { |yaml| yaml.to_yaml } } unless defined?(XML_FORMATTING)
 
XML_PARSING = { "symbol" => Proc.new { |symbol| symbol.to_sym }, "date" => Proc.new { |date| ::Date.parse(date) }, "datetime" => Proc.new { |time| ::Time.parse(time).utc rescue ::DateTime.parse(time).utc }, "integer" => Proc.new { |integer| integer.to_i }, "float" => Proc.new { |float| float.to_f }, "decimal" => Proc.new { |number| BigDecimal(number) }, "boolean" => Proc.new { |boolean| %w(1 true).include?(boolean.strip) }, "string" => Proc.new { |string| string.to_s }, "yaml" => Proc.new { |yaml| YAML::load(yaml) rescue yaml }, "base64Binary" => Proc.new { |bin| ActiveSupport::Base64.decode64(bin) }, "file" => Proc.new do |file, entity| f = StringIO.new(ActiveSupport::Base64.decode64(file)) f.extend(FileLike) f.original_filename = entity['name'] f.content_type = entity['content_type'] f end }
 
Class Public methods
included(klass)
# File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 87
def self.included(klass)
  klass.extend(ClassMethods)
end
Instance Public methods
rename_key(key, options = {})
# File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 161
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)
to_query(namespace = nil)

Converts a hash into a string suitable for use as a URL query string. An optional namespacecan 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"
Also aliased as: to_param
# File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 98
def to_query(namespace = nil)
  collect do |key, value|
    value.to_query(namespace ? "#{namespace}[#{key}]" : key)
  end.sort * '&'
end
to_xml(options = {})
# File activesupport/lib/active_support/core_ext/hash/conversions.rb, line 106
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