Module ActiveSupport::CoreExtensions::Array::Conversions
In: vendor/rails/activesupport/lib/active_support/core_ext/array/conversions.rb

Methods

Public Instance methods

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"

[Source]

    # File vendor/rails/activesupport/lib/active_support/core_ext/array/conversions.rb, line 62
62:         def to_formatted_s(format = :default)
63:           case format
64:             when :db
65:               if respond_to?(:empty?) && self.empty?
66:                 "null"
67:               else
68:                 collect { |element| element.id }.join(",")
69:               end
70:             else
71:               to_default_s
72:           end
73:         end

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

[Source]

    # File vendor/rails/activesupport/lib/active_support/core_ext/array/conversions.rb, line 33
33:         def to_param
34:           collect { |e| e.to_param }.join '/'
35:         end

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"

[Source]

    # File vendor/rails/activesupport/lib/active_support/core_ext/array/conversions.rb, line 41
41:         def to_query(key)
42:           prefix = "#{key}[]"
43:           collect { |value| value.to_query(prefix) }.join '&'
44:         end

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

  • :connector - The word used to join the last element in arrays with two or more elements (default: "and")
  • :skip_last_comma - Set to true to return "a, b and c" instead of "a, b, and c".

[Source]

    # File vendor/rails/activesupport/lib/active_support/core_ext/array/conversions.rb, line 10
10:         def to_sentence(options = {})          
11:           options.assert_valid_keys(:connector, :skip_last_comma, :locale)
12:           
13:           default = I18n.translate('support.array.sentence_connector''support.array.sentence_connector', :locale => options[:locale])
14:           default_skip_last_comma = I18n.translate('support.array.skip_last_comma''support.array.skip_last_comma', :locale => options[:locale])
15:           options.reverse_merge! :connector => default, :skip_last_comma => default_skip_last_comma
16:           options[:connector] = "#{options[:connector]} " unless options[:connector].nil? || options[:connector].strip == ''
17: 
18:           case length
19:             when 0
20:               ""
21:             when 1
22:               self[0].to_s
23:             when 2
24:               "#{self[0]} #{options[:connector]}#{self[1]}"
25:             else
26:               "#{self[0...-1].join(', ')}#{options[:skip_last_comma] ? '' : ','} #{options[:connector]}#{self[-1]}"
27:           end
28:         end

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>

[Source]

     # File vendor/rails/activesupport/lib/active_support/core_ext/array/conversions.rb, line 150
150:         def to_xml(options = {})
151:           raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
152: 
153:           options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
154:           options[:children] ||= options[:root].singularize
155:           options[:indent]   ||= 2
156:           options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
157: 
158:           root     = options.delete(:root).to_s
159:           children = options.delete(:children)
160: 
161:           if !options.has_key?(:dasherize) || options[:dasherize]
162:             root = root.dasherize
163:           end
164: 
165:           options[:builder].instruct! unless options.delete(:skip_instruct)
166: 
167:           opts = options.merge({ :root => children })
168: 
169:           xml = options[:builder]
170:           if empty?
171:             xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
172:           else
173:             xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
174:               yield xml if block_given?
175:               each { |e| e.to_xml(opts.merge({ :skip_instruct => true })) }
176:             }
177:           end
178:         end

[Validate]