Module: ActiveSupport::CoreExtensions::Array::Conversions

Module | ActiveSupport::CoreExtensions::Array::Conversions
In: | lib/active_support/core_ext/array/conversions.rb

### Methods

to_formatted_s to_param to_query to_sentence to_xml

### Public Instance methods

to_formatted_s(format = :default)

Converts a collection of elements into a formatted string by calling `to_s` on all elements and joining them:

      Blog.find(:all).to_formatted_s # => "First PostSecond PostThird Post"

Adding in the `:db` argument as the format yields a prettier output:

      Blog.find(:all).to_formatted_s(:db) # => "First Post,Second Post,Third Post"

to_param()

Calls `to_param` on all its elements and joins the result with slashes. This is used by `url_for` in Action Pack.

to_query(key)

Converts an array into a string suitable for use as a URL query string, using the given `key` as the param name.

      ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"

to_sentence(options = {})

Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:

- `:words_connector` - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
- `:two_words_connector` - The sign or word used to join the elements in arrays with two elements (default: " and ")
- `:last_word_connector` - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")

to_xml(options = {}) {|xml if block_given?| ...}

Returns a string that represents this array in XML by sending `to_xml` to each element. Active Record collections delegate their representation in XML to this method.

All elements are expected to respond to `to_xml`, if any of them does not an exception is raised.

The root node reflects the class name of the first element in plural if all elements belong to the same type and that‘s not Hash:

      customer.projects.to_xml

      <?xml version="1.0" encoding="UTF-8"?>
      <projects type="array">
        <project>
          <amount type="decimal">20000.0</amount>
          <customer-id type="integer">1567</customer-id>
          <deal-date type="date">2008-04-09</deal-date>
          ...
        </project>
        <project>
          <amount type="decimal">57230.0</amount>
          <customer-id type="integer">1567</customer-id>
          <deal-date type="date">2008-04-15</deal-date>
          ...
        </project>
      </projects>

Otherwise the root element is "records":

      [{:foo => 1, :bar => 2}, {:baz => 3}].to_xml

      <?xml version="1.0" encoding="UTF-8"?>
      <records type="array">
        <record>
          <bar type="integer">2</bar>
          <foo type="integer">1</foo>
        </record>
        <record>
          <baz type="integer">3</baz>
        </record>
      </records>

If the collection is empty the root element is "nil-classes" by default:

      [].to_xml

      <?xml version="1.0" encoding="UTF-8"?>
      <nil-classes type="array"/>

To ensure a meaningful root element use the `:root` option:

      customer_with_no_projects.projects.to_xml(:root => "projects")

      <?xml version="1.0" encoding="UTF-8"?>
      <projects type="array"/>

By default root children have as node name the one of the root singularized. You can change it with the `:children` option.

The `options` hash is passed downwards:

      Message.all.to_xml(:skip_types => true)

      <?xml version="1.0" encoding="UTF-8"?>
      <messages>
        <message>
          <created-at>2008-03-07T09:58:18+01:00</created-at>
          <id>1</id>
          <name>1</name>
          <updated-at>2008-03-07T09:58:18+01:00</updated-at>
          <user-id>1</user-id>
        </message>
      </messages>

[Validate]