simple_enum 2.0.0 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d2ccef9004864a8144f12e09b8f9d3b7337f2a6e
-  data.tar.gz: 42a62edab3dbf1af37c8368f4eeecfb5d0c5ab5f
+  metadata.gz: ead9e5d2a63ed29727c934fa36cf37a544dacd65
+  data.tar.gz: 89da3f9fa8ee6e7ef19f028bed68167d8e592f55
 SHA512:
-  metadata.gz: 1ad263fa8e8705c4534a11f278db11cf564b6ce1371b3f50883d4e4dd41a583492e2e807410d7da63e794d3b110a991d45d2857fb6f8369367d529db879f78c1
-  data.tar.gz: 913a6473142147a01aecec53ac5ce3ad6b6e0a96aac61898384536383df16b8118a4aa512f1ff8f590866efd9223db066c43c2858d3de955eca704011e124f67
+  metadata.gz: 834dd3a7c5e92d44c0317ac88356af38a56fdc0581dd4b4101583dbb494f0fa1d027e88f2bd1d9d134783bab08171ff998d604d78db5ce3588cec24c301f4b1e
+  data.tar.gz: a4947957c71ddeb731981403288daea009f8e6b565657cf04a140de9201cf507e2f0c81490981b2d481f903035ac608572c89e3b62b8b4499d671775f4ffa6a9

data/.gitignore

@@ -6,4 +6,5 @@ pkg
 .*.sw?
 tmp
 Gemfile.lock
+gemfiles/*.lock
 :memory*

data/Gemfile

@@ -1,5 +1,8 @@
 source "http://rubygems.org"
 
+gem 'activesupport', '~> 5.0.0'
+gem 'activerecord', '~> 5.0.0'
+
 gemspec
 
 # some development deps

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Lukas Westermann (Zurich, Switzerland)
+Copyright (c) 2015 Lukas Westermann (Zurich, Switzerland)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,8 +1,9 @@
 SimpleEnum
 ==========
 
+[![Gem Version](https://badge.fury.io/rb/simple_enum.svg)](https://badge.fury.io/rb/simple_enum)
 [![Build Status](https://travis-ci.org/lwe/simple_enum.svg)](https://travis-ci.org/lwe/simple_enum)
-[![Code Climate](https://codeclimate.com/github/lwe/simple_enum.png)](https://codeclimate.com/github/lwe/simple_enum)
+[![Code Climate](https://codeclimate.com/github/lwe/simple_enum.svg)](https://codeclimate.com/github/lwe/simple_enum)
 
 Unobtrusive enum-like fields for ActiveRecord and Ruby, brings enums functionality
 to ActiveRecord and Mongoid models (built for Rails 4+).
@@ -50,7 +51,7 @@ to use simple_enum with another version of mongoid, use version 1.6 instead.
 Load mongoid support in the `Gemfile`:
 
 ```ruby
-gem 'simple_enum', '2.0.0.rc1' , require: 'simple_enum/mongoid'
+gem 'simple_enum', '~> 2.3.0' , require: 'simple_enum/mongoid'
 ```
 
 Add this to a model:
@@ -96,9 +97,40 @@ joe.gender_cd # => 0
 Accessing actual enum values is possible at the class level:
 
 ```ruby
-User.genders            # => #<SimpleEnum::Enum:0x0....>
-User.genders[:male]     # => 0
-User.females            # => #<ActiveRecord::Relation:0x0.....> (WHERE gender_cd = 1)
+User.genders                            # => #<SimpleEnum::Enum:0x0....>
+User.genders[:male]                     # => 0
+User.genders.values_at(:male, :female)  # => [0, 1] (since 2.1.0)
+User.females                            # => #<ActiveRecord::Relation:0x0.....> (WHERE gender_cd = 1)
+```
+
+By default, scope names are generated as pluralized forms of the defined enum values e.g.
+
+```ruby
+class Booking < ActiveRecord::Base
+  as_enum :status, %i{active cancelled pending}
+end
+```
+
+would generate the following:
+```ruby
+Booking.actives     # => #<ActiveRecord::Relation:0x0.....> (WHERE status_cd = 1)
+Booking.cancelleds  # => #<ActiveRecord::Relation:0x0.....> (WHERE status_cd = 2)
+Booking.pendings    # => #<ActiveRecord::Relation:0x0.....> (WHERE status_cd = 3)
+```
+
+By setting `pluralize_scopes: false` will not generate pluralized versions of scopes e.g.
+
+```ruby
+class Booking < ActiveRecord::Base
+  as_enum :status, %i{active cancelled pending}, pluralize_scopes: false
+end
+```
+
+would generate the following:
+```ruby
+Booking.active     # => #<ActiveRecord::Relation:0x0.....> (WHERE status_cd = 1)
+Booking.cancelled  # => #<ActiveRecord::Relation:0x0.....> (WHERE status_cd = 2)
+Booking.pending    # => #<ActiveRecord::Relation:0x0.....> (WHERE status_cd = 3)
 ```
 
 ### Wait, there's more!
@@ -112,7 +144,7 @@ User.females            # => #<ActiveRecord::Relation:0x0.....> (WHERE gender_cd
   end
   ```
 
-  **Disclaimer**: if you _ever_ decide to reorder this array, beaware that any
+  **Disclaimer**: if you _ever_ decide to reorder this array, beware that any
   previous mapping is lost. So it's recommended to create mappings (that might
   change) using hashes instead of arrays. For stuff like gender it might be
   probably perfectly fine to use arrays though.
@@ -207,9 +239,56 @@ User.females            # => #<ActiveRecord::Relation:0x0.....> (WHERE gender_cd
 
   ```ruby
   # See lib/simple_enum.rb for other options
-  SimpleEnum.with = [:accessor, :scope]
+  SimpleEnum.with = [:attribute, :scope]
+  ```
+
+### View Helpers
+
+Require translated enum values? See [SimpleEnum::ViewHelpers][VE.rb] for more
+details and functions. _Disclaimer_: these methods are release candidate quality
+so expect them to change in future versions of SimpleEnum.
+
+- Translate the current value in a view:
+
+  ```ruby
+  translate_enum user, :gender # => "Frau" # assuming :de and translations exist
+  te user, :gender # translate_enum is also aliased to te
+  ```
+
+  Provide translations in the i18n yaml file like:
+
+  ```ruby
+    de:
+      enums:
+        gender:
+          female: 'Frau'
+          male: 'Mann'
   ```
 
+- Build a select tag with a translated dropdown and symbol as value:
+
+  ```ruby
+  select :user, :gender, enum_option_pairs(User, :gender)
+  ```
+
+- ...and one with the index as value:
+
+  ```ruby
+  select :user, :gender_cd, enum_option_pairs(User, :gender, true)
+  ```
+
+## Extensions
+
+`simple_enum` provides hooks to extend its functionality, starting with 2.3.0
+the following extensions can be used:
+
+- **Multi-select enum** support for SimpleEnum:
+  [simple_enum-multiple](https://github.com/bbtfr/simple_enum-multiple)
+- **Persistence values**, i.e. store values in the DB:
+  [simple_enum-persistence](https://github.com/bbtfr/simple_enum-persistence)
+- **Scopes**, scopes helper for ActiveRecord enum attributes:
+  [simple_enum-scopes](https://github.com/aovertus/simple_enum-scopes)
+
 ## Best practices
 
 Do not use values named after existing, or well known method names, like `new`, `create` etc.
@@ -219,7 +298,7 @@ Do not use values named after existing, or well known method names, like `new`,
 as_enum :handle, [:new, :create, :update]
 
 # GOOD, prefixes all methods
-as_enum :handle, [:new, :create, :update], :prefix => true
+as_enum :handle, [:new, :create, :update], prefix: true
 ```
 
 Searching for certain values by using the finder methods:
@@ -231,18 +310,22 @@ User.females # => returns an ActiveRecord::Relation
 Contributors
 ------------
 
-* @dmitry - bugfixes and other improvements
-* @tarsolya - implemented all the ruby 1.9 and rails 3 goodness!
-* @dbalatero - rails 2.3.5 bugfix & validator fixes
-* @johnthethird - feature for <tt>_for_select</tt> to return the values
-* @sinsiliux - ruby 1.9 fixes and removed AR dependency
-* @sled - mongoid support
-* @abrom - <tt>find_by_...</tt> method
-* @mhuggins - translations fixes
-* @patbenatar - for helping move towards 2.0 (scopes et all)
-* and all others: https://github.com/lwe/simple_enum/graphs/contributors thanks
+- [@dmitry](https://github.com/dmitry) - bugfixes and other improvements
+- [@tarsolya](https://github.com/tarsolya) - implemented all the ruby 1.9 and rails 3 goodness!
+- [@dbalatero](https://github.com/dbalatero) - rails 2.3.5 bugfix & validator fixes
+- [@johnthethird](https://github.com/johnthethird) - feature for `_for_select` to return the values
+- @sinsiliux - ruby 1.9 fixes and removed AR dependency
+- [@sled](https://github.com/sled) - mongoid support
+- [@abrom](https://github.com/abrom) - `find_by_...` method
+- [@mhuggins](https://github.com/mhuggins) - translations fixes
+- [@patbenatar](https://github.com/patbenatar) - for helping move towards 2.0 (scopes et all)
+- [@abacha](https://github.com/abacha) - translation helpers, README fixes
+- [@bbtfr](https://github.com/bbtfr) - for support, ideas and pushing extensions
+- and all others: https://github.com/lwe/simple_enum/graphs/contributors thanks
 
 License & Copyright
 -------------------
 
-Copyright (c) 2011-2014 by Lukas Westermann, Licensed under MIT Licence (see LICENSE file)
+Copyright (c) 2011-2015 by Lukas Westermann, Licensed under MIT License (see LICENSE file)
+
+[VE.rb]: https://github.com/lwe/simple_enum/blob/master/lib/simple_enum/view_helpers.rb

data/Rakefile

@@ -5,11 +5,20 @@ require 'rake/testtask'
 Bundler::GemHelper.install_tasks
 
 desc 'Default: run all unit tests for both ActiveRecord & Mongoid.'
-task :default => :spec
+task :default => :'spec:all'
 
-desc 'Run rspec test suite'
-task :spec do
-  sh 'bundle exec rspec spec/'
+desc 'Run basic specs only (skips mongoid)'
+task :spec => :'spec:basic'
+
+namespace :spec do
+  desc 'Run all specs'
+  task :all do
+    sh 'bundle', 'exec', 'rspec', 'spec/'
+  end
+
+  task :basic do
+    sh 'bundle', 'exec', 'rspec', 'spec/', '-t', '~mongoid'
+  end
 end
 
 # Mongodb

data/lib/simple_enum/accessors/accessor.rb

@@ -29,11 +29,17 @@ module SimpleEnum
       end
 
       def changed?(object)
-        object.attribute_changed?(source)
+        object.send(:attribute_changed?, source)
       end
 
       def was(object)
-        enum.key(object.attribute_was(source))
+        changes = object.send(:changed_attributes)
+        key = changes.fetch(source, read_before_type_cast(object))
+        enum.key(key) if key
+      end
+
+      def scope(relation, value)
+        relation.where(source => value)
       end
 
       def to_s

data/lib/simple_enum/accessors.rb

@@ -15,4 +15,14 @@ module SimpleEnum
       klass.new(name, enum, options[:source], options[:prefix])
     end
   end
+
+  # Public: Extension method to register a custom accessor.
+  #
+  # key - The Symbol of the accessor key, e.g. `:bitwise`
+  # clazz - The Class with the accessor implementation
+  #
+  # Returns nothing
+  def self.register_accessor(key, clazz)
+    Accessors::ACCESSORS[key] = clazz
+  end
 end

data/lib/simple_enum/attribute.rb

@@ -13,8 +13,11 @@ module SimpleEnum
   # original method.
   #
   module Attribute
+    # Registered registrator methods from extensions
+    EXTENSIONS = []
+
     def as_enum(name, values, options = {})
-      options.assert_valid_keys(:source, :prefix, :with, :accessor, :map)
+      options.assert_valid_keys(:source, :prefix, :with, :accessor, :map, :pluralize_scopes)
 
       hash     = SimpleEnum::Hasher.map(values, options)
       enum     = SimpleEnum::Enum.new(name, hash)
@@ -22,9 +25,10 @@ module SimpleEnum
 
       generate_enum_class_accessors_for(enum, accessor)
       generate_enum_instance_accessors_for(enum, accessor)
+      generate_additional_enum_methods_for(enum, accessor, options)
 
-      Array.wrap(options.fetch(:with, SimpleEnum.with)).each do |feature|
-        send "generate_enum_#{feature}_methods_for", enum, accessor
+      EXTENSIONS.uniq.each do |extension|
+        send "generate_enum_#{extension}_extension_for", enum, accessor
       end
 
       enum
@@ -50,6 +54,20 @@ module SimpleEnum
       end
     end
 
+    def generate_additional_enum_methods_for(enum, accessor, options)
+      with_options = Array.wrap(options.fetch(:with, SimpleEnum.with))
+      scope_option, feature_options = with_options.partition { |option| option == :scope }
+
+      feature_options.each do |feature|
+        send "generate_enum_#{feature}_methods_for", enum, accessor
+      end
+
+      unless scope_option.empty?
+        pluralize_scopes = options.fetch(:pluralize_scopes, SimpleEnum.pluralize_scopes)
+        generate_enum_scope_methods_for(enum, accessor, pluralize_scopes)
+      end
+    end
+
     def generate_enum_dirty_methods_for(enum, accessor)
       simple_enum_module.module_eval do
         define_method("#{accessor}_changed?") { accessor.changed?(self) }
@@ -66,12 +84,26 @@ module SimpleEnum
       end
     end
 
-    def generate_enum_scope_methods_for(enum, accessor)
+    def generate_enum_scope_methods_for(enum, accessor, pluralize_scopes)
       return unless respond_to?(:scope)
 
       enum.each_pair do |key, value|
-        scope "#{accessor.prefix}#{key.pluralize}", -> { where(accessor.source => value) }
+        scope_key = pluralize_scopes ? key.pluralize : key
+        scope "#{accessor.prefix}#{scope_key}", -> { accessor.scope(self, value) }
       end
     end
   end
+
+  # Public: Register a generator method and add module as part of
+  # SimpleEnum::Attribute. The generator method is called after all default
+  # generators have been created, this allows to override/change existing methods.
+  #
+  # name - The Symbol with the name of the extension
+  # mod - The Module implementing `generate_enum_{name}_extension_for` method
+  #
+  # Returns nothing
+  def self.register_generator(name, mod)
+    Attribute.send :include, mod
+    Attribute::EXTENSIONS << name.to_s
+  end
 end

data/lib/simple_enum/enum.rb

@@ -25,6 +25,10 @@ module SimpleEnum
     end
     alias_method :[], :value
 
+    def fetch(key)
+      value(key) || raise("Key \"#{key}\" not found")
+    end
+
     def each_pair(&block)
       hash.each_pair(&block)
     end
@@ -38,6 +42,15 @@ module SimpleEnum
       hash.keys
     end
 
+    def values
+      hash.values
+    end
+
+    def values_at(*keys)
+      keys = keys.map(&:to_s)
+      hash.values_at(*keys)
+    end
+
     def to_s
       name
     end

data/lib/simple_enum/mongoid.rb

@@ -33,14 +33,16 @@ module SimpleEnum
       # Wrap method chain to create mongoid field and additional
       # column options
       def as_enum(name, values, options = {})
-        source = options[:source].to_s.presence || "#{name}#{SimpleEnum.suffix}"
         field_options = options.delete(:field)
+        enum = super
+        accessor = send("#{name.to_s.pluralize}_accessor")
+
         unless field_options === false
           field_options ||= SimpleEnum.field
-          field(source, field_options) if field_options
+          field(accessor.source, field_options) if field_options
         end
 
-        super
+        enum
       end
     end
   end

data/lib/simple_enum/translation.rb

@@ -3,6 +3,8 @@ require 'i18n'
 module SimpleEnum
   module Translation
     def human_enum_name(enum, key, options = {})
+      return '' unless key.present?
+
       defaults = lookup_ancestors.map do |klass|
         :"#{self.i18n_scope}.enums.#{klass.model_name.i18n_key}.#{enum}.#{key}"
       end

data/lib/simple_enum/version.rb

@@ -1,5 +1,5 @@
 module SimpleEnum
 
   # The current `SimpleEnum` version.
-  VERSION = "2.0.0"
+  VERSION = "2.3.2"
 end

data/lib/simple_enum/view_helpers.rb

@@ -29,6 +29,22 @@ module SimpleEnum
       }
     end
 
+    # Helper method to return the translated value of an enum.
+    #
+    #     translate_enum(user, :gender) # => "Frau"
+    #
+    # Has been aliased to `te` as a convenience method as well.
+    #
+    # record - The model instance holding the enum
+    # key - The Symbol with the name of the enum, i.e. same key as used in the
+    #       `as_enum` call
+    #
+    # Returns String with translation of enum
+    def translate_enum(record, key)
+      record.class.human_enum_name(key, record.public_send(key))
+    end
+    alias_method :te, :translate_enum
+
     private
 
     def translate_enum_key(enum, key)

data/lib/simple_enum.rb

@@ -33,6 +33,9 @@ module SimpleEnum
   mattr_accessor :field
   @@field = {}
 
+  mattr_accessor :pluralize_scopes
+  @@pluralize_scopes = true
+
   def self.configure
     yield(self)
   end

data/simple_enum.gemspec

@@ -25,6 +25,6 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake', '>= 10.1.0'
   s.add_development_dependency 'activerecord', '>= 4.0.0'
-  s.add_development_dependency 'mongoid', '>= 4.0.0.beta1'
+  s.add_development_dependency 'mongoid', '>= 4.0.0'
   s.add_development_dependency 'rspec', '~> 2.14'
 end

data/spec/simple_enum/accessors_spec.rb

@@ -19,6 +19,22 @@ describe SimpleEnum::Accessors do
     end
   end
 
+  context '.register_accessor' do
+    let(:accessor) { Class.new { def initialize(*args); end } }
+    subject { described_class.accessor(:gender, "enum", accessor: :would_be) }
+
+    before { SimpleEnum.register_accessor :would_be, accessor }
+    after { SimpleEnum::Accessors::ACCESSORS.delete(:would_be) }
+
+    it 'adds accessor to ACCESSORS' do
+      expect(SimpleEnum::Accessors::ACCESSORS[:would_be]).to eq accessor
+    end
+
+    it 'allows to create an instance of our WouldBeAccessor' do
+      expect(subject).to be_a accessor
+    end
+  end
+
   context 'Accessor' do
     subject { described_class::Accessor.new(:gender, enum) }
 
@@ -125,64 +141,134 @@ describe SimpleEnum::Accessors do
 
     context '#selected?' do
       it 'returns false when gender_cd is nil' do
-        expect(subject.selected?(object)).to be_false
-        expect(subject.selected?(object, :male)).to be_false
+        expect(subject.selected?(object)).to be_falsey
+        expect(subject.selected?(object, :male)).to be_falsey
       end
 
       it 'returns true when gender_cd is != nil' do
-        expect(subject.selected?(klass.new(0))).to be_true
-        expect(subject.selected?(klass.new(1))).to be_true
+        expect(subject.selected?(klass.new(0))).to be_truthy
+        expect(subject.selected?(klass.new(1))).to be_truthy
       end
 
       it 'returns true when gender_cd is 0 and :male is passed' do
-        expect(subject.selected?(klass.new(0), :male)).to be_true
+        expect(subject.selected?(klass.new(0), :male)).to be_truthy
       end
 
       it 'returns false when gender_cd is 0 and :female is passed' do
-        expect(subject.selected?(klass.new(0), :female)).to be_false
+        expect(subject.selected?(klass.new(0), :female)).to be_falsey
       end
 
       it 'returns false when gender_cd is 1 and :other is passed' do
-        expect(subject.selected?(klass.new(0), :other)).to be_false
+        expect(subject.selected?(klass.new(0), :other)).to be_falsey
       end
     end
 
     context '#changed?' do
       it 'delegates to attribute_changed?' do
         expect(object).to receive(:attribute_changed?).with('gender_cd') { true }
-        expect(subject.changed?(object)).to be_true
+        expect(subject.changed?(object)).to be_truthy
       end
     end
 
-    context 'was' do
-      it 'delegates to attribute_was and resolves symbol' do
-        expect(object).to receive(:attribute_was).with('gender_cd') { 1 }
+    context '#was' do
+      let(:changes) do
+        { 'gender_cd' => 1 }
+      end
+
+      it 'delegates to changed_attributes and resolves symbol' do
+        expect(object).to receive(:changed_attributes) { changes }
         expect(subject.was(object)).to eq :female
       end
     end
   end
 
+  context 'dirty attributes on ActiveModel', active_record: true do
+    fake_active_record(:klass) { as_enum :gender, %w{male female} }
+    let(:object) { klass.create(gender: :male) }
+
+    it 'does not raise error "private method attribute_was called"' do
+      object.gender = :female
+      expect do
+        expect(object.gender_changed?).to be_truthy
+        expect(object.gender_was).to eq :male
+      end.to_not raise_error
+    end
+
+    context 'github.com/lwe/simple_enum/issues/109' do
+      fake_active_record(:klass) {
+        as_enum(:gender_cd, %w{female male}, source: :gender_cd)
+        as_enum(:role_cd, %w{completed cap dnf dns}, map: :string, source: :role_cd)
+      }
+      let(:object) { klass.create(role_cd: "cap", gender_cd: :female) }
+
+      context '#gender_cd_was' do
+        it 'returns nil when nil' do
+          expect(klass.create.gender_cd_was).to be_nil
+        end
+
+        it 'returns the current gender' do
+          expect(object.gender_cd_was).to eq :female
+        end
+
+        it 'returns the old gender' do
+          object.gender_cd = :male
+          expect(object.gender_cd_was).to eq :female
+        end
+      end
+
+      context '#role_cd_was' do
+        it 'returns nil when nil' do
+          expect(klass.create.role_cd_was).to be_nil
+        end
+
+        it 'returns the current role' do
+          expect(object.role_cd_was).to eq :cap
+        end
+
+        it 'returns completed when changed' do
+          object.role_cd = :completed
+          expect(object.role_cd_was).to eq :cap
+        end
+      end
+    end
+  end
+
+  context '#scope' do
+    fake_active_record(:klass) { as_enum :gender, [:male, :female] }
+    let(:accessor) { described_class::Accessor.new(:gender, enum) }
+    subject { accessor.scope(klass, 1) }
+
+    it 'returns an ActiveRecord::Relation' do
+      expect(subject).to be_a(ActiveRecord::Relation)
+    end
+
+    it "queries for gender_cd = 1" do
+      values_hash = { "gender_cd" => 1 }
+      expect(subject.where_values_hash).to eq values_hash
+    end
+  end
+
   context 'IgnoreAccessor' do
     subject { described_class::IgnoreAccessor.new(:gender, enum) }
 
     it 'sets gender_cd to 0 with symbol' do
-      expect(subject.write(object, :male)).to_not be_false
+      expect(subject.write(object, :male)).to_not be_falsey
       expect(object.gender_cd).to eq 0
     end
 
     it 'sets gender_cd to 1 via value (1)' do
-      expect(subject.write(object, 1)).to_not be_false
+      expect(subject.write(object, 1)).to_not be_falsey
       expect(object.gender_cd).to eq 1
     end
 
     it 'sets gender_cd to nil' do
-      expect(subject.write(object, nil)).to be_false
+      expect(subject.write(object, nil)).to be_falsey
       expect(object.gender_cd).to be_nil
     end
 
     it 'keeps existing value when unknown value is passed' do
       object.gender_cd = 1
-      expect(subject.write(object, :other)).to be_false
+      expect(subject.write(object, :other)).to be_falsey
       expect(object.gender_cd).to eq 1
     end
   end

data/spec/simple_enum/attribute_spec.rb

@@ -10,6 +10,37 @@ describe SimpleEnum::Attribute do
     end
   end
 
+  context '.register_generator' do
+    let(:mod) {
+      Module.new do
+        def generate_enum_spec_extension_for(enum, accessor)
+          module_eval { attr_accessor :some_reader }
+          simple_enum_module.module_eval do
+            define_method("extension_method") { "as_enum(#{enum.name})" }
+          end
+        end
+      end
+    }
+
+    before { SimpleEnum.register_generator :spec, mod }
+    after { described_class::EXTENSIONS.clear }
+
+    subject { klass.new }
+
+    it 'adds "spec" to EXTENSIONS' do
+      expect(described_class::EXTENSIONS).to eq %w{spec}
+    end
+
+    it 'calls generate_enum_spec_extension_for during as_enum' do
+      expect(subject.extension_method).to eq "as_enum(gender)"
+    end
+
+    it 'allows to add behavior to class itself (e.g. attr_accessor)' do
+      subject.some_reader = "some value"
+      expect(subject.some_reader).to eq "some value"
+    end
+  end
+
   context 'generate_enum_class_accessors_for' do
     context '.genders' do
       subject { klass.genders }
@@ -48,7 +79,7 @@ describe SimpleEnum::Attribute do
     context '#gender?' do
       it 'delegates to accessor' do
         expect(accessor).to receive(:selected?).with(subject, nil) { nil }
-        expect(subject.gender?).to be_false
+        expect(subject.gender?).to be_falsey
       end
     end
   end
@@ -70,7 +101,7 @@ describe SimpleEnum::Attribute do
 
       it 'delegates #gender_changed? to accessor' do
         expect(accessor).to receive(:changed?).with(subject) { true }
-        expect(subject.gender_changed?).to be_true
+        expect(subject.gender_changed?).to be_truthy
       end
 
       it 'delegates #gender_was to accesso' do
@@ -99,17 +130,17 @@ describe SimpleEnum::Attribute do
 
       it 'delegates #gender? to accessor' do
         expect(accessor).to receive(:selected?).with(subject, nil) { :female }
-        expect(subject.gender?).to be_true
+        expect(subject.gender?).to be_truthy
       end
 
       it 'delegates #male? to accessor' do
         expect(accessor).to receive(:selected?).with(subject, 'male') { true }
-        expect(subject.male?).to be_true
+        expect(subject.male?).to be_truthy
       end
 
       it 'delegates #female? to accessor' do
         expect(accessor).to receive(:selected?).with(subject, 'female') { false }
-        expect(subject.female?).to be_false
+        expect(subject.female?).to be_falsey
       end
 
       it 'delegates #male! to accessor' do
@@ -129,17 +160,17 @@ describe SimpleEnum::Attribute do
 
       it 'delegates #gender? to accessor' do
         expect(accessor).to receive(:selected?).with(subject, nil) { :female }
-        expect(subject.gender?).to be_true
+        expect(subject.gender?).to be_truthy
       end
 
       it 'delegates #gender_male? to accessor' do
         expect(accessor).to receive(:selected?).with(subject, 'male') { true }
-        expect(subject.gender_male?).to be_true
+        expect(subject.gender_male?).to be_truthy
       end
 
       it 'delegates #gender_female? to accessor' do
         expect(accessor).to receive(:selected?).with(subject, 'female') { false }
-        expect(subject.gender_female?).to be_false
+        expect(subject.gender_female?).to be_falsey
       end
 
       it 'delegates #gender_male! to accessor' do
@@ -159,25 +190,23 @@ describe SimpleEnum::Attribute do
       as_enum :gender, [:male, :female], with: [:scope]
     }
 
-    shared_examples_for 'returning a relation' do |value|
-      it 'returns an ActiveRecord::Relation' do
-        expect(subject).to be_a(ActiveRecord::Relation)
-      end
+    let(:accessor) { klass.genders_accessor }
 
-      it "queries for gender_cd = #{value}" do
-        values_hash = { "gender_cd" => value }
-        expect(subject.where_values_hash).to eq values_hash
+    shared_examples_for 'delegates to accessor#scope' do |value|
+      it 'delegates to #scope' do
+        expect(accessor).to receive(:scope).with(klass, value)
+        subject
       end
     end
 
     context '.males' do
       subject { klass.males }
-      it_behaves_like 'returning a relation', 0
+      it_behaves_like 'delegates to accessor#scope', 0
     end
 
     context '.females' do
       subject { klass.females }
-      it_behaves_like 'returning a relation', 1
+      it_behaves_like 'delegates to accessor#scope', 1
     end
 
     context 'with prefix' do
@@ -187,12 +216,44 @@ describe SimpleEnum::Attribute do
 
       context '.gender_males' do
         subject { klass.gender_males }
-        it_behaves_like 'returning a relation', 0
+        it_behaves_like 'delegates to accessor#scope', 0
       end
 
       context '.gender_females' do
         subject { klass.gender_females }
-        it_behaves_like 'returning a relation', 1
+        it_behaves_like 'delegates to accessor#scope', 1
+      end
+
+      context 'and pluralize scopes option is set to false' do
+        fake_active_record(:klass) {
+          as_enum :gender, [:male, :female], with: [:scope], prefix: true, pluralize_scopes: false
+        }
+
+        context '.gender_male' do
+          subject { klass.gender_male }
+          it_behaves_like 'delegates to accessor#scope', 0
+        end
+
+        context '.gender_female' do
+          subject { klass.gender_female }
+          it_behaves_like 'delegates to accessor#scope', 1
+        end
+      end
+    end
+
+    context 'when pluralize scopes option is set to false' do
+      fake_active_record(:klass) {
+        as_enum :gender, [:male, :female], with: [:scope], pluralize_scopes: false
+      }
+
+      context '.male' do
+        subject { klass.male }
+        it_behaves_like 'delegates to accessor#scope', 0
+      end
+
+      context '.female' do
+        subject { klass.female }
+        it_behaves_like 'delegates to accessor#scope', 1
       end
     end
 

data/spec/simple_enum/enum_spec.rb

@@ -38,6 +38,12 @@ describe SimpleEnum::Enum do
     end
   end
 
+  context '#values' do
+    it 'returns the values in the order added' do
+      expect(subject.values).to eq [0, 1]
+    end
+  end
+
   context '#each_pair (aliased to #each)' do
     it 'yields twice with #each_pair' do
       expect { |b| subject.each_pair(&b) }.to yield_control.exactly(2).times
@@ -70,6 +76,24 @@ describe SimpleEnum::Enum do
     end
   end
 
+  context '#fetch' do
+    it 'looks up by string' do
+      expect(subject.fetch('male')).to eq 0
+    end
+
+    it 'looks up by symbol' do
+      expect(subject.fetch(:female)).to eq 1
+    end
+
+    it 'looks up by value' do
+      expect(subject.fetch(0)).to be 0
+    end
+
+    it 'throws exception when key is not found' do
+      expect{subject.fetch(:inexistent)}.to raise_error(/not found/i)
+    end
+  end
+
   context '#key' do
     it 'returns symbolized key for supplied value' do
       expect(subject.key(0)).to eq :male
@@ -83,20 +107,30 @@ describe SimpleEnum::Enum do
 
   context '#include?' do
     it 'returns true by string' do
-      expect(subject.include?('male')).to be_true
+      expect(subject.include?('male')).to be_truthy
     end
 
     it 'returns true by symbol' do
-      expect(subject.include?(:female)).to be_true
+      expect(subject.include?(:female)).to be_truthy
     end
 
     it 'returns true by checking actual value' do
-      expect(subject.include?(1)).to be_true
+      expect(subject.include?(1)).to be_truthy
     end
 
     it 'returns false when neither in keys nor values' do
-      expect(subject.include?(:other)).to be_false
-      expect(subject.include?(2)).to be_false
+      expect(subject.include?(:other)).to be_falsey
+      expect(subject.include?(2)).to be_falsey
+    end
+  end
+
+  context '#values_at' do
+    it 'fetches multiple values by string' do
+      expect(subject.values_at("male", "female")).to eq [0, 1]
+    end
+
+    it 'fetches multiple values by symbol' do
+      expect(subject.values_at(:male)).to eq [0]
     end
   end
 end

data/spec/simple_enum/translation_spec.rb

@@ -13,6 +13,10 @@ describe SimpleEnum::Translation do
       it 'translates :female to "Mrs."' do
         expect(subject.human_enum_name(:gender, :female)).to eq 'Mrs.'
       end
+
+      it 'returns empty string when key is missing' do
+        expect(subject.human_enum_name(:gender, nil)).to eq ''
+      end
     end
 
     context '{i18n_scope}.enums.{i18n_key}.gender.{key}' do

data/spec/simple_enum/view_helpers_spec.rb

@@ -59,4 +59,13 @@ describe SimpleEnum::ViewHelpers, i18n: true do
       end
     end
   end
+
+  context '#translate_enum' do
+    let(:fake_object) { klass.new }
+    it "translates with object scope" do
+      fake_object.gender = :male
+      expect(klass).to receive(:human_enum_name).with(:gender, :male) { "Mr." }
+      expect(helper.translate_enum(fake_object, :gender)).to eq "Mr."
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -6,8 +6,8 @@ require 'active_record'
 require 'mongoid'
 
 if ENV['CODECLIMATE_REPO_TOKEN']
-  require "codeclimate-test-reporter"
-  CodeClimate::TestReporter.start
+  require 'simplecov'
+  SimpleCov.start
 end
 
 require 'simple_enum'

data/spec/support/i18n_support.rb

@@ -1,7 +1,7 @@
 module I18nSupport
   def self.included(base)
     base.let!(:i18n_previous_backend) { I18n.backend }
-    base.let(:i18n_backend) { I18n::Backend::KeyValue.new({}) }
+    base.let(:i18n_backend) { I18n::Backend::Simple.new() }
     base.before { I18n.backend = i18n_backend }
     base.after { I18n.backend = i18n_previous_backend }
   end

data/spec/support/mongoid_support.rb

@@ -1,20 +1,46 @@
 require 'mongoid'
 
+# Hack to disable auto-retries for Mongo::Client - unless running
+# on Travis CI
+if ENV['CI'] && Mongoid.respond_to?(:default_client)
+  require 'mongo'
+
+  module Mongo
+    class Cluster
+      def scan!
+        raise ArgumentError, 'no retries please.'
+      end
+    end
+  end
+end
+
 module MongoidSupport
   def self.connection
-    @connection ||= begin
-      Mongoid.configure.connect_to("simple_enum_mongoid_test")
-      Mongoid.default_session.options[:max_retries] = 0
+    @connection_config ||= begin
+      Mongoid.configure do |config|
+        config.connect_to("simple_enum_mongoid_test", max_retries: ENV['CI'] ? 5 : 0)
+      end
+
+      # Disable client errors
+      Moped.logger.level = Logger::ERROR if defined?(Moped)
+      Mongo::Logger.logger.level = Logger::ERROR if defined?(Mongo)
+
+      # Return instance
+      return Mongoid.default_client if Mongoid.respond_to?(:default_client)
+      Mongoid.default_session
     end
-    Mongoid.default_session
   end
 
   def self.included(base)
     base.before {
       begin
-        MongoidSupport.connection.collection_names
-      rescue Moped::Errors::ConnectionFailure
-        pending "Start MongoDB server to run Mongoid integration tests..."
+        MongoidSupport.connection.database_names
+      rescue => e
+        if ENV['CI']
+          raise e
+        else
+          skip "Start MongoDB server to run Mongoid integration tests..."
+        end
       end
     }
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_enum
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.3.2
 platform: ruby
 authors:
 - Lukas Westermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-02 00:00:00.000000000 Z
+date: 2018-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0.beta1
+        version: 4.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0.beta1
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -138,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Simple enum-like field support for models.