enum_ext 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d99346b1ae5f9458733025608cad6e8a1ab427091ce44d10a544e880722633c
-  data.tar.gz: 6a1943ddedaa37022bdfe421dbc4c5d063c63149a96aaa0f05cdab35f423de6b
+  metadata.gz: 2c17ae56d510836b3106e8b1ca84b83f69a6854a0988192e71d7a7a62910dde0
+  data.tar.gz: 870773a5d09b15840695a8ff0ee57823b4bcc4c89753a88840b3daca7a69ae28
 SHA512:
-  metadata.gz: ce540db8aca9002c6a46a5ae5eb7a45f7a296d4fd183493a8796e3b9dd007ebb04bc0793b1162b82e177de5b59ff06e8e553248a2aa4c725b17d3570d682444f
-  data.tar.gz: 7db85461bd47c03b3169259f699a29e7a1855fd791d53fb4fe84995b812739fe4968b8184665dfd04230b71e2d78152dc8868f78f89452f37d6b20ed00c77ecc
+  metadata.gz: dd80dfc1f862eb03fbd9065af6f1eee36a95254ce4dd7e708073683ca4d5483163457cb5a8b96da851943d93246436a0897965d11b0f5478d966a4a590c82276
+  data.tar.gz: f07fd0d4869deba68067d29a0e6ac6a8003ae4df28dea658decd66455f12a5cbcdd622e816042f93de452c7186bb7af885b9b0d549b2fe3c40edfccd6b3fadf1

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 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/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

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,75 @@
 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 } )
+      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_name scope
-        scope superset_name, -> { where( enum_name => enum_obj.send(superset_name) ) } if respond_to?(:scope)
+        scope superset_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) )
+          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.8.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ext
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 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