File: conversions.rb

package info (click to toggle)
rails 2.3.5-1.2+squeeze8
  • links: PTS, VCS
  • area: main
  • in suites: squeeze
  • size: 18,248 kB
  • ctags: 20,944
  • sloc: ruby: 122,413; makefile: 72; sql: 43; sh: 1
file content (264 lines) | stat: -rw-r--r-- 11,064 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
require 'date'
require 'active_support/core_ext/module/attribute_accessors'

module ActiveSupport #:nodoc:
  # these accessors are here because people using ActiveResource and REST to integrate with other systems
  # have to be able to control the default behavior of rename_key. dasherize_xml is set to true to emulate
  # existing behavior. In a future version it should be set to false by default.
  mattr_accessor :dasherize_xml
  mattr_accessor :camelize_xml
  self.dasherize_xml = true
  self.camelize_xml  = false
  module CoreExtensions #:nodoc:
    module Hash #:nodoc:
      module Conversions
        # This module exists to decorate files deserialized using Hash.from_xml with
        # the <tt>original_filename</tt> and <tt>content_type</tt> methods.
        module FileLike #:nodoc:
          attr_writer :original_filename, :content_type

          def original_filename
            @original_filename || 'untitled'
          end

          def content_type
            @content_type || 'application/octet-stream'
          end
        end

        DISALLOWED_XML_TYPES = %w(symbol yaml)
        class DisallowedType < StandardError #:nodoc:
          def initialize(type)
            super "Disallowed type attribute: #{type.inspect}"
          end
        end

        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)

        # TODO: use Time.xmlschema instead of Time.parse;
        #       use regexp instead of Date.parse
        unless defined?(XML_PARSING)
          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
          }

          XML_PARSING.update(
            "double"   => XML_PARSING["float"],
            "dateTime" => XML_PARSING["datetime"]
          )
        end

        def self.included(klass)
          klass.extend(ClassMethods)
        end

        # Converts a hash into a string suitable for use as a URL query string. An optional <tt>namespace</tt> 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"
        def to_query(namespace = nil)
          collect do |key, value|
            value.to_query(namespace ? "#{namespace}[#{key}]" : key)
          end.sort * '&'
        end
        
        alias_method :to_param, :to_query

        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

        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

        module ClassMethods
          def from_xml(xml, disallowed_types = nil)
            typecast_xml_value(unrename_keys(XmlMini.parse(xml)), disallowed_types)
          end

          def from_trusted_xml(xml)
            from_xml xml, []
          end

          private
            def typecast_xml_value(value, disallowed_types = nil)
              disallowed_types ||= DISALLOWED_XML_TYPES

              case value.class.to_s
                when 'Hash'
                  if value.include?('type') && !value['type'].is_a?(Hash) && disallowed_types.include?(value['type'])
                    raise DisallowedType, value['type']
                  end

                  if value['type'] == 'array'
                    child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
                    if entries.nil? || (c = value['__content__'] && c.blank?)
                      []
                    else
                      case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
                      when "Array"
                        entries.collect { |v| typecast_xml_value(v, disallowed_types) }
                      when "Hash"
                        [typecast_xml_value(entries, disallowed_types)]
                      else
                        raise "can't typecast #{entries.inspect}"
                      end
                    end
                  elsif value.has_key?("__content__")
                    content = value["__content__"]
                    if parser = XML_PARSING[value["type"]]
                      if parser.arity == 2
                        XML_PARSING[value["type"]].call(content, value)
                      else
                        XML_PARSING[value["type"]].call(content)
                      end
                    else
                      content
                    end
                  elsif value['type'] == 'string' && value['nil'] != 'true'
                    ""
                  # blank or nil parsed values are represented by nil
                  elsif value.blank? || value['nil'] == 'true'
                    nil
                  # If the type is the only element which makes it then 
                  # this still makes the value nil, except if type is
                  # a XML node(where type['value'] is a Hash)
                  elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
                    nil
                  else
                    xml_value = value.inject({}) do |h,(k,v)|
                      h[k] = typecast_xml_value(v, disallowed_types)
                      h
                    end
                    
                    # Turn { :files => { :file => #<StringIO> } into { :files => #<StringIO> } so it is compatible with
                    # how multipart uploaded files from HTML appear
                    xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
                  end
                when 'Array'
                  value.map! { |i| typecast_xml_value(i, disallowed_types) }
                  case value.length
                    when 0 then nil
                    when 1 then value.first
                    else value
                  end
                when 'String'
                  value
                else
                  raise "can't typecast #{value.class.name} - #{value.inspect}"
              end
            end

            def unrename_keys(params)
              case params.class.to_s
                when "Hash"
                  params.inject({}) do |h,(k,v)|
                    h[k.to_s.tr("-", "_")] = unrename_keys(v)
                    h
                  end
                when "Array"
                  params.map { |v| unrename_keys(v) }
                else
                  params
              end
            end
        end
      end
    end
  end
end