2017-07-09 13:41:28 -04:00
|
|
|
# frozen_string_literal: true
|
|
|
|
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
require "active_support/core_ext/hash/slice"
|
2016-08-06 12:24:04 -04:00
|
|
|
require "active_support/core_ext/object/deep_dup"
|
2014-04-07 21:52:21 -04:00
|
|
|
|
2013-11-02 15:01:31 -04:00
|
|
|
module ActiveRecord
|
2013-12-30 11:47:11 -05:00
|
|
|
# Declare an enum attribute where the values map to integers in the database,
|
|
|
|
# but can be queried by name. Example:
|
2013-11-02 15:01:31 -04:00
|
|
|
#
|
|
|
|
# class Conversation < ActiveRecord::Base
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# enum :status, [ :active, :archived ]
|
2013-11-02 15:01:31 -04:00
|
|
|
# end
|
|
|
|
#
|
|
|
|
# # conversation.update! status: 0
|
|
|
|
# conversation.active!
|
|
|
|
# conversation.active? # => true
|
2013-11-06 04:49:22 -05:00
|
|
|
# conversation.status # => "active"
|
2013-11-02 16:08:36 -04:00
|
|
|
#
|
2013-11-02 15:01:31 -04:00
|
|
|
# # conversation.update! status: 1
|
|
|
|
# conversation.archived!
|
|
|
|
# conversation.archived? # => true
|
2013-11-06 04:49:22 -05:00
|
|
|
# conversation.status # => "archived"
|
2013-11-02 16:08:36 -04:00
|
|
|
#
|
2015-08-25 04:38:38 -04:00
|
|
|
# # conversation.status = 1
|
2013-11-06 04:49:22 -05:00
|
|
|
# conversation.status = "archived"
|
2013-11-02 15:01:31 -04:00
|
|
|
#
|
2013-12-20 07:12:59 -05:00
|
|
|
# conversation.status = nil
|
|
|
|
# conversation.status.nil? # => true
|
|
|
|
# conversation.status # => nil
|
|
|
|
#
|
2013-12-30 11:47:11 -05:00
|
|
|
# Scopes based on the allowed values of the enum field will be provided
|
2014-05-09 16:46:22 -04:00
|
|
|
# as well. With the above example:
|
|
|
|
#
|
|
|
|
# Conversation.active
|
2019-02-26 15:47:27 -05:00
|
|
|
# Conversation.not_active
|
2014-05-09 16:46:22 -04:00
|
|
|
# Conversation.archived
|
2019-02-26 15:47:27 -05:00
|
|
|
# Conversation.not_archived
|
2013-12-30 11:47:11 -05:00
|
|
|
#
|
2015-04-23 06:39:48 -04:00
|
|
|
# Of course, you can also query them directly if the scopes don't fit your
|
2015-02-13 19:18:22 -05:00
|
|
|
# needs:
|
|
|
|
#
|
|
|
|
# Conversation.where(status: [:active, :archived])
|
2015-02-14 03:04:16 -05:00
|
|
|
# Conversation.where.not(status: :active)
|
2015-02-13 19:18:22 -05:00
|
|
|
#
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# Defining scopes can be disabled by setting +:scopes+ to +false+.
|
2019-10-01 16:21:34 -04:00
|
|
|
#
|
|
|
|
# class Conversation < ActiveRecord::Base
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# enum :status, [ :active, :archived ], scopes: false
|
2019-10-01 16:21:34 -04:00
|
|
|
# end
|
|
|
|
#
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# You can set the default enum value by setting +:default+, like:
|
2013-11-02 15:01:31 -04:00
|
|
|
#
|
2020-07-21 12:27:39 -04:00
|
|
|
# class Conversation < ActiveRecord::Base
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# enum :status, [ :active, :archived ], default: :active
|
2013-11-02 15:01:31 -04:00
|
|
|
# end
|
2013-11-02 16:08:36 -04:00
|
|
|
#
|
2020-07-21 12:27:39 -04:00
|
|
|
# conversation = Conversation.new
|
|
|
|
# conversation.status # => "active"
|
2013-11-02 21:32:08 -04:00
|
|
|
#
|
2013-12-05 03:41:09 -05:00
|
|
|
# Finally, it's also possible to explicitly map the relation between attribute and
|
2015-07-08 06:16:16 -04:00
|
|
|
# database integer with a hash:
|
2013-11-02 21:32:08 -04:00
|
|
|
#
|
|
|
|
# class Conversation < ActiveRecord::Base
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# enum :status, active: 0, archived: 1
|
2013-11-02 21:32:08 -04:00
|
|
|
# end
|
2013-11-06 09:25:04 -05:00
|
|
|
#
|
2015-07-08 06:16:16 -04:00
|
|
|
# Note that when an array is used, the implicit mapping from the values to database
|
2013-12-05 03:41:09 -05:00
|
|
|
# integers is derived from the order the values appear in the array. In the example,
|
2013-12-06 14:21:12 -05:00
|
|
|
# <tt>:active</tt> is mapped to +0+ as it's the first element, and <tt>:archived</tt>
|
2013-12-05 03:41:09 -05:00
|
|
|
# is mapped to +1+. In general, the +i+-th element is mapped to <tt>i-1</tt> in the
|
|
|
|
# database.
|
|
|
|
#
|
|
|
|
# Therefore, once a value is added to the enum array, its position in the array must
|
|
|
|
# be maintained, and new values should only be added to the end of the array. To
|
2015-07-08 06:16:16 -04:00
|
|
|
# remove unused values, the explicit hash syntax should be used.
|
2013-12-05 03:41:09 -05:00
|
|
|
#
|
2013-11-06 09:25:04 -05:00
|
|
|
# In rare circumstances you might need to access the mapping directly.
|
2014-01-14 18:41:44 -05:00
|
|
|
# The mappings are exposed through a class method with the pluralized attribute
|
2015-02-13 19:22:20 -05:00
|
|
|
# name, which return the mapping in a +HashWithIndifferentAccess+:
|
2013-11-06 09:25:04 -05:00
|
|
|
#
|
2015-02-13 19:22:20 -05:00
|
|
|
# Conversation.statuses[:active] # => 0
|
|
|
|
# Conversation.statuses["archived"] # => 1
|
2013-11-06 09:25:04 -05:00
|
|
|
#
|
2015-02-14 03:04:16 -05:00
|
|
|
# Use that class method when you need to know the ordinal value of an enum.
|
|
|
|
# For example, you can use that when manually building SQL strings:
|
2015-02-13 19:50:08 -05:00
|
|
|
#
|
|
|
|
# Conversation.where("status <> ?", Conversation.statuses[:archived])
|
|
|
|
#
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# You can use the +:prefix+ or +:suffix+ options when you need to define
|
2015-07-23 08:27:09 -04:00
|
|
|
# multiple enums with same values. If the passed value is +true+, the methods
|
2015-07-23 13:21:19 -04:00
|
|
|
# are prefixed/suffixed with the name of the enum. It is also possible to
|
|
|
|
# supply a custom value:
|
2015-04-19 05:25:09 -04:00
|
|
|
#
|
2015-07-23 13:21:19 -04:00
|
|
|
# class Conversation < ActiveRecord::Base
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
# enum :status, [ :active, :archived ], suffix: true
|
|
|
|
# enum :comments_status, [ :active, :inactive ], prefix: :comments
|
2015-04-19 05:25:09 -04:00
|
|
|
# end
|
|
|
|
#
|
2015-07-23 13:21:19 -04:00
|
|
|
# With the above example, the bang and predicate methods along with the
|
|
|
|
# associated scopes are now prefixed and/or suffixed accordingly:
|
2015-04-19 05:25:09 -04:00
|
|
|
#
|
2015-07-23 13:21:19 -04:00
|
|
|
# conversation.active_status!
|
|
|
|
# conversation.archived_status? # => false
|
2015-04-19 05:25:09 -04:00
|
|
|
#
|
2015-07-23 13:21:19 -04:00
|
|
|
# conversation.comments_inactive!
|
|
|
|
# conversation.comments_active? # => false
|
2013-11-02 15:01:31 -04:00
|
|
|
module Enum
|
2014-07-16 13:44:41 -04:00
|
|
|
def self.extended(base) # :nodoc:
|
2017-05-29 12:01:50 -04:00
|
|
|
base.class_attribute(:defined_enums, instance_writer: false, default: {})
|
2014-04-07 10:01:03 -04:00
|
|
|
end
|
2014-01-20 18:59:20 -05:00
|
|
|
|
2014-07-16 13:44:41 -04:00
|
|
|
def inherited(base) # :nodoc:
|
2014-04-07 21:52:21 -04:00
|
|
|
base.defined_enums = defined_enums.deep_dup
|
|
|
|
super
|
2014-01-20 18:59:20 -05:00
|
|
|
end
|
|
|
|
|
2015-11-07 12:58:44 -05:00
|
|
|
class EnumType < Type::Value # :nodoc:
|
2016-06-24 04:43:25 -04:00
|
|
|
delegate :type, to: :subtype
|
|
|
|
|
2016-01-23 10:42:40 -05:00
|
|
|
def initialize(name, mapping, subtype)
|
2015-02-11 16:56:26 -05:00
|
|
|
@name = name
|
|
|
|
@mapping = mapping
|
2016-01-23 10:42:40 -05:00
|
|
|
@subtype = subtype
|
2015-02-11 16:56:26 -05:00
|
|
|
end
|
|
|
|
|
2015-02-17 15:39:42 -05:00
|
|
|
def cast(value)
|
2015-02-11 16:56:26 -05:00
|
|
|
if mapping.has_key?(value)
|
|
|
|
value.to_s
|
|
|
|
elsif mapping.has_value?(value)
|
|
|
|
mapping.key(value)
|
2019-12-24 02:11:07 -05:00
|
|
|
elsif value.blank?
|
|
|
|
nil
|
2015-02-11 16:56:26 -05:00
|
|
|
else
|
2015-09-24 13:50:11 -04:00
|
|
|
assert_valid_value(value)
|
2015-02-11 16:56:26 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-02-17 13:29:51 -05:00
|
|
|
def deserialize(value)
|
2016-01-23 10:42:40 -05:00
|
|
|
mapping.key(subtype.deserialize(value))
|
2015-02-11 16:56:26 -05:00
|
|
|
end
|
|
|
|
|
2020-01-14 16:14:39 -05:00
|
|
|
def serializable?(value)
|
|
|
|
(value.blank? || mapping.has_key?(value) || mapping.has_value?(value)) && super
|
|
|
|
end
|
|
|
|
|
2015-02-17 15:35:23 -05:00
|
|
|
def serialize(value)
|
2015-02-11 16:56:26 -05:00
|
|
|
mapping.fetch(value, value)
|
|
|
|
end
|
|
|
|
|
2015-09-24 13:50:11 -04:00
|
|
|
def assert_valid_value(value)
|
2020-01-14 16:14:39 -05:00
|
|
|
unless serializable?(value)
|
2015-09-24 13:50:11 -04:00
|
|
|
raise ArgumentError, "'#{value}' is not a valid #{name}"
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-01-16 19:12:25 -05:00
|
|
|
attr_reader :subtype
|
|
|
|
|
2018-02-16 20:14:27 -05:00
|
|
|
private
|
2021-01-16 19:12:25 -05:00
|
|
|
attr_reader :name, :mapping
|
2015-02-11 16:56:26 -05:00
|
|
|
end
|
|
|
|
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
def enum(name = nil, values = nil, **options)
|
|
|
|
if name
|
|
|
|
values, options = options, {} unless values
|
|
|
|
return _enum(name, values, **options)
|
|
|
|
end
|
2020-07-10 08:19:17 -04:00
|
|
|
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default)
|
|
|
|
options.transform_keys! { |key| :"#{key[1..-1]}" }
|
2020-07-10 08:19:17 -04:00
|
|
|
|
Allow new syntax for `enum` to avoid leading `_` from reserved options
Unlike other features built on Attribute API, reserved options for
`enum` has leading `_`.
* `_prefix`/`_suffix`: #19813, #20999
* `_scopes`: #34605
* `_default`: #39820
That is due to `enum` takes one hash argument only, which contains both
enum definitions and reserved options.
I propose new syntax for `enum` to avoid leading `_` from reserved
options, by allowing `enum(attr_name, ..., **options)` more Attribute
API like syntax.
Before:
```ruby
class Book < ActiveRecord::Base
enum status: [ :proposed, :written ], _prefix: true, _scopes: false
enum cover: [ :hard, :soft ], _suffix: true, _default: :hard
end
```
After:
```ruby
class Book < ActiveRecord::Base
enum :status, [ :proposed, :written ], prefix: true, scopes: false
enum :cover, [ :hard, :soft ], suffix: true, default: :hard
end
```
2021-02-04 00:13:16 -05:00
|
|
|
definitions.each { |name, values| _enum(name, values, **options) }
|
2021-02-02 06:49:27 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
def _enum(name, values, prefix: nil, suffix: nil, scopes: true, **options)
|
2018-10-06 12:08:45 -04:00
|
|
|
assert_valid_enum_definition_values(values)
|
2014-01-14 06:58:22 -05:00
|
|
|
# statuses = { }
|
|
|
|
enum_values = ActiveSupport::HashWithIndifferentAccess.new
|
2017-05-03 05:35:45 -04:00
|
|
|
name = name.to_s
|
2013-11-02 15:01:31 -04:00
|
|
|
|
2016-03-05 22:15:12 -05:00
|
|
|
# def self.statuses() statuses end
|
2017-05-03 05:35:45 -04:00
|
|
|
detect_enum_conflict!(name, name.pluralize, true)
|
2018-12-20 11:39:18 -05:00
|
|
|
singleton_class.define_method(name.pluralize) { enum_values }
|
2017-05-03 05:35:45 -04:00
|
|
|
defined_enums[name] = enum_values
|
2014-01-14 06:58:22 -05:00
|
|
|
|
2015-02-11 16:56:26 -05:00
|
|
|
detect_enum_conflict!(name, name)
|
|
|
|
detect_enum_conflict!(name, "#{name}=")
|
|
|
|
|
2021-02-08 06:47:19 -05:00
|
|
|
attribute(name, **options) do |subtype|
|
2021-01-16 19:12:25 -05:00
|
|
|
subtype = subtype.subtype if EnumType === subtype
|
2021-02-08 06:47:19 -05:00
|
|
|
EnumType.new(name, enum_values, subtype)
|
2016-01-23 10:42:40 -05:00
|
|
|
end
|
2014-01-11 06:57:09 -05:00
|
|
|
|
2021-01-01 00:34:06 -05:00
|
|
|
value_method_names = []
|
2015-02-11 16:56:26 -05:00
|
|
|
_enum_methods_module.module_eval do
|
2021-02-02 06:49:27 -05:00
|
|
|
prefix = if prefix
|
|
|
|
prefix == true ? "#{name}_" : "#{prefix}_"
|
2021-01-19 00:51:39 -05:00
|
|
|
end
|
|
|
|
|
2021-02-02 06:49:27 -05:00
|
|
|
suffix = if suffix
|
|
|
|
suffix == true ? "_#{name}" : "_#{suffix}"
|
2021-01-19 00:51:39 -05:00
|
|
|
end
|
2021-01-01 00:34:06 -05:00
|
|
|
|
2013-11-04 13:36:22 -05:00
|
|
|
pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
|
2017-05-03 05:35:45 -04:00
|
|
|
pairs.each do |label, value|
|
2021-01-01 00:34:06 -05:00
|
|
|
enum_values[label] = value
|
2021-01-29 18:01:56 -05:00
|
|
|
label = label.to_s
|
2015-04-19 05:25:09 -04:00
|
|
|
|
2021-01-01 00:34:06 -05:00
|
|
|
value_method_name = "#{prefix}#{label}#{suffix}"
|
2020-11-24 12:38:49 -05:00
|
|
|
value_method_names << value_method_name
|
2021-02-02 06:49:27 -05:00
|
|
|
define_enum_methods(name, value_method_name, value, scopes)
|
2021-01-01 00:34:06 -05:00
|
|
|
|
|
|
|
method_friendly_label = label.gsub(/[\W&&[:ascii:]]+/, "_")
|
|
|
|
value_method_alias = "#{prefix}#{method_friendly_label}#{suffix}"
|
2013-11-02 15:01:31 -04:00
|
|
|
|
2021-01-01 00:34:06 -05:00
|
|
|
if value_method_alias != value_method_name && !value_method_names.include?(value_method_alias)
|
|
|
|
value_method_names << value_method_alias
|
2021-02-02 06:49:27 -05:00
|
|
|
define_enum_methods(name, value_method_alias, value, scopes)
|
2021-01-01 00:34:06 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2021-02-02 06:49:27 -05:00
|
|
|
detect_negative_enum_conditions!(value_method_names) if scopes
|
2021-01-01 00:34:06 -05:00
|
|
|
enum_values.freeze
|
|
|
|
end
|
|
|
|
|
|
|
|
class EnumMethods < Module # :nodoc:
|
|
|
|
def initialize(klass)
|
|
|
|
@klass = klass
|
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
attr_reader :klass
|
|
|
|
|
2021-02-02 06:49:27 -05:00
|
|
|
def define_enum_methods(name, value_method_name, value, scopes)
|
2021-02-01 05:32:04 -05:00
|
|
|
# def active?() status_for_database == 0 end
|
2015-04-19 05:25:09 -04:00
|
|
|
klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
|
2021-02-01 05:32:04 -05:00
|
|
|
define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
|
2013-11-02 15:01:31 -04:00
|
|
|
|
2017-05-03 05:35:45 -04:00
|
|
|
# def active!() update!(status: 0) end
|
2015-04-19 05:25:09 -04:00
|
|
|
klass.send(:detect_enum_conflict!, name, "#{value_method_name}!")
|
2021-02-01 05:32:04 -05:00
|
|
|
define_method("#{value_method_name}!") { update!(name => value) }
|
2014-01-27 04:39:52 -05:00
|
|
|
|
2017-05-03 05:35:45 -04:00
|
|
|
# scope :active, -> { where(status: 0) }
|
2019-02-26 15:47:27 -05:00
|
|
|
# scope :not_active, -> { where.not(status: 0) }
|
2021-02-02 06:49:27 -05:00
|
|
|
if scopes
|
2018-12-03 04:52:59 -05:00
|
|
|
klass.send(:detect_enum_conflict!, name, value_method_name, true)
|
2021-02-01 05:32:04 -05:00
|
|
|
klass.scope value_method_name, -> { where(name => value) }
|
2019-02-26 15:47:27 -05:00
|
|
|
|
|
|
|
klass.send(:detect_enum_conflict!, name, "not_#{value_method_name}", true)
|
2021-02-01 05:32:04 -05:00
|
|
|
klass.scope "not_#{value_method_name}", -> { where.not(name => value) }
|
2018-12-03 04:52:59 -05:00
|
|
|
end
|
2013-11-04 13:36:22 -05:00
|
|
|
end
|
2013-11-02 15:01:31 -04:00
|
|
|
end
|
2021-01-01 00:34:06 -05:00
|
|
|
private_constant :EnumMethods
|
2013-11-04 13:36:22 -05:00
|
|
|
|
2013-12-05 21:12:42 -05:00
|
|
|
def _enum_methods_module
|
|
|
|
@_enum_methods_module ||= begin
|
2021-01-01 00:34:06 -05:00
|
|
|
mod = EnumMethods.new(self)
|
2013-12-05 21:12:42 -05:00
|
|
|
include mod
|
|
|
|
mod
|
|
|
|
end
|
2013-11-04 13:36:22 -05:00
|
|
|
end
|
2014-01-27 04:39:52 -05:00
|
|
|
|
2018-10-06 12:08:45 -04:00
|
|
|
def assert_valid_enum_definition_values(values)
|
2021-02-06 23:08:19 -05:00
|
|
|
unless values.is_a?(Hash) || values.all?(Symbol) || values.all?(String)
|
2018-10-06 12:08:45 -04:00
|
|
|
error_message = <<~MSG
|
|
|
|
Enum values #{values} must be either a hash, an array of symbols, or an array of strings.
|
|
|
|
MSG
|
|
|
|
raise ArgumentError, error_message
|
|
|
|
end
|
2018-11-07 17:38:41 -05:00
|
|
|
|
|
|
|
if values.is_a?(Hash) && values.keys.any?(&:blank?) || values.is_a?(Array) && values.any?(&:blank?)
|
|
|
|
raise ArgumentError, "Enum label name must not be blank."
|
|
|
|
end
|
2018-10-06 12:08:45 -04:00
|
|
|
end
|
|
|
|
|
2014-01-27 04:39:52 -05:00
|
|
|
ENUM_CONFLICT_MESSAGE = \
|
|
|
|
"You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
|
|
|
|
"this will generate a %{type} method \"%{method}\", which is already defined " \
|
|
|
|
"by %{source}."
|
2018-10-06 12:15:14 -04:00
|
|
|
private_constant :ENUM_CONFLICT_MESSAGE
|
2014-01-27 04:39:52 -05:00
|
|
|
|
|
|
|
def detect_enum_conflict!(enum_name, method_name, klass_method = false)
|
|
|
|
if klass_method && dangerous_class_method?(method_name)
|
2016-08-06 12:24:04 -04:00
|
|
|
raise_conflict_error(enum_name, method_name, type: "class")
|
2017-11-18 14:22:00 -05:00
|
|
|
elsif klass_method && method_defined_within?(method_name, Relation)
|
|
|
|
raise_conflict_error(enum_name, method_name, type: "class", source: Relation.name)
|
2014-01-27 04:39:52 -05:00
|
|
|
elsif !klass_method && dangerous_attribute_method?(method_name)
|
2015-09-18 11:46:11 -04:00
|
|
|
raise_conflict_error(enum_name, method_name)
|
2014-01-27 04:39:52 -05:00
|
|
|
elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
|
2016-08-06 12:24:04 -04:00
|
|
|
raise_conflict_error(enum_name, method_name, source: "another enum")
|
2014-01-27 04:39:52 -05:00
|
|
|
end
|
|
|
|
end
|
2015-09-18 11:46:11 -04:00
|
|
|
|
2016-08-06 12:24:04 -04:00
|
|
|
def raise_conflict_error(enum_name, method_name, type: "instance", source: "Active Record")
|
2015-09-18 11:46:11 -04:00
|
|
|
raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
|
|
|
|
enum: enum_name,
|
2016-08-07 19:05:28 -04:00
|
|
|
klass: name,
|
2015-09-18 11:46:11 -04:00
|
|
|
type: type,
|
|
|
|
method: method_name,
|
|
|
|
source: source
|
|
|
|
}
|
|
|
|
end
|
2019-06-02 17:01:01 -04:00
|
|
|
|
2020-11-24 12:38:49 -05:00
|
|
|
def detect_negative_enum_conditions!(method_names)
|
|
|
|
return unless logger
|
|
|
|
|
|
|
|
method_names.select { |m| m.start_with?("not_") }.each do |potential_not|
|
|
|
|
inverted_form = potential_not.sub("not_", "")
|
|
|
|
if method_names.include?(inverted_form)
|
|
|
|
logger.warn "Enum element '#{potential_not}' in #{self.name} uses the prefix 'not_'." \
|
|
|
|
" This has caused a conflict with auto generated negative scopes." \
|
|
|
|
" Avoid using enum elements starting with 'not' where the positive form is also an element."
|
|
|
|
end
|
2019-06-02 17:01:01 -04:00
|
|
|
end
|
|
|
|
end
|
2013-11-02 15:01:31 -04:00
|
|
|
end
|
|
|
|
end
|