Module: ActiveSupport::XmlMini

Extended by:
XmlMini
Included in:
XmlMini
Defined in:
activesupport/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_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.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

#backend ⇒ Object

Returns the value of attribute backend



79
80
81
 
# File 'activesupport/lib/active_support/xml_mini.rb', line 79

def backend
  @backend
end

Instance Method Details

#rename_key(key, options = {}) ⇒ Object 



130
131
132
133
134
135
136
137
138
 
# File 'activesupport/lib/active_support/xml_mini.rb', line 130

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 



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

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

    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 



91
92
93
94
95
96
 
# File 'activesupport/lib/active_support/xml_mini.rb', line 91

def with_backend(name)
  old_backend, self.backend = backend, name
  yield
ensure
  self.backend = old_backend
end