assignable_values 0.5.0 → 0.5.1

data/README.md

@@ -94,15 +94,15 @@ The default is applied to new records:
 
     Song.new.genre # => 'rock'
 
-Defaults can be lambdas:
+Defaults can be procs:
 
     class Song < ActiveRecord::Base
-      assignable_values_for :genre, :default => lambda { Date.today.year } do
+      assignable_values_for :genre, :default => proc { Date.today.year } do
         1980 .. 2011
       end
     end
 
-The lambda will be evaluated in the context of the record instance.
+The proc will be evaluated in the context of the record instance.
 
 You can also default a secondary default that is only set if the primary default value is not assignable:
 

data/lib/assignable_values/active_record/restriction/base.rb

@@ -41,7 +41,11 @@ module AssignableValues
           assignable_values = []
           old_value = previously_saved_value(record)
           assignable_values << old_value if old_value.present?
-          assignable_values |= raw_assignable_values(record)
+          parsed_values = parsed_assignable_values(record)
+          assignable_values |= parsed_values.delete(:values)
+          parsed_values.each do |meta_name, meta_content|
+            assignable_values.singleton_class.send(:define_method, meta_name) { meta_content }
+          end
           if decorate
             assignable_values = decorate_values(assignable_values)
           end
@@ -77,7 +81,7 @@ module AssignableValues
         end
 
         def parse_values(values)
-          values.to_a
+          { :values => values.to_a }
         end
 
         def current_value(record)
@@ -166,7 +170,7 @@ module AssignableValues
           end
         end
 
-        def raw_assignable_values(record)
+        def parsed_assignable_values(record)
           if delegate?
             values = assignable_values_from_delegate(record)
           else

data/lib/assignable_values/active_record/restriction/scalar_attribute.rb

@@ -9,10 +9,10 @@ module AssignableValues
           define_humanized_values_method
         end
 
-        def humanized_value(value)
+        def humanized_value(values, value) # we take the values because that contains the humanizations in case humanizations are hard-coded as a hash
           if value.present?
-            if @hardcoded_humanizations
-              @hardcoded_humanizations[value]
+            if values.respond_to?(:humanizations)
+              values.humanizations[value]
             else
               dictionary_scope = "assignable_values.#{model.name.underscore}.#{property}"
               I18n.t(value, :scope => dictionary_scope, :default => default_humanization_for_value(value))
@@ -21,8 +21,9 @@ module AssignableValues
         end
 
         def humanized_values(record)
-          assignable_values(record).collect do |value|
-            HumanizedValue.new(value, humanized_value(value))
+          values = assignable_values(record)
+          values.collect do |value|
+            HumanizedValue.new(value, humanized_value(values, value))
           end
         end
 
@@ -38,8 +39,18 @@ module AssignableValues
 
         def parse_values(values)
           if values.is_a?(Hash)
-            @hardcoded_humanizations = values
-            values = values.keys
+            { :values => values.keys,
+              :humanizations => values }
+            #puts "----"
+            #puts "HAS HUMANIZATIONS"
+            #humanizations = values
+            #values = values.keys.dup
+            #values.singleton_class.send(:define_method, :humanizations) do
+            #  puts "----"
+            #  puts "HUMANIZATIONS used"
+            #  humanizations
+            #end
+            #values
           else
             super
           end
@@ -49,9 +60,10 @@ module AssignableValues
           restriction = self
           enhance_model do
             define_method "humanized_#{restriction.property}" do |*args|
+              values = restriction.assignable_values(self)
               given_value = args[0]
               value = given_value || send(restriction.property)
-              restriction.humanized_value(value)
+              restriction.humanized_value(values, value)
             end
           end
         end
@@ -71,7 +83,7 @@ module AssignableValues
             if value.is_a?(String)
               value = value.dup
               value.singleton_class.send(:define_method, :humanized) do
-                restriction.humanized_value(value)
+                restriction.humanized_value(values, value)
               end
             end
             value

data/lib/assignable_values/version.rb

@@ -1,3 +1,3 @@
 module AssignableValues
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 end

data/spec/shared/app_root/db/migrate/002_create_songs.rb

@@ -5,6 +5,7 @@ class CreateSongs < ActiveRecord::Migration
       t.integer :artist_id
       t.string :genre
       t.integer :year
+      t.integer :duration
     end
   end
 

data/spec/shared/assignable_values/active_record_spec.rb

@@ -379,30 +379,6 @@ describe AssignableValues::ActiveRecord do
 
       context 'humanization' do
 
-        context 'legacy methods for API compatibility' do
-
-          it "should define a method #humanized on assignable string values, which return up the value's' translation" do
-            klass = Song.disposable_copy do
-              assignable_values_for :genre do
-                %w[pop rock]
-              end
-            end
-            klass.new.assignable_genres.collect(&:humanized).should == ['Pop music', 'Rock music']
-          end
-
-          it 'should not define a method #humanized on values that are not strings' do
-            klass = Song.disposable_copy do
-              assignable_values_for :year do
-                [1999, 2000, 2001]
-              end
-            end
-            years = klass.new.assignable_years
-            years.should == [1999, 2000, 2001]
-            years.first.should_not respond_to(:humanized)
-          end
-
-        end
-
         it 'should define a method that return pairs of values and their humanization' do
           klass = Song.disposable_copy do
             assignable_values_for :genre do
@@ -435,13 +411,28 @@ describe AssignableValues::ActiveRecord do
           years.collect(&:humanized).should == ['The year a new hope was born', 'The year the Empire stroke back', 'The year the Jedi returned']
         end
 
-        it 'should allow to directly declare humanized values by passing a hash to assignable_values_for' do
-          klass = Song.disposable_copy do
-            assignable_values_for :genre do
-              { 'pop' => 'Pop music', 'rock' => 'Rock music' }
+        context 'hardcoded humanizations' do
+
+          it 'should allow to directly declare humanized values by passing a hash to assignable_values_for' do
+            klass = Song.disposable_copy do
+              assignable_values_for :genre do
+                { 'pop' => 'Pop music', 'rock' => 'Rock music' }
+              end
             end
+            klass.new.humanized_genres.collect(&:humanized).sort.should =~ ['Pop music', 'Rock music']
           end
-          klass.new.humanized_genres.collect(&:humanized).should =~ ['Pop music', 'Rock music']
+
+          it "should correctly humanize values if the humanizations were declared using a hash, the values are not strings, and the list of humanized values hasn't been called before (bugfix)" do
+            klass = Song.disposable_copy do
+              assignable_values_for :duration do
+                { 60 => '1:00',
+                  90 => '1:30' }
+              end
+            end
+            klass.new(:duration => 60).humanized_duration.should == '1:00'
+            klass.new(:duration => 90).humanized_duration.should == '1:30'
+          end
+
         end
 
         it 'should properly look up humanizations for namespaced models' do
@@ -454,6 +445,30 @@ describe AssignableValues::ActiveRecord do
           years.collect(&:humanized).should == ['The year a new hope was born', 'The year the Empire stroke back', 'The year the Jedi returned']
         end
 
+        context 'legacy methods for API compatibility' do
+
+          it "should define a method #humanized on assignable string values, which return up the value's' translation" do
+            klass = Song.disposable_copy do
+              assignable_values_for :genre do
+                %w[pop rock]
+              end
+            end
+            klass.new.assignable_genres.collect(&:humanized).should == ['Pop music', 'Rock music']
+          end
+
+          it 'should not define a method #humanized on values that are not strings' do
+            klass = Song.disposable_copy do
+              assignable_values_for :year do
+                [1999, 2000, 2001]
+              end
+            end
+            years = klass.new.assignable_years
+            years.should == [1999, 2000, 2001]
+            years.first.should_not respond_to(:humanized)
+          end
+
+        end
+
       end
 
       context 'with :through option' do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assignable_values
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
   - 5
-  - 0
-  version: 0.5.0
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Henning Koch
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-14 00:00:00 +02:00
+date: 2012-11-28 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -207,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.9.3
+rubygems_version: 1.3.9.4
 signing_key: 
 specification_version: 3
 summary: Restrict the values assignable to ActiveRecord attributes or associations. Or enums on steroids.