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

Defined in:
lib/support/active_support_lite/array/conversions.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object

:nodoc



62
63
64
65
66
67
 
# File 'lib/support/active_support_lite/array/conversions.rb', line 62

def self.included(base) #:nodoc
  base.class_eval do
    alias_method :to_default_s, :to_s
    alias_method :to_s, :to_formatted_s
  end
end

Instance Method Details

#to_formatted_s(format = :default) ⇒ Object

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"

:nodoc



79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/support/active_support_lite/array/conversions.rb', line 79

def to_formatted_s(format = :default)
  case format
    when :db
      if respond_to?(:empty?) && self.empty?
        "null"
      else
        collect { |element| element.id }.join(",")
      end
    else
      to_default_s
  end
end

#to_param ⇒ Object

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



47
48
49
 
# File 'lib/support/active_support_lite/array/conversions.rb', line 47

def to_param
  collect { |e| e.to_param }.join '/'
end

#to_query(key) ⇒ Object

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"

:nodoc



56
57
58
59
 
# File 'lib/support/active_support_lite/array/conversions.rb', line 56

def to_query(key)
  prefix = "#{key}[]"
  collect { |value| value.to_query(prefix) }.join '&'
end

#to_sentence(options = {}) ⇒ Object

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 ”)

:nodoc



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/support/active_support_lite/array/conversions.rb', line 10

def to_sentence(options = {})
  default_words_connector     = I18n.translate(:'support.array.words_connector',     :locale => options[:locale])
  default_two_words_connector = I18n.translate(:'support.array.two_words_connector', :locale => options[:locale])
  default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])

  # Try to emulate to_senteces previous to 2.3
  if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
    ::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
    ::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma

    skip_last_comma = options.delete :skip_last_comma
    if connector = options.delete(:connector)
      options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
    else
      options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
    end
  end
  
  options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)       
  options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
  
  case length
    when 0
      ""
    when 1
      self[0].to_s
    when 2
      "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
    else
      "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
  end
end

#to_xml(options = {}) ⇒ Object

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>

:nodoc



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/support/active_support_lite/array/conversions.rb', line 168

def to_xml(options = {})
  raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
  require 'builder' unless defined?(Builder)

  options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
  options[:children] ||= options[:root].singularize
  options[:indent]   ||= 2
  options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])

  root     = options.delete(:root).to_s
  children = options.delete(:children)

  if !options.has_key?(:dasherize) || options[:dasherize]
    root = root.dasherize
  end

  options[:builder].instruct! unless options.delete(:skip_instruct)

  opts = options.merge({ :root => children })

  xml = options[:builder]
  if empty?
    xml.tag!(root, options[:skip_types] ? {} : {:type => "array"})
  else
    xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
      yield xml if block_given?
      each { |e| e.to_xml(opts.merge({ :skip_instruct => true })) }
    }
  end
end