has_constant 0.6.1 → 0.6.2

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.6.2

data/has_constant.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{has_constant}
-  s.version = "0.6.1"
+  s.version = "0.6.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["mattbeedle"]

data/lib/has_constant/orm/active_model.rb

@@ -16,7 +16,7 @@ module HasConstant
               if values.is_a?(Array)
                 self.class.send(name)[read_attribute(singular).to_i]
               elsif values.is_a?(Hash)
-                self.class.send(name)[read_attribute(singular)]
+                HashWithIndifferentAccess.new(self.class.send(name))[read_attribute(singular)]
               end
             end
           end

data/lib/has_constant/orm/mongoid.rb

@@ -23,7 +23,7 @@ module HasConstant
 
           class_eval do
             unless fields.map(&:first).include?(singular.to_s)
-              field singular.to_sym, { :type => values.is_a?(Hash) ? String : Integer }.merge(options)
+              field singular.to_sym, { :type => Integer }.merge(options)
             end
 
             index singular.to_sym, :background => true if options[:index]
@@ -34,10 +34,8 @@ module HasConstant
 
           define_method("#{singular}=") do |val|
             if val.instance_of?(String)
-              if values.is_a?(Array) && index = self.class.send(name.to_s).index(val)
+              if index = self.class.send(name.to_s).index(val)
                 write_attribute singular.to_sym, index
-              elsif values.is_a?(Hash) && values.has_value?(val)
-                write_attribute singular.to_sym, values.invert[val]
               elsif !val.blank?
                 values = values.call if values.respond_to?(:call)
                 @has_constant_errors ||= {}
@@ -50,11 +48,7 @@ module HasConstant
 
           # Add the getter method. This returns the string representation of the stored value
           define_method(singular) do
-            if values.is_a?(Array)
-              self.class.send(name.to_s)[attributes[singular].to_i] if attributes[singular]
-            else
-              self.class.send(name.to_s)[attributes[singular]] if attributes[singular]
-            end
+            eval("#{self.class}.#{name.to_s}[self.attributes[singular].to_i] if self.attributes[singular]")
           end
 
           (class << self; self; end).instance_eval do

data/lib/has_constant.rb

@@ -42,7 +42,6 @@ module HasConstant
       singular = (options[:accessor] || name.to_s.singularize).to_s
 
       (class << self; self; end).instance_eval do
-        values = HashWithIndifferentAccess.new(values) if values.is_a?(Hash)
         define_method(name.to_s, values) if values.respond_to?(:call)
         define_method(name.to_s, lambda { values }) unless values.respond_to?(:call)
       end
@@ -54,10 +53,8 @@ module HasConstant
       # Add the setter method. This takes the string representation and converts it to an integer to store in the DB
       define_method("#{singular}=") do |val|
         if val.instance_of?(String)
-          if values.is_a?(Array) && values.index(val)
+          if values.index(val)
             instance_variable_set("@#{singular}", values.index(val))
-          elsif values.is_a?(Hash) && values.has_value?(val)
-            instance_variable_set("@#{singular}", values.invert[val].to_s)
           else
             raise ArgumentError,
               "value for #{singular} must be in #{self.class.send(name.to_s).join(', ')}"

data/test/has_constant_test.rb

@@ -7,13 +7,6 @@ end
 
 class TestHasConstant < Test::Unit::TestCase
 
-  should 'be able to store values in a hash' do
-    Model.has_constant :salutations, { :first => 'Mr', :second => 'Mrs' }
-    m = Model.new
-    m.salutation = 'Mr'
-    assert m.instance_variable_get("@salutation") == 'first'
-  end
-
   should 'default values to translated values list' do
     I18n.stubs(:t).returns(['a', 'b'])
     Model.has_constant :titles

data/test/unit/orm/mongoid_test.rb

@@ -6,76 +6,68 @@ setup_mongoid
 class MongoUser
   include Mongoid::Document
   include HasConstant
+
+  has_constant :salutations, ['Mr', 'Mrs']
 end if defined?(Mongoid)
 
-class MongoUser2
+class MongoUserWithProc
   include Mongoid::Document
   include HasConstant
+
+  has_constant :salutations, lambda { ['Mr', 'Mrs'] }
 end if defined?(Mongoid)
 
-class MongoUserWithHash
+class MongoUserWithout
   include Mongoid::Document
   include HasConstant
-end if defined?(Mongoid)
+end
+
+class AnotherUser
+  include Mongoid::Document
+  include HasConstant
+end
 
 class MongoidTest < Test::Unit::TestCase
   context 'Instance' do
-
-    context 'using a hash' do
-      setup do
-        MongoUserWithHash.has_constant :salutations, { :first => 'Mr', :second => 'Mrs' }
-        @m = MongoUserWithHash.new(:salutation => 'Mr')
-      end
-
-      should 'store the hash key' do
-        assert_equal 'first', @m.attributes['salutation']
-      end
-
-      should 'return the correct value' do
-        assert_equal 'Mr', @m.salutation
-      end
-    end
-
     should 'add the field automatically' do
-      MongoUser.has_constant :salutations, ['Mr', 'Mrs']
-      assert MongoUser.fields.map(&:first).include?('salutation')
+      MongoUserWithout.has_constant :salutations, ['Mr', 'Mrs']
+      assert MongoUserWithout.fields.map(&:first).include?('salutation')
     end
 
     should 'not add the field if it is already there' do
-      MongoUser.send(:field, :salutation, :type => Integer, :default => 0)
-      MongoUser.has_constant :salutations, ['Mr', 'Mrs']
-      assert_equal 'Mr', MongoUser.new.salutation
+      MongoUserWithout.send(:field, :salutation, :type => Integer, :default => 0)
+      MongoUserWithout.has_constant :salutations, ['Mr', 'Mrs']
+      assert_equal 'Mr', MongoUserWithout.new.salutation
     end
 
     should 'be able to take default option' do
-      MongoUser2.has_constant :salutations, lambda { %w(Mr Mrs) }, { :default => 0 }
-      assert_equal 'Mr', MongoUser2.new.salutation
+      AnotherUser.has_constant :salutations, lambda { %w(Mr Mrs) }, { :default => 0 }
+      assert_equal 'Mr', AnotherUser.new.salutation
     end
 
     should 'take the accessor into account when adding the field' do
-      MongoUser.has_constant :salutations, ['Mr', 'Mrs'], :accessor => :sal
-      assert MongoUser.fields.map(&:first).include?('sal')
+      MongoUserWithProc.has_constant :salutations, ['Mr', 'Mrs'], :accessor => :sal
+      assert MongoUserWithProc.fields.map(&:first).include?('sal')
     end
 
     should 'default values to translated values list' do
       I18n.stubs(:t).returns(['a', 'b'])
-      MongoUser.has_constant :titles
-      assert_equal ['a', 'b'], MongoUser.titles
+      MongoUserWithout.has_constant :titles
+      assert_equal ['a', 'b'], MongoUserWithout.titles
     end
 
     should 'add index when index option is supplied' do
-      MongoUser.has_constant :salutations, ['Mr', 'Mrs'], :index => true
-      MongoUser.create_indexes
-      assert MongoUser.index_information.keys.any? { |key| key.match(/salutation/) }
+      MongoUserWithout.has_constant :salutations, ['Mr', 'Mrs'], :index => true
+      MongoUserWithout.create_indexes
+      assert MongoUserWithout.index_information.keys.any? { |key| key.match(/salutation/) }
     end
 
     should 'not index when index option is not supplied' do
-      MongoUser2.create_indexes
-      assert !MongoUser2.index_information.keys.any? { |key| key.match(/salutation/) }
+      MongoUser.create_indexes
+      assert !MongoUser.index_information.keys.any? { |key| key.match(/salutation/) }
     end
 
     should 'save values as integers' do
-      MongoUser.has_constant :salutations, %w(Mr Mrs)
       m = MongoUser.new(:salutation => 'Mr')
       m.save!
       assert_equal 'Mr', m.salutation
@@ -83,29 +75,25 @@ class MongoidTest < Test::Unit::TestCase
     end
 
     should 'not be valid when an incorrect value is supplied' do
-      MongoUser.has_constant :salutations, %w(Mr Mrs)
       m = MongoUser.new(:salutation => 'asefe')
       assert !m.valid?
       assert_equal ['must be one of Mr, Mrs'], m.errors[:salutation]
     end
 
     should 'not be valid with an incorrect value is supplied and a proc/lambda has been used' do
-      MongoUser.has_constant :salutations, Proc.new { %w(Mr Mrs) }
-      m = MongoUser.new(:salutation => 'asefe')
+      m = MongoUserWithProc.new(:salutation => 'asefe')
       assert !m.valid?
       assert_equal ['must be one of Mr, Mrs'], m.errors[:salutation]
     end
 
     should 'be valid when a blank value is supplied' do
-      MongoUser.has_constant :salutations, Proc.new { %w(Mr Mrs) }
-      m = MongoUser.new(:salutation => '')
+      m = MongoUserWithProc.new(:salutation => '')
       assert m.valid?
     end
   end
 
   context 'Named Scopes' do
     setup do
-      MongoUser.has_constant :salutations, %w(Mr Mrs)
       @man = MongoUser.create!(:salutation => 'Mr')
       @woman = MongoUser.create!(:salutation => 'Mrs')
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: has_constant
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 3
   prerelease: false
   segments: 
   - 0
   - 6
-  - 1
-  version: 0.6.1
+  - 2
+  version: 0.6.2
 platform: ruby
 authors: 
 - mattbeedle