class Array

def self.wrap(object)
  if object.nil?
    []
  elsif object.respond_to?(:to_ary)
    object.to_ary
  else
    [object]
  end
end

def as_json(options = nil) self end #:nodoc:

def encode_json(encoder) "[#{map { |v| encoder.encode(v) } * ','}]" end #:nodoc:

def extract_options!
  if last.is_a?(Hash) && last.extractable_options?
    pop
  else
    {}
  end
end

def fifth
  self[4]
end

def forty_two
  self[41]
end

def fourth
  self[3]
end

def from(position)
  self[position..-1]
end

def in_groups(number, fill_with = nil)
  # size / number gives minor group size;
  # size % number gives how many objects need extra accommodation;
  # each group hold either division or division + 1 items.
  division = size / number
  modulo = size % number
  # create a new array avoiding dup
  groups = []
  start = 0
  number.times do |index|
    length = division + (modulo > 0 && modulo > index ? 1 : 0)
    padding = fill_with != false &&
      modulo > 0 && length == division ? 1 : 0
    groups << slice(start, length).concat([fill_with] * padding)
    start += length
  end
  if block_given?
    groups.each { |g| yield(g) }
  else
    groups
  end
end

def in_groups_of(number, fill_with = nil)
  if fill_with == false
    collection = self
  else
    # size % number gives how many extra we have;
    # subtracting from number gives how many to add;
    # modulo number ensures we don't add group of just fill.
    padding = (number - size % number) % number
    collection = dup.concat([fill_with] * padding)
  end
  if block_given?
    collection.each_slice(number) { |slice| yield(slice) }
  else
    groups = []
    collection.each_slice(number) { |group| groups << group }
    groups
  end
end

def sample(n=nil)
  return self[Kernel.rand(size)] if n.nil?
  n = n.to_int
rescue Exception => e
  raise TypeError, "Coercion error: #{n.inspect}.to_int => Integer failed:\n(#{e.message})"
else
  raise TypeError, "Coercion error: obj.to_int did NOT return an Integer (was #{n.class})" unless n.kind_of? Integer
  raise ArgumentError, "negative array size" if n < 0
  n = size if n > size
  result = Array.new(self)
  n.times do |i|
    r = i + Kernel.rand(size - i)
    result[i], result[r] = result[r], result[i]
  end
  result[n..size] = []
  result
end unless method_defined? :sample

def second
  self[1]
end

def split(value = nil)
  using_block = block_given?
  inject([[]]) do |results, element|
    if (using_block && yield(element)) || (value == element)
      results << []
    else
      results.last << element
    end
    results
  end
end

def third
  self[2]
end

def to(position)
  self[0..position]
end

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

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

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

def to_sentence(options = {})
  if defined?(I18n)
    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])
  else
    default_words_connector     = ", "
    default_two_words_connector = " and "
    default_last_word_connector = ", and "
  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

def to_xml(options = {})
  require 'active_support/builder' unless defined?(Builder)
  options = options.dup
  options[:indent]  ||= 2
  options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
  options[:root]    ||= if first.class.to_s != "Hash" && all? { |e| e.is_a?(first.class) }
    underscored = ActiveSupport::Inflector.underscore(first.class.name)
    ActiveSupport::Inflector.pluralize(underscored).tr('/', '_')
  else
    "objects"
  end
  builder = options[:builder]
  builder.instruct! unless options.delete(:skip_instruct)
  root = ActiveSupport::XmlMini.rename_key(options[:root].to_s, options)
  children = options.delete(:children) || root.singularize
  attributes = options[:skip_types] ? {} : {:type => "array"}
  return builder.tag!(root, attributes) if empty?
  builder.__send__(:method_missing, root, attributes) do
    each { |value| ActiveSupport::XmlMini.to_tag(children, value, options) }
    yield builder if block_given?
  end
end

def uniq_by
  hash, array = {}, []
  each { |i| hash[yield(i)] ||= (array << i) }
  array
end

def uniq_by!
  replace(uniq_by{ |i| yield(i) })
end