has_constant 0.5.1 → 0.6.0

data/.rvmrc

@@ -1,2 +1,3 @@
+rvm_gemset_create_on_use_flag=1
 rvm use 1.8.7
 rvm gemset use has_constant

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/has_constant.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{has_constant}
-  s.version = "0.5.1"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["mattbeedle"]
@@ -28,12 +28,10 @@ Gem::Specification.new do |s|
     "has_constant.gemspec",
     "lib/has_constant.rb",
     "lib/has_constant/orm/active_model.rb",
-    "lib/has_constant/orm/active_record.rb",
     "lib/has_constant/orm/mongoid.rb",
     "test/has_constant_test.rb",
     "test/helper.rb",
     "test/unit/orm/active_model_test.rb",
-    "test/unit/orm/active_record_test.rb",
     "test/unit/orm/mongoid_test.rb"
   ]
   s.homepage = %q{http://github.com/mattbeedle/has_constant}
@@ -44,7 +42,6 @@ Gem::Specification.new do |s|
     "test/has_constant_test.rb",
     "test/helper.rb",
     "test/unit/orm/active_model_test.rb",
-    "test/unit/orm/active_record_test.rb",
     "test/unit/orm/mongoid_test.rb"
   ]
 

data/lib/has_constant/orm/active_model.rb

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

data/lib/has_constant.rb

@@ -42,6 +42,7 @@ 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
@@ -53,8 +54,10 @@ 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.index(val)
+          if values.is_a?(Array) && 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(', ')}"
           end

data/test/has_constant_test.rb

@@ -7,6 +7,13 @@ 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/helper.rb

@@ -35,6 +35,9 @@ def connect_active_record
     create_table :users, :force => true do |t|
       t.integer :salutation
     end
+    create_table :things, :force => true do |t|
+      t.string :salutation
+    end
   end
 end
 

data/test/unit/orm/active_model_test.rb

@@ -7,8 +7,27 @@ class User < ActiveRecord::Base
   include HasConstant
 end
 
+class Thing < ActiveRecord::Base
+  include HasConstant
+end
+
 class ActiveModelTest < Test::Unit::TestCase
   context 'Instance' do
+    context 'using a hash' do
+      setup do
+        Thing.has_constant :salutations, { :first => 'Mr', :second => 'Mrs' }
+        @u = Thing.new :salutation => 'Mrs'
+      end
+
+      should 'store the hash key' do
+        assert_equal 'second', @u.attributes['salutation']
+      end
+
+      should 'return the correct value' do
+        assert_equal 'Mrs', @u.salutation
+      end
+    end
+
     should 'save values as integers' do
       User.has_constant :salutations, %w(Mr Mrs)
       u = User.new(:salutation => 'Mr')

data/test/unit/orm/mongoid_test.rb

@@ -6,58 +6,71 @@ setup_mongoid
 class MongoUser
   include Mongoid::Document
   include HasConstant
-
-  has_constant :salutations, ['Mr', 'Mrs']
 end if defined?(Mongoid)
 
-class MongoUserWithProc
+class MongoUser2
   include Mongoid::Document
   include HasConstant
-
-  has_constant :salutations, lambda { ['Mr', 'Mrs'] }
 end if defined?(Mongoid)
 
-class MongoUserWithout
+class MongoUserWithHash
   include Mongoid::Document
   include HasConstant
-end
+end if defined?(Mongoid)
 
 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
-      MongoUserWithout.has_constant :salutations, ['Mr', 'Mrs']
-      assert MongoUserWithout.fields.map(&:first).include?('salutation')
+      MongoUser.has_constant :salutations, ['Mr', 'Mrs']
+      assert MongoUser.fields.map(&:first).include?('salutation')
     end
 
     should 'not add the field if it is already there' do
-      MongoUserWithout.send(:field, :salutation, :type => Integer, :default => 0)
-      MongoUserWithout.has_constant :salutations, ['Mr', 'Mrs']
-      assert_equal 'Mr', MongoUserWithout.new.salutation
+      MongoUser.send(:field, :salutation, :type => Integer, :default => 0)
+      MongoUser.has_constant :salutations, ['Mr', 'Mrs']
+      assert_equal 'Mr', MongoUser.new.salutation
     end
 
     should 'take the accessor into account when adding the field' do
-      MongoUserWithout.has_constant :salutations, ['Mr', 'Mrs'], :accessor => :sal
-      assert MongoUserWithout.fields.map(&:first).include?('sal')
+      MongoUser.has_constant :salutations, ['Mr', 'Mrs'], :accessor => :sal
+      assert MongoUser.fields.map(&:first).include?('sal')
     end
 
     should 'default values to translated values list' do
       I18n.stubs(:t).returns(['a', 'b'])
-      MongoUserWithout.has_constant :titles
-      assert_equal ['a', 'b'], MongoUserWithout.titles
+      MongoUser.has_constant :titles
+      assert_equal ['a', 'b'], MongoUser.titles
     end
 
     should 'add index when index option is supplied' do
-      MongoUserWithout.has_constant :salutations, ['Mr', 'Mrs'], :index => true
-      MongoUserWithout.create_indexes
-      assert MongoUserWithout.index_information.keys.any? { |key| key.match(/salutation/) }
+      MongoUser.has_constant :salutations, ['Mr', 'Mrs'], :index => true
+      MongoUser.create_indexes
+      assert MongoUser.index_information.keys.any? { |key| key.match(/salutation/) }
     end
 
     should 'not index when index option is not supplied' do
-      MongoUser.create_indexes
-      assert !MongoUser.index_information.keys.any? { |key| key.match(/salutation/) }
+      MongoUser2.create_indexes
+      assert !MongoUser2.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
@@ -65,25 +78,29 @@ 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
-      m = MongoUserWithProc.new(:salutation => 'asefe')
+      MongoUser.has_constant :salutations, Proc.new { %w(Mr Mrs) }
+      m = MongoUser.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
-      m = MongoUserWithProc.new(:salutation => '')
+      MongoUser.has_constant :salutations, Proc.new { %w(Mr Mrs) }
+      m = MongoUser.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: 9
+  hash: 7
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 1
-  version: 0.5.1
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - mattbeedle
@@ -81,12 +81,10 @@ files:
 - has_constant.gemspec
 - lib/has_constant.rb
 - lib/has_constant/orm/active_model.rb
-- lib/has_constant/orm/active_record.rb
 - lib/has_constant/orm/mongoid.rb
 - test/has_constant_test.rb
 - test/helper.rb
 - test/unit/orm/active_model_test.rb
-- test/unit/orm/active_record_test.rb
 - test/unit/orm/mongoid_test.rb
 has_rdoc: true
 homepage: http://github.com/mattbeedle/has_constant
@@ -126,5 +124,4 @@ test_files:
 - test/has_constant_test.rb
 - test/helper.rb
 - test/unit/orm/active_model_test.rb
-- test/unit/orm/active_record_test.rb
 - test/unit/orm/mongoid_test.rb

data/lib/has_constant/orm/active_record.rb

@@ -1,65 +0,0 @@
-module HasConstant
-  module Orm
-    module ActiveRecord
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def has_constant( name, values, options = {} )
-          super(name, values, options)
-
-          singular = (options[:accessor] || name.to_s.singularize).to_s
-
-          # Add the getter method. This returns the string representation of
-          # the stored value
-          define_method(singular) do
-            if read_attribute(singular)
-              self.class.send(name)[read_attribute(singular).to_i]
-            end
-          end
-
-          define_method("#{singular}=") do |val|
-            if val.instance_of?(String)
-              write_attribute singular.to_sym, self.class.send(name.to_s).index(val)
-            else
-              write_attribute singular.to_sym, val
-            end
-          end
-
-          class_eval do
-            if respond_to?(:scope)
-              scope :by_constant, lambda { |constant,value| { :conditions =>
-                { constant.to_sym =>
-                  eval("#{self.to_s}.#{constant.pluralize}.index(value)") } } }
-
-              scope "#{singular}_is".to_sym, lambda { |*values| { :conditions =>
-                { singular.to_sym => indexes_for(name, values) }
-              } }
-
-              scope "#{singular}_is_not".to_sym, lambda { |*values| {
-                :conditions => ["#{singular} NOT IN (?)",
-                                indexes_for(name, values)] } }
-            else
-              named_scope :by_constant, lambda { |constant,value| {
-                :conditions =>
-                { constant.to_sym =>
-                  eval("#{self.to_s}.#{constant.pluralize}.index(value)") } } }
-
-              named_scope "#{singular}_is".to_sym, lambda { |*values| {
-                :conditions => { singular.to_sym => indexes_for(name, values) }
-              } }
-
-              named_scope "#{singular}_is_not".to_sym, lambda { |*values| {
-                :conditions => ["#{singular} NOT IN (?)",
-                                indexes_for(name, values)] } }
-            end
-          end
-        end
-
-      private
-        def indexes_for( name, values )
-          values.map { |v| self.send(name.to_sym).index(v) }
-        end
-      end
-    end
-  end
-end

data/test/unit/orm/active_record_test.rb

@@ -1,40 +0,0 @@
-require 'helper'
-
-setup_active_record
-
-class User < ActiveRecord::Base
-  include HasConstant
-
-  has_constant :salutations, ['Mr', 'Mrs']
-end
-
-class ActiveRecordTest < Test::Unit::TestCase
-  should 'save values as integers' do
-    u = User.new(:salutation => 'Mr')
-    u.save!
-    assert_equal 'Mr', u.salutation
-    assert_equal 0, u.attributes['salutation']
-  end
-
-  context 'scopes' do
-    setup do
-      @man = User.create!(:salutation => 'Mr')
-      @woman = User.create!(:salutation => 'Mrs')
-    end
-
-    should 'provide by_constant scope' do
-      assert_equal 1, User.by_constant('salutation', 'Mr').count
-      assert_equal @man, User.by_constant('salutation', 'Mr').first
-    end
-
-    should 'provide singular_is scope' do
-      assert_equal 1, User.salutation_is('Mr').count
-      assert_equal @man, User.salutation_is('Mr').first
-    end
-
-    should 'provide singular_is_not scope' do
-      assert_equal 1, User.salutation_is_not('Mr').count
-      assert_equal @woman, User.salutation_is_not('Mr').first
-    end
-  end
-end if defined?(ActiveRecord)