enum_ext 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a1510d12023a14d33c2e944a41354de1e7aee23
-  data.tar.gz: 54ec02ec7bcc827fd6b3d5a731e8ba0ebe3f88a8
+  metadata.gz: ed6a02d91d85ab0c0580df99fc4747513053eef1
+  data.tar.gz: d66d1b253f9bd512c1eed331b980591b4c774222
 SHA512:
-  metadata.gz: 797719321c75c6b9b9920075cbd7f18e60eab038cd3d92c16bbdb83f878044c7233f30869e491009926cae6b7fa79303d176abebe7854f58ab9101ebaaf53287
-  data.tar.gz: 95558724f73fcd3311983c9f4932ebadb833d4b44056dea8110a0b1a4135c0ed1d9c84af02473afbf7d0c983d66f67de76a5e97b949039de946eeea6009f4816
+  metadata.gz: 14ac092e452730ef84fcc313877de7fb83254c35ca009ba032e9a1794bb3e391141b4f553c0aa7884e2b69d332feb1c94f06e2527a87ca434657562ec0a4de4c
+  data.tar.gz: 171c5a7736a49e9c592c3d92005b93c312610698cc0c7e7d60aed13e5a712eed9728629473aa41f1b1f1d4dd40fd72c4a84227561217051620dd463f64ae1055

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    enum_ext (0.1.7)
+    enum_ext (0.1.8)
       activerecord (>= 4.1)
 
 GEM

data/README.md

@@ -7,7 +7,7 @@ EnumExt extends rails enum adding localization template, mass-assign on scopes w
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'enum_ext'
+gem 'enum_ext', '~> 0.2'
 ```
 
 And then execute:
@@ -24,7 +24,8 @@ Or install it yourself as:
     class SomeModel
       extend EnumExt
       
-      localize_enum ...
+      humanize_enum ...
+      translate_enum ...
       ext_enum_sets ...
       mass_assign_enum ...
     end
@@ -43,15 +44,12 @@ 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 ) }
         
@@ -81,10 +79,26 @@ If you need some substitution you can go like this:
        request.t_status % {date: Time.now.to_s}  >> Delivered at: 05.02.2016
 
 If you need select status on form:
-    
-        f.select :status, Request.t_statuses.invert.to_a
+       f.select :status, Request.t_statuses_options
+
+Works with ext_enum_sets, slicing t_enum_set from original set of enum values ( enum - status, set_name - delivery_set )
+            
+       f.select :status, Request.t_delivery_set_statuses_options
 
-Works with ext_enum_sets, slicing t_enum_set from original set of enum values
+### Translate (translate_enum) 
+
+Enum is translated using scope 'active_record.attributes.class_name_underscore.enum', or the given one:\
+
+       translate_enum :status, 'active_record.request.enum'
+
+Or it can be done with block either with translate or humanize:
+        
+       translate_enum :status do 
+         I18n.t( "active_record.request.enum.#{status}" )
+       end
+
+Also since we place by default enum translation in same place as enum name translation 
+human_attribute_name is redefined so it will work fine in ActiveAdmin, but you need to add translation to locale.
 
 ### Enum to_i shortcut ( enum_i )
 
@@ -96,7 +110,6 @@ Defines method enum_name_i shortcut for Model.enum_names[elem.enum_name]
   request.payed_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?.
@@ -147,6 +160,7 @@ You can call ext_enum_sets more than one time defining a superposition of alread
                           outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )... # any other array operations like &, + and so can be used
                        }
 
+
 ### Mass-assign ( mass_assign_enum )
  
  Syntax sugar for mass-assigning enum values. 
@@ -177,6 +191,7 @@ You can call ext_enum_sets more than one time defining a superposition of alread
         order.requests.delivered.count              # >> N + M
 
 
+
 ####Rem:
 
  **mass_assign_enum** accepts additional options as last argument. Calling  

data/lib/enum_ext/version.rb

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

data/lib/enum_ext.rb

@@ -12,62 +12,6 @@ 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
 
   def enum_i( enum_name )
     define_method "#{enum_name}_i" do
@@ -75,6 +19,7 @@ module EnumExt
     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
@@ -120,18 +65,30 @@ module EnumExt
       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 ) }
 
+
         define_singleton_method( "#{set_name}_#{enum_name.to_s.pluralize}" ) do
           enum_vals
         end
 
+        # set?
         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
 
+        # t_set_enums
         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}") )
+          send( "t_#{enum_name.to_s.pluralize}" ).slice( *self.send("#{set_name}_#{enum_name.to_s.pluralize}") )
         end
 
+        # t_set_enums_options
+        define_singleton_method( "t_#{set_name}_#{enum_name.to_s.pluralize}_options" ) do
+          send( "t_#{set_name}_#{enum_name.to_s.pluralize}" ).invert.to_a.map do | key_val |
+            key_val[0] = key_val[0].call if key_val[0].respond_to?(:call) && key_val[0].try(:arity) < 1
+            key_val
+          end
+        end
+
+        # set_enums_i
         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
         end
@@ -219,4 +176,119 @@ module EnumExt
     end
   end
 
+  # Ex using localize_enum with Request
+  # class Request
+  #
+  # if app doesn't need internationalization, it may use humanize_enum to make enum user friendly
+  #
+  # 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{ I18n.t("request.status.payed", count: self.sum ) }
+  #
+  #     #locale independent:
+  #     ready_for_shipment: "Ready to go!"
+  #   }
+  # end
+  #
+  # Example with block:
+  #
+  # humanize_enum :status do
+  #  I18n.t("scope.#{status}")
+  # 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_options
+  #
+  # Rem: select options breaks when using lambda
+
+  def humanize_enum( *args, &block )
+    enum_name = args.shift
+    localizations = args.pop
+    enum_pural = enum_name.to_s.pluralize
+
+    self.instance_eval do
+
+      #t_enums
+      define_singleton_method( "t_#{enum_pural}" ) do
+        # if localization is abscent than block must be given
+        localizations.try(:with_indifferent_access) || localizations ||
+            send(enum_pural).keys.map {|en| [en, self.new( {enum_name => en} ).send("t_#{enum_name}")] }.to_h
+      end
+
+      #t_enums_options
+      define_singleton_method( "t_#{enum_pural}_options" ) do
+        send("t_#{enum_pural}").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
+          key_val[0] = ( key_val[0].try(:call) || "Cannot create option for #{key_val[0]}" ) if key_val[0].respond_to?(:call) && key_val[0].try(:arity) < 1
+          key_val
+        end
+      end
+
+      #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
+    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
+    t_scope = args.pop || "activerecord.attributes.#{self.name.underscore}.#{enum_name}"
+
+    translated_enums << enum_name.to_sym
+
+    if block_given?
+      humanize_enum( enum_name, &block )
+    else
+      humanize_enum( enum_name, send(enum_name.to_s.pluralize).keys.map{|en| [ en, Proc.new{ I18n.t("#{t_scope}.#{en}") }] }.to_h )
+    end
+
+  end
+
+  # It useful for Active Admin, since it use by default human_attribute_name
+  # to translate or humanize elements, if no translation given.
+  # So when enums translated it breaks default human_attribute_name since it's search I18n scope from
+  def human_attribute_name( name, options = {} )
+    enum_translated?(name) ? super( "t_#{name}", options ) : super( name, options )
+  end
+
+  # helper to determine is attribute is translated enum
+  def enum_translated?( name )
+    translated_enums.include?( name.to_sym )
+  end
+
+  private
+  def translated_enums
+    @translated_enums ||= Set.new
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ext
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - alekseyl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-10 00:00:00.000000000 Z
+date: 2017-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord