class Array

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

def as_json(options = nil) #:nodoc:
  map { |v| options ? v.as_json(options.dup) : v.as_json }
end

def deep_dup
  map { |it| it.deep_dup }
end

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, length] || []
end

def in_groups(number, fill_with = nil)
  # size.div 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.div 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)
    groups << last_group = slice(start, length)
    last_group << fill_with if fill_with != false &&
      modulo > 0 && length == division
    start += length
  end
  if block_given?
    groups.each { |g| yield(g) }
  else
    groups
  end
end

def in_groups_of(number, fill_with = nil)
  if number.to_i <= 0
    raise ArgumentError,
      "Group size must be a positive integer, was #{number.inspect}"
  end
  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(Array.new(padding, fill_with))
  end
  if block_given?
    collection.each_slice(number) { |slice| yield(slice) }
  else
    collection.each_slice(number).to_a
  end
end

def second
  self[1]
end

def split(value = nil)
  if block_given?
    inject([[]]) do |results, element|
      if yield(element)
        results << []
      else
        results.last << element
      end
      results
    end
  else
    results, arr = [[]], self.dup
    until arr.empty?
      if (idx = arr.index(value))
        results.last.concat(arr.shift(idx))
        arr.shift
        results << []
      else
        results.last.concat(arr.shift(arr.size))
      end
    end
    results
  end
end

def third
  self[2]
end

def to(position)
  if position >= 0
    first position + 1
  else
    self[0..position]
  end
end

def to_formatted_s(format = :default)
  case format
  when :db
    if 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}[]"
  if empty?
    nil.to_query(prefix)
  else
    collect { |value| value.to_query(prefix) }.join '&'
  end
end

def to_sentence(options = {})
  options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
  default_connectors = {
    :words_connector     => ', ',
    :two_words_connector => ' and ',
    :last_word_connector => ', and '
  }
  if defined?(I18n)
    i18n_connectors = I18n.translate(:'support.array', locale: options[:locale], default: {})
    default_connectors.merge!(i18n_connectors)
  end
  options = default_connectors.merge!(options)
  case length
  when 0
    ''
  when 1
    self[0].to_s.dup
  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