Duplicated scope / default scope not consistent or unexpected

[braindeaf]

Just found something this morning that is just really strange.

I have been working a project refactoring the default scope of some of our models. In some cases you need to unscope and reapply scopes. Just the nature of the beast. However I discovered that if you have a model that has a subclass the default_scope is applied twice.

class Cat
  include Mongoid::Document

  field :name
  field :lazy, type: Mongoid::Boolean

  default_scope -> { where(lazy: true) }
end
# irb(main):001:0> Cat.all
# => #<Mongoid::Criteria
#   selector: {"lazy"=>true}
#   options:  {}
#   class:    Cat
#   embedded: false>

So all is well in our Cat

class Sphynx < Cat
end
# irb(main):002:0> Sphynx.all
# => #<Mongoid::Criteria
#   selector: {"lazy"=>true, "$and"=>[{"lazy"=>true}]}
#   options:  {}
#   class:    Sphynx
#   embedded: false>

But our Sphynx has duplicated selectors, there is no point to re-apply the default scope here if it is a duplicate. This might not seem problematic unless you're in my situation where I want to play with unscoping and rescoping. But...

This indicates that the duplication of scopes is a little peculiar, what we are seeing is basically the same as this

irb(main):004:0> Cat.where(lazy: true).selector
=> {"lazy"=>true, "$and"=>[{"lazy"=>true}]}

But it doesn't duplicate here

irb(main):005:0> Cat.where(lazy: true).where(lazy: true).where(lazy: true).selector
=> {"lazy"=>true, "$and"=>[{"lazy"=>true}]}

But it does replace it here.

irb(main):006:0> Cat.where(lazy: true).where(lazy: true).where(lazy: false).selector
=> {"lazy"=>true, "$and"=>[{"lazy"=>false}]}

which is where this becomes problematic. It's just not consistent. The default scopes in my mind should be smart enough to de-dupe. I appreciate that a default_scope in a subclass might stack with the parent class too.

irb(main):012:0> Donskoy.all.selector
=> {"lazy"=>true, "$and"=>[{"lazy"=>true}], "whiskers"=>true}

In ActiveRecord successive where scopes append (with AND) to the original scope similar above. But ActiveRecord doesn't duplicate default_scope in the first place which I think where my personal issue is coming from. So it wouldn't then replace the $and clause contents with the most recent options, but even if it did why doesn't it replace the $and Array and not the 'lazy' key?

I can demonstrate in specs in this project

https://github.com/braindeaf/mongoid-where-oddity

Also opened a JIRA ticket

https://jira.mongodb.org/browse/MONGOID-5204

Many thanks

RobL

[braindeaf]

Trying to work around this pain point. I am finding it nigh on impossible to unscope the subclass in way that allows me to change a default_scope defined in the parent because of this issue. Real-world example. The parent class defines a scope

default_scope -> { where(tenant_id: Tenant.current.id) }
default_scope -> { where(:state.ne => 'template') }

which is resolved on the subclass first, then it's parent resulting in

selector: {"tenant_id"=>BSON::ObjectId('61ba02a17d391b626b428931'), "state"=>{"$ne"=>"template"}, "$and"=>[{"tenant_id"=>BSON::ObjectId('61ba02a17d391b626b428931')}, "state"=>{"$ne"=>"template"}]}

Which you then can't unscope :(

However, I have found that in storable.rb the if a duplicate key is found in a selector $and is always added. I don't see the value in adding duplicates. So the best way to avoid this issue is to never add an $and if the value is already set.

def add_field_expression(field, value)
  unless field.is_a?(String)
    raise ArgumentError, "Field must be a string: #{field}"
  end

  if field[0] == ?$
    raise ArgumentError, "Field cannot be an operator (i.e. begin with $): #{field}"
  end

  if selector[field]
    # We already have a restriction by the field we are trying
    # to restrict, combine the restrictions.
    if value.is_a?(Hash) && selector[field].is_a?(Hash) &&
      value.keys.all? { |key|
        key_s = key.to_s
        key_s[0] == ?$ && !selector[field].key?(key_s)
      }

      # Multiple operators can be combined on the same field by
      # adding them to the existing hash.
      new_value = selector[field].merge(value)
      selector.store(field, new_value)
    else
      value = value.clone.to_s if value.is_a?(Symbol) # However,.....
      return if selector[field] == value                   # This stops the behaviour.

      add_operator_expression('$and', [{field => value}])
    end
  else
    selector.store(field, value)
  end

  self
end