enum_ext 0.1.8 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1a1510d12023a14d33c2e944a41354de1e7aee23
-  data.tar.gz: 54ec02ec7bcc827fd6b3d5a731e8ba0ebe3f88a8
+SHA256:
+  metadata.gz: 2fb6aee80ce2daab446b5670b4e241cdf7c3628696be8c391280eda35c5370bf
+  data.tar.gz: dfc6d38cfe49d9335e167f02b8a9af72d825f74913302a7dec028faea6af9836
 SHA512:
-  metadata.gz: 797719321c75c6b9b9920075cbd7f18e60eab038cd3d92c16bbdb83f878044c7233f30869e491009926cae6b7fa79303d176abebe7854f58ab9101ebaaf53287
-  data.tar.gz: 95558724f73fcd3311983c9f4932ebadb833d4b44056dea8110a0b1a4135c0ed1d9c84af02473afbf7d0c983d66f67de76a5e97b949039de946eeea6009f4816
+  metadata.gz: c46755afcf16127058c21af572d54845c7c4dc8c87190ef086d1a2df80af3a74f249704fdf9939ac90316dc7019cb8198864d20f10a5a91dddcbc124a70462f0
+  data.tar.gz: cadb8ecb8fa5ea4a6be810ce8579dfd200bbc680e69c75f860a986bccadf9e66b8f9fdef10c5c3dff28c6cc7559d0e2b485fddc1316bc335c9153f5be5b68736

data/.travis.yml

@@ -0,0 +1,6 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.4
+  - 2.5.1
+  - 2.3.7

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# 0.4.1
+* security dependency issues resolved
+* activerecord version raised 
+* humanize_enum could be called multiple times all definitions will be merged, i.e. there is no need to define all localizations in one place at once 

data/Gemfile.lock

@@ -1,42 +1,87 @@
 PATH
   remote: .
   specs:
-    enum_ext (0.1.7)
-      activerecord (>= 4.1)
+    enum_ext (0.4.1)
+      activerecord (>= 5.2.4.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.5)
-      activesupport (= 4.2.5)
+    actionpack (6.0.3.4)
+      actionview (= 6.0.3.4)
+      activesupport (= 6.0.3.4)
+      rack (~> 2.0, >= 2.0.8)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (6.0.3.4)
+      activesupport (= 6.0.3.4)
       builder (~> 3.1)
-    activerecord (4.2.5)
-      activemodel (= 4.2.5)
-      activesupport (= 4.2.5)
-      arel (~> 6.0)
-    activesupport (4.2.5)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activemodel (6.0.3.4)
+      activesupport (= 6.0.3.4)
+    activerecord (6.0.3.4)
+      activemodel (= 6.0.3.4)
+      activesupport (= 6.0.3.4)
+    activesupport (6.0.3.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
       minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
-    arel (6.0.3)
-    builder (3.2.2)
-    i18n (0.7.0)
-    json (1.8.3)
-    minitest (5.8.3)
-    rake (10.4.2)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    builder (3.2.4)
+    byebug (11.1.3)
+    concurrent-ruby (1.1.7)
+    crass (1.0.6)
+    erubi (1.10.0)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    loofah (2.8.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (1.0.0)
+    mini_portile2 (2.4.0)
+    minitest (5.14.2)
+    nokogiri (1.10.10)
+      mini_portile2 (~> 2.4.0)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.3.0)
+      loofah (~> 2.3)
+    rails-i18n (6.0.0)
+      i18n (>= 0.7, < 2)
+      railties (>= 6.0.0, < 7)
+    railties (6.0.3.4)
+      actionpack (= 6.0.3.4)
+      activesupport (= 6.0.3.4)
+      method_source
+      rake (>= 0.8.7)
+      thor (>= 0.20.3, < 2.0)
+    rake (13.0.1)
+    sqlite3 (1.4.2)
+    thor (1.0.1)
+    thread_safe (0.3.6)
+    tzinfo (1.2.8)
       thread_safe (~> 0.1)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.11)
+  bundler (>= 1.11)
+  byebug
   enum_ext!
-  rake (~> 10.0)
+  minitest
+  rails-i18n (>= 4)
+  rake (>= 10.0)
+  sqlite3
 
 BUNDLED WITH
-   1.11.2
+   2.1.4

data/README.md

@@ -1,13 +1,13 @@
 # EnumExt
 
-EnumExt extends rails enum adding localization template, mass-assign on scopes with bang and some sets logic over existing enum.
+EnumExt extends rails enum with localization/translation and it's helpers, mass-assign on scopes with bang, advanced sets logic over existing enum.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'enum_ext'
+gem 'enum_ext', '~> 0.3'
 ```
 
 And then execute:
@@ -19,22 +19,26 @@ Or install it yourself as:
     $ gem install enum_ext
 
 ## Usage
- To use enum extension extend main model class with EnumExt module, and extend enum the way you need:
+ To use enum extension extend main model class with EnumExt module, 
+ and customize your enums the way you need:
  
     class SomeModel
       extend EnumExt
       
-      localize_enum ...
+      enum_i ...
+      humanize_enum ...
+      translate_enum ...
       ext_enum_sets ...
       mass_assign_enum ...
     end
  
- Let's assume that we have model Request representing some buying requests with enum **status**, and we have model Order with requests, representing single purchase, like this:
+ Let's assume that we have model Request representing some buying requests with enum **status**, and we have model Order with requests, 
+ representing single purchase, like this:
 
      class Request
        extend EnumExt
        belongs_to :order
-       enum status: [ :in_cart, :waiting_for_payment, :payed, :ready_for_shipment, :on_delivery, :delivered ]
+       enum status: [ :in_cart, :waiting_for_payment, :paid, :ready_for_shipment, :on_delivery, :delivered ]
      end
 
      class Order
@@ -43,48 +47,77 @@ Or install it yourself as:
 
  Now let's review some examples of possible enum extensions
 
-### Localization (localize_enum) 
+### Humanization (humanize_enum) 
   
-     class Request
-      ...
-      localize_enum :status, {
-    
-         #locale dependent example ( it dynamically use current locale ):
-         in_cart: -> { I18n.t("request.status.in_cart") },
-    
-         #locale dependent example with internal pluralization and lambda:
-         payed: -> (t_self) { I18n.t("request.status.payed", count: t_self.sum ) }
-        
-         #locale dependent example with internal pluralization and proc:
-         payed: proc { I18n.t("request.status.payed", count: sum ) }
-        
-         #locale independent:
-         ready_for_shipment: "Ready to go!" 
-       }
-     end
+  if app doesn't need internationalization, it may use humanize_enum to make enum user friendly
 
-Console:
+  ```  
+  humanize_enum :status, {
+      #locale dependent example with pluralization and lambda:
+      in_cart: -> (t_self) { I18n.t("request.status.in_cart", count: t_self.sum ) }
+  
+      #locale dependent example with pluralization and proc:
+      paid: Proc.new{ I18n.t("request.status.paid", count: self.sum ) }
+  
+      #locale independent:
+      ready_for_shipment: "Ready to go!"
+    }
+  end
+  ```  
+   
+  This humanize_enum adds to instance:
+   - t_in_cart, t_paid, t_ready_for_shipment
+  
+  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
 
-       request.sum = 3
-       request.payed!
-       request.status      # >> payed
-       request.t_status    # >> "Payed 3 dollars"
-       Request.t_statuses  # >> { in_cart: -> { I18n.t("request.status.in_cart") }, ....  }
+  
+  Example with block:
 
-If you need some substitution you can go like this:
+  ```
+  humanize_enum :status do
+   I18n.t("scope.#{status}")
+  end
+  ```
+  
+  Example for select:
+  
+  ```
+    f.select :status, Request.t_statuses_options
+  ```
+  
+  in Active Admin filters
+  ```
+    filter :status, as: :select, label: 'Status', collection: Request.t_statuses_options_i
+  ```
+ 
+  
+  Rem: select options may break when using lambda() or proc with instance method, but will survive with block
+  
+  Console:
+  ```
+    request.sum = 3
+    request.paid!
+    request.status     # >> paid
+    request.t_status   # >> "paid 3 dollars"
+    Request.t_statuses # >> { in_cart: -> { I18n.t("request.status.in_cart") }, ....  }
+  ```  
+
+  Could be called multiple times, all humanization definitions will be merged under the hood.  
+    
+### Translate (translate_enum) 
 
-       localize_enum :status, {
-             ..
-        delivered: "Delivered at: %{date}"
-       }
-       request.delivered!
-       request.t_status % {date: Time.now.to_s}  >> Delivered at: 05.02.2016
+Enum is translated using scope 'active_record.attributes.class_name_underscore.enum_plural', or the given one:
 
-If you need select status on form:
-    
-        f.select :status, Request.t_statuses.invert.to_a
+       translate_enum :status, 'active_record.request.enum'
 
-Works with ext_enum_sets, slicing t_enum_set from original set of enum values
+Or it can be done with block either with translate or humanize:
+        
+       translate_enum :status do 
+         I18n.t( "active_record.request.enum.#{status}" )
+       end
 
 ### Enum to_i shortcut ( enum_i )
 
@@ -93,124 +126,99 @@ Defines method enum_name_i shortcut for Model.enum_names[elem.enum_name]
 **Ex** 
   enum_i :status
   ...
-  request.payed_i # 10
+  request.paid_i # 10
   
 
-
 ### Enum Sets (ext_enum_sets)
  
- **Use-case** For example you have pay bills of different types, and you want to group some types in debit and credit "super-types", and have scope PayBill.debit, instance method with question mark as usual enum does pay_bill.debit?.
- 
- You can do this with method **ext_enum_sets**, it creates: scopes for subsets like enum did, instance method with ? similar to enum methods, and so...
+ **Use-case** For example you have pay bills of different types, and you want to group some types in debit and credit "super-types", 
+ and have scope PayBill.debit, instance method with question mark as usual enum does pay_bill.debit?.
  
- I strongly recommend you to create special comment near method call, to remember what methods will be defined on instance, on class itself, and what scopes will be defined
-  
-      class Request
-            ...
-           #instance methods: non_payed?, delivery_set?, in_warehouse?
-           #scopes: non_payed, delivery_set, in_warehouse
-           #scopes: with_statuses, without_statuses
-           #class methods: non_payed_statuses, delivery_set_statuses ( = [:in_cart, :waiting_for_payment], [:ready_for_shipment, :on_delivery, :delivered].. )
-           #class methods: t_non_payed_statuses, t_delivery_set_statuses ( = {in_cart: "In cart localization" ...} )
-           
-           ext_enum_sets :status, {
-                           non_payed: [:in_cart, :waiting_for_payment],
-                           delivery_set: [:ready_for_shipment, :on_delivery, :delivered]  #for shipping department for example
-                           in_warehouse: [:ready_for_shipment]                            #it's just for example below
-                         }
-      end
-
-Console:
-
-        request.waiting_for_payment!
-        request.non_payed?                     # >> true
-        
-        Request.non_payed.exists?(request)     # >> true
-        Request.delivery_set.exists?(request)  # >> false
-        
-        Request.non_payed_statuses             # >> [:in_cart, :waiting_for_payment]
-        
-        Request.with_statuses( :payed, :in_cart )       # >> scope for all in_cart and payed requests
-        Request.without_statuses( :payed )              # >> scope for all requests with statuses not eq to payed
-        Request.without_statuses( :payed, :non_payed )  # >> scope all requests with statuses not eq to payed and in_cart + waiting_for_payment
-
-
-#### Rem:
-
-You can call ext_enum_sets more than one time defining a superposition of already defined sets:
-
-      class Request
-        ...
-        ext_enum_sets (... first time you call ext_enum_sets )
-        ext_enum_sets :status, {
-                          already_payed: ( [:payed] | delivery_set_statuses ),
-                          outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )... # any other array operations like &, + and so can be used
-                       }
+ You can do this with method **ext_enum_sets** it creates:  scopes for subsets, instance method with ? and some class methods helpers
+   
+   For this call:
+   ```
+     ext_enum_sets :status, {
+                     delivery_set: [:ready_for_shipment, :on_delivery, :delivered] # for shipping department for example
+                     in_warehouse: [:ready_for_shipment]  # this just for superposition example  below
+                   }
+   ```
+it will generate:
+```
+instance:
+    - methods: delivery_set?, in_warehouse?
+
+class:
+    - named scopes: delivery_set, in_warehouse
+    - parametrized scopes: with_statuses, without_statuses
+    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_... ):
+        - t_delivery_set_statuses_options (= [['translation or humanization', :ready_for_shipment] ...] ) for select inputs purposes
+        - t_delivery_set_statuses_options_i (= [['translation or humanization', 3] ...]) same as above but with integer as value ( for example to use in Active admin filters )
+```
 
-### Mass-assign ( mass_assign_enum )
+ ```
+   Console:
+    request.on_delivery!
+    request.delivery_set?                    # >> true
  
- Syntax sugar for mass-assigning enum values. 
+    Request.delivery_set.exists?(request)    # >> true
+    Request.in_warehouse.exists?(request)    # >> false
+   
+    Request.delivery_set_statuses            # >> [:ready_for_shipment, :on_delivery, :delivered]
+   
+    Request.with_statuses( :payed, :delivery_set )    # >> :payed and [:ready_for_shipment, :on_delivery, :delivered] requests
+    Request.without_statuses( :payed )                # >> scope for all requests with statuses not eq to :payed
+    Request.without_statuses( :payed, :in_warehouse ) # >> scope all requests with statuses not eq to :payed or :ready_for_shipment
+ ```  
  
- **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)
- If you need callbacks you can do like this: some_scope.each(&:new_stat!) but if you don't need callbacks and you has hundreds and thousands of records to change at once you need update_all
-
-     class Request
-       ...
-       mass_assign_enum( :status )
-     end
+   Rem:
+    ext_enum_sets can be called twice defining a superposition of already defined sets ( considering previous example ):
+    
+```
+    ext_enum_sets :status, {
+                outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )... any other array operations like &, + and so can be used
+              }
+```
 
- Console:
  
-        request1.in_cart!
-        request2.waiting_for_payment!
-        Request.non_payed.payed!
-        request1.payed?                         # >> true
-        request2.payed?                         # >> true
-        request1.updated_at                     # >> ~ Time.now
-        defined?(Request::MassAssignEnum) # >> true
-        
-        
-        order.requests.already_payed.count          # >> N
-        order.requests.delivered.count              # >> M
-        order.requests.already_payed.delivered!
-        order.requests.already_payed.count          # >> 0
-        order.requests.delivered.count              # >> N + M
-
-
-####Rem:
-
- **mass_assign_enum** accepts additional options as last argument. Calling  
+### Mass-assign ( mass_assign_enum )
  
-    mass_assign_enum( :status ) 
+ Syntax sugar for mass-assigning enum values. 
  
- actually is equal to call:
-  
-    mass_assign_enum( :status, { relation: true, association_relation: true } )
-
-###### Meaning:
+ **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)
+ ```
+ 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 need update_all
 
- relation: true - Request.some_scope.payed! - works
+ ```
+    mass_assign_enum( :status )
+ ```
 
- association_relation: true - Order.first.requests.scope.new_stat! - works
- 
- **but it wouldn't work without 'scope' part!** If you want to use it without 'scope' you may do it this way:
- 
-     class Request
-       ...
-       mass_assign_enum( :status, relation: true, association_relation: false )
-     end
+ Console:
 
-     class Order
-      has_many :requests, extend: Request::MassAssignEnum
-     end
+```
+    request1.in_cart!
+    request2.waiting_for_payment!
+    Request.non_paid.paid!
+    request1.paid?                         # >> true
+    request2.paid?                         # >> true
+    request1.updated_at                     # >> ~ Time.now
     
-     Order.first.requests.respond_to?(:in_cart!)  # >> true
-
-#### Rem2:
- You can mass-assign more than one enum ::MassAssignEnum module will contain mass assign for both. It will break nothing since all enum name must be uniq across model
+    order.requests.already_paid.count          # >> N
+    order.requests.delivered.count              # >> M
+    order.requests.already_paid.delivered!
+    order.requests.already_paid.count          # >> 0
+    order.requests.delivered.count              # >> N + M
+```
 
 ## Tests
- Right now goes without automated tests :(
+   rake test
  
 ## Development
 
@@ -224,3 +232,6 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/alekse
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
+### Thanks
+
+Thanks for the star vzamanillo, it inspires me to do mass refactor and gracefully cover code in this gem by tests.

data/Rakefile

@@ -1,2 +1,9 @@
 require "bundler/gem_tasks"
-task :default => :spec
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "enum_ext"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/enum_ext.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["alekseyl"]
   spec.email         = ["leshchuk@gmail.com"]
 
-  spec.summary       = %q{Enum extension, ads enum sets, mass-assign for them, localization for them.}
-  spec.description   = %q{Enum extension, ads enum sets, mass-assign for them, localization for them.}
+  spec.summary       = %q{Enum extension, ads enum sets, mass-assign, localization, and some sugar helpers.}
+  spec.description   = %q{Enum extension, ads enum sets, mass-assign, localization, and some sugar helpers.}
   spec.homepage      = "https://github.com/alekseyl/enum_ext"
   spec.license       = "MIT"
 
@@ -19,8 +19,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", ">=4.1"
+  spec.add_dependency 'activerecord', ">= 5.2.4.3"
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'bundler', '>= 1.11'
+  spec.add_development_dependency 'rake', '>= 10.0'
+  spec.add_development_dependency 'rails-i18n', '>=4'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'byebug'
 end

data/lib/enum_ext.rb

@@ -1,10 +1,10 @@
-require "enum_ext/version"
+require 'enum_ext/version'
 
 # Let's assume we have model Request with enum status, and we have model Order with requests like this:
 # class Request
 #   extend EnumExt
 #   belongs_to :order
-#   enum status: [ :in_cart, :waiting_for_payment, :payed, :ready_for_shipment, :on_delivery, :delivered ]
+#   enum status: { in_cart: 0, waiting_for_payment: 1, payed: 2, ready_for_shipment: 3, on_delivery: 4, delivered: 5 }
 # end
 #
 # class Order
@@ -12,211 +12,296 @@ require "enum_ext/version"
 # end
 #
 module EnumExt
-  # Ex using localize_enum with Request
-  # class Request
-  #  ...
-  #  localize_enum :status, {
-  #
-  #     #locale dependent example ( it dynamically use current locale ):
-  #     in_cart: -> { I18n.t("request.status.in_cart") },
-
-  #     #locale dependent example with pluralization and lambda:
-  #     payed: -> (t_self) { I18n.t("request.status.payed", count: t_self.sum ) }
-
-  #     #locale dependent example with pluralization and proc:
-  #     payed: proc{ I18n.t("request.status.payed", count: self.sum ) }
-  #
-  #     #locale independent:
-  #     ready_for_shipment: "Ready to go!"
-  #
-  #
-  #   }
-  # end
-
-  # Console:
-  #   request.sum = 3
-  #   request.payed!
-  #   request.status # >> payed
-  #   request.t_status # >> "Payed 3 dollars"
-  #   Request.t_statuses # >> { in_cart: -> { I18n.t("request.status.in_cart") }, ....  }
-
-  #   if you need some substitution you can go like this
-  #   localize_enum :status, {
-  #         ..
-  #    delivered: "Delivered at: %{date}"
-  #   }
-  #   request.delivered!
-  #   request.t_status % {date: Time.now.to_s} # >> Delivered at: 05.02.2016
-  #
-  # Using in select:
-  #   f.select :status, Request.t_statuses.invert.to_a
-  #
-  def localize_enum( enum_name, localizations )
-    self.instance_eval do
-      define_singleton_method( "t_#{enum_name.to_s.pluralize}" ) do
-        localizations.try(:with_indifferent_access) || localizations
-      end
-      define_method "t_#{enum_name}" do
-        t = localizations.try(:with_indifferent_access)[send(enum_name)]
-        if t.try(:lambda?)
-          t.try(:arity) == 1 && t.call( self ) || t.try(:call)
-        elsif t.is_a?(Proc)
-          instance_eval(&t)
-        else
-          t
-        end.to_s
-      end
-    end
-  end
 
+  # defines shortcut for getting integer value of enum.
+  # for enum named 'status' will generate:
+  # instance.status_i
   def enum_i( enum_name )
     define_method "#{enum_name}_i" do
       self.class.send("#{enum_name.to_s.pluralize}")[send(enum_name)].to_i
     end
   end
 
-  # Ex ext_enum_sets
-  # This method intend for creating and using some sets of enum values with similar to original enum syntax
-  # it creates: scopes for subsets like enum did, instance method with ? similar to enum methods, and methods like Request.statuses
-  # Usually I supply comment near method call to remember what methods will be defined
-  #  class Request
-  #   ...
-  #   #instance non_payed?, delivery_set?, in_warehouse?
-  #   #class scopes: non_payed, delivery_set, in_warehouse
-  #   #class scopes: with_statuses, without_statuses
-  #   #class non_payed_statuses, delivery_set_statuses ( = [:in_cart, :waiting_for_payment], [:ready_for_shipment, :on_delivery, :delivered].. )
+
+  # ext_enum_sets
+  # This method intend for creating and using some sets of enum values
+  # it creates: scopes for subsets,
+  #             instance method with ?,
+  #             and some class methods helpers
+  #
+  # For this call:
   #   ext_enum_sets :status, {
-  #                   non_payed: [:in_cart, :waiting_for_payment],
   #                   delivery_set: [:ready_for_shipment, :on_delivery, :delivered] # for shipping department for example
-  #                   in_warehouse: [:ready_for_shipment]                           # it's just for example below
+  #                   in_warehouse: [:ready_for_shipment]       # this scope is just for superposition example below
   #                 }
-  #  end
+  #
+  # it will generate:
+  #   instance:
+  #     methods: delivery_set?, in_warehouse?
+  #   class:
+  #     named scopes: delivery_set, in_warehouse
+  #     parametrized scopes: with_statuses, without_statuses
+  #     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.waiting_for_payment!
-  #  request.non_payed?                    # >> true
+  #  request.on_delivery!
+  #  request.delivery_set?                    # >> true
 
-  #  Request.non_payed.exists?(request)    # >> true
-  #  Request.delivery_set.exists?(request) # >> false
-
-  #  Request.non_payed_statuses            # >> [:in_cart, :waiting_for_payment]
+  #  Request.delivery_set.exists?(request)    # >> true
+  #  Request.in_warehouse.exists?(request)    # >> false
+  #
+  #  Request.delivery_set_statuses            # >> [:ready_for_shipment, :on_delivery, :delivered]
   #
-  #  Request.with_statuses( :payed, :in_cart )      # >> scope for all in_cart and payed requests
-  #  Request.without_statuses( :payed )             # >> scope for all requests with statuses not eq to payed
-  #  Request.without_statuses( :payed, :non_payed ) # >> scope all requests with statuses not eq to payed and in_cart + waiting_for_payment
+  #  Request.with_statuses( :payed, :delivery_set )    # >> :payed and [:ready_for_shipment, :on_delivery, :delivered] requests
+  #  Request.without_statuses( :payed )                # >> scope for all requests with statuses not eq to :payed
+  #  Request.without_statuses( :payed, :in_warehouse ) # >> scope all requests with statuses not eq to :payed or :ready_for_shipment
   #
 
   #Rem:
-  #  ext_enum_sets can be called twice defining a superpositoin of already defined sets:
-  #  class Request
-  #    ...
-  #    ext_enum_sets (... first time call )
-  #    ext_enum_sets :status, {
-  #                      already_payed: ( [:payed] | delivery_set_statuses ),
-  #                      outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )... any other array operations like &, + and so can be used
-  #                   }
+  #  ext_enum_sets can be called twice defining a superposition of already defined sets ( considering previous example ):
+  #  ext_enum_sets :status, {
+  #                  outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )... any other array operations like &, + and so can be used
+  #                }
   def ext_enum_sets( enum_name, options )
+    enum_plural = enum_name.to_s.pluralize
+
     self.instance_eval do
       options.each do |set_name, enum_vals|
-        scope set_name, -> { where( enum_name => self.send( enum_name.to_s.pluralize ).slice( *enum_vals.map(&:to_s) ).values ) }
+        # set_name scope
+        scope set_name, -> { where( enum_name => self.send( enum_plural ).slice( *enum_vals.map(&:to_s) ).values ) }
+
+        # with_enums scope
+        scope "with_#{enum_plural}", -> (sets_arr) {
+          where( enum_name => self.send( enum_plural ).slice(
+                     *sets_arr.map{|set_name| self.try( "#{set_name}_#{enum_plural}" ) || set_name }.flatten.uniq.map(&:to_s) ).values )
+        } unless respond_to?("with_#{enum_plural}")
+
+        # without_enums scope
+        scope "without_#{enum_plural}", -> (sets_arr) {
+          where.not( id: self.send("with_#{enum_plural}", sets_arr) )
+        } unless respond_to?("without_#{enum_plural}")
 
-        define_singleton_method( "#{set_name}_#{enum_name.to_s.pluralize}" ) do
+
+        # class.enum_set_values
+        define_singleton_method( "#{set_name}_#{enum_plural}" ) do
           enum_vals
         end
 
-        define_method "#{set_name}?" do
-          self.send(enum_name) && ( enum_vals.include?( self.send(enum_name) ) || enum_vals.include?( self.send(enum_name).to_sym ))
+        # class.enum_set_enums_i
+        define_singleton_method( "#{set_name}_#{enum_plural}_i" ) do
+          self.send( "#{enum_plural}" ).slice( *self.send("#{set_name}_#{enum_plural}") ).values
         end
 
-        define_singleton_method( "t_#{set_name}_#{enum_name.to_s.pluralize}" ) do
-          self.send( "t_#{enum_name.to_s.pluralize}" ).slice( *self.send("#{set_name}_#{enum_name.to_s.pluralize}") )
+        # t_... - are translation dependent methods
+        # class.t_enums_options
+        define_singleton_method( "t_#{set_name}_#{enum_plural}_options" ) do
+          return [["Enum translations call missed. Did you forget to call translate #{enum_name}"]*2] unless respond_to?( "t_#{enum_plural}_options_raw" )
+
+          send("t_#{enum_plural}_options_raw", send("t_#{set_name}_#{enum_plural}") )
         end
 
-        define_singleton_method( "#{set_name}_#{enum_name.to_s.pluralize}_i" ) do
-          self.send( "#{enum_name.to_s.pluralize}" ).slice( *self.send("#{set_name}_#{enum_name.to_s.pluralize}") ).values
+        # class.t_enums_options_i
+        define_singleton_method( "t_#{set_name}_#{enum_plural}_options_i" ) do
+          return [["Enum translations call missed. Did you forget to call translate #{enum_name}"]*2] unless respond_to?( "t_#{enum_plural}_options_raw_i" )
+
+          send("t_#{enum_plural}_options_raw_i", send("t_#{set_name}_#{enum_plural}") )
         end
 
-      end
+        # instance.set_name?
+        define_method "#{set_name}?" do
+          self.send(enum_name) && ( enum_vals.include?( self.send(enum_name) ) || enum_vals.include?( self.send(enum_name).to_sym ))
+        end
 
-      scope "with_#{enum_name.to_s.pluralize}", -> (sets_arr) {
-        where( enum_name => self.send( enum_name.to_s.pluralize ).slice(
-                   *sets_arr.map{|set_name| self.try( "#{set_name}_#{enum_name.to_s.pluralize}" ) || set_name }.flatten.uniq.map(&:to_s) ).values )
-      } unless respond_to?("with_#{enum_name.to_s.pluralize}")
+        # protected?
+        # class.t_setname_enums ( translations or humanizations subset for a given set )
+        define_singleton_method( "t_#{set_name}_#{enum_plural}" ) do
+          return [(["Enum translations call missed. Did you forget to call translate #{enum_name}"]*2)].to_h unless respond_to?( "t_#{enum_plural}" )
 
-      scope "without_#{enum_name.to_s.pluralize}", -> (sets_arr) {
-        where.not( id: self.send("with_#{enum_name.to_s.pluralize}", sets_arr) )
-      } unless respond_to?("without_#{enum_name.to_s.pluralize}")
+          send( "t_#{enum_plural}" ).slice( *self.send("#{set_name}_#{enum_plural}") )
+        end
+      end
     end
   end
 
   # Ex mass_assign_enum
-  # Used for mass assigning for collection, it creates dynamically nested module with methods similar to enum bang methods, and includes it to relation classes
-  # Behind the scene it creates bang methods for collections using update_all.
-  # 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)
-  # If you need callbacks you can do like this: some_scope.each(&:new_stat!) but if you don't need callbacks and you has hundreds and thousands of records to change at once you need update_all
+  # 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)
+  # 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
   #
-  # class Request
-  #   ...
-  #   mass_assign_enum( :status )
-  # end
+  #  mass_assign_enum( :status )
+  #
+  #  class methods:
+  #    in_cart! paid! in_warehouse! and so
   #
   # Console:
   # request1.in_cart!
   # request2.waiting_for_payment!
-  # Request.non_payed.payed!
-  # request1.payed?                         # >> true
-  # request2.payed?                         # >> true
+  # Request.with_statuses( :in_cart, :waiting_for_payment ).payed!
+  # request1.paid?                         # >> true
+  # request2.paid?                         # >> true
   # request1.updated_at                     # >> Time.now
   # defined?(Request::MassAssignEnum)      # >> true
   #
-  # order.requests.already_payed.all?(&:already_payed?) # >> true
-  # order.requests.already_payed.delivered!
+  # order.requests.paid.all?(&:paid?) # >> true
+  # order.requests.paid.delivered!
   # order.requests.map(&:status).uniq                   #>> [:delivered]
-  #
-  #
-  # Rem:
-  # mass_assign_enum accepts additional options as last argument.
-  # calling  mass_assign_enum( :status ) actually is equal to call: mass_assign_enum( :status, { relation: true, association_relation: true } )
-  #
-  # Meaning:
 
-  # relation: true - Request.some_scope.payed! - works
+  def mass_assign_enum( *enums_names )
+    enums_names.each do |enum_name|
+      enum_vals = self.send( enum_name.to_s.pluralize )
 
-  # association_relation: true - Order.first.requests.scope.new_stat! - works
-  # but it wouldn't works without 'scope' part! If you want to use it without 'scope' you may do it this way:
+      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} : {} ))
+        end
+      end
+    end
+  end
+
+  # if app doesn't need internationalization, it may use humanize_enum to make enum user friendly
   # class Request
-  #   ...
-  #   mass_assign_enum( :status, association_relation: false )
+  # humanize_enum :status, {
+  #     #locale dependent example with pluralization and lambda:
+  #     payed: -> (t_self) { I18n.t("request.status.payed", count: t_self.sum ) }
+  #
+  #     #locale dependent example with pluralization and proc:
+  #     payed: Proc.new{ I18n.t("request.status.payed", count: self.sum ) }
+  #
+  #     #locale independent:
+  #     ready_for_shipment: "Ready to go!"
+  #   }
   # end
-  # class Order
-  #  has_many :requests, extend: Request::MassAssignEnum
+  #
+  # Could be called multiple times, all humanization definitions will be merged under the hood:
+  #  humanize_enum :status, {
+  #     payed: I18n.t("scope.#{status}")
+  # }
+  # humanize_enum :status, {
+  #   billed: I18n.t("scope.#{status}")
+  # }
+  #
+  #
+  # Example with block:
+  #
+  # humanize_enum :status do
+  #  I18n.t("scope.#{status}")
   # end
   #
-  # Order.first.requests.respond_to?(:in_cart!) # >> true
+  # in views select:
+  #   f.select :status, Request.t_statuses_options
   #
-  # Rem2:
-  # you can mass-assign more than one enum ::MassAssignEnum module will contain mass assign for both. It will break nothing since all enum name must be uniq across model
+  # in select in Active Admin filter
+  #   collection: Request.t_statuses_options_i
+  #
+  # Rem: select options breaks when using lambda() with params
+  #
+  # Console:
+  #   request.sum = 3
+  #   request.payed!
+  #   request.status     # >> payed
+  #   request.t_status   # >> "Payed 3 dollars"
+  #   Request.t_statuses # >> { in_cart: -> { I18n.t("request.status.in_cart") }, ....  }
+  def humanize_enum( *args, &block )
+    enum_name = args.shift
+    localizations = args.pop
+    enum_plural = enum_name.to_s.pluralize
 
-  def mass_assign_enum( *options )
-    relation_options = (options[-1].is_a?(Hash) && options.pop || {relation: true, association_relation: true} ).with_indifferent_access
-    enums_names = options
-    enums_names.each do |enum_name|
-      enum_vals = self.send( enum_name.to_s.pluralize )
+    self.instance_eval do
+
+      #t_enum
+      define_method "t_#{enum_name}" do
+        t = block || localizations.try(:with_indifferent_access)[send(enum_name)]
+        if t.try(:lambda?)
+          t.try(:arity) == 1 && t.call( self ) || t.try(:call)
+        elsif t.is_a?(Proc)
+          instance_eval(&t)
+        else
+          t
+        end.to_s
+      end
+
+      @@localizations ||= {}.with_indifferent_access
+      # if localization is abscent than block must be given
+      @@localizations.merge!(
+        localizations.try(:with_indifferent_access) ||
+          localizations ||
+          send(enum_plural).keys.map{|en| [en, Proc.new{ self.new({ enum_name => en }).send("t_#{enum_name}") }] }.to_h.with_indifferent_access
+      )
+      #t_enums
+      define_singleton_method( "t_#{enum_plural}" ) do
+        @@localizations
+      end
 
-      mass_ass_module = ( defined?(self::MassAssignEnum) && self::MassAssignEnum || Module.new )
+      #t_enums_options
+      define_singleton_method( "t_#{enum_plural}_options" ) do
+        send("t_#{enum_plural}_options_raw", send("t_#{enum_plural}") )
+      end
+
+      #t_enums_options_i
+      define_singleton_method( "t_#{enum_plural}_options_i" ) do
+        send("t_#{enum_plural}_options_raw_i", send("t_#{enum_plural}") )
+      end
+
+      define_method "t_#{enum_name}=" do |new_val|
+        send("#{enum_name}=", new_val)
+      end
+
+      #protected?
+      define_singleton_method( "t_#{enum_plural}_options_raw_i" ) do |t_enum_set|
+        send("t_#{enum_plural}_options_raw", t_enum_set ).map do | key_val |
+          key_val[1] = send(enum_plural)[key_val[1]]
+          key_val
+        end
+      end
 
-      mass_ass_module.instance_eval do
-        enum_vals.keys.each do |enum_el|
-          define_method( "#{enum_el}!" ) do
-            self.update_all( {enum_name => enum_vals[enum_el]}.merge( self.column_names.include?('updated_at') ? {updated_at: Time.now} : {} ))
+      define_singleton_method( "t_#{enum_plural}_options_raw" ) do |t_enum_set|
+        t_enum_set.invert.to_a.map do | key_val |
+          # since all procs in t_enum are evaluated in context of a record than it's not always possible to create select options
+          if key_val[0].respond_to?(:call)
+            if key_val[0].try(:arity) < 1
+              key_val[0] = key_val[0].try(:call) rescue "Cannot create option for #{key_val[1]} ( proc fails to evaluate )"
+            else
+              key_val[0] = "Cannot create option for #{key_val[1]} because of a lambda"
+            end
           end
+          key_val
         end
       end
-      self.const_set( :MassAssignEnum, mass_ass_module ) unless defined?(self::MassAssignEnum)
+    end
+  end
+  alias localize_enum humanize_enum
+
+  # Simple way to translate enum.
+  # It use either given scope as second argument, or generated activerecord.attributes.model_name_underscore.enum_name
+  # If block is given than no scopes are taken in consider
+  def translate_enum( *args, &block )
+    enum_name = args.shift
+    enum_plural = enum_name.to_s.pluralize
+    t_scope = args.pop || "activerecord.attributes.#{self.name.underscore}.#{enum_plural}"
 
-      self::ActiveRecord_Relation.include( self::MassAssignEnum ) if relation_options[:relation]
-      self::ActiveRecord_AssociationRelation.include( self::MassAssignEnum ) if relation_options[:association_relation]
+    if block_given?
+      humanize_enum( enum_name, &block )
+    else
+      humanize_enum( enum_name, send(enum_plural).keys.map{|en| [ en, Proc.new{ I18n.t("#{t_scope}.#{en}") }] }.to_h )
     end
   end
 
+  # human_attribute_name is redefined for automation like this:
+  # p #{object.class.human_attribute_name( attr_name )}:
+  # p object.send(attr_name)
+  def human_attribute_name( name, options = {} )
+    # if name starts from t_ and there is a column with the last part then ...
+    name[0..1] == 't_' && column_names.include?(name[2..-1]) ? super( name[2..-1], options ) : super( name, options )
+  end
+
+
 end

data/lib/enum_ext/version.rb

@@ -1,3 +1,3 @@
 module EnumExt
-  VERSION = "0.1.8"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ext
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.4.1
 platform: ruby
 authors:
 - alekseyl
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2016-11-10 00:00:00.000000000 Z
+date: 2020-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,44 +16,100 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: 5.2.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: 5.2.4.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Enum extension, ads enum sets, mass-assign for them, localization for
-  them.
+- !ruby/object:Gem::Dependency
+  name: rails-i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Enum extension, ads enum sets, mass-assign, localization, and some sugar
+  helpers.
 email:
 - leshchuk@gmail.com
 executables: []
@@ -61,11 +117,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/setup
 - enum_ext.gemspec
 - lib/enum_ext.rb
 - lib/enum_ext/version.rb
@@ -73,7 +133,7 @@ homepage: https://github.com/alekseyl/enum_ext
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -88,9 +148,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
-summary: Enum extension, ads enum sets, mass-assign for them, localization for them.
+summary: Enum extension, ads enum sets, mass-assign, localization, and some sugar
+  helpers.
 test_files: []