module ActiveSupport::XmlMini - activesupport-4.2.3 Documentation

# 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 86
    def backend
      current_thread_backend || @backend
    end

backend=(name) click to toggle source

    # 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 = {}) click to toggle source

    # 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) click to toggle source

    # 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) { || ... } click to toggle source

    # 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

### Protected Instance Methods

_dasherize(key) click to toggle source

    # File lib/active_support/xml_mini.rb, line 149
    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_file(file, entity) click to toggle source

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

### Private Instance Methods

cast_backend_name_to_module(name) click to toggle source

    # File lib/active_support/xml_mini.rb, line 183
    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 175
    def current_thread_backend
      Thread.current[:xml_mini_backend]
    end

current_thread_backend=(name) click to toggle source

    # File lib/active_support/xml_mini.rb, line 179
    def current_thread_backend=(name)
      Thread.current[:xml_mini_backend] = name && cast_backend_name_to_module(name)
    end