← Back to branch summary

~michaelforrest/use-case-mapper/trunk

« back to all changes in this revision

Viewing changes to vendor/rails/activesupport/lib/active_support/core_ext/hash/conversions.rb

  • Committer: Richard Lee (Canonical)
  • Date: 2010-10-15 15:17:58 UTC
  • mfrom: (190.1.3 use-case-mapper)
  • Revision ID: richard.lee@canonical.com-20101015151758-wcvmfxrexsongf9d
Merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/rails/activesupport/lib/active_support/core_ext/hash/conversions.rb
1
 
require 'date'
2
 
require 'active_support/core_ext/module/attribute_accessors'
3
 
 
4
 
module ActiveSupport #:nodoc:
5
 
  # these accessors are here because people using ActiveResource and REST to integrate with other systems
6
 
  # have to be able to control the default behavior of rename_key. dasherize_xml is set to true to emulate
7
 
  # existing behavior. In a future version it should be set to false by default.
8
 
  mattr_accessor :dasherize_xml
9
 
  mattr_accessor :camelize_xml
10
 
  self.dasherize_xml = true
11
 
  self.camelize_xml  = false
12
 
  module CoreExtensions #:nodoc:
13
 
    module Hash #:nodoc:
14
 
      module Conversions
15
 
        # This module exists to decorate files deserialized using Hash.from_xml with
16
 
        # the <tt>original_filename</tt> and <tt>content_type</tt> methods.
17
 
        module FileLike #:nodoc:
18
 
          attr_writer :original_filename, :content_type
19
 
 
20
 
          def original_filename
21
 
            @original_filename || 'untitled'
22
 
          end
23
 
 
24
 
          def content_type
25
 
            @content_type || 'application/octet-stream'
26
 
          end
27
 
        end
28
 
 
29
 
        XML_TYPE_NAMES = {
30
 
          "Symbol"     => "symbol",
31
 
          "Fixnum"     => "integer",
32
 
          "Bignum"     => "integer",
33
 
          "BigDecimal" => "decimal",
34
 
          "Float"      => "float",
35
 
          "TrueClass"  => "boolean",
36
 
          "FalseClass" => "boolean",
37
 
          "Date"       => "date",
38
 
          "DateTime"   => "datetime",
39
 
          "Time"       => "datetime",
40
 
          "ActiveSupport::TimeWithZone" => "datetime"
41
 
        } unless defined?(XML_TYPE_NAMES)
42
 
 
43
 
        XML_FORMATTING = {
44
 
          "symbol"   => Proc.new { |symbol| symbol.to_s },
45
 
          "date"     => Proc.new { |date| date.to_s(:db) },
46
 
          "datetime" => Proc.new { |time| time.xmlschema },
47
 
          "binary"   => Proc.new { |binary| ActiveSupport::Base64.encode64(binary) },
48
 
          "yaml"     => Proc.new { |yaml| yaml.to_yaml }
49
 
        } unless defined?(XML_FORMATTING)
50
 
 
51
 
        # TODO: use Time.xmlschema instead of Time.parse;
52
 
        #       use regexp instead of Date.parse
53
 
        unless defined?(XML_PARSING)
54
 
          XML_PARSING = {
55
 
            "symbol"       => Proc.new  { |symbol|  symbol.to_sym },
56
 
            "date"         => Proc.new  { |date|    ::Date.parse(date) },
57
 
            "datetime"     => Proc.new  { |time|    ::Time.parse(time).utc rescue ::DateTime.parse(time).utc },
58
 
            "integer"      => Proc.new  { |integer| integer.to_i },
59
 
            "float"        => Proc.new  { |float|   float.to_f },
60
 
            "decimal"      => Proc.new  { |number|  BigDecimal(number) },
61
 
            "boolean"      => Proc.new  { |boolean| %w(1 true).include?(boolean.strip) },
62
 
            "string"       => Proc.new  { |string|  string.to_s },
63
 
            "yaml"         => Proc.new  { |yaml|    YAML::load(yaml) rescue yaml },
64
 
            "base64Binary" => Proc.new  { |bin|     ActiveSupport::Base64.decode64(bin) },
65
 
            "file"         => Proc.new do |file, entity|
66
 
              f = StringIO.new(ActiveSupport::Base64.decode64(file))
67
 
              f.extend(FileLike)
68
 
              f.original_filename = entity['name']
69
 
              f.content_type = entity['content_type']
70
 
              f
71
 
            end
72
 
          }
73
 
 
74
 
          XML_PARSING.update(
75
 
            "double"   => XML_PARSING["float"],
76
 
            "dateTime" => XML_PARSING["datetime"]
77
 
          )
78
 
        end
79
 
 
80
 
        def self.included(klass)
81
 
          klass.extend(ClassMethods)
82
 
        end
83
 
 
84
 
        # Converts a hash into a string suitable for use as a URL query string. An optional <tt>namespace</tt> can be
85
 
        # passed to enclose the param names (see example below).
86
 
        #
87
 
        # ==== Examples
88
 
        #   { :name => 'David', :nationality => 'Danish' }.to_query # => "name=David&nationality=Danish"
89
 
        #
90
 
        #   { :name => 'David', :nationality => 'Danish' }.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
91
 
        def to_query(namespace = nil)
92
 
          collect do |key, value|
93
 
            value.to_query(namespace ? "#{namespace}[#{key}]" : key)
94
 
          end.sort * '&'
95
 
        end
96
 
        
97
 
        alias_method :to_param, :to_query
98
 
 
99
 
        def to_xml(options = {})
100
 
          require 'builder' unless defined?(Builder)
101
 
 
102
 
          options = options.dup
103
 
          options[:indent] ||= 2
104
 
          options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
105
 
                                   :root => "hash" })
106
 
          options[:builder].instruct! unless options.delete(:skip_instruct)
107
 
          root = rename_key(options[:root].to_s, options)
108
 
 
109
 
          options[:builder].__send__(:method_missing, root) do
110
 
            each do |key, value|
111
 
              case value
112
 
                when ::Hash
113
 
                  value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
114
 
                when ::Array
115
 
                  value.to_xml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
116
 
                when ::Method, ::Proc
117
 
                  # If the Method or Proc takes two arguments, then
118
 
                  # pass the suggested child element name.  This is
119
 
                  # used if the Method or Proc will be operating over
120
 
                  # multiple records and needs to create an containing
121
 
                  # element that will contain the objects being
122
 
                  # serialized.
123
 
                  if 1 == value.arity
124
 
                    value.call(options.merge({ :root => key, :skip_instruct => true }))
125
 
                  else
126
 
                    value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
127
 
                  end
128
 
                else
129
 
                  if value.respond_to?(:to_xml)
130
 
                    value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
131
 
                  else
132
 
                    type_name = XML_TYPE_NAMES[value.class.name]
133
 
 
134
 
                    key = rename_key(key.to_s, options)
135
 
 
136
 
                    attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
137
 
                    if value.nil?
138
 
                      attributes[:nil] = true
139
 
                    end
140
 
 
141
 
                    options[:builder].tag!(key,
142
 
                      XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
143
 
                      attributes
144
 
                    )
145
 
                  end
146
 
              end
147
 
            end
148
 
            
149
 
            yield options[:builder] if block_given?
150
 
          end
151
 
 
152
 
        end
153
 
 
154
 
        def rename_key(key, options = {})
155
 
          camelize  = options.has_key?(:camelize) ? options[:camelize]   : ActiveSupport.camelize_xml
156
 
          dasherize = options.has_key?(:dasherize) ? options[:dasherize] : ActiveSupport.dasherize_xml
157
 
          key = key.camelize if camelize
158
 
          key = key.dasherize if dasherize
159
 
          key
160
 
        end
161
 
 
162
 
        module ClassMethods
163
 
          def from_xml(xml)
164
 
            typecast_xml_value(unrename_keys(XmlMini.parse(xml)))
165
 
          end
166
 
 
167
 
          private
168
 
            def typecast_xml_value(value)
169
 
              case value.class.to_s
170
 
                when 'Hash'
171
 
                  if value['type'] == 'array'
172
 
                    child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
173
 
                    if entries.nil? || (c = value['__content__'] && c.blank?)
174
 
                      []
175
 
                    else
176
 
                      case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
177
 
                      when "Array"
178
 
                        entries.collect { |v| typecast_xml_value(v) }
179
 
                      when "Hash"
180
 
                        [typecast_xml_value(entries)]
181
 
                      else
182
 
                        raise "can't typecast #{entries.inspect}"
183
 
                      end
184
 
                    end
185
 
                  elsif value.has_key?("__content__")
186
 
                    content = value["__content__"]
187
 
                    if parser = XML_PARSING[value["type"]]
188
 
                      if parser.arity == 2
189
 
                        XML_PARSING[value["type"]].call(content, value)
190
 
                      else
191
 
                        XML_PARSING[value["type"]].call(content)
192
 
                      end
193
 
                    else
194
 
                      content
195
 
                    end
196
 
                  elsif value['type'] == 'string' && value['nil'] != 'true'
197
 
                    ""
198
 
                  # blank or nil parsed values are represented by nil
199
 
                  elsif value.blank? || value['nil'] == 'true'
200
 
                    nil
201
 
                  # If the type is the only element which makes it then 
202
 
                  # this still makes the value nil, except if type is
203
 
                  # a XML node(where type['value'] is a Hash)
204
 
                  elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
205
 
                    nil
206
 
                  else
207
 
                    xml_value = value.inject({}) do |h,(k,v)|
208
 
                      h[k] = typecast_xml_value(v)
209
 
                      h
210
 
                    end
211
 
                    
212
 
                    # Turn { :files => { :file => #<StringIO> } into { :files => #<StringIO> } so it is compatible with
213
 
                    # how multipart uploaded files from HTML appear
214
 
                    xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
215
 
                  end
216
 
                when 'Array'
217
 
                  value.map! { |i| typecast_xml_value(i) }
218
 
                  case value.length
219
 
                    when 0 then nil
220
 
                    when 1 then value.first
221
 
                    else value
222
 
                  end
223
 
                when 'String'
224
 
                  value
225
 
                else
226
 
                  raise "can't typecast #{value.class.name} - #{value.inspect}"
227
 
              end
228
 
            end
229
 
 
230
 
            def unrename_keys(params)
231
 
              case params.class.to_s
232
 
                when "Hash"
233
 
                  params.inject({}) do |h,(k,v)|
234
 
                    h[k.to_s.tr("-", "_")] = unrename_keys(v)
235
 
                    h
236
 
                  end
237
 
                when "Array"
238
 
                  params.map { |v| unrename_keys(v) }
239
 
                else
240
 
                  params
241
 
              end
242
 
            end
243
 
        end
244
 
      end
245
 
    end
246
 
  end
247
 
end