class RuboCop::Cop::Style::WordArray

def autocorrect(node)
  @interpolated = false
  contents = autocorrect_words(node.children, node.loc.line)
  char = @interpolated ? 'W' : 'w'
  lambda do |corrector|
    corrector.replace(node.loc.expression, "%#{char}(#{contents})")
  end
end

def autocorrect_words(word_nodes, base_line_number)
  previous_node_line_number = base_line_number
  word_nodes.map do |node|
    number_of_line_breaks = node.loc.line - previous_node_line_number
    line_breaks = "\n" * number_of_line_breaks
    previous_node_line_number = node.loc.line
    line_breaks + source_for(node)
  end.join(' ')
end

def character_literal?(node)
  node.loc.end.nil?
end

def comments_in_array?(node)
  comments = processed_source.comments
  array_range = node.loc.expression.to_a
  comments.any? do |comment|
    !(comment.loc.expression.to_a & array_range).empty?
  end
end

def complex_content?(arr_sexp)
  arr_sexp.each do |s|
    source = s.loc.expression.source
    next if source.start_with?('?') # %W(\r \n) can replace [?\r, ?\n]
    str_content = Util.strip_quotes(source)
    return true unless str_content =~ word_regex
  end
  false
end

def min_size
  cop_config['MinSize']
end

def on_array(node)
  array_elems = node.children
  return unless array_of?(:str, node) &&
                !complex_content?(array_elems) &&
                array_elems.size > min_size && !comments_in_array?(node)
  add_offense(node, :expression) { self.max = array_elems.size }
end

def parameter_name
  'MinSize'
end

def source_for(str_node)
  if character_literal?(str_node)
    @interpolated = true
    begin_pos = str_node.loc.expression.begin_pos + '?'.length
    end_pos = str_node.loc.expression.end_pos
  else
    begin_pos = str_node.loc.begin.end_pos
    end_pos = str_node.loc.end.begin_pos
  end
  Parser::Source::Range.new(str_node.loc.expression.source_buffer,
                            begin_pos, end_pos).source
end

def word_regex
  cop_config['WordRegex']
end