Ability to create selectors passing symbols

[lucke84]

Let's say we have a simple Mongoid model:

class Article 
  include SimpleEnum::Mongoid

  VALID_TYPES = { blog: 0, vlog: 1, xlog: 2 }

  # ...
  as_enum :type, VALID_TYPES, source: :type
end

As far as I can see (correct me if I'm wrong!), it's not possible to query using a selector that takes the symbol corresponding to a value of an enum, like this:

Article.where(type: :blog).count

while instead is possible to do this:

Article.where(type: 0).count
Article.where(type: Article::VALID_TYPES[:blog]).count # or this, don't like it though

I'm aware of the fact that it's possible to use chained selectors, like this:

Article.blogs.count

but in our codebase we often build selectors as hashes that are passed to instances of different classes.

Besides this maybe not being the best approach of all times, IMHO it'd be very beneficial to be able to consume the gem in a consistent way, always passing the symbol (key of the hash), not the value.

Do you think it's a complicated matter? Can you give me pointers to where to look at, so maybe I can submit a PR?

[Startouf]

That can actually become nasty !

User.find_or_create_by(name: "Test user", gender: :male)

... I was wondering why I had so many users in my test database :P

(as_enum: :gender)

[lwe]

Personally I really think we should not override things like e.g. where and mess with how selection works.

[Startouf]

You're right. But maybe we could define an extra convenience method that preprocesses the inputs so as to replace "meaningful enums" by their "meaningless database representation"

Something like that

def preprocess_enums_in_hash(class, hash={})
  preprocessed_hash = {}
  hash.each do |key,val|
    # The key corresponds to an enum value ? if yes convert it to {key_cd, integer_value_of(value)}
    # EX : {gender: :male} should be converted to {gender_cd: 0} because we know :gender is an enum declared in the class class
    if is_enum_of(class, key)? 
      enum_symbol = "#{key.to_s}_cd" # Also handle the case where enums are prefixed
      enum_value = integer_value_of_enum(class, enum_symbol, val)
      preprocessed_hash << {:enum_symbol => enum_value}
    else
      # Don't modify the current (key, val) of the hash
      preprocessed_hash << {key => val}
    end
  end
  preprocessed_hash
end

Then

Person.where(preprocess_enums_in_hash(Person, {age: 21, gender: :male}

Would become

Person.where(age: 21, gender_cd: 0}

[lwe]

All right if somebody can start a Pull Request I'm happy to merge, one thing I'd prefer it to be optional, so that an additional file needs to be required or something and that it registers itself as extension.

See https://github.com/lwe/simple_enum/blob/e65073193ed4a50bb1bac365b1620eb5a8123650/lib/simple_enum/attribute.rb#L85-96

Update: from an "API" perspective I'd rather have it be something like Person.expand_enums_in_hash, rather than an external utility, or not? Also a good / clear method name needs to be found 😄

[lucke84]

I vote for the Person.expand_enums_in_hash approach. The other option (preprocess_enums_in_hash(Person, {age: 21, gender: :male})) would feel unnatural to use (and hard to read).

As per the name, something like .enums_to_selector?

[Startouf]

I vote for expand_enums_in_hash (unless better choice appears)

.enums_to_selector makes it feel like we're going to use the hash for a DB query, which isn't necessarily the case ? (Haven't used SimpleEnum outside the scope of mongoid/active_record, but then it's possible)

In my mind, it was external because it reminded me of enum_option_pairs(class_name, enum), but it does make more sense to have Person.expand_enums_in_hash

[lucke84]

@Startouf as per the nature of the gem, I was imagining it used for DB queries only, otherwise a simple to_hash would be enough.

Also, in my mind, the method should also take care of dealing with lists of values and translate them into the right DB selector, e.g.:

Person.enums_to_selector(gender: :male)             # --> { gender: 0 }
Person.enums_to_selector(gender: [:male, :female])  # --> { :gender.in => [0, 1] }

Hence the name I came up with.

Does this make sense to everybody?

[lwe]

We should go with enums_to_selector, because as @lucke84 pointed out this method is only ever used in combination within a where clause.

[Startouf]

I believe ActiveRecord/Mongoid are already doing the transformations from {gender: [0, 1]} to {:gender.in => [0,1]}

[lwe]

Yes, correct, I think at the moment we should focus on the following:

{ gender: :male } # => { gender: 0 }
{ gender: [:male, :female] } # => { gender: [0, 1] }
{ foo: "bar", gender: :female } # => { foo: "bar", gender: 1 }

[Startouf]

Do we need the inverse operation ?

.enums_to_int / .int_to_enums
.expand_enums
.meaningless (enum to int) /.meaningful (int to enum)
.as_int / .as_enum (name collision ?)

[lwe]

No, I don't think we need the inversions.

[lwe]

An intriguing idea was given in #101, to basically add a method like

Klass.gender_scope(:female) # => where(gender_cd: 1)

this could be extend to allow both single arguments or hashes, with the expansion / support as described above?

Klass.gender_scope(gender: :male, foo: "bar") # => where(gender_cd: 0, foo: "bar")