module ActiveSupport::XmlMini

XmlMini

To use the much faster libxml parser:

gem 'libxml-ruby', '=0.9.7'
XmlMini.backend = 'LibXML'

Constants

DEFAULT_ENCODINGS
FORMATTING
PARSING
TYPE_NAMES

Attributes

depth[RW]

Public Instance Methods

backend() click to toggle source
# File lib/active_support/xml_mini.rb, line 97
def backend
  current_thread_backend || @backend
end
backend=(name) click to toggle source
# File lib/active_support/xml_mini.rb, line 101
def backend=(name)
  backend = name && cast_backend_name_to_module(name)
  self.current_thread_backend = backend if current_thread_backend
  @backend = backend
end
rename_key(key, options = {}) click to toggle source
# File lib/active_support/xml_mini.rb, line 148
def rename_key(key, options = {})
  camelize  = options[:camelize]
  dasherize = !options.has_key?(:dasherize) || options[:dasherize]
  if camelize
    key = true == camelize ? key.camelize : key.camelize(camelize)
  end
  key = _dasherize(key) if dasherize
  key
end
to_tag(key, value, options) click to toggle source
# File lib/active_support/xml_mini.rb, line 115
def to_tag(key, value, options)
  type_name = options.delete(:type)
  merged_options = options.merge(root: key, skip_instruct: true)

  if value.is_a?(::Method) || value.is_a?(::Proc)
    if value.arity == 1
      value.call(merged_options)
    else
      value.call(merged_options, key.to_s.singularize)
    end
  elsif value.respond_to?(:to_xml)
    value.to_xml(merged_options)
  else
    type_name ||= TYPE_NAMES[value.class.name]
    type_name ||= value.class.name if value && !value.respond_to?(:to_str)
    type_name   = type_name.to_s   if type_name
    type_name   = "dateTime" if type_name == "datetime"

    key = rename_key(key.to_s, options)

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

    encoding = options[:encoding] || DEFAULT_ENCODINGS[type_name]
    attributes[:encoding] = encoding if encoding

    formatted_value = FORMATTING[type_name] && !value.nil? ?
      FORMATTING[type_name].call(value) : value

    options[:builder].tag!(key, formatted_value, attributes)
  end
end
with_backend(name) { || ... } click to toggle source
# File lib/active_support/xml_mini.rb, line 107
def with_backend(name)
  old_backend = current_thread_backend
  self.current_thread_backend = name && cast_backend_name_to_module(name)
  yield
ensure
  self.current_thread_backend = old_backend
end

Private Instance Methods

_dasherize(key) click to toggle source
# File lib/active_support/xml_mini.rb, line 159
def _dasherize(key)
  # $2 must be a non-greedy regex for this to work
  left, middle, right = /\A(_*)(.*?)(_*)\Z/.match(key.strip)[1, 3]
  "#{left}#{middle.tr('_ ', '--')}#{right}"
end
_parse_binary(bin, entity) click to toggle source

TODO: Add support for other encodings

# File lib/active_support/xml_mini.rb, line 166
def _parse_binary(bin, entity)
  case entity["encoding"]
  when "base64"
    ::Base64.decode64(bin)
  else
    bin
  end
end
_parse_file(file, entity) click to toggle source
# File lib/active_support/xml_mini.rb, line 175
def _parse_file(file, entity)
  f = StringIO.new(::Base64.decode64(file))
  f.extend(FileLike)
  f.original_filename = entity["name"]
  f.content_type = entity["content_type"]
  f
end
cast_backend_name_to_module(name) click to toggle source
# File lib/active_support/xml_mini.rb, line 191
def cast_backend_name_to_module(name)
  if name.is_a?(Module)
    name
  else
    require "active_support/xml_mini/#{name.downcase}"
    ActiveSupport.const_get("XmlMini_#{name}")
  end
end
current_thread_backend() click to toggle source
# File lib/active_support/xml_mini.rb, line 183
def current_thread_backend
  IsolatedExecutionState[:xml_mini_backend]
end
current_thread_backend=(name) click to toggle source
# File lib/active_support/xml_mini.rb, line 187
def current_thread_backend=(name)
  IsolatedExecutionState[:xml_mini_backend] = name && cast_backend_name_to_module(name)
end