enum_simulator 1.0.4 → 1.1.0

data/README.rdoc

@@ -24,6 +24,26 @@ In order to mark an AR attribute as enumerated, make sure the column in question
     enum :flavor, [:chocolate, :vanilla, :strawberry, :rockyroad]
   end
 
-enum_simulator will handle validation of inclusion and conversion of the attribute values from symbols to strings and back internally. Honestly, that's really all it does - it's just such a common pattern that I figured we might as well have a more succinct way of using it.  It will infer whether or not to allow assignment of nil to your attribute from the column definition.
+You can also pass a hash to enum, which will automatically validate the attribute's inclusion in the keys of that hash. This is useful for attributes that may need longer human-readable descriptions on display. An example of this:
+
+  class PickupTruck < ActiveRecord::Base
+    TRUCK_TYPES = {
+      :compact_sb => "Compact Short Bed",
+      :compact_lb => "Compact Long Bed",
+      :compact_ext_sb => "Compact Extended Cab Short Bed",
+      :fullsize_sb => "Full-sized Short Bed",
+      :fullsize_lb => "Full-sized Long Bed",
+      :fullsize_ext_sb => "Full-sized Extended Cab Short Bed"
+    }
+    enum :truck_type, TRUCK_TYPES
+  end
+
+And then in a view you can do something like this:
+
+  <%= select_tag :truck_type, options_for_select(PickupTruck.enumerated_attributes[:truck_type].map { |k, v| [ v, k ] }) %>
+
+You could also have used the PickupTruck::TRUCK_TYPES constant in this example, but the enumerated_attributes hash is a handy way to access whatever values were passed into the enum definition, especially if you haven't put them in a constant somewhere.
+
+enum_simulator will handle validation of inclusion and conversion of the attribute values from symbols to strings and back internally. Honestly, that's really all it does - it's just such a common pattern that I figured we might as well have a more succinct way of using it.  It will infer whether or not to allow assignment of nil to your attribute from the column definition.  If your column allows null, then then enumerated_attributes hash for that column will also include nil.  This means you do not need an :include_blank in any form tags related to the attribute in question.
 
 Copyright (c) 2012 Centresource, released under the MIT license

data/Rakefile

@@ -23,7 +23,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-Echoe.new('enum_simulator', '1.0.4') do |p|
+Echoe.new('enum_simulator', '1.1.0') do |p|
   p.description     = 'A simple plugin for abstracting out standard ActiveRecord enumerated attributes.'
   p.url             = 'https://github.com/centresource/enum_simulator.git'
   p.author          = ['Jeremy Holland', 'Brandon Valentine']

data/enum_simulator.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = "enum_simulator"
-  s.version = "1.0.4"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jeremy Holland, Brandon Valentine"]

data/lib/enum_simulator.rb

@@ -6,10 +6,17 @@ module EnumSimulator
 
   module ClassMethods
     def enum(attr, values)
-      values << nil if self.columns_hash[attr.to_s].respond_to? :null and self.columns_hash[attr.to_s].null
+      if self.columns_hash[attr.to_s].respond_to? :null and self.columns_hash[attr.to_s].null
+        if values.is_a? Hash
+          values[nil] = ""
+        else
+          values << nil
+        end
+      end
+      valid = values.is_a?(Hash) ? values.keys : values
       @enumerated_attributes ||= {}
       @enumerated_attributes[attr] = values
-      validates_inclusion_of attr, :in => values
+      validates_inclusion_of attr, :in => valid
 
       class_eval <<RUBY
         def #{attr}

data/spec/enum_simulator_spec.rb

@@ -29,6 +29,11 @@ describe EnumSimulator do
       x.should { validate_inclusion_of :flavor, :in => [:sweet, :sour, :salty, :bitter, :umami] }
     end
 
+    it "should require the symbolized value of the attribute specified in the first argument to be a key in the hash passed as the second argument" do
+      x = Thingy.new
+      x.should { validate_inclusion_of :smell, :in => [:floral, :sulphorous, :smoky, :stale, nil] }
+    end
+
     it "should require a value for the attribute if the column definition does not allow null" do
       lambda { x = Thingy.create! }.should raise_error ActiveRecord::RecordInvalid
     end
@@ -64,10 +69,22 @@ describe EnumSimulator do
         Thingy.enumerated_attributes[:flavor].should_not include(:corned_beef)
       end
 
-      it "should conditionally include nil in array of possible enumerable values when column allows null" do
+      it "should not include nil in array of possible enumerable values even when column allows null" do
         Thingy.enumerated_attributes[:flavor].should_not include(nil)
         Thingy.enumerated_attributes[:smell].should include(nil)
       end
+
+      describe "when an array is passed to enum" do
+        it "should be an array of all possible enumerable values for the key in question" do
+          Thingy.enumerated_attributes[:flavor].should be_a(Array)
+        end
+      end
+
+      describe "when a hash is passed to enum" do
+        it "should be a hash of all possible enumerable values for the key in question" do
+          Thingy.enumerated_attributes[:smell].should be_a(Hash)
+        end
+      end
     end
   end
 end

data/spec/support/models/thingy.rb

@@ -1,4 +1,4 @@
 class Thingy < ActiveRecord::Base
   enum :flavor, [:salty, :sweet, :bitter, :sour, :umami]
-  enum :smell, [:floral, :sulphorous, :smoky, :stale]
+  enum :smell, {:floral => "Floral", :sulphorous => "Sulphorous", :smoky => "Smoky", :stale => "Stale"}
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enum_simulator
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors: