enum_accessor 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d86255884f7966bd0e809b50e930e329c42d4b41
-  data.tar.gz: 6c54bd945c9ae2d6046b5e4b5b13b27dc8cdc01d
+  metadata.gz: 14d9609313d6c0cf506e0ddec8e2e1b040f0f0a4
+  data.tar.gz: 55f3e47cc0ad9fc6a638428ffeae93d820c556a6
 SHA512:
-  metadata.gz: 6a19a3a40b302f92ac389bde732a5c461d6b5927885eeefce29d5ab0fcede07dc49f98f295ce6504577a23705d4de303303e9a25703d962406791379b1db7be8
-  data.tar.gz: d02c42efa9212eba91bd9a90fdb6bf36f717786a55953319f4c892bb0201f8d69e765c3f1ef71570fe57b9ea46446f90af178354a7ff26978538be4b1cade89b
+  metadata.gz: 38379123736f3948c01b9423e6f12e9be0977332c9d2be9865253ed030685b4ae7d7e4fcb45132e5f0a9dbc84fdd823a8150563e588451028fde205a4275b429
+  data.tar.gz: ad2fda272424b398d077ed2b80bc940dc225283970652010daa691fc3662b31f479d6440a709200646f830c9c951a58067442711cd633b0625534d75075b2174

data/README.md

@@ -4,7 +4,7 @@ EnumAccessor lets you define enum for attributes, and store them as integer in t
 
 It is very similar to [Official Rails 4.1 Implementation](http://edgeguides.rubyonrails.org/4_1_release_notes.html#active-record-enums), but EnumAccessor offers quite a few advantages:
 
-* Safe predicate methods (`user.status_active?` instead of `user.active?`)
+* No-conflict safe predicate methods (`user.status_active?` instead of `user.active?`)
 * Validation
 * Scope
 * Translation
@@ -40,7 +40,7 @@ user.gender = :male
 user.gender_female?     # => false
 user.gender_raw         # => 1
 
-User.genders.dict       # => { 'female' => 0, 'male' => 1 }
+User.genders            # => { 'female' => 0, 'male' => 1 }
 ```
 
 Notice that zero-based numbering is used as database values.
@@ -79,12 +79,18 @@ Also takes multiple values.
 User.where_status(:active, :pending)
 ```
 
+To use under direct `where` context (e.g. `find_by` or `find_or_create_by`), pass integer value.
+
+```ruby
+Social.find_or_create_by(kind: Social.kinds[:facebook], external_id: facebook_user_id)
+```
+
 ## Validations
 
-You can pass `validates: true` to enable validation.
+By default, models are validated using `inclusion`. To disable, pass `false` to `validates` option.
 
 ```ruby
-enum_accessor :status, [:on, :off], validates: true
+enum_accessor :status, [:on, :off], validates: false
 ```
 
 You can also pass validation options.
@@ -112,15 +118,17 @@ and now `human_*` methods return a translated string. It defaults to `humanize`
 ```ruby
 I18n.locale = :ja
 user.human_gender         # => '女'
-User.genders.human_dict   # => { 'female' => '女', 'male' => '男' }
+User.human_genders        # => { 'female' => '女', 'male' => '男' }
 
 I18n.locale = :en
 user.human_gender         # => 'Female'
-User.genders.human_dict   # => { 'female' => 'Female', 'male' => 'Male' }
+User.human_genders        # => { 'female' => 'Female', 'male' => 'Male' }
 ```
 
 ## Changelog
 
+- v2.0.0:
+  - Reworked to remove the "dict" methods. Now `User.genders.dict` is `User.genders` and `User.genders.human_dict` is `User.human_genders`
 - v1.1.0:
   - Validate by default again.
   - Added `:class_attribute` option to specify class attribute to hold definitions

data/lib/enum_accessor.rb

@@ -7,20 +7,33 @@ module EnumAccessor
 
   module ClassMethods
     def enum_accessor(column, keys, options={})
+      # Normalize keys
+      dict = case keys
+      when Array
+        Hash[keys.map.with_index{|i,index| [i, index] }]
+      when Hash
+        keys
+      else
+        raise ArgumentError.new('enum_accessor takes Array or Hash as the second argument')
+      end
+
+      # Define class attributes
       definition = options[:class_attribute] || column.to_s.pluralize.to_sym
       class_attribute definition
-      send "#{definition}=", Definition.new(column, keys, self)
+      class_attribute "_human_#{definition}"
+      send "#{definition}=", dict.with_indifferent_access.freeze
+      send "_human_#{definition}=", {}
 
       # Getter
       define_method(column) do
-        send(definition).dict.key(read_attribute(column))
+        send(definition).key(read_attribute(column))
       end
 
       # Setter
       define_method("#{column}=") do |arg|
         case arg
         when String, Symbol
-          write_attribute column, send(definition).dict[arg]
+          write_attribute column, send(definition)[arg]
         when Integer, NilClass
           write_attribute column, arg
         end
@@ -32,7 +45,7 @@ module EnumAccessor
       end
 
       # Predicate
-      send(definition).dict.each do |key, int|
+      send(definition).each do |key, int|
         define_method("#{column}_#{key}?") do
           read_attribute(column) == int
         end
@@ -40,10 +53,17 @@ module EnumAccessor
 
       # Human-friendly print
       define_method("human_#{column}") do
-        send(definition).human_dict[send(column)]
+        self.class.send("human_#{definition}")[send(column)]
       end
 
       # Human-friendly print on class level
+      define_singleton_method("human_#{definition}") do
+        send("_human_#{definition}")[I18n.locale] ||= begin
+          Hash[send(definition).keys.map{|key| [key, send("human_#{column}", key)] }].with_indifferent_access.freeze
+        end
+      end
+
+      # Internal method for translation
       # Mimics ActiveModel::Translation.human_attribute_name
       define_singleton_method "human_#{column}" do |key, options={}|
         defaults = lookup_ancestors.map do |klass|
@@ -60,7 +80,7 @@ module EnumAccessor
 
       # Scopes
       define_singleton_method "where_#{column}" do |*args|
-        integers = args.map{|arg| send(definition).dict[arg] }.compact
+        integers = args.map{|arg| send(definition)[arg] }.compact
         where(column => integers)
       end
 
@@ -70,33 +90,7 @@ module EnumAccessor
       end
       unless options[:validates] == false
         validation_options = options[:validates].is_a?(Hash) ? options[:validates] : {}
-        validates column, { inclusion: { in: send(definition).dict.keys } }.merge(validation_options)
-      end
-    end
-
-    class Definition
-      attr_accessor :dict
-
-      def initialize(column, keys, klass)
-        dict = case keys
-        when Array
-          Hash[keys.map.with_index{|i,index| [i, index] }]
-        when Hash
-          keys
-        else
-          raise ArgumentError.new('enum_accessor takes Array or Hash as the second argument')
-        end
-
-        @column = column
-        @klass = klass
-        @dict = dict.with_indifferent_access.freeze
-        @human_dict = {}
-      end
-
-      def human_dict
-        @human_dict[I18n.locale] ||= begin
-          Hash[@dict.keys.map{|key| [key, @klass.send("human_#{@column}", key)] }].with_indifferent_access.freeze
-        end
+        validates column, { inclusion: { in: send(definition).keys } }.merge(validation_options)
       end
     end
   end

data/lib/enum_accessor/version.rb

@@ -1,3 +1,3 @@
 module EnumAccessor
-  VERSION = '1.1.0'
+  VERSION = '2.0.0'
 end

data/spec/enum_accessor_spec.rb

@@ -43,20 +43,20 @@ describe EnumAccessor do
   it 'adds humanized methods' do
     I18n.locale = :ja
     expect(User.human_attribute_name(:gender)).to eq('性別')
-    expect(User.genders.human_dict).to eq({ 'female' => '女', 'male' => '男' })
-    expect(User.genders.human_dict[:female]).to eq('女')
+    expect(User.human_genders).to eq({ 'female' => '女', 'male' => '男' })
+    expect(User.human_genders[:female]).to eq('女')
     expect(@user.human_gender).to eq('女')
 
     I18n.locale = :en
     expect(User.human_attribute_name(:gender)).to eq('Gender')
-    expect(User.genders.human_dict).to eq({ 'female' => 'Female', 'male' => 'Male' })
-    expect(User.genders.human_dict[:female]).to eq('Female')
+    expect(User.human_genders).to eq({ 'female' => 'Female', 'male' => 'Male' })
+    expect(User.human_genders[:female]).to eq('Female')
     expect(@user.human_gender).to eq('Female')
   end
 
   it 'adds class methods' do
-    expect(User.genders.dict).to eq({ 'female' => 0, 'male' => 1 })
-    expect(User.genders.dict[:female]).to eq(0)
+    expect(User.genders).to eq({ 'female' => 0, 'male' => 1 })
+    expect(User.genders[:female]).to eq(0)
   end
 
   it 'supports manual coding' do
@@ -111,7 +111,7 @@ describe EnumAccessor do
     # `find_or_create_by` uses where-based raw value for find,
     # then passes the raw value to the setter method for create.
     expect {
-      User.find_or_create_by(gender: User.genders.dict[:female])
+      User.find_or_create_by(gender: User.genders[:female])
     }.to change{ User.count }.by(1)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_accessor
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Kenn Ejima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-23 00:00:00.000000000 Z
+date: 2014-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport