extended_has_enumeration 0.0.2 → 0.0.4

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.4

data/features/step_definitions/has_enumeration_steps.rb

@@ -34,16 +34,16 @@ Then /^the ([a-z_]+\?) predicate should be (true|false)$/ do |predicate, value|
   else
     expected_value = false
   end
-  @object.color.send(predicate).should == expected_value  
+  @object.color.send(predicate).should == expected_value
 end
 
 
 Given /^a set of objects with a variety of values for the enumeration$/ do
-  a = ExplicitlyMappedModel.new(:color => :red)
-  a.color = :red
-  p a
+  #a = ExplicitlyMappedModel.new(:color => :red)
+  #a.color = :red
+  #p a
   @model_class.delete_all
-  
+
   2.times do
     [:red, :green, :blue].each do |color|
       @model_class.create!(:color => color)

data/features/support/env.rb

@@ -20,6 +20,10 @@ class CreateTables < ActiveRecord::Migration
     t.integer :color
   end
 
+  create_table :explicitly_mapped_model_with_defaults, :force => true do |t|
+    t.integer :color
+  end
+
   create_table :implicitly_mapped_models, :force => true do |t|
     t.string :color
   end

data/features/support/explicitly_mapped_model.rb

@@ -1,3 +1,3 @@
 class ExplicitlyMappedModel < ActiveRecord::Base
-  has_enumeration :color, :red => 'Red color', :green => 2, :blue => 3
+  has_enumeration :color, {:red => 'Red color', :green => 2, :blue => 3}, {allow_blank: true}
 end

data/features/support/explicitly_mapped_model_with_default.rb

@@ -0,0 +1,3 @@
+class ExplicitlyMappedModelWithDefault < ActiveRecord::Base
+  has_enumeration :color, {:red => 'Red color', :green => 2, :blue => 3}, {allow_blank: true, default: :red}
+end

data/features/support/mapped_model_with_initial.rb

@@ -0,0 +1,3 @@
+class MappedModelWithInitial < ActiveRecord::Base
+  has_enumeration :color, {:red => 'Red color', :green => 2, :blue => 3}, {initial: :red, allow_blank: true}
+end

data/features/support/model_with_wrong_default.rb

@@ -0,0 +1,3 @@
+class ModelWithWrongDefault < ActiveRecord::Base
+  has_enumeration :color, {:red => 'Red color', :green => 2, :blue => 3}, {allow_nil: true, default: :yellow}
+end

data/lib/extended_has_enumeration/class_methods.rb

@@ -29,13 +29,24 @@ module ExtendedHasEnumeration
         mapping = mapping_hash
       end
 
+      if options[:initial].present?
+        class_eval do
+          after_initialize :"initialize_#{enumeration}"
+
+          define_method :"initialize_#{enumeration}" do
+            self.send("#{enumeration}=", self.send(enumeration).blank? ? options[:initial] : self.send(enumeration))
+          end
+        end
+      end
+
+
       # The underlying attribute
       attribute = options[:attribute] || enumeration
 
       # ActiveRecord's composed_of method will do most of the work for us.
       # All we have to do is cons up a class that implements the bidirectional
       # mapping described by the provided hash.
-      klass = create_enumeration_mapping_class(mapping)
+      klass = create_enumeration_mapping_class(mapping, options)
       attr_enumeration_mapping_classes[enumeration] = klass
 
       # Bind the class to a name within the scope of this class
@@ -46,8 +57,8 @@ module ExtendedHasEnumeration
       composed_of(enumeration,
         :class_name => scoped_class_name,
         :mapping => [attribute.to_s, 'raw_value'],
-        :converter => :from_sym,
-        :allow_nil => true
+        :constructor => :constructor,
+        :converter => :from_sym
       )
 
       if ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR == 0
@@ -68,38 +79,44 @@ module ExtendedHasEnumeration
       @attr_enumeration_mapping_classes ||= {}
     end
 
-    def create_enumeration_mapping_class(mapping)
+    def create_enumeration_mapping_class(mapping, options={})
       mapping = mapping.with_indifferent_access
+      default = options[:default]
+      allow_blank = options[:allow_blank]
       Class.new do
-        attr_reader :raw_value
-        alias_method :humanize, :raw_value
+        # attr_reader :raw_value
+        # alias_method :humanize, :raw_value
+        delegate :blank?, to: :raw_value
 
         define_method :initialize do |raw_value|
           @raw_value = raw_value
-          @value = mapping[raw_value]
+          @value = mapping[@raw_value]
+        end
+
+        define_method :raw_value do
+          @raw_value.blank? ? default : @raw_value
         end
 
         define_method :to_sym do
-          @value
+          raw_value.try(:to_sym)
         end
 
         define_method :value do
-          @values
+          mapping[raw_value]
         end
 
         define_method :to_s do
-          @value.to_s
+          raw_value.to_s
         end
 
         define_method :humanize do
-          @raw_value.to_s.humanize
+          to_s.humanize
         end
 
         mapping.keys.each do |sym|
           predicate = "#{sym}?".to_sym
-          value = mapping[sym]
           define_method predicate do
-            @raw_value.to_sym == sym.to_sym
+            to_sym == sym.to_sym
           end
         end
 
@@ -108,13 +125,20 @@ module ExtendedHasEnumeration
             mapping
           end
           define_method :from_sym do |sym|
-            unless mapping.has_key?(sym)
+            if !mapping.has_key?(sym) && !sym.blank?
               raise ArgumentError.new(
                 "#{sym.inspect} is not one of {#{mapping.keys.map(&:inspect).sort.join(', ')}}"
               )
+            elsif !allow_blank && sym.blank?
+              raise ArgumentError.new(
+                "#{name.split('::').last} can't be blank"
+              )
             end
             new(sym)
           end
+          define_method :constructor do |sym|
+            new(sym)
+          end
         end
       end
     end

data/spec/extended_has_enumeration/extended_has_enumeration_spec.rb

@@ -40,14 +40,14 @@ end
 describe ExtendedHasEnumeration, 'with an uninitialied value' do
   context 'in a newly-created object' do
     it 'returns nil for the value of the enumeration' do
-      ExplicitlyMappedModel.new.color.should be_nil
+      ExplicitlyMappedModel.new.color.raw_value.should be_nil
     end
   end
 
   context 'in an existing object' do
     it 'returns nil for the value of the enumeration' do
       object = ExplicitlyMappedModel.find(ExplicitlyMappedModel.create!.id)
-      object.color.should be_nil
+      object.color.raw_value.should be_nil
     end
   end
 end
@@ -56,45 +56,123 @@ describe ExtendedHasEnumeration, 'assignment of nil' do
   it 'sets the enumeration to nil' do
     object = ExplicitlyMappedModel.new(:color => :red)
     object.color = nil
-    object.color.should be_nil
+    object.color.raw_value.should be_nil
   end
 
   it 'persists across a trip to the database' do
     object = ExplicitlyMappedModel.create!(:color => :red)
     object.color = nil
     object.save!
-    ExplicitlyMappedModel.find(object.id).color.should be_nil
+    ExplicitlyMappedModel.find(object.id).color.raw_value.should be_nil
   end
 end
 
 describe ExtendedHasEnumeration, 'string formatting' do
-  it 'returns the value as a string if to_s is called on it'  do
+  it 'returns the value as a string if to_s is called on it' do
     object = ExplicitlyMappedModel.new(:color => :red)
-    object.color.to_s.should == 'Red color'
+    object.color.to_s.should == 'red'
+  end
+end
+
+describe ExtendedHasEnumeration, 'symbol formatting' do
+  it 'returns the value as a string if to_s is called on it' do
+    object = ExplicitlyMappedModel.new(:color => :red)
+    object.color.to_sym.should == :red
+  end
+end
+
+describe ExtendedHasEnumeration, 'symbol formatting' do
+  it 'returns the value as a string if to_s is called on it' do
+    object = ExplicitlyMappedModel.new(:color => :red)
+    object.color.value.should == 'Red color'
   end
 end
 
 describe ExtendedHasEnumeration, 'hash value' do
-  it 'returns the raw value as a string if raw_value is called on it'  do
+  it 'returns the raw value as a string if raw_value is called on it' do
     object = ExplicitlyMappedModel.new(:color => :red)
     object.color.raw_value.should == :red
   end
 
-  it 'returns the raw value as a string if humanize is called on it'  do
+  it 'returns the raw value as a string if humanize is called on it' do
     object = ExplicitlyMappedModel.new(:color => :red)
     object.color.humanize.should == 'Red'
   end
 end
 
 describe ExtendedHasEnumeration, 'source' do
-  it 'returns the passed hash'  do
-    ExplicitlyMappedModel::Color.source.should == {'red'=>'Red color', 'green'=>2, 'blue'=>3}    
+  it 'returns the passed hash' do
+    ExplicitlyMappedModel::Color.source.should == {'red' => 'Red color', 'green' => 2, 'blue' => 3}
   end
 end
 
 describe ExtendedHasEnumeration, 'has hash with with_indifferent_access' do
-  it 'it allows assign string'  do
+  it 'allows assign string' do
     object = ExplicitlyMappedModel.create!(:color => 'red')
     object.color.raw_value.should == 'red'
   end
 end
+
+describe ExtendedHasEnumeration, 'constructor' do
+  it 'returns class without passing value' do
+    object = ExplicitlyMappedModel.create!
+    object.color.class.should == ExplicitlyMappedModel::Color
+  end
+
+  it 'returns nil on raw_value without passing value' do
+    object = ExplicitlyMappedModel.create! color: nil
+    object.color.raw_value.should be_blank
+  end
+end
+
+describe ExtendedHasEnumeration, 'default value' do
+
+  it 'returns true when calls red? on it' do
+    object = ExplicitlyMappedModelWithDefault.create!
+    object.color.red?.should be_true
+  end
+
+  it 'returns default value' do
+    object = ExplicitlyMappedModelWithDefault.create!
+    object.color.raw_value.should == :red
+  end
+
+  it 'returns default value of hash' do
+    object = ExplicitlyMappedModelWithDefault.create!
+    object.color.value.should == 'Red color'
+  end
+
+  it 'returns nil if default is wrong' do
+    object = ModelWithWrongDefault.create!
+    object.color.value.should be_nil
+  end
+end
+
+describe ExtendedHasEnumeration, 'initial value' do
+
+  it 'returns true when calls red? on it' do
+    object = MappedModelWithInitial.create!
+    object.color.red?.should be_true
+  end
+
+  it 'returns initial value' do
+    object = MappedModelWithInitial.create!
+    object.color.raw_value.should == :red
+  end
+
+  it 'returns initial value of hash' do
+    object = MappedModelWithInitial.create!
+    object.color.value.should == 'Red color'
+  end
+
+  it 'returns nil after seting to it' do
+    object = MappedModelWithInitial.create!
+    object.color = nil
+    object.color.raw_value.should be_nil
+  end
+
+  it 'returns nil if default is wrong' do
+    object = ModelWithWrongDefault.create!
+    object.color.value.should be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -6,6 +6,9 @@ require 'rspec'
 
 require File.expand_path('../lib/extended_has_enumeration', File.dirname(__FILE__))
 require File.expand_path('../features/support/explicitly_mapped_model', File.dirname(__FILE__))
+require File.expand_path('../features/support/explicitly_mapped_model_with_default', File.dirname(__FILE__))
+require File.expand_path('../features/support/model_with_wrong_default', File.dirname(__FILE__))
+require File.expand_path('../features/support/mapped_model_with_initial', File.dirname(__FILE__))
 
 ActiveRecord::Base.establish_connection(
   :adapter => defined?(JRUBY_VERSION) ? 'jdbcsqlite3': 'sqlite3',
@@ -18,6 +21,18 @@ end
 
 class CreateTables < ActiveRecord::Migration
   create_table :explicitly_mapped_models, :force => true do |t|
-    t.integer :color
+    t.string :color
+  end
+
+  create_table :explicitly_mapped_model_with_defaults, :force => true do |t|
+    t.string :color
+  end
+
+  create_table :model_with_wrong_defaults, :force => true do |t|
+    t.string :color
+  end
+
+  create_table :mapped_model_with_initials, :force => true do |t|
+    t.string :color
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: extended_has_enumeration
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -85,6 +85,9 @@ files:
 - features/step_definitions/has_enumeration_steps.rb
 - features/support/env.rb
 - features/support/explicitly_mapped_model.rb
+- features/support/explicitly_mapped_model_with_default.rb
+- features/support/model_with_wrong_default.rb
+- features/support/mapped_model_with_initial.rb
 - features/support/implicitly_mapped_model.rb
 - features/support/nonstandard_attribute_model.rb
 - install_gemsets.sh