class RuboCop::Cop::Performance::Count

Model.select(:value).count
Model.select(‘field AS field_one’).count
[1, 2, 3].count { |e| e < 2 && e.even? }
[1, 2, 3].count { |e| e > 2 && e.odd? }
[1, 2, 3].count { |e| e < 2 }
[1, 2, 3].count { |e| e > 2 }
# good
array.select(&:value).count
[1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
[1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
[1, 2, 3].reject { |e| e > 2 }.length
[1, 2, 3].select { |e| e > 2 }.length
[1, 2, 3].reject { |e| e > 2 }.size
[1, 2, 3].select { |e| e > 2 }.size
# bad
@example
`Enumerable` and change them to ‘size`.
This cop is used to identify usages of `count` on an

def autocorrect(node)

def autocorrect(node)
  selector, selector_loc = parse(node)
  return if selector == :reject
  range = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                    node.loc.dot.begin_pos,
                                    node.loc.expression.end_pos)
  lambda do |corrector|
    corrector.remove(range)
    corrector.replace(selector_loc, 'count')
  end
end

def contains_selector?(node)

def contains_selector?(node)
  node.respond_to?(:loc) && node.loc.respond_to?(:selector)
end

def on_send(node)

def on_send(node)
  selector, selector_loc, params, counter = parse(node)
  return unless COUNTERS.include?(counter)
  return unless SELECTORS.include?(selector)
  return if params && !params.block_pass_type?
  return if node.parent && node.parent.block_type?
  range = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                    selector_loc.begin_pos,
                                    node.loc.expression.end_pos)
  add_offense(node, range, format(MSG, selector, counter))
end

def parse(node)

def parse(node)
  left, counter = *node
  expression, selector, params = *left
  selector_loc =
    if selector.is_a?(Symbol)
      if expression && expression.parent.loc.respond_to?(:selector)
        expression.parent.loc.selector
      else
        left.loc.selector if left.loc.respond_to?(:selector)
      end
    else
      _enumerable, selector, params = *expression
      expression.loc.selector if contains_selector?(expression)
    end
  [selector, selector_loc, params, counter]
end