     # If the attribute test is true, perform the query
     if test
       if q.parsedQuery #nested queries
-        test = single([q], getter, isScore)(model)
+        test = single([q], getter)(model)
       else test = performQuery q.type, q.value, attr, model, getter
     if test
       passes++
-      if isScore
-        boost = q.boost ? 1
-        score += (scoreInc * boost)
+
     switch type
       when "$and"
         # Early false return for $and queries when any test fails
-        return false unless isScore or test
+        return false unless test
       when "$not"
         # Early false return for $not queries when any test passes
         return false if test

# This function should accept an obj like this:
# $and: [queries], $or: [queries]
# should return false if fails
single = (queries, getter, isScore) ->
  getter = parseGetter(getter) if getter

  if isScore
    throw new Error("score operations currently don't work on compound queries") unless queries.length is 1
    queryObj = queries[0]
    throw new Error("score operations only work on $and queries (not #{queryObj.type}") unless queryObj.type is "$and"
    (model) ->
      model._score = performQuerySingle(queryObj.type, queryObj.parsedQuery, getter, model, true)
      model
  else
    (model) ->
      for queryObj in queries
        # Early false return if any of the queries fail
        return false unless performQuerySingle(queryObj.type, queryObj.parsedQuery, getter, model, isScore)
      # All queries passes, so return true
      true

performQuerySingle = (type, query, getter, model, isScore) ->
  passes = 0
  score = 0
  scoreInc = 1 / query.length

parseGetter = (getter) ->
  return if typeof getter is 'string' then (obj, key) -> obj[getter](key) else getter

runQuery = (items, query, getter, first) ->
  if arguments.length < 2
    # If no arguments or only the items are provided, then use the buildQuery interface
    return buildQuery.apply this, arguments
  if getter then getter = parseGetter(getter)
  query = single(parseQuery(query), getter) unless (utils.getType(query) is "Function")

  if first
    fn = utils.find
