simple_enum 1.6.9 → 2.0.0.rc1

data/spec/simple_enum/attribute_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe SimpleEnum::Attribute do
+  fake_model(:klass) { as_enum :gender, %w{male female}, with: [] }
+  let(:accessor) { subject.class.genders_accessor }
+
+  context '.as_enum' do
+    it 'returns a SimpleEnum::Enum' do
+      expect(klass.as_enum(:gender, %w{male female})).to be_a(SimpleEnum::Enum)
+    end
+  end
+
+  context 'generate_enum_class_accessors_for' do
+    context '.genders' do
+      subject { klass.genders }
+
+      it 'returns a SimpleEnum::Enum' do
+        expect(subject).to be_a(SimpleEnum::Enum)
+      end
+    end
+
+    context '.genders_accessor' do
+      subject { klass.genders_accessor }
+
+      it 'returns a SimpleEnum::Accessor' do
+        expect(subject).to be_a(SimpleEnum::Accessors::Accessor)
+      end
+    end
+  end
+
+  context 'generate_enum_instance_accessors_for' do
+    subject { klass.new(1) }
+
+    context '#gender' do
+      it 'delegates to accessor' do
+        expect(accessor).to receive(:read).with(subject) { :female }
+        expect(subject.gender).to eq :female
+      end
+    end
+
+    context '#gender=' do
+      it 'delegates to accessor' do
+        expect(accessor).to receive(:write).with(subject, :male) { 0 }
+        subject.gender = :male
+      end
+    end
+  end
+
+  context 'generate_enum_dirty_methods_for' do
+    subject { klass.new }
+
+    it 'does not respond to #gender_changed?' do
+      expect(subject).to_not respond_to(:gender_changed?)
+    end
+
+    it 'does not responds to #gender_was' do
+      expect(subject).to_not respond_to(:gender_was)
+    end
+
+    context 'with: :dirty' do
+      fake_model(:klass_with_dirty) { as_enum :gender, %w{male female}, with: [:dirty] }
+      subject { klass_with_dirty.new }
+
+      it 'delegates #gender_changed? to accessor' do
+        expect(accessor).to receive(:changed?).with(subject) { true }
+        expect(subject.gender_changed?).to be_true
+      end
+
+      it 'delegates #gender_was to accesso' do
+        expect(accessor).to receive(:was).with(subject) { :female }
+        expect(subject.gender_was).to eq :female
+      end
+    end
+  end
+
+  context 'generate_enum_attribute_methods_for' do
+    subject { klass.new }
+
+    it 'does not respond to #gender?' do
+      expect(subject).to_not respond_to(:gender?)
+    end
+
+    it 'does not respond to #male? or #female?' do
+      expect(subject).to_not respond_to(:male?)
+      expect(subject).to_not respond_to(:female?)
+    end
+
+    it 'does not respond to #male! or #female!' do
+      expect(subject).to_not respond_to(:male!)
+      expect(subject).to_not respond_to(:female!)
+    end
+
+    context 'with: :attribute' do
+      fake_model(:klass_with_attributes) { as_enum :gender, %w{male female}, with: [:attribute] }
+      subject { klass_with_attributes.new }
+
+      it 'delegates #gender? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, nil) { :female }
+        expect(subject.gender?).to be_true
+      end
+
+      it 'delegates #male? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'male') { true }
+        expect(subject.male?).to be_true
+      end
+
+      it 'delegates #female? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'female') { false }
+        expect(subject.female?).to be_false
+      end
+
+      it 'delegates #male! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'male') { 0 }
+        expect(subject.male!).to eq 0
+      end
+
+      it 'delegates #female! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'female') { 1 }
+        expect(subject.female!).to eq 1
+      end
+    end
+
+    context 'with a prefix' do
+      fake_model(:klass_with_prefix) { as_enum :gender, %w{male female}, with: [:attribute], prefix: true }
+      subject { klass_with_prefix.new }
+
+      it 'delegates #gender? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, nil) { :female }
+        expect(subject.gender?).to be_true
+      end
+
+      it 'delegates #gender_male? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'male') { true }
+        expect(subject.gender_male?).to be_true
+      end
+
+      it 'delegates #gender_female? to accessor' do
+        expect(accessor).to receive(:selected?).with(subject, 'female') { false }
+        expect(subject.gender_female?).to be_false
+      end
+
+      it 'delegates #gender_male! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'male') { 0 }
+        expect(subject.gender_male!).to eq 0
+      end
+
+      it 'delegates #gender_female! to accessor' do
+        expect(accessor).to receive(:write).with(subject, 'female') { 1 }
+        expect(subject.gender_female!).to eq 1
+      end
+    end
+  end
+
+  context 'generate_enum_scope_methods_for', active_record: true do
+    fake_active_record(:klass) {
+      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
+
+      it "queries for gender_cd = #{value}" do
+        values_hash = { "gender_cd" => value }
+        expect(subject.where_values_hash).to eq values_hash
+      end
+    end
+
+    context '.male' do
+      subject { klass.male }
+      it_behaves_like 'returning a relation', 0
+    end
+
+    context '.female' do
+      subject { klass.female }
+      it_behaves_like 'returning a relation', 1
+    end
+
+    context 'with prefix' do
+      fake_active_record(:klass) {
+        as_enum :gender, [:male, :female], with: [:scope], prefix: true
+      }
+
+      context '.gender_male' do
+        subject { klass.gender_male }
+        it_behaves_like 'returning a relation', 0
+      end
+
+      context '.gender_female' do
+        subject { klass.gender_female }
+        it_behaves_like 'returning a relation', 1
+      end
+    end
+
+    context 'without scope method' do
+      fake_model(:klass_without_scope_method) {
+        as_enum :gender, [:male, :female], with: [:scope]
+      }
+      subject { klass_without_scope_method }
+
+      it 'does not add .male nor .female' do
+        expect(subject).to_not respond_to(:male)
+        expect(subject).to_not respond_to(:female)
+      end
+    end
+  end
+end

data/spec/simple_enum/enum_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe SimpleEnum::Enum do
+  let(:hash) do
+    { "male" => 0, "female" => 1 }
+  end
+
+  fake_model(:klass)
+  let(:object) { klass.new }
+
+  subject { described_class.new(:gender, hash) }
+
+  context '#name' do
+    it 'returns the enum name as string' do
+      expect(subject.name).to eq 'gender'
+    end
+  end
+
+  context '#to_s' do
+    it 'returns the name' do
+      expect(subject.to_s).to eq 'gender'
+    end
+  end
+
+  context '#hash' do
+    subject { described_class.new(:gender, hash).hash }
+
+    it 'returns hash that was set in the constructor' do
+      expect(subject).to be_a(Hash)
+      expect(subject.keys).to eq %w{male female}
+      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
+    end
+
+    it 'yields twice with #each' do
+      expect { |b| subject.each(&b) }.to yield_control.exactly(2).times
+    end
+  end
+
+  context '#value (aliased to #[])' do
+    it 'looks up by string' do
+      expect(subject.value('male')).to eq 0
+      expect(subject['male']).to eq 0
+    end
+
+    it 'looks up by symbol' do
+      expect(subject.value(:female)).to eq 1
+      expect(subject[:female]).to eq 1
+    end
+
+    it 'looks up by value' do
+      expect(subject.value(0)).to be 0
+      expect(subject[0]).to be 0
+    end
+
+    it 'returns nil when key is not found' do
+      expect(subject.value(:inexistent)).to be_nil
+      expect(subject[:inexistent]).to be_nil
+    end
+  end
+
+  context '#key' do
+    it 'returns symbolized key for supplied value' do
+      expect(subject.key(0)).to eq :male
+      expect(subject.key(1)).to eq :female
+    end
+
+    it 'returns nil if value is not found' do
+      expect(subject.key(12)).to be_nil
+    end
+  end
+
+  context '#include?' do
+    it 'returns true by string' do
+      expect(subject.include?('male')).to be_true
+    end
+
+    it 'returns true by symbol' do
+      expect(subject.include?(:female)).to be_true
+    end
+
+    it 'returns true by checking actual value' do
+      expect(subject.include?(1)).to be_true
+    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
+    end
+  end
+end

data/spec/simple_enum/hasher_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'simple_enum/hasher'
+
+describe SimpleEnum::Hasher do
+  subject { described_class }
+
+  context '.map' do
+    subject { described_class.map(%w{male female}, map: :string) }
+
+    it 'uses DefaultHasher by default' do
+      result = { "male" => 0, "female" => 1 }
+      expect(described_class.map(%w{male female})).to eq result
+    end
+
+    it 'returns a frozen Hash' do
+      expect(subject).to be_a(Hash)
+      expect(subject).to be_frozen
+    end
+
+    it 'uses the builder supplied if available' do
+      result = { "male" => "male", "female" => "female" }
+      expect(subject).to eq result
+    end
+
+    it 'accepts a Proc as well' do
+      proc =  ->(hash) { { "static" => 1 } }
+      result = { "static" => 1 }
+      expect(described_class.map(%w{male female}, map: proc) ).to eq result
+    end
+  end
+
+  context 'DefaultHasher.call' do
+    let(:result) do; { "male" => 0, "female" => 1 } end
+
+    it 'returns string => index for Array of strings' do
+      expect(subject::DefaultHasher.call(%w{male female})).to eq result
+    end
+
+    it 'returns string => index for Array of symbols' do
+      expect(subject::DefaultHasher.call([:male, :female])).to eq result
+    end
+
+    it 'returns string => number for Hash with symbolized keys' do
+      expect(subject::DefaultHasher.call(male: 0, female: 1)).to eq result
+    end
+
+    it 'returns string => number for hash with string keys' do
+      expect(subject::DefaultHasher.call('male' => 0, 'female' => 1)).to eq result
+    end
+  end
+
+  context 'StringHasher.call' do
+    let(:result) do; { "male" => "male", "female" => "female" } end
+
+    it 'retuns string => string for Array of strings' do
+      expect(subject::StringHasher.call(%w{male female})).to eq result
+    end
+
+    it 'returns string => string for Array of symbols' do
+      expect(subject::StringHasher.call([:male, :female])).to eq result
+    end
+  end
+end

data/spec/simple_enum/mongoid_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'simple_enum/mongoid'
+
+describe SimpleEnum::Mongoid, mongoid: true do
+  fake_mongoid_model(:klass) {
+    as_enum :gender, %w{male female}
+  }
+
+  let(:field) { klass.fields['gender_cd'] }
+
+  context '.as_enum' do
+    subject { klass }
+
+    it 'has the genders enum' do
+      expect(klass.genders).to be_a(SimpleEnum::Enum)
+    end
+
+    it 'creates the :gender_cd field' do
+      expect(field).to_not be_nil
+      expect(field.type).to eq Object
+    end
+
+    context 'field: { type: Integer }' do
+      fake_mongoid_model(:klass) {
+        as_enum :gender, %w{male female}, field: { type: Integer }
+      }
+
+      it 'creates the :gender_cd field as Integer' do
+        expect(field).to_not be_nil
+        expect(field.type).to eq Integer
+      end
+    end
+
+    context 'field: false' do
+      fake_mongoid_model(:klass) {
+        as_enum :gender, %w{male female}, field: false
+      }
+
+      it 'does not create the field' do
+        expect(field).to be_nil
+      end
+    end
+  end
+end

data/spec/simple_enum/translation_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe SimpleEnum::Translation do
+  context '.human_enum_name', i18n: true do
+    fake_model(:klass) { extend SimpleEnum::Translation }
+    subject { klass }
+
+    shared_examples_for 'translating gender' do
+      it 'translates :male to "Mr."' do
+        expect(subject.human_enum_name(:gender, :male)).to eq 'Mr.'
+      end
+
+      it 'translates :female to "Mrs."' do
+        expect(subject.human_enum_name(:gender, :female)).to eq 'Mrs.'
+      end
+    end
+
+    context '{i18n_scope}.enums.{i18n_key}.gender.{key}' do
+      before do
+        store_translations :en, 'activemodel' => {
+          'enums' => {
+            'fake_model' => {
+              'gender' => { 'male' => 'Mr.', 'female' => 'Mrs.' }
+            }
+          }
+        }
+      end
+
+      it_behaves_like 'translating gender'
+    end
+
+    context 'enums.{i18n_key}.gender.{key}' do
+      before do
+        store_translations :en, 'enums' => {
+          'fake_model' => {
+            'gender' => { 'male' => 'Mr.', 'female' => 'Mrs.' }
+          }
+        }
+      end
+
+      it_behaves_like 'translating gender'
+    end
+
+    context 'enums.gender.{key}' do
+      before do
+        store_translations :en, 'enums' => {
+          'gender' => { 'male' => 'Mr.', 'female' => 'Mrs.' }
+        }
+      end
+
+      it_behaves_like 'translating gender'
+    end
+
+    context 'uses :default if available' do
+      it 'translates :female to "Frau" using default:' do
+        expect(subject.human_enum_name(:gender, :female, default: 'Frau')).to eq 'Frau'
+      end
+    end
+
+    context 'falls back to titleize' do
+      it 'translates using .titleize if no translations found' do
+        expect(subject.human_enum_name(:gender, :female)).to eq 'Female'
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rspec'
+require 'active_record'
+require 'mongoid'
+
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require 'simple_enum'
+
+require 'support/active_record_support'
+require 'support/i18n_support'
+require 'support/model_support'
+require 'support/mongoid_support'
+
+I18n.enforce_available_locales = false
+
+RSpec.configure do |config|
+  config.include ModelSupport
+  config.include I18nSupport, i18n: true
+  config.include ActiveRecordSupport, active_record: true
+  config.include MongoidSupport, mongoid: true
+end

data/spec/support/active_record_support.rb

@@ -0,0 +1,23 @@
+module ActiveRecordSupport
+  def self.connection
+    @connection_pool ||= ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+    ActiveRecord::Base.connection
+  end
+
+  def self.included(base)
+    base.before(:each) { self.reset_active_record }
+  end
+
+  def reset_active_record
+    ActiveRecordSupport.connection.create_table :dummies, :force => true do |t|
+      t.column :name, :string
+      t.column :gender_cd, :integer
+      t.column :word_cd, :string, :limit => 5
+      t.column :role_cd, :string
+      t.column :other, :integer
+      t.column :numeric_cd, :string
+      t.column :nilish_cd, :string
+      t.column :style_cd, :integer
+    end
+  end
+end

data/spec/support/i18n_support.rb

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

data/spec/support/model_support.rb

@@ -0,0 +1,47 @@
+require 'active_record'
+require 'mongoid'
+
+module ModelSupport
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    def fake_active_record(name, &block)
+      let(name) {
+        Class.new(ActiveRecord::Base) do
+          self.table_name = 'dummies'
+          instance_eval &block
+        end
+      }
+    end
+
+    def fake_mongoid_model(name, &block)
+      let(name) {
+        Class.new do
+          include Mongoid::Document
+          include SimpleEnum::Mongoid
+
+          store_in collection: 'dummies'
+          instance_eval &block
+        end
+      }
+    end
+
+    def fake_model(name, *fields, &block)
+      fields << :gender_cd
+      let(name) {
+        Struct.new(*fields) do
+          extend ActiveModel::Translation
+          extend SimpleEnum::Attribute
+          instance_eval &block if block_given?
+
+          def self.model_name
+            @model_name ||= ActiveModel::Name.new(self, nil, "FakeModel")
+          end
+        end
+      }
+    end
+  end
+end

data/spec/support/mongoid_support.rb

@@ -0,0 +1,21 @@
+require 'mongoid'
+
+module MongoidSupport
+  def self.connection
+    @connection ||= begin
+      Mongoid.configure.connect_to("simple_enum_mongoid_test")
+      Mongoid.default_session.options[:max_retries] = 0
+    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..."
+      end
+    }
+  end
+end