enum_ext 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d99346b1ae5f9458733025608cad6e8a1ab427091ce44d10a544e880722633c
-  data.tar.gz: 6a1943ddedaa37022bdfe421dbc4c5d063c63149a96aaa0f05cdab35f423de6b
+  metadata.gz: efd427aa71da1e4f38c9ee7837d170ef9732a709dc23a80332d7d61456632350
+  data.tar.gz: 42e2acb52324970fb199cf036c5763f7c4d4c8ce5e7fdd8c7fca80dc08913807
 SHA512:
-  metadata.gz: ce540db8aca9002c6a46a5ae5eb7a45f7a296d4fd183493a8796e3b9dd007ebb04bc0793b1162b82e177de5b59ff06e8e553248a2aa4c725b17d3570d682444f
-  data.tar.gz: 7db85461bd47c03b3169259f699a29e7a1855fd791d53fb4fe84995b812739fe4968b8184665dfd04230b71e2d78152dc8868f78f89452f37d6b20ed00c77ecc
+  metadata.gz: 3c1aaf8307cba00ba948a79f2ceee1acd09dd1b310c9ee22c892c5e776d63716addcb3e2f3c505146b98c206fdc9f8134309a58b268c323e7df697f380221650
+  data.tar.gz: e7ea79641953c863d45427c3a5eca6a942089a9cfb1f796ddc54a0fd5dbb275ca598d172d03f61ded14e5a5751c6cdca44423053c3acfb1ecdf3d87db542fa68

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.9
+* supersets works fine and same way with prefixes and suffixes as usual enum does
+
+# 0.8.1
+* Fixes issue https://github.com/alekseyl/enum_ext/issues/50
+* Better describe for supersets.
+* Multiple readme and comments fixes
+
 # 0.8.0
 * Methods annotations added:
   * Full descriptions: Class.enum.describe(short=true) / Class.enum.describe_short / Class.enum.describe_long / Class.enum.describe_basic

data/Gemfile_rails_6.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    enum_ext (0.8.0)
+    enum_ext (0.9.0)
       activerecord (>= 5.2.4.3)
 
 GEM
@@ -82,6 +82,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord (< 7)
   amazing_print
   bundler (>= 1.11)
   byebug

data/README.md

@@ -7,7 +7,7 @@ EnumExt extends rails enum with localization/translation and it's helpers, mass-
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'enum_ext', '~> 0.7'
+gem 'enum_ext', '~> 0.8'
 ```
 
 And then execute:
@@ -26,12 +26,12 @@ Or install it yourself as:
       
    class SomeModel
       extend EnumExt
-    
-      enum kinds: {}, ext: [:enum_i, :enum_mass_assign, ]
-        humanize_enum #...
-        translate_enum #...
-        ext_enum_sets #...
-    end
+        
+      enum status: {}, ext: [:enum_i, :enum_mass_assign, enum_supersets: { superset: [:basic_enum] } ]
+      humanize_enum  #...
+      translate_enum #...
+      ext_enum_sets  # if needed 
+  end
 ```
  
  Let's assume that we have model Request representing some buying requests with enum **status**, and we have model Order with requests, 
@@ -56,16 +56,16 @@ This is a preferable way now, and old helpers are private starting version 0.6!:
 
 ```ruby
     #Instead of three method calls:    
-    enum kind: {}
-    enum_i :kind # will raise an private method error starting ver 0.6
-    enum_mass_assign :kind # will raise an private method error starting ver 0.6
+    enum status: {}
+    enum_i :status # will raise an private method error starting ver 0.6
+    enum_mass_assign :status # will raise an private method error starting ver 0.6!!!
 
     #You should go with ext  option instead:
-    enum kinds: {}, ext: [:enum_i, :enum_mass_assign]
+    enum status: {}, ext: [:enum_i, :enum_mass_assign]
 
     # OR in case of standalone enum definition:
-    enum kinds: {} # somewhere where you can't or don't want reach 
-    enum_ext :kinds, [:enum_i, :enum_mass_assign, enum_supersets: {} ]
+    enum status: {} # somewhere where you can't or don't want to reach 
+    enum_ext :status, [:enum_i, :enum_mass_assign, enum_supersets: {} ]
 ```
 Rem: enum_ext could be called multiple times and merge later definitions, though I can't imagine why would you split it to multiple calls. 
 
@@ -75,10 +75,10 @@ Rem: The only exceptions for the new syntax are full translation/humanization he
 
 ```ruby
 # GOOD: 
-  enum_ext :kinds, [:enum_i, :enum_mass_assign, :translate_enum, enum_supersets: {}]
+  enum_ext :status, [:enum_i, :enum_mass_assign, :translate_enum, enum_supersets: {}]
 
 # BAD (even if correctly defines internationalization): 
-  enum_ext :kinds, [:enum_i, :enum_mass_assign, :translate_enum, enum_supersets: {}] do
+  enum_ext :status, [:enum_i, :enum_mass_assign, :translate_enum, enum_supersets: {}] do
     I18n.t("scope.#{kind}")
   end
 ```
@@ -87,7 +87,7 @@ Rem: The only exceptions for the new syntax are full translation/humanization he
 
 ### Humanization (humanize_enum) 
   
-  if app doesn't need internationalization, it may use humanize_enum to make enum user friendly
+  If app doesn't need internationalization, it may use humanize_enum to make enum output user friendly
 
 ```ruby
   humanize_enum :status, {
@@ -103,14 +103,13 @@ Rem: The only exceptions for the new syntax are full translation/humanization he
 ```  
    
   This humanize_enum adds to instance:
-   - t_in_cart, t_paid, t_ready_for_shipment
+   - t_status
   
-  and to class:
-   - t_statuses - as given or generated values
-   - t_statuses_options - translated enum values options for select input
-   - t_statuses_options_i - same as above but use int values with translations works for ActiveAdmin filters for instance
+  and to enum object:
+   - statuses.t_options - translated enum values options for select input
+   - statuses.t_options_i - same as above but use int values with translations works for ActiveAdmin filters for instance
+   
 
-  
   Example with block:
 
   ```ruby
@@ -122,12 +121,12 @@ Rem: The only exceptions for the new syntax are full translation/humanization he
   Example for select:
   
   ```ruby
-    f.select :status, Request.t_statuses_options
+    f.select :status, Request.statuses.t_options
   ```
   
   in Active Admin filters
   ```ruby
-    filter :status, as: :select, label: 'Status', collection: Request.t_statuses_options_i
+    filter :status, as: :select, label: 'Status', collection: Request.statuses.t_options_i
   ```
   
   **Rem:** select options may break when using lambda() or proc with instance method, but will survive with block
@@ -138,7 +137,7 @@ Rem: The only exceptions for the new syntax are full translation/humanization he
     request.paid!
     request.status     # >> paid
     request.t_status   # >> "paid 3 dollars"
-    Request.t_statuses # >> { in_cart: -> { I18n.t("request.status.in_cart") }, ....  }
+    Request.statuses.localizations # >> { in_cart: -> { I18n.t("request.status.in_cart") }, ....  }
   ```  
 
   Could be called multiple times, all humanization definitions will be merged under the hood.  
@@ -158,6 +157,8 @@ Or it can be done with block either with translate or humanize:
    end
 ```
 
+All humanization examples also should work same way as expected.
+
 ## Enum extended functionality
 
 ### Enum to_i shortcut ( enum_i )
@@ -172,6 +173,8 @@ Defines method enum_name_i shortcut for Model.enum_names[elem.enum_name] or enum
   request.paid_i # 10
 ```
 
+Rem: whenever underlying enum is not an integer will refuse to define helper and outputs WARNING
+
 ### Enum SuperSets (enum_supersets)
  
  **Use-case** whenever you need superset of enums to behave like a super enum.
@@ -185,16 +188,16 @@ Defines method enum_name_i shortcut for Model.enum_names[elem.enum_name] or enum
 ```ruby
      enum status: [:in_cart, :waiting_for_payment, :paid, :packing, :ready_for_shipment, :on_delivery, :delivered],
           ext: [enum_supersets: {
-                  delivery_set: [:ready_for_shipment, :on_delivery], # for shipping department for example
+                  around_delivery: [:ready_for_shipment, :on_delivery], # for shipping department for example
                   in_warehouse: [:packing, :ready_for_shipment],    # this scope is just for superposition example below
-                  sold: [:paid, :delivery_set, :in_warehouse, :delivered] # also you can define any superposition of already defined supersets or enum values
+                  sold: [:paid, :around_delivery, :in_warehouse, :delivered] # also you can define any superposition of already defined supersets or enum values
                 }]
 
      # supersets will be stored inside enum wrapper object, and can be de-referenced to basic enum values 
      # using wrapper defined methods: "superset_enum_plural", i.e. statuses.sold_statuses -> [:paid, :packing, :ready_for_shipment, :on_delivery, :delivered]
      # so new supersets could be defined using Array operations against newly defined methods
      enum_ext :status, enum_supersets: {
-                    outside_warehouse: ( statuses.delivery_set_statuses - statuses.in_warehouse_statuses ) #... any other array operations like &, + and so can be used
+                    outside_warehouse: ( statuses.around_delivery - statuses.in_warehouse ) #... any other array operations like &, + and so can be used
                   }
 ```
 
@@ -202,39 +205,38 @@ it will generate:
 
 ```
 instance:
-    - methods: delivery_set?, in_warehouse?
+    - methods: around_delivery?, in_warehouse?
 
 class:
-    - named scopes: delivery_set, in_warehouse
-    - parametrized scopes: with_statuses, without_statuses ( available as a standalone extension now, and will not be included by default in a versionafter 0.5.0)
+    - named scopes: around_delivery, in_warehouse
 
 enum methods:    
     - Class.statuses.supersets -- will output superset definition hash
     - Class.statuses.supersets_raw -- will output superset decompositions to basic enum types hash 
     
-    - Class.statuses.delivery_superset (=[:ready_for_shipment, :on_delivery, :delivered] ), in_warehouse_statuses
-    - delivery_set_statuses_i (= [3,4,5]), in_warehouse_statuses_i (=[3])
+    - Class.statuses.around_delivery (=[:ready_for_shipment, :on_delivery, :delivered] ), in_warehouse_statuses
+    - around_delivery_statuses_i (= [3,4,5]), in_warehouse_statuses_i (=[3])
 
-    translation helpers ( started with t_... ):
-    - Class.statuses.t_delivery_set_options (= [['translation or humanization', :ready_for_shipment] ...] ) for select inputs purposes
-    - Class.statuses.t_delivery_set_options_i (= [['translation or humanization', 3] ...]) same as above but with integer as value ( for example to use in Active admin filters )
+    translation helpers grouped for superset ( started with t_... ):
+    - Class.statuses.t_around_delivery_options (= [['translation or humanization', :ready_for_shipment] ...] ) for select inputs purposes
+    - Class.statuses.t_around_delivery_options_i (= [['translation or humanization', 3] ...]) same as above but with integer as value ( for example to use in Active admin filters )
 ```
 
  ```ruby
     request.on_delivery!
-    request.delivery_set?                    # >> true
+    request.around_delivery?                    # >> true
     
-    Request.delivery_set.exists?(request)    # >> true
+    Request.around_delivery.exists?(request)    # >> true
     Request.in_warehouse.exists?(request)    # >> false
     
-    Request.delivery_set_statuses            # >> ["ready_for_shipment", "on_delivery", "delivered"]
+    Request.statuses.around_delivery            # >> ["ready_for_shipment", "on_delivery", "delivered"]
 ```
 Rem:
 supersets creation could be called multiple times defining a superposition of already defined sets ( considering previous example ):
 
 ```ruby
  enum_ext :status, enum_supersets: {
-   outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )#... any other array operations like &, + and so can be used
+   outside_wharehouse: ( statuses.around_delivery_superset - statuses.in_warehouse_superset )#... any other array operations like &, + and so can be used
  }
 ```
 
@@ -242,8 +244,8 @@ Rem: you can refer previously defined set as usual kind in the same method call:
     
 ```ruby
     enum_ext :status, enum_supersets: {
-        delivery_set: [:ready_for_shipment, :on_delivery, :delivered],
-        not_in_cart: [:paid, :delivery_set] #
+        around_delivery: [:ready_for_shipment, :on_delivery, :delivered],
+        not_in_cart: [:paid, :around_delivery] #
     }
 ```
 
@@ -254,7 +256,7 @@ Rem: you can refer previously defined set as usual kind in the same method call:
        ext: [:multi_enum_scopes]
 
 # some place else:
-    Request.with_statuses( :payed, :delivery_set )    # >> status IN (:payed, :ready_for_shipment, :on_delivery, :delivered) 
+    Request.with_statuses( :payed, :around_delivery )    # >> status IN (:payed, :ready_for_shipment, :on_delivery, :delivered) 
     Request.without_statuses( :payed, :in_warehouse ) # >> status NOT IN (:payed, :ready_for_shipment)
 ``` 
 
@@ -264,7 +266,7 @@ Rem: you can refer previously defined set as usual kind in the same method call:
  
  **Use-case:** it's often case when I need bulk update without callbacks, so it's gets frustrating to repeat: 
  ```
-    some_scope.update_all(status: Request.statuses[:new_status], update_at: Time.now)
+    some_scope.update_all(status: :new_status, update_at: Time.now)
  ```
  If you need callbacks you can do like this: some_scope.each(&:new_stat!) but if you don't need callbacks and you 
  have hundreds and thousands of records to change at once you better call update_all
@@ -323,15 +325,19 @@ Starting version 0.6 added support for rails 7+ enum definitions, that's making
 Now testings are done via `docker-compose up`. Look closer to Dockerfiles and `docker-compose.yml` 
 to get the idea how they working simultaneously without interference with each other. 
 
+Rem. I'm always freaking googling everytime I need to run single test so I'll just keep here:
+
+```ruby
+rake test TEST=test/test_enum_ext.rb TESTOPTS="--name=/bb/"
+```
 
 ## Development
 
 ## TODO
 [] better support for suffix/prefix as enum does
-[] describe method to observe current extension 
+[] add global config and allow global extension
 
 ## Contributing
-
 Bug reports and pull requests are welcome on GitHub at https://github.com/alekseyl/enum_ext or by email: leshchuk@gmail.com
 
 

data/lib/enum_ext/annotated.rb

@@ -2,15 +2,15 @@
 # but have no idea how to do this in a super-neat way, so it a little bit chaotic and experimental
 module EnumExt::Annotated
 
-  # call it to see what's your enum current opitons
+  # call it to see what's your enum current options are
   def describe_basic
     puts yellow( "Basic #{enum_name} definition: \n" )
     print_hash(enum_values)
   end
 
-  # call it to see all enum extensions defined.
+  # call it to see which enum extensions are defined.
   def describe_long
-    puts yellow( "\nEnumExt extensions:" )
+    puts yellow( "\n\nEnumExt extensions:" )
 
     puts [
       describe_enum_i(false),
@@ -80,10 +80,19 @@ module EnumExt::Annotated
     description = if enabled_features[:supersets].blank?
       red( "\nSupersets not used!\n" )
     else
+      superset_method = enabled_features[:supersets].keys.first
       red( "\nSupersets definitions:\n" ) << inspect_hash(enabled_features[:supersets]) << <<~SUPERSETS
+          
           # Instance methods added: #{enabled_features[:supersets].keys.join("?, ")}?
-   
-          # Class level methods added: #{enabled_features[:supersets].keys.join(", ")}
+          # Usage:
+          #{black("instance")}.#{cyan(superset_method)}?
+          # Will be equal true if any of: #{supersets_raw[superset_method].join("?, ")}? is true
+          
+          # Class level methods/scopes added: #{enabled_features[:supersets].keys.join(", ")}
+          # Usage:
+          #{black(base_class.to_s)}.#{cyan(superset_method)}
+          # Will be getting all instances with #{enum_name} equals to any of: #{supersets_raw[superset_method].join(", ")}
+
        SUPERSETS
     end
 

data/lib/enum_ext/basic_helpers.rb

@@ -1,18 +1,26 @@
 module EnumExt::BasicHelpers
 
+  private
   # Defines instance method a shortcut for getting integer value of an enum.
   # for enum named 'status' will generate:
   #
   # instance.status_i
-  private
+  #
+  # Rem. Will not define helper when enum values are strings, and will print warning
   def enum_i( enum_name )
+    return puts(<<~NOTINTEGER) if columns_hash[enum_name.to_s].type != :integer
+      ---------------------NOTINTEGER WARNING!---------------------------
+      #{enum_name} is not an integer column, so enum_i helper useless and method will not be defined
+    NOTINTEGER
+
     define_method "#{enum_name}_i" do
-      self.class.send("#{enum_name.to_s.pluralize}")[send(enum_name)].to_i
+      self.class.send(enum_name.to_s.pluralize)[send(enum_name)].to_i
     end
   end
 
   # Defines two scopes for one for an inclusion: `WHERE enum IN( enum1, enum2 )`,
   # and the second for an exclusion: `WHERE enum NOT IN( enum1, enum2 )`
+  # works fine with supersets and basic enums
   #
   # Ex:
   #  Request.with_statuses( :payed, :delivery_set )    # >> :payed and [:ready_for_shipment, :on_delivery, :delivered] requests
@@ -20,7 +28,6 @@ module EnumExt::BasicHelpers
   #  Request.without_statuses( :payed, :in_warehouse ) # >> scope all requests with statuses not eq to :payed or :ready_for_shipment
   def multi_enum_scopes(enum_name)
     enum_plural = enum_name.to_s.pluralize
-    enum_obj = send(enum_plural)
 
     self.instance_eval do
       # EnumExt.define_superset_to_enum_method(self, enum_plural)
@@ -28,12 +35,12 @@ module EnumExt::BasicHelpers
 
       # with_enums scope
       scope "with_#{enum_plural}", -> (*enum_list) {
-        enum_list.blank? ? nil : where( enum_name => enum_obj.superset_to_enum(*enum_list) )
+        enum_list.blank? ? nil : where( enum_name => send(enum_plural).superset_to_enum(*enum_list) )
       } if !respond_to?("with_#{enum_plural}") && respond_to?(:scope)
 
       # without_enums scope
       scope "without_#{enum_plural}", -> (*enum_list) {
-        enum_list.blank? ? nil : where.not( enum_name => enum_obj.superset_to_enum(*enum_list) )
+        enum_list.blank? ? nil : where.not( enum_name => send(enum_plural).superset_to_enum(*enum_list) )
       } if !respond_to?("without_#{enum_plural}") && respond_to?(:scope)
     end
   end
@@ -42,7 +49,7 @@ module EnumExt::BasicHelpers
   #
   # Used for mass assigning for collection without callbacks it creates bang methods for collections using update_all.
   # it's often case when you need bulk update without callbacks, so it's gets frustrating to repeat:
-  # some_scope.update_all(status: Request.statuses[:new_status], update_at: Time.now)
+  # some_scope.update_all(status: :new_status, update_at: Time.now)
   #
   # If you need callbacks you can do like this: some_scope.each(&:new_stat!) but if you don't need callbacks
   # and you have lots of records to change at once you need update_all
@@ -66,11 +73,11 @@ module EnumExt::BasicHelpers
 
   def mass_assign_enum( *enums_names )
     enums_names.each do |enum_name|
-      enum_vals = self.send( enum_name.to_s.pluralize )
-
-      enum_vals.keys.each do |enum_el|
-        define_singleton_method( "#{enum_el}!" ) do
-          self.update_all( {enum_name => enum_vals[enum_el]}.merge( self.column_names.include?('updated_at') ? {updated_at: Time.now} : {} ))
+      enum_plural = enum_name.to_s.pluralize
+      self.send(enum_plural).keys.each do |label|
+        method_name = self.send(enum_plural).transform_enum_label(label)
+        define_singleton_method( "#{method_name}!" ) do
+          self.update_all( {enum_name => self.send(enum_plural)[label]}.merge( self.column_names.include?('updated_at') ? {updated_at: Time.now} : {} ))
         end
       end
     end

data/lib/enum_ext/enum_wrapper.rb

@@ -5,12 +5,12 @@ class EnumExt::EnumWrapper
   include EnumExt::Annotated
 
   # supersets is storing exact definitions, if you need a raw mapping use class.statuses.superset_statuses
-  attr_reader :enum_values, :supersets, :supersets_raw, :t_options_raw, :localizations, :base_class, :enum_name
+  attr_reader :enum_values, :supersets, :supersets_raw, :t_options_raw, :localizations, :base_class, :enum_name, :suffix, :prefix
 
   delegate_missing_to :enum_values
   delegate :inspect, to: :enum_values
 
-  def initialize(enum_values, base_class, enum_name)
+  def initialize(enum_values, base_class, enum_name, **options)
     @enum_values = enum_values
     @supersets = ActiveSupport::HashWithIndifferentAccess.new
     @supersets_raw = ActiveSupport::HashWithIndifferentAccess.new
@@ -20,6 +20,8 @@ class EnumExt::EnumWrapper
 
     @base_class = base_class
     @enum_name = enum_name
+    @suffix = options[:suffix] || options[:_suffix]
+    @prefix = options[:prefix] || options[:_prefix]
   end
 
   #  ext_sets_to_kinds( :ready_for_shipment, :delivery_set ) -->
@@ -51,6 +53,18 @@ class EnumExt::EnumWrapper
 
   alias_method :t, :localizations
 
+  def transform_enum_label(label)
+    _prefix = if prefix
+      prefix == true ? "#{enum_name}_" : "#{prefix}_"
+    end
+
+    _suffix = if suffix
+      suffix == true ? "_#{enum_name}" : "_#{suffix}"
+    end
+
+    "#{_prefix}#{label}#{_suffix}"
+  end
+
   private
 
   def evaluate_localizations(t_enum_set)
@@ -75,4 +89,6 @@ class EnumExt::EnumWrapper
     end
   end
 
+
+
 end

data/lib/enum_ext/humanize_helpers.rb

@@ -34,7 +34,7 @@ module EnumExt::HumanizeHelpers
   #   f.select :status, Request.t_statuses_options
   #
   # in select in Active Admin filter
-  #   collection: Request.t_statuses_options_i
+  #   collection: Request.statuses.t_options_i
   #
   # Rem: select options breaks when using lambda() with params
   #
@@ -48,12 +48,11 @@ module EnumExt::HumanizeHelpers
     enum_name = args.shift
     localization_definitions = args.pop
     enum_plural = enum_name.to_s.pluralize
-    enum_object = send( enum_plural )
 
     self.instance_eval do
       # instance.t_enum
       define_method "t_#{enum_name}" do
-        t = block || enum_object.localizations[send(enum_name)]
+        t = block || self.class.send(enum_plural).localizations[send(enum_name)]
         if t.try(:lambda?)
           t.try(:arity) == 1 && t.call( self ) || t.try(:call)
         elsif t.is_a?(Proc)
@@ -64,7 +63,7 @@ module EnumExt::HumanizeHelpers
       end
 
       # if localization is absent than block must be given
-      enum_object.localizations.merge!(
+      send(enum_plural).localizations.merge!(
         localization_definitions.try(:with_indifferent_access) ||
           send(enum_plural).map do |k, _v|
             # little bit hackerish: instantiate object just with enum setup and then call its t_.. method which
@@ -110,9 +109,8 @@ module EnumExt::HumanizeHelpers
   #
   def self.define_superset_humanization_helpers(base_class, superset_name, enum_name)
     enum_plural = enum_name.to_s.pluralize
-    enum_object = base_class.send(enum_plural)
 
-    enum_object.define_singleton_method( "t_#{superset_name}_options" ) do
+    base_class.send(enum_plural).define_singleton_method( "t_#{superset_name}_options" ) do
       result = evaluate_localizations(send("t_#{superset_name}"))
       return result unless result.blank?
 
@@ -120,7 +118,7 @@ module EnumExt::HumanizeHelpers
     end
 
     # enums.t_options_i
-    enum_object.define_singleton_method( "t_#{superset_name}_options_i" ) do
+    base_class.send(enum_plural).define_singleton_method( "t_#{superset_name}_options_i" ) do
       result = evaluate_localizations_to_i( send("t_#{superset_name}") )
       return result unless result.to_h.values.all?(&:blank?)
 
@@ -129,10 +127,10 @@ module EnumExt::HumanizeHelpers
 
 
     # enums.t_superset ( translations or humanizations subset for a given set )
-    enum_object.define_singleton_method( "t_#{superset_name}" ) do
+    base_class.send(enum_plural).define_singleton_method( "t_#{superset_name}" ) do
       return [(["Enum translations are missing. Did you forget to translate #{enum_name}"]*2)].to_h if localizations.blank?
 
-      enum_object.localizations.slice( *enum_object.send(superset_name) )
+      base_class.send(enum_plural).localizations.slice( *base_class.send(enum_plural).send(superset_name) )
     end
   end
 end

data/lib/enum_ext/superset_helpers.rb

@@ -1,69 +1,78 @@
 module EnumExt::SupersetHelpers
   # enum_supersets
-  # This method intend for creating and using some sets of enum values,
-  # you should
+  # **Use-case** whenever you need superset of enums to behave like a super enum.
   #
-  # it creates: scopes for subsets,
-  #             instance method with ?
+  #   You can do this with method **enum_supersets** it creates:
+  #     - scopes for subsets,
+  #     - instance methods with `?`
   #
-  # For this call:
-  #   enum status: [:in_cart, :waiting_for_payment, :paid, :packing, :ready_for_shipment, :on_delivery, :delivered],
-  #      ext:[  , supersets: {
-  #                   delivery_set: [:ready_for_shipment, :on_delivery] # for shipping department for example
-  #                   in_warehouse: [:packing, :ready_for_shipment]            # this scope is just for superposition example below
-  #                   sold: [:payd, :delivery_set, :in_warehouse, :delivered]
-  #                 } ]
-  #Rem:
-  #  enum_supersets can be called twice defining a superposition of already defined supersets
-  #  based on array operations, with already defined array methods ( considering previous example ):
-  #  enum_supersets :status, {
-  #                  outside_warehouse: ( delivery_set_statuses - in_warehouse_statuses )... any other array operations like &, + and so can be used
-  #                }
+  #   For example:
+  #    enum status: [:in_cart, :waiting_for_payment, :paid, :packing, :ready_for_shipment, :on_delivery, :delivered],
+  #         ext: [enum_supersets: {
+  #                 around_delivery: [:ready_for_shipment, :on_delivery], # for shipping department for example
+  #                 in_warehouse: [:packing, :ready_for_shipment],    # this scope is just for superposition example below
+  #                 sold: [:paid, :around_delivery, :in_warehouse, :delivered] # also you can define any superposition of already defined supersets or enum values
+  #               }]
   #
-  # so the enum_supersets will generate:
-  #   instance:
-  #     methods: delivery_set?, in_warehouse?
-  #   class:
-  #     named scopes: delivery_set, in_warehouse
-  #     class helpers:
-  #       - delivery_set_statuses (=[:ready_for_shipment, :on_delivery, :delivered] ), in_warehouse_statuses
-  #       - delivery_set_statuses_i (= [3,4,5]), in_warehouse_statuses_i (=[3])
-  #     class translation helpers ( started with t_... )
-  #       for select inputs purposes:
-  #       - t_delivery_set_statuses_options (= [['translation or humanization', :ready_for_shipment] ...])
-  #       same as above but with integer as value ( for example to use in Active admin filters )
-  #       - t_delivery_set_statuses_options_i (= [['translation or humanization', 3] ...])
-
-  # Console:
-  #  request.on_delivery!
-  #  request.delivery_set?                    # >> true
-
-  #  Request.delivery_set.exists?(request)    # >> true
-  #  Request.in_warehouse.exists?(request)    # >> false
+  #    # supersets will be stored inside enum wrapper object, and can be de-referenced to basic enum values
+  #    # using wrapper defined methods: "superset_enum_plural", i.e. statuses.sold_statuses -> [:paid, :packing, :ready_for_shipment, :on_delivery, :delivered]
+  #    # so new supersets could be defined using Array operations against newly defined methods
+  #    enum_ext :status, enum_supersets: {
+  #                   outside_warehouse: ( statuses.around_delivery - statuses.in_warehouse ) #... any other array operations like &, + and so can be used
+  #                 }
+  #
+  #   it will generate:
+  #
+  # instance:
+  #   - methods: around_delivery?, in_warehouse?
+  #
+  # class:
+  #   - named scopes: around_delivery, in_warehouse
+  #
+  # enum methods:
+  #   - Class.statuses.supersets -- will output superset definition hash
+  #   - Class.statuses.supersets_raw -- will output superset decompositions to basic enum types hash
   #
-  #  Request.statuses.supersets[:delivery_set]           # >> [:ready_for_shipment, :on_delivery, :delivered]
+  #   - Class.statuses.around_delivery (=[:ready_for_shipment, :on_delivery, :delivered] ), in_warehouse_statuses
+  #   - around_delivery_statuses_i (= [3,4,5]), in_warehouse_statuses_i (=[3])
+  #
+  #   translation helpers grouped for superset ( started with t_... ):
+  #   - Class.statuses.t_around_delivery_options (= [['translation or humanization', :ready_for_shipment] ...] ) for select inputs purposes
+  #   - Class.statuses.t_around_delivery_options_i (= [['translation or humanization', 3] ...]) same as above but with integer as value ( for example to use in Active admin filters )
+  #
+  #   In console:
+  #   request.on_delivery!
+  #   request.around_delivery?                    # >> true
+  #
+  #   Request.around_delivery.exists?(request)    # >> true
+  #   Request.in_warehouse.exists?(request)    # >> false
+  #
+  #   Request.statuses.around_delivery            # >> ["ready_for_shipment", "on_delivery", "delivered"]
+
   private
   def enum_supersets( enum_name, options = {} )
     enum_plural = enum_name.to_s.pluralize
 
     self.instance_eval do
-      enum_obj = send(enum_plural)
-      enum_obj.supersets.merge!( options.transform_values{ _1.try(:map, &:to_s) || _1.to_s } )
+      suffix = send(enum_plural).suffix
+      prefix = send(enum_plural).prefix
+      send(enum_plural).supersets.merge!( options.transform_values{ _1.try(:map, &:to_s) || _1.to_s } )
 
       options.each do |superset_name, enum_vals|
-        raise "Can't define superset with name: #{superset_name}, #{enum_plural} already has such method!" if enum_obj.respond_to?(superset_name)
+        raise "Can't define superset with name: #{superset_name}, #{enum_plural} already has such method!" if send(enum_plural).respond_to?(superset_name)
 
-        enum_obj.supersets_raw[superset_name] = enum_obj.superset_to_enum(*enum_vals)
+        send(enum_plural).supersets_raw[superset_name] = send(enum_plural).superset_to_enum(*enum_vals)
 
-        # class.statuses.superset_statuses
-        enum_obj.define_singleton_method(superset_name) { enum_obj.superset_to_enum(*enum_vals) }
+        # class.enum_wrapper.superset
+        send(enum_plural).define_singleton_method(superset_name) { base_class.send(enum_plural).superset_to_enum(*enum_vals) }
 
+        superset_method_name = send(enum_plural).transform_enum_label(superset_name)
         # superset_name scope
-        scope superset_name, -> { where( enum_name => enum_obj.send(superset_name) ) } if respond_to?(:scope)
+        scope superset_method_name, -> { where( enum_name => send(enum_plural).send(superset_name) ) } if respond_to?(:scope)
 
         # instance.superset_name?
-        define_method "#{superset_name}?" do
-          send(enum_name) && enum_obj.send(superset_name).include?( send(enum_name) )
+        define_method "#{superset_method_name}?" do
+          send(enum_name) && self.class.send(enum_plural).send(superset_name).include?( send(enum_name) )
         end
 
         EnumExt::HumanizeHelpers.define_superset_humanization_helpers( self, superset_name, enum_name )

data/lib/enum_ext/version.rb

@@ -1,3 +1,3 @@
 module EnumExt
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/enum_ext.rb

@@ -49,33 +49,38 @@ module EnumExt
   def enum(name = nil, values = nil, **options)
     single_enum_definition = name.present?
     extensions = options.delete(:ext)
+    options_dup = options.dup
 
     (ActiveRecord::VERSION::MAJOR >= 7 ? super : super(options)).tap do |multiple_enum_definitions|
       if single_enum_definition
-        enum_ext(name, extensions)
+        replace_enum_with_wrapper(name, options_dup)
+        enum_ext(name, [*extensions])
       else
-        multiple_enum_definitions.each { |enum_name,| enum_ext(enum_name, extensions) }
+        multiple_enum_definitions.each { |enum_name,|
+          replace_enum_with_wrapper(enum_name, options_dup)
+          enum_ext(enum_name, [*extensions])
+        }
       end
     end
   end
 
   # its an extension helper, on the opposite to basic enum method could be called multiple times
   def enum_ext(enum_name, extensions)
-    replace_enum_with_wrapper(enum_name)
-      # [:enum_i, :enum_multi_scopes, enum_supersets: { valid: [:fresh, :cool], invalid: [:stale] }]
+    # [:enum_i, :enum_multi_scopes, enum_supersets: { valid: [:fresh, :cool], invalid: [:stale] }]
     #   --> [:enum_i, :enum_multi_scopes, [:enum_supersets, { valid: [:fresh, :cool], invalid: [:stale] }]
     [*extensions].map { _1.try(:to_a)&.flatten || _1 }
                  .each { |(ext_method, params)| send(*[ext_method, enum_name, params].compact) }
   end
 
   private
-  def replace_enum_with_wrapper(enum_name)
+
+  def replace_enum_with_wrapper(enum_name, options_dup)
     enum_name_plural = enum_name.to_s.pluralize
     return if send(enum_name_plural).is_a?(EnumWrapper)
 
     # enum will freeze values so there is no other way to move extended functionality,
     # than to use wrapper and delegate everything to enum_values
-    enum_wrapper = EnumWrapper.new(send(enum_name_plural), self, enum_name)
+    enum_wrapper = EnumWrapper.new(send(enum_name_plural), self, enum_name, **options_dup)
     # "self" here is a base enum class, so we are replacing original enum definition, with a wrapper
     define_singleton_method(enum_name_plural) { enum_wrapper }
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ext
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-02 00:00:00.000000000 Z
+date: 2023-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord