Module: ActiveSupport::XmlMini

Extended by:
XmlMini
Included in:
XmlMini
Defined in:
lib/active_support/xml_mini.rb

Overview

XmlMini

To use the much faster libxml parser:

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

Defined Under Namespace

Modules: FileLike

Constant Summary collapse

DEFAULT_ENCODINGS = 
{
  "binary" => "base64"
}
TYPE_NAMES = 
{
  "Symbol"     => "symbol",
  "Fixnum"     => "integer",
  "Bignum"     => "integer",
  "BigDecimal" => "decimal",
  "Float"      => "float",
  "TrueClass"  => "boolean",
  "FalseClass" => "boolean",
  "Date"       => "date",
  "DateTime"   => "dateTime",
  "Time"       => "dateTime",
  "Array"      => "array",
  "Hash"       => "hash"
}
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| ::Base64.encode64(binary) },
  "yaml"     => Proc.new { |yaml| yaml.to_yaml }
}
PARSING = 
{
  "symbol"       => Proc.new { |symbol|  symbol.to_s.to_sym },
  "date"         => Proc.new { |date|    ::Date.parse(date) },
  "datetime"     => Proc.new { |time|    Time.xmlschema(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.to_s.strip) },
  "string"       => Proc.new { |string|  string.to_s },
  "yaml"         => Proc.new { |yaml|    YAML::load(yaml) rescue yaml },
  "base64Binary" => Proc.new { |bin|     ::Base64.decode64(bin) },
  "binary"       => Proc.new { |bin, entity| _parse_binary(bin, entity) },
  "file"         => Proc.new { |file, entity| _parse_file(file, entity) }
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#depth ⇒ Object

Returns the value of attribute depth.



81
82
83
 
# File 'lib/active_support/xml_mini.rb', line 81

def depth
  @depth
end

Instance Method Details

#backend ⇒ Object 



86
87
88
 
# File 'lib/active_support/xml_mini.rb', line 86

def backend
  current_thread_backend || @backend
end

#backend=(name) ⇒ Object 



90
91
92
93
94
 
# File 'lib/active_support/xml_mini.rb', line 90

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 = {}) ⇒ Object 



137
138
139
140
141
142
143
144
145
 
# File 'lib/active_support/xml_mini.rb', line 137

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) ⇒ Object 



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
 
# File 'lib/active_support/xml_mini.rb', line 104

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) ⇒ Object 



96
97
98
99
100
101
102
 
# File 'lib/active_support/xml_mini.rb', line 96

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