Module: Sequel::Plugins::XmlSerializer::InstanceMethods

Defined in:
lib/sequel/plugins/xml_serializer.rb

Instance Method Summary collapse

Instance Method Details

#from_xml(xml, opts = OPTS) ⇒ Object

Update the contents of this instance based on the given XML. Accepts the following options:

:name_proc

Proc or Hash that accepts a string and returns a string, used to convert tag names to column or association names.

:underscore

Sets the :name_proc option to one that calls underscore on the input string. Requires that you load the inflector extension or another library that adds String#underscore.



210
211
212
# File 'lib/sequel/plugins/xml_serializer.rb', line 210

def from_xml(xml, opts=OPTS)
  from_xml_node(Nokogiri::XML(xml).children.first, opts)
end

#from_xml_node(parent, opts = OPTS) ⇒ Object

Update the contents of this instance based on the given XML node, which should be a Nokogiri::XML::Node instance. By default, just calls set with a hash created from the content of the node.

Options:

:associations

Indicates that the associations cache should be updated by creating a new associated object using data from the hash. Should be a Symbol for a single association, an array of symbols for multiple associations, or a hash with symbol keys and dependent association option hash values.

:fields

Changes the behavior to call set_fields using the provided fields, instead of calling set.



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
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
# File 'lib/sequel/plugins/xml_serializer.rb', line 224

def from_xml_node(parent, opts=OPTS)
  unless parent
    raise Error, "Malformed XML used"
  end
  if !parent.children.empty? && parent.children.all?{|node| node.is_a?(Nokogiri::XML::Text)}
    raise Error, "XML consisting of just text nodes used"
  end

  if assocs = opts[:associations]
    assocs = case assocs
    when Symbol
      {assocs=>{}}
    when Array
      assocs_tmp = {}
      assocs.each{|v| assocs_tmp[v] = {}}
      assocs_tmp
    when Hash
      assocs
    else
      raise Error, ":associations should be Symbol, Array, or Hash if present"
    end

    assocs_hash = {}
    assocs.each{|k,v| assocs_hash[k.to_s] = v}
    assocs_present = []
  end

  hash = {}
  populate_associations = {}
  name_proc = model.xml_deserialize_name_proc(opts)
  parent.children.each do |node|
    next if node.is_a?(Nokogiri::XML::Text)
    k = name_proc[node.name]
    if assocs_hash && assocs_hash[k]
      assocs_present << [k.to_sym, node]
    else
      hash[k] = node.key?('nil') ? nil : node.children.first.to_s
    end
  end

  if assocs_present
    assocs_present.each do |assoc, node|
      assoc_opts = assocs[assoc]

      unless r = model.association_reflection(assoc)
        raise Error, "Association #{assoc} is not defined for #{model}"
      end

      populate_associations[assoc] = if r.returns_array?
        node.children.reject{|c| c.is_a?(Nokogiri::XML::Text)}.map{|c| r.associated_class.from_xml_node(c, assoc_opts)}
      else
        r.associated_class.from_xml_node(node, assoc_opts)
      end
    end
  end

  if fields = opts[:fields]
    set_fields(hash, fields, opts)
  else
    set(hash)
  end

  populate_associations.each do |assoc, values|
    associations[assoc] = values
  end

  self
end

#to_xml(opts = OPTS) ⇒ Object

Return a string in XML format. If a block is given, yields the XML builder object so you can add additional XML tags. Accepts the following options:

:builder

The builder instance used to build the XML, which should be an instance of Nokogiri::XML::Node. This is necessary if you are serializing entire object graphs, like associated objects.

:builder_opts

Options to pass to the Nokogiri::XML::Builder initializer, if the :builder option is not provided.

:camelize

Sets the :name_proc option to one that calls camelize on the input string. Requires that you load the inflector extension or another library that adds String#camelize.

:dasherize

Sets the :name_proc option to one that calls dasherize on the input string. Requires that you load the inflector extension or another library that adds String#dasherize.

:encoding

The encoding to use for the XML output, passed to the Nokogiri::XML::Builder initializer.

:except

Symbol or Array of Symbols of columns not to include in the XML output.

:include

Symbol, Array of Symbols, or a Hash with Symbol keys and Hash values specifying associations or other non-column attributes to include in the XML output. Using a nested hash, you can pass options to associations to affect the XML used for associated objects.

:name_proc

Proc or Hash that accepts a string and returns a string, used to format tag names.

:only

Symbol or Array of Symbols of columns to only include in the JSON output, ignoring all other columns.

:root_name

The base name to use for the XML tag that contains the data for this instance. This will be the name of the root node if you are only serializing a single object, but not if you are serializing an array of objects using Model.to_xml or Dataset#to_xml.

:types

Set to true to include type information for all of the columns, pulled from the db_schema.



331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
# File 'lib/sequel/plugins/xml_serializer.rb', line 331

def to_xml(opts=OPTS)
  vals = values
  types = opts[:types]
  inc = opts[:include]

  cols = if only = opts[:only]
    Array(only)
  else
    vals.keys - Array(opts[:except])
  end

  name_proc = model.xml_serialize_name_proc(opts)
  x = model.xml_builder(opts)
  x.send(name_proc[opts.fetch(:root_name, model.send(:underscore, model.name).gsub('/', '__')).to_s]) do |x1|
    cols.each do |c|
      attrs = {}
      if types
        attrs[:type] = db_schema.fetch(c, {})[:type]
      end
      v = vals[c]
      if v.nil?
        attrs[:nil] = ''
      end
      x1.send(name_proc[c.to_s], v, attrs)
    end
    if inc.is_a?(Hash)
      inc.each{|k, v| to_xml_include(x1, k, v)}
    else
      Array(inc).each{|i| to_xml_include(x1, i)}
    end
    yield x1 if block_given?
  end
  x.to_xml
end